Merge branch 'cli-query-node' into olympia-staging

cli/.eslintignore

@@ -1,2 +1,5 @@
 /lib
+# Temporarly ignore before merging `Sumer`
+/src/commands/media
+/src/commands/content-directory
 .eslintrc.js

cli/codegen.yml

@@ -0,0 +1,32 @@
+overwrite: true
+
+schema: '../query-node/generated/graphql-server/generated/schema.graphql'
+
+documents:
+  - './src/graphql/queries/*.graphql'
+
+config:
+  scalars:
+    Date: Date
+  preResolveTypes: true # avoid using Pick
+  skipTypename: true # skip __typename field in typings unless it's part of the query
+
+generates:
+  src/graphql/generated/schema.ts:
+    hooks:
+      afterOneFileWrite:
+        - prettier --write
+        - eslint --fix
+    plugins:
+      - typescript
+  src/graphql/generated/queries.ts:
+    preset: import-types
+    presetConfig:
+      typesPath: ./schema
+    hooks:
+      afterOneFileWrite:
+        - prettier --write
+        - eslint --fix
+    plugins:
+      - typescript-operations
+      - typescript-document-nodes

cli/package.json

@@ -1,13 +1,15 @@
 {
   "name": "@joystream/cli",
   "description": "Command Line Interface for Joystream community and governance activities",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "author": "Leszek Wiesner",
   "bin": {
     "joystream-cli": "./bin/run"
   },
   "bugs": "https://github.com/Joystream/joystream/issues",
   "dependencies": {
+    "@apollo/client": "^3.3.13",
+    "cross-fetch": "^3.0.6",
     "@apidevtools/json-schema-ref-parser": "^9.0.6",
     "@ffprobe-installer/ffprobe": "^1.1.0",
     "@joystream/types": "^0.15.0",
@@ -56,7 +58,12 @@
     "nyc": "^14.1.1",
     "ts-node": "^8.8.2",
     "typescript": "^3.8.3",
-    "json-schema-to-typescript": "^9.1.1"
+    "json-schema-to-typescript": "^9.1.1",
+    "@graphql-codegen/cli": "^1.21.4",
+    "@graphql-codegen/typescript": "^1.22.0",
+    "@graphql-codegen/import-types-preset": "^1.18.1",
+    "@graphql-codegen/typescript-operations": "^1.17.16",
+    "@graphql-codegen/typescript-document-nodes": "^1.17.11"
   },
   "engines": {
     "node": ">=12.18.0",
@@ -124,7 +131,9 @@
     "lint": "eslint ./src --ext .ts",
     "checks": "tsc --noEmit --pretty && prettier ./ --check && yarn lint",
     "format": "prettier ./ --write",
-    "generate:schema-typings": "rm -rf ./src/json-schemas/typings && json2ts -i ./src/json-schemas/ -o ./src/json-schemas/typings/"
+    "generate:schema-typings": "rm -rf ./src/json-schemas/typings && json2ts -i ./src/json-schemas/ -o ./src/json-schemas/typings/ && yarn format",
+    "generate:graphql-typings": "graphql-codegen",
+    "generate:all": "yarn generate:schema-typings && yarn generate:graphql-typings"
   },
   "types": "lib/index.d.ts",
   "volta": {

cli/src/Api.ts

@@ -1,89 +1,99 @@
 import BN from 'bn.js'
 import { types } from '@joystream/types/'
 import { ApiPromise, WsProvider } from '@polkadot/api'
-import { QueryableStorageMultiArg, SubmittableExtrinsic, QueryableStorageEntry } from '@polkadot/api/types'
+import { SubmittableExtrinsic, AugmentedQuery } from '@polkadot/api/types'
 import { formatBalance } from '@polkadot/util'
-import { Balance, Moment, BlockNumber } from '@polkadot/types/interfaces'
+import { Balance } from '@polkadot/types/interfaces'
 import { KeyringPair } from '@polkadot/keyring/types'
-import { Codec, CodecArg } from '@polkadot/types/types'
-import { Option, Vec, UInt } from '@polkadot/types'
+import { Codec, Observable } from '@polkadot/types/types'
+import { UInt } from '@polkadot/types'
 import {
   AccountSummary,
-  CouncilInfoObj,
-  CouncilInfoTuple,
-  createCouncilInfoObj,
   WorkingGroups,
   Reward,
   GroupMember,
-  OpeningStatus,
-  GroupOpeningStage,
-  GroupOpening,
-  GroupApplication,
-  openingPolicyUnstakingPeriodsKeys,
-  UnstakingPeriods,
-  StakingPolicyUnstakingPeriodKey,
+  ApplicationDetails,
+  OpeningDetails,
+  UnaugmentedApiPromise,
+  MemberDetails,
 } from './Types'
 import { DeriveBalancesAll } from '@polkadot/api-derive/types'
 import { CLIError } from '@oclif/errors'
-import ExitCodes from './ExitCodes'
 import {
   Worker,
   WorkerId,
-  RoleStakeProfile,
-  Opening as WGOpening,
-  Application as WGApplication,
-  StorageProviderId,
-} from '@joystream/types/working-group'
-import {
-  Opening,
+  OpeningId,
   Application,
-  OpeningStage,
-  ApplicationStageKeys,
   ApplicationId,
-  OpeningId,
-  StakingPolicy,
-} from '@joystream/types/hiring'
-import { MemberId, Membership } from '@joystream/types/members'
-import { RewardRelationship, RewardRelationshipId } from '@joystream/types/recurring-rewards'
-import { Stake, StakeId } from '@joystream/types/stake'
-
-import { InputValidationLengthConstraint } from '@joystream/types/common'
+  StorageProviderId,
+  Opening,
+} from '@joystream/types/working-group'
+import { Membership, StakingAccountMemberBinding } from '@joystream/types/members'
+import { AccountId, MemberId } from '@joystream/types/common'
 import { Class, ClassId, CuratorGroup, CuratorGroupId, Entity, EntityId } from '@joystream/types/content-directory'
 import { ContentId, DataObject } from '@joystream/types/media'
-import { ServiceProviderRecord, Url } from '@joystream/types/discovery'
+import { ServiceProviderRecord } from '@joystream/types/discovery'
 import _ from 'lodash'
+import { ApolloClient, InMemoryCache, HttpLink, NormalizedCacheObject, DocumentNode } from '@apollo/client'
+import fetch from 'cross-fetch'
+import { Maybe } from './graphql/generated/schema'
+import {
+  GetMemberById,
+  GetMemberByIdQuery,
+  GetMemberByIdQueryVariables,
+  MembershipFieldsFragment,
+} from './graphql/generated/queries'
 
 export const DEFAULT_API_URI = 'ws://localhost:9944/'
 const DEFAULT_DECIMALS = new BN(12)
 
 // Mapping of working group to api module
-export const apiModuleByGroup: { [key in WorkingGroups]: string } = {
+export const apiModuleByGroup = {
   [WorkingGroups.StorageProviders]: 'storageWorkingGroup',
   [WorkingGroups.Curators]: 'contentDirectoryWorkingGroup',
+  [WorkingGroups.Forum]: 'forumWorkingGroup',
+  [WorkingGroups.Membership]: 'membershipWorkingGroup',
+} as const
+
+export const lockIdByWorkingGroup: { [K in WorkingGroups]: string } = {
+  [WorkingGroups.StorageProviders]: '0x0606060606060606',
+  [WorkingGroups.Curators]: '0x0707070707070707',
+  [WorkingGroups.Forum]: '0x0808080808080808',
+  [WorkingGroups.Membership]: '0x0909090909090909',
 }
 
 // Api wrapper for handling most common api calls and allowing easy API implementation switch in the future
 export default class Api {
   private _api: ApiPromise
+  private _queryNode?: ApolloClient<NormalizedCacheObject>
   private _cdClassesCache: [ClassId, Class][] | null = null
-
-  private constructor(originalApi: ApiPromise) {
+  public isDevelopment = false
+
+  private constructor(
+    originalApi: ApiPromise,
+    isDevelopment: boolean,
+    queryNodeClient?: ApolloClient<NormalizedCacheObject>
+  ) {
+    this.isDevelopment = isDevelopment
     this._api = originalApi
+    this._queryNode = queryNodeClient
   }
 
   public getOriginalApi(): ApiPromise {
     return this._api
   }
 
-  private static async initApi(
-    apiUri: string = DEFAULT_API_URI,
-    metadataCache: Record<string, any>
-  ): Promise<ApiPromise> {
+  // Get api for use-cases where no type augmentations are desirable
+  public getUnaugmentedApi(): UnaugmentedApiPromise {
+    return (this._api as unknown) as UnaugmentedApiPromise
+  }
+
+  private static async initApi(apiUri: string = DEFAULT_API_URI, metadataCache: Record<string, any>) {
     const wsProvider: WsProvider = new WsProvider(apiUri)
     const api = await ApiPromise.create({ provider: wsProvider, types, metadata: metadataCache })
 
     // Initializing some api params based on pioneer/packages/react-api/Api.tsx
-    const [properties] = await Promise.all([api.rpc.system.properties()])
+    const [properties, chainType] = await Promise.all([api.rpc.system.properties(), api.rpc.system.chainType()])
 
     const tokenSymbol = properties.tokenSymbol.unwrapOr('DEV').toString()
     const tokenDecimals = properties.tokenDecimals.unwrapOr(DEFAULT_DECIMALS).toNumber()
@@ -94,29 +104,66 @@ export default class Api {
       unit: tokenSymbol,
     })
 
-    return api
+    return { api, properties, chainType }
   }
 
-  static async create(apiUri: string = DEFAULT_API_URI, metadataCache: Record<string, any>): Promise<Api> {
-    const originalApi: ApiPromise = await Api.initApi(apiUri, metadataCache)
-    return new Api(originalApi)
+  private static async createQueryNodeClient(uri: string) {
+    return new ApolloClient({
+      link: new HttpLink({ uri, fetch }),
+      cache: new InMemoryCache(),
+      defaultOptions: { query: { fetchPolicy: 'no-cache', errorPolicy: 'all' } },
+    })
   }
 
-  private queryMultiOnce(queries: Parameters<typeof ApiPromise.prototype.queryMulti>[0]): Promise<Codec[]> {
-    return new Promise((resolve, reject) => {
-      let unsub: () => void
-      this._api
-        .queryMulti(queries, (res) => {
-          // unsub should already be set at this point
-          if (!unsub) {
-            reject(new CLIError('API queryMulti issue - unsub method not set!', { exit: ExitCodes.ApiError }))
-          }
-          unsub()
-          resolve(res)
-        })
-        .then((unsubscribe) => (unsub = unsubscribe))
-        .catch((e) => reject(e))
-    })
+  static async create(
+    apiUri = DEFAULT_API_URI,
+    metadataCache: Record<string, any>,
+    queryNodeUri?: string
+  ): Promise<Api> {
+    const { api, chainType } = await Api.initApi(apiUri, metadataCache)
+    const queryNodeClient = queryNodeUri ? await this.createQueryNodeClient(queryNodeUri) : undefined
+    return new Api(api, chainType.isDevelopment || chainType.isLocal, queryNodeClient)
+  }
+
+  // Query-node: get entity by unique input
+  protected async uniqueEntityQuery<
+    QueryT extends { [k: string]: Maybe<Record<string, unknown>> | undefined },
+    VariablesT extends Record<string, unknown>
+  >(
+    query: DocumentNode,
+    variables: VariablesT,
+    resultKey: keyof QueryT
+  ): Promise<Required<QueryT>[keyof QueryT] | null | undefined> {
+    if (!this._queryNode) {
+      return
+    }
+    return (await this._queryNode.query<QueryT, VariablesT>({ query, variables })).data[resultKey] || null
+  }
+
+  // Query-node: get entities by "non-unique" input and return first result
+  protected async firstEntityQuery<
+    QueryT extends { [k: string]: unknown[] },
+    VariablesT extends Record<string, unknown>
+  >(
+    query: DocumentNode,
+    variables: VariablesT,
+    resultKey: keyof QueryT
+  ): Promise<QueryT[keyof QueryT][number] | null | undefined> {
+    if (!this._queryNode) {
+      return
+    }
+    return (await this._queryNode.query<QueryT, VariablesT>({ query, variables })).data[resultKey][0] || null
+  }
+
+  // Query-node: get multiple entities
+  protected async multipleEntitiesQuery<
+    QueryT extends { [k: string]: unknown[] },
+    VariablesT extends Record<string, unknown>
+  >(query: DocumentNode, variables: VariablesT, resultKey: keyof QueryT): Promise<QueryT[keyof QueryT] | undefined> {
+    if (!this._queryNode) {
+      return
+    }
+    return (await this._queryNode.query<QueryT, VariablesT>({ query, variables })).data[resultKey]
   }
 
   async bestNumber(): Promise<number> {
@@ -140,27 +187,6 @@ export default class Api {
     return { balances }
   }
 
-  async getCouncilInfo(): Promise<CouncilInfoObj> {
-    const queries: { [P in keyof CouncilInfoObj]: QueryableStorageMultiArg<'promise'> } = {
-      activeCouncil: this._api.query.council.activeCouncil,
-      termEndsAt: this._api.query.council.termEndsAt,
-      autoStart: this._api.query.councilElection.autoStart,
-      newTermDuration: this._api.query.councilElection.newTermDuration,
-      candidacyLimit: this._api.query.councilElection.candidacyLimit,
-      councilSize: this._api.query.councilElection.councilSize,
-      minCouncilStake: this._api.query.councilElection.minCouncilStake,
-      minVotingStake: this._api.query.councilElection.minVotingStake,
-      announcingPeriod: this._api.query.councilElection.announcingPeriod,
-      votingPeriod: this._api.query.councilElection.votingPeriod,
-      revealingPeriod: this._api.query.councilElection.revealingPeriod,
-      round: this._api.query.councilElection.round,
-      stage: this._api.query.councilElection.stage,
-    }
-    const results: CouncilInfoTuple = (await this.queryMultiOnce(Object.values(queries))) as CouncilInfoTuple
-
-    return createCouncilInfoObj(...results)
-  }
-
   async estimateFee(account: KeyringPair, tx: SubmittableExtrinsic<'promise'>): Promise<Balance> {
     const paymentInfo = await tx.paymentInfo(account)
     return paymentInfo.partialFee
@@ -174,12 +200,10 @@ export default class Api {
   // TODO: This is a lot of repeated logic from "/pioneer/joy-utils/transport"
   // It will be refactored to "joystream-js" soon
   async entriesByIds<IDType extends UInt, ValueType extends Codec>(
-    apiMethod: QueryableStorageEntry<'promise'>,
-    firstKey?: CodecArg // First key in case of double maps
+    apiMethod: AugmentedQuery<'promise', (key: IDType) => Observable<ValueType>>
   ): Promise<[IDType, ValueType][]> {
-    const entries: [IDType, ValueType][] = (await apiMethod.entries<ValueType>(firstKey)).map(([storageKey, value]) => [
-      // If double-map (first key is provided), we map entries by second key
-      storageKey.args[firstKey !== undefined ? 1 : 0] as IDType,
+    const entries: [IDType, ValueType][] = (await apiMethod.entries()).map(([storageKey, value]) => [
+      storageKey.args[0] as IDType,
       value,
     ])
 
@@ -193,7 +217,7 @@ export default class Api {
   }
 
   protected async blockTimestamp(height: number): Promise<Date> {
-    const blockTime = (await this._api.query.timestamp.now.at(await this.blockHash(height))) as Moment
+    const blockTime = await this._api.query.timestamp.now.at(await this.blockHash(height))
 
     return new Date(blockTime.toNumber())
   }
@@ -203,15 +227,43 @@ export default class Api {
     return this._api.query[module]
   }
 
-  protected async membershipById(memberId: MemberId): Promise<Membership | null> {
-    const profile = (await this._api.query.members.membershipById(memberId)) as Membership
+  protected async fetchMemberQueryNodeData(memberId: MemberId): Promise<MembershipFieldsFragment | null | undefined> {
+    return this.uniqueEntityQuery<GetMemberByIdQuery, GetMemberByIdQueryVariables>(
+      GetMemberById,
+      {
+        id: memberId.toString(),
+      },
+      'membershipByUniqueInput'
+    )
+  }
 
-    // Can't just use profile.isEmpty because profile.suspended is Bool (which isEmpty method always returns false)
-    return profile.handle.isEmpty ? null : profile
+  async memberDetails(memberId: MemberId, membership: Membership): Promise<MemberDetails> {
+    const memberData = await this.fetchMemberQueryNodeData(memberId)
+
+    return {
+      id: memberId,
+      name: memberData?.metadata.name,
+      handle: memberData?.handle,
+      membership,
+    }
+  }
+
+  protected async membershipById(memberId: MemberId): Promise<MemberDetails | null> {
+    const membership = await this._api.query.members.membershipById(memberId)
+    return membership.isEmpty ? null : await this.memberDetails(memberId, membership)
+  }
+
+  protected async expectedMembershipById(memberId: MemberId): Promise<MemberDetails> {
+    const member = await this.membershipById(memberId)
+    if (!member) {
+      throw new CLIError(`Expected member was not found by id: ${memberId.toString()}`)
+    }
+
+    return member
   }
 
   async groupLead(group: WorkingGroups): Promise<GroupMember | null> {
-    const optLeadId = (await this.workingGroupApiQuery(group).currentLead()) as Option<WorkerId>
+    const optLeadId = await this.workingGroupApiQuery(group).currentLead()
 
     if (!optLeadId.isSome) {
       return null
@@ -220,33 +272,22 @@ export default class Api {
     const leadWorkerId = optLeadId.unwrap()
     const leadWorker = await this.workerByWorkerId(group, leadWorkerId.toNumber())
 
-    return await this.parseGroupMember(leadWorkerId, leadWorker)
-  }
-
-  protected async stakeValue(stakeId: StakeId): Promise<Balance> {
-    const stake = await this._api.query.stake.stakes<Stake>(stakeId)
-    return stake.value
+    return await this.parseGroupMember(group, leadWorkerId, leadWorker)
   }
 
-  protected async workerStake(stakeProfile: RoleStakeProfile): Promise<Balance> {
-    return this.stakeValue(stakeProfile.stake_id)
-  }
-
-  protected async workerReward(relationshipId: RewardRelationshipId): Promise<Reward> {
-    const rewardRelationship = await this._api.query.recurringRewards.rewardRelationships<RewardRelationship>(
-      relationshipId
+  protected async fetchStake(account: AccountId | string, group: WorkingGroups): Promise<Balance> {
+    return this._api.createType(
+      'Balance',
+      new BN(
+        (await this._api.query.balances.locks(account)).find((lock) => lock.id.eq(lockIdByWorkingGroup[group]))
+          ?.amount || 0
+      )
     )
-
-    return {
-      totalRecieved: rewardRelationship.total_reward_received,
-      value: rewardRelationship.amount_per_payout,
-      interval: rewardRelationship.payout_interval.unwrapOr(undefined)?.toNumber(),
-      nextPaymentBlock: rewardRelationship.next_payment_at_block.unwrapOr(new BN(0)).toNumber(),
-    }
   }
 
-  protected async parseGroupMember(id: WorkerId, worker: Worker): Promise<GroupMember> {
+  protected async parseGroupMember(group: WorkingGroups, id: WorkerId, worker: Worker): Promise<GroupMember> {
     const roleAccount = worker.role_account_id
+    const stakingAccount = worker.staking_account_id
     const memberId = worker.member_id
 
     const profile = await this.membershipById(memberId)
@@ -255,19 +296,17 @@ export default class Api {
       throw new Error(`Group member profile not found! (member id: ${memberId.toNumber()})`)
     }
 
-    let stake: Balance | undefined
-    if (worker.role_stake_profile && worker.role_stake_profile.isSome) {
-      stake = await this.workerStake(worker.role_stake_profile.unwrap())
-    }
+    const stake = await this.fetchStake(worker.staking_account_id, group)
 
-    let reward: Reward | undefined
-    if (worker.reward_relationship && worker.reward_relationship.isSome) {
-      reward = await this.workerReward(worker.reward_relationship.unwrap())
+    const reward: Reward = {
+      valuePerBlock: worker.reward_per_block.unwrapOr(undefined),
+      totalMissed: worker.missed_reward.unwrapOr(undefined),
     }
 
     return {
       workerId: id,
       roleAccount,
+      stakingAccount,
       memberId,
       profile,
       stake,
@@ -294,14 +333,14 @@ export default class Api {
 
   async groupMember(group: WorkingGroups, workerId: number) {
     const worker = await this.workerByWorkerId(group, workerId)
-    return await this.parseGroupMember(this._api.createType('WorkerId', workerId), worker)
+    return await this.parseGroupMember(group, this._api.createType('WorkerId', workerId), worker)
   }
 
   async groupMembers(group: WorkingGroups): Promise<GroupMember[]> {
     const workerEntries = await this.groupWorkers(group)
 
     const groupMembers: GroupMember[] = await Promise.all(
-      workerEntries.map(([id, worker]) => this.parseGroupMember(id, worker))
+      workerEntries.map(([id, worker]) => this.parseGroupMember(group, id, worker))
     )
 
     return groupMembers.reverse() // Sort by newest
@@ -311,185 +350,101 @@ export default class Api {
     return this.entriesByIds<WorkerId, Worker>(this.workingGroupApiQuery(group).workerById)
   }
 
-  async openingsByGroup(group: WorkingGroups): Promise<GroupOpening[]> {
-    let openings: GroupOpening[] = []
-    const nextId = await this.workingGroupApiQuery(group).nextOpeningId<OpeningId>()
-
-    // This is chain specfic, but if next id is still 0, it means no openings have been added yet
-    if (!nextId.eq(0)) {
-      const ids = Array.from(Array(nextId.toNumber()).keys()).reverse() // Sort by newest
-      openings = await Promise.all(ids.map((id) => this.groupOpening(group, id)))
-    }
+  async openingsByGroup(group: WorkingGroups): Promise<OpeningDetails[]> {
+    const openings = await this.entriesByIds<OpeningId, Opening>(this.workingGroupApiQuery(group).openingById)
 
-    return openings
+    return Promise.all(openings.map(([id, opening]) => this.fetchOpeningDetails(group, opening, id.toNumber())))
   }
 
-  protected async hiringOpeningById(id: number | OpeningId): Promise<Opening> {
-    const result = await this._api.query.hiring.openingById<Opening>(id)
-    return result
-  }
-
-  protected async hiringApplicationById(id: number | ApplicationId): Promise<Application> {
-    const result = await this._api.query.hiring.applicationById<Application>(id)
-    return result
-  }
-
-  async wgApplicationById(group: WorkingGroups, wgApplicationId: number): Promise<WGApplication> {
+  async applicationById(group: WorkingGroups, applicationId: number): Promise<Application> {
     const nextAppId = await this.workingGroupApiQuery(group).nextApplicationId<ApplicationId>()
 
-    if (wgApplicationId < 0 || wgApplicationId >= nextAppId.toNumber()) {
+    if (applicationId < 0 || applicationId >= nextAppId.toNumber()) {
       throw new CLIError('Invalid working group application ID!')
     }
 
-    const result = await this.workingGroupApiQuery(group).applicationById<WGApplication>(wgApplicationId)
-    return result
-  }
+    const result = await this.workingGroupApiQuery(group).applicationById(applicationId)
 
-  protected async parseApplication(wgApplicationId: number, wgApplication: WGApplication): Promise<GroupApplication> {
-    const appId = wgApplication.application_id
-    const application = await this.hiringApplicationById(appId)
+    if (result.isEmpty) {
+      throw new CLIError(`Application of ID=${applicationId} no longer exists!`)
+    }
 
-    const { active_role_staking_id: roleStakingId, active_application_staking_id: appStakingId } = application
+    return result
+  }
 
+  protected async fetchApplicationDetails(
+    applicationId: number,
+    application: Application
+  ): Promise<ApplicationDetails> {
     return {
-      wgApplicationId,
-      applicationId: appId.toNumber(),
-      wgOpeningId: wgApplication.opening_id.toNumber(),
-      member: await this.membershipById(wgApplication.member_id),
-      roleAccout: wgApplication.role_account_id,
-      stakes: {
-        application: appStakingId.isSome ? (await this.stakeValue(appStakingId.unwrap())).toNumber() : 0,
-        role: roleStakingId.isSome ? (await this.stakeValue(roleStakingId.unwrap())).toNumber() : 0,
-      },
-      humanReadableText: application.human_readable_text.toString(),
-      stage: application.stage.type as ApplicationStageKeys,
+      applicationId,
+      member: await this.expectedMembershipById(application.member_id),
+      roleAccout: application.role_account_id,
+      rewardAccount: application.reward_account_id,
+      stakingAccount: application.staking_account_id,
+      descriptionHash: application.description_hash.toString(),
+      openingId: application.opening_id.toNumber(),
     }
   }
 
-  async groupApplication(group: WorkingGroups, wgApplicationId: number): Promise<GroupApplication> {
-    const wgApplication = await this.wgApplicationById(group, wgApplicationId)
-    return await this.parseApplication(wgApplicationId, wgApplication)
+  async groupApplication(group: WorkingGroups, applicationId: number): Promise<ApplicationDetails> {
+    const application = await this.applicationById(group, applicationId)
+    return await this.fetchApplicationDetails(applicationId, application)
   }
 
-  protected async groupOpeningApplications(group: WorkingGroups, wgOpeningId: number): Promise<GroupApplication[]> {
-    const wgApplicationEntries = await this.entriesByIds<ApplicationId, WGApplication>(
+  protected async groupOpeningApplications(group: WorkingGroups, openingId: number): Promise<ApplicationDetails[]> {
+    const applicationEntries = await this.entriesByIds<ApplicationId, Application>(
       this.workingGroupApiQuery(group).applicationById
     )
 
     return Promise.all(
-      wgApplicationEntries
-        .filter(([, /* id */ wgApplication]) => wgApplication.opening_id.eqn(wgOpeningId))
-        .map(([id, wgApplication]) => this.parseApplication(id.toNumber(), wgApplication))
+      applicationEntries
+        .filter(([, application]) => application.opening_id.eqn(openingId))
+        .map(([id, application]) => this.fetchApplicationDetails(id.toNumber(), application))
     )
   }
 
-  async groupOpening(group: WorkingGroups, wgOpeningId: number): Promise<GroupOpening> {
-    const nextId = ((await this.workingGroupApiQuery(group).nextOpeningId()) as OpeningId).toNumber()
+  async fetchOpening(group: WorkingGroups, openingId: number): Promise<Opening> {
+    const nextId = (await this.workingGroupApiQuery(group).nextOpeningId()).toNumber()
 
-    if (wgOpeningId < 0 || wgOpeningId >= nextId) {
+    if (openingId < 0 || openingId >= nextId) {
       throw new CLIError('Invalid working group opening ID!')
     }
 
-    const groupOpening = await this.workingGroupApiQuery(group).openingById<WGOpening>(wgOpeningId)
-
-    const openingId = groupOpening.hiring_opening_id.toNumber()
-    const opening = await this.hiringOpeningById(openingId)
-    const applications = await this.groupOpeningApplications(group, wgOpeningId)
-    const stage = await this.parseOpeningStage(opening.stage)
-    const type = groupOpening.opening_type
-    const { application_staking_policy: applSP, role_staking_policy: roleSP } = opening
-    const stakes = {
-      application: applSP.unwrapOr(undefined),
-      role: roleSP.unwrapOr(undefined),
-    }
+    const opening = await this.workingGroupApiQuery(group).openingById(openingId)
 
-    const unstakingPeriod = (period: Option<BlockNumber>) => period.unwrapOr(new BN(0)).toNumber()
-    const spUnstakingPeriod = (sp: Option<StakingPolicy>, key: StakingPolicyUnstakingPeriodKey) =>
-      sp.isSome ? unstakingPeriod(sp.unwrap()[key]) : 0
-
-    const unstakingPeriods: Partial<UnstakingPeriods> = {
-      'review_period_expired_application_stake_unstaking_period_length': spUnstakingPeriod(
-        applSP,
-        'review_period_expired_unstaking_period_length'
-      ),
-      'crowded_out_application_stake_unstaking_period_length': spUnstakingPeriod(
-        applSP,
-        'crowded_out_unstaking_period_length'
-      ),
-      'review_period_expired_role_stake_unstaking_period_length': spUnstakingPeriod(
-        roleSP,
-        'review_period_expired_unstaking_period_length'
-      ),
-      'crowded_out_role_stake_unstaking_period_length': spUnstakingPeriod(
-        roleSP,
-        'crowded_out_unstaking_period_length'
-      ),
+    if (opening.isEmpty) {
+      throw new CLIError(`Opening of ID=${openingId} no longer exists!`)
     }
 
-    openingPolicyUnstakingPeriodsKeys.forEach((key) => {
-      unstakingPeriods[key] = unstakingPeriod(groupOpening.policy_commitment[key])
-    })
-
-    return {
-      wgOpeningId,
-      openingId,
-      opening,
-      stage,
-      stakes,
-      applications,
-      type,
-      unstakingPeriods: unstakingPeriods as UnstakingPeriods,
-    }
+    return opening
   }
 
-  async parseOpeningStage(stage: OpeningStage): Promise<GroupOpeningStage> {
-    let status: OpeningStatus | undefined, stageBlock: number | undefined, stageDate: Date | undefined
-
-    if (stage.isOfType('WaitingToBegin')) {
-      const stageData = stage.asType('WaitingToBegin')
-      const currentBlockNumber = (await this._api.derive.chain.bestNumber()).toNumber()
-      const expectedBlockTime = (this._api.consts.babe.expectedBlockTime as Moment).toNumber()
-      status = OpeningStatus.WaitingToBegin
-      stageBlock = stageData.begins_at_block.toNumber()
-      stageDate = new Date(Date.now() + (stageBlock - currentBlockNumber) * expectedBlockTime)
-    }
-
-    if (stage.isOfType('Active')) {
-      const stageData = stage.asType('Active')
-      const substage = stageData.stage
-      if (substage.isOfType('AcceptingApplications')) {
-        status = OpeningStatus.AcceptingApplications
-        stageBlock = substage.asType('AcceptingApplications').started_accepting_applicants_at_block.toNumber()
-      }
-      if (substage.isOfType('ReviewPeriod')) {
-        status = OpeningStatus.InReview
-        stageBlock = substage.asType('ReviewPeriod').started_review_period_at_block.toNumber()
-      }
-      if (substage.isOfType('Deactivated')) {
-        status = substage.asType('Deactivated').cause.isOfType('Filled')
-          ? OpeningStatus.Complete
-          : OpeningStatus.Cancelled
-        stageBlock = substage.asType('Deactivated').deactivated_at_block.toNumber()
-      }
-      if (stageBlock) {
-        stageDate = new Date(await this.blockTimestamp(stageBlock))
-      }
+  async fetchOpeningDetails(group: WorkingGroups, opening: Opening, openingId: number): Promise<OpeningDetails> {
+    const applications = await this.groupOpeningApplications(group, openingId)
+    const type = opening.opening_type
+    const stake = {
+      unstakingPeriod: opening.stake_policy.leaving_unstaking_period.toNumber(),
+      value: opening.stake_policy.stake_amount,
     }
 
     return {
-      status: status || OpeningStatus.Unknown,
-      block: stageBlock,
-      date: stageDate,
+      openingId,
+      applications,
+      type,
+      stake,
+      createdAtBlock: opening.created.toNumber(),
+      rewardPerBlock: opening.reward_per_block.unwrapOr(undefined),
     }
   }
 
-  async getMemberIdsByControllerAccount(address: string): Promise<MemberId[]> {
-    const ids = await this._api.query.members.memberIdsByControllerAccountId<Vec<MemberId>>(address)
-    return ids.toArray()
+  async groupOpening(group: WorkingGroups, openingId: number): Promise<OpeningDetails> {
+    const opening = await this.fetchOpening(group, openingId)
+    return this.fetchOpeningDetails(group, opening, openingId)
   }
 
-  async workerExitRationaleConstraint(group: WorkingGroups): Promise<InputValidationLengthConstraint> {
-    return await this.workingGroupApiQuery(group).workerExitRationaleText<InputValidationLengthConstraint>()
+  async allMembers(): Promise<[MemberId, Membership][]> {
+    return this.entriesByIds<MemberId, Membership>(this._api.query.members.membershipById)
   }
 
   // Content directory
@@ -505,15 +460,15 @@ export default class Api {
 
   async curatorGroupById(id: number): Promise<CuratorGroup | null> {
     const exists = !!(await this._api.query.contentDirectory.curatorGroupById.size(id)).toNumber()
-    return exists ? await this._api.query.contentDirectory.curatorGroupById<CuratorGroup>(id) : null
+    return exists ? await this._api.query.contentDirectory.curatorGroupById(id) : null
   }
 
   async nextCuratorGroupId(): Promise<number> {
-    return (await this._api.query.contentDirectory.nextCuratorGroupId<CuratorGroupId>()).toNumber()
+    return (await this._api.query.contentDirectory.nextCuratorGroupId()).toNumber()
   }
 
   async classById(id: number): Promise<Class | null> {
-    const c = await this._api.query.contentDirectory.classById<Class>(id)
+    const c = await this._api.query.contentDirectory.classById(id)
     return c.isEmpty ? null : c
   }
 
@@ -524,25 +479,23 @@ export default class Api {
 
   async entityById(id: number): Promise<Entity | null> {
     const exists = !!(await this._api.query.contentDirectory.entityById.size(id)).toNumber()
-    return exists ? await this._api.query.contentDirectory.entityById<Entity>(id) : null
+    return exists ? await this._api.query.contentDirectory.entityById(id) : null
   }
 
   async dataObjectByContentId(contentId: ContentId): Promise<DataObject | null> {
-    const dataObject = await this._api.query.dataDirectory.dataObjectByContentId<Option<DataObject>>(contentId)
+    const dataObject = await this._api.query.dataDirectory.dataObjectByContentId(contentId)
     return dataObject.unwrapOr(null)
   }
 
   async ipnsIdentity(storageProviderId: number): Promise<string | null> {
-    const accountInfo = await this._api.query.discovery.accountInfoByStorageProviderId<ServiceProviderRecord>(
-      storageProviderId
-    )
+    const accountInfo = await this._api.query.discovery.accountInfoByStorageProviderId(storageProviderId)
     return accountInfo.isEmpty || accountInfo.expires_at.toNumber() <= (await this.bestNumber())
       ? null
       : accountInfo.identity.toString()
   }
 
   async getRandomBootstrapEndpoint(): Promise<string | null> {
-    const endpoints = await this._api.query.discovery.bootstrapEndpoints<Vec<Url>>()
+    const endpoints = await this._api.query.discovery.bootstrapEndpoints()
     const randomEndpoint = _.sample(endpoints.toArray())
     return randomEndpoint ? randomEndpoint.toString() : null
   }
@@ -555,4 +508,9 @@ export default class Api {
     const bestNumber = await this.bestNumber()
     return !!accounInfoEntries.filter(([, info]) => info.expires_at.toNumber() > bestNumber).length
   }
+
+  async stakingAccountStatus(account: string): Promise<StakingAccountMemberBinding | null> {
+    const status = await this.getOriginalApi().query.members.stakingAccountIdMemberStatus(account)
+    return status.isEmpty ? null : status
+  }
 }

cli/src/QueryNodeApiSchema.generated.ts

@@ -0,0 +1,636 @@
+export type Maybe<T> = T | null
+export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] }
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> }
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> }
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+  ID: string
+  String: string
+  Boolean: boolean
+  Int: number
+  Float: number
+  /** The javascript `Date` as string. Type represents date and time as the ISO Date string. */
+  DateTime: any
+  /** GraphQL representation of BigInt */
+  BigInt: any
+}
+
+export type BaseGraphQlObject = {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+}
+
+export type BaseModel = BaseGraphQlObject & {
+  __typename?: 'BaseModel'
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+}
+
+export type BaseModelUuid = BaseGraphQlObject & {
+  __typename?: 'BaseModelUUID'
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+}
+
+export type BaseWhereInput = {
+  id_eq?: Maybe<Scalars['String']>
+  id_in?: Maybe<Array<Scalars['String']>>
+  createdAt_eq?: Maybe<Scalars['String']>
+  createdAt_lt?: Maybe<Scalars['String']>
+  createdAt_lte?: Maybe<Scalars['String']>
+  createdAt_gt?: Maybe<Scalars['String']>
+  createdAt_gte?: Maybe<Scalars['String']>
+  createdById_eq?: Maybe<Scalars['String']>
+  updatedAt_eq?: Maybe<Scalars['String']>
+  updatedAt_lt?: Maybe<Scalars['String']>
+  updatedAt_lte?: Maybe<Scalars['String']>
+  updatedAt_gt?: Maybe<Scalars['String']>
+  updatedAt_gte?: Maybe<Scalars['String']>
+  updatedById_eq?: Maybe<Scalars['String']>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['String']>
+  deletedAt_lt?: Maybe<Scalars['String']>
+  deletedAt_lte?: Maybe<Scalars['String']>
+  deletedAt_gt?: Maybe<Scalars['String']>
+  deletedAt_gte?: Maybe<Scalars['String']>
+  deletedById_eq?: Maybe<Scalars['String']>
+}
+
+export type Block = BaseGraphQlObject & {
+  __typename?: 'Block'
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  block: Scalars['Int']
+  executedAt: Scalars['DateTime']
+  network: Network
+  membershipregisteredAtBlock?: Maybe<Array<Membership>>
+}
+
+export type BlockConnection = {
+  __typename?: 'BlockConnection'
+  totalCount: Scalars['Int']
+  edges: Array<BlockEdge>
+  pageInfo: PageInfo
+}
+
+export type BlockCreateInput = {
+  block: Scalars['Float']
+  executedAt: Scalars['DateTime']
+  network: Network
+}
+
+export type BlockEdge = {
+  __typename?: 'BlockEdge'
+  node: Block
+  cursor: Scalars['String']
+}
+
+export enum BlockOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  BlockAsc = 'block_ASC',
+  BlockDesc = 'block_DESC',
+  ExecutedAtAsc = 'executedAt_ASC',
+  ExecutedAtDesc = 'executedAt_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+}
+
+export type BlockUpdateInput = {
+  block?: Maybe<Scalars['Float']>
+  executedAt?: Maybe<Scalars['DateTime']>
+  network?: Maybe<Network>
+}
+
+export type BlockWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  block_eq?: Maybe<Scalars['Int']>
+  block_gt?: Maybe<Scalars['Int']>
+  block_gte?: Maybe<Scalars['Int']>
+  block_lt?: Maybe<Scalars['Int']>
+  block_lte?: Maybe<Scalars['Int']>
+  block_in?: Maybe<Array<Scalars['Int']>>
+  executedAt_eq?: Maybe<Scalars['DateTime']>
+  executedAt_lt?: Maybe<Scalars['DateTime']>
+  executedAt_lte?: Maybe<Scalars['DateTime']>
+  executedAt_gt?: Maybe<Scalars['DateTime']>
+  executedAt_gte?: Maybe<Scalars['DateTime']>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+}
+
+export type BlockWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type DeleteResponse = {
+  id: Scalars['ID']
+}
+
+export type MembersByHandleFtsOutput = {
+  __typename?: 'MembersByHandleFTSOutput'
+  item: MembersByHandleSearchResult
+  rank: Scalars['Float']
+  isTypeOf: Scalars['String']
+  highlight: Scalars['String']
+}
+
+export type MembersByHandleSearchResult = Membership
+
+/** Stored information about a registered user */
+export type Membership = BaseGraphQlObject & {
+  __typename?: 'Membership'
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** The unique handle chosen by member */
+  handle: Scalars['String']
+  /** Member's name */
+  name?: Maybe<Scalars['String']>
+  /** A Url to member's Avatar image */
+  avatarUri?: Maybe<Scalars['String']>
+  /** Short text chosen by member to share information about themselves */
+  about?: Maybe<Scalars['String']>
+  /** Member's controller account id */
+  controllerAccount: Scalars['String']
+  /** Member's root account id */
+  rootAccount: Scalars['String']
+  registeredAtBlock: Block
+  registeredAtBlockId: Scalars['String']
+  /** Timestamp when member was registered */
+  registeredAtTime: Scalars['DateTime']
+  /** How the member was registered */
+  entry: MembershipEntryMethod
+  /** Whether member has been verified by membership working group. */
+  isVerified: Scalars['Boolean']
+  /** Staking accounts bounded to membership. */
+  boundAccounts: Array<Scalars['String']>
+  /** Current count of invites left to send. */
+  inviteCount: Scalars['Int']
+  invitees: Array<Membership>
+  invitedBy?: Maybe<Membership>
+  invitedById?: Maybe<Scalars['String']>
+  referredMembers: Array<Membership>
+  referredBy?: Maybe<Membership>
+  referredById?: Maybe<Scalars['String']>
+}
+
+export type MembershipConnection = {
+  __typename?: 'MembershipConnection'
+  totalCount: Scalars['Int']
+  edges: Array<MembershipEdge>
+  pageInfo: PageInfo
+}
+
+export type MembershipCreateInput = {
+  handle: Scalars['String']
+  name?: Maybe<Scalars['String']>
+  avatarUri?: Maybe<Scalars['String']>
+  about?: Maybe<Scalars['String']>
+  controllerAccount: Scalars['String']
+  rootAccount: Scalars['String']
+  registeredAtBlockId: Scalars['ID']
+  registeredAtTime: Scalars['DateTime']
+  entry: MembershipEntryMethod
+  isVerified: Scalars['Boolean']
+  boundAccounts: Array<Scalars['String']>
+  inviteCount: Scalars['Float']
+  invitedById?: Maybe<Scalars['ID']>
+  referredById?: Maybe<Scalars['ID']>
+}
+
+export type MembershipEdge = {
+  __typename?: 'MembershipEdge'
+  node: Membership
+  cursor: Scalars['String']
+}
+
+export enum MembershipEntryMethod {
+  Paid = 'PAID',
+  Invited = 'INVITED',
+  Genesis = 'GENESIS',
+}
+
+export enum MembershipOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  HandleAsc = 'handle_ASC',
+  HandleDesc = 'handle_DESC',
+  NameAsc = 'name_ASC',
+  NameDesc = 'name_DESC',
+  AvatarUriAsc = 'avatarUri_ASC',
+  AvatarUriDesc = 'avatarUri_DESC',
+  AboutAsc = 'about_ASC',
+  AboutDesc = 'about_DESC',
+  ControllerAccountAsc = 'controllerAccount_ASC',
+  ControllerAccountDesc = 'controllerAccount_DESC',
+  RootAccountAsc = 'rootAccount_ASC',
+  RootAccountDesc = 'rootAccount_DESC',
+  RegisteredAtBlockIdAsc = 'registeredAtBlockId_ASC',
+  RegisteredAtBlockIdDesc = 'registeredAtBlockId_DESC',
+  RegisteredAtTimeAsc = 'registeredAtTime_ASC',
+  RegisteredAtTimeDesc = 'registeredAtTime_DESC',
+  EntryAsc = 'entry_ASC',
+  EntryDesc = 'entry_DESC',
+  IsVerifiedAsc = 'isVerified_ASC',
+  IsVerifiedDesc = 'isVerified_DESC',
+  InviteCountAsc = 'inviteCount_ASC',
+  InviteCountDesc = 'inviteCount_DESC',
+  InvitedByIdAsc = 'invitedById_ASC',
+  InvitedByIdDesc = 'invitedById_DESC',
+  ReferredByIdAsc = 'referredById_ASC',
+  ReferredByIdDesc = 'referredById_DESC',
+}
+
+export type MembershipSystem = BaseGraphQlObject & {
+  __typename?: 'MembershipSystem'
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Initial invitation count of a new member. */
+  defaultInviteCount: Scalars['Int']
+  /** Current price to buy a membership. */
+  membershipPrice: Scalars['BigInt']
+  /** Amount of tokens diverted to invitor. */
+  referralCut: Scalars['BigInt']
+  /** The initial, locked, balance credited to controller account of invitee. */
+  invitedInitialBalance: Scalars['BigInt']
+}
+
+export type MembershipSystemConnection = {
+  __typename?: 'MembershipSystemConnection'
+  totalCount: Scalars['Int']
+  edges: Array<MembershipSystemEdge>
+  pageInfo: PageInfo
+}
+
+export type MembershipSystemCreateInput = {
+  defaultInviteCount: Scalars['Float']
+  membershipPrice: Scalars['BigInt']
+  referralCut: Scalars['BigInt']
+  invitedInitialBalance: Scalars['BigInt']
+}
+
+export type MembershipSystemEdge = {
+  __typename?: 'MembershipSystemEdge'
+  node: MembershipSystem
+  cursor: Scalars['String']
+}
+
+export enum MembershipSystemOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  DefaultInviteCountAsc = 'defaultInviteCount_ASC',
+  DefaultInviteCountDesc = 'defaultInviteCount_DESC',
+  MembershipPriceAsc = 'membershipPrice_ASC',
+  MembershipPriceDesc = 'membershipPrice_DESC',
+  ReferralCutAsc = 'referralCut_ASC',
+  ReferralCutDesc = 'referralCut_DESC',
+  InvitedInitialBalanceAsc = 'invitedInitialBalance_ASC',
+  InvitedInitialBalanceDesc = 'invitedInitialBalance_DESC',
+}
+
+export type MembershipSystemUpdateInput = {
+  defaultInviteCount?: Maybe<Scalars['Float']>
+  membershipPrice?: Maybe<Scalars['BigInt']>
+  referralCut?: Maybe<Scalars['BigInt']>
+  invitedInitialBalance?: Maybe<Scalars['BigInt']>
+}
+
+export type MembershipSystemWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  defaultInviteCount_eq?: Maybe<Scalars['Int']>
+  defaultInviteCount_gt?: Maybe<Scalars['Int']>
+  defaultInviteCount_gte?: Maybe<Scalars['Int']>
+  defaultInviteCount_lt?: Maybe<Scalars['Int']>
+  defaultInviteCount_lte?: Maybe<Scalars['Int']>
+  defaultInviteCount_in?: Maybe<Array<Scalars['Int']>>
+  membershipPrice_eq?: Maybe<Scalars['BigInt']>
+  membershipPrice_gt?: Maybe<Scalars['BigInt']>
+  membershipPrice_gte?: Maybe<Scalars['BigInt']>
+  membershipPrice_lt?: Maybe<Scalars['BigInt']>
+  membershipPrice_lte?: Maybe<Scalars['BigInt']>
+  membershipPrice_in?: Maybe<Array<Scalars['BigInt']>>
+  referralCut_eq?: Maybe<Scalars['BigInt']>
+  referralCut_gt?: Maybe<Scalars['BigInt']>
+  referralCut_gte?: Maybe<Scalars['BigInt']>
+  referralCut_lt?: Maybe<Scalars['BigInt']>
+  referralCut_lte?: Maybe<Scalars['BigInt']>
+  referralCut_in?: Maybe<Array<Scalars['BigInt']>>
+  invitedInitialBalance_eq?: Maybe<Scalars['BigInt']>
+  invitedInitialBalance_gt?: Maybe<Scalars['BigInt']>
+  invitedInitialBalance_gte?: Maybe<Scalars['BigInt']>
+  invitedInitialBalance_lt?: Maybe<Scalars['BigInt']>
+  invitedInitialBalance_lte?: Maybe<Scalars['BigInt']>
+  invitedInitialBalance_in?: Maybe<Array<Scalars['BigInt']>>
+}
+
+export type MembershipSystemWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type MembershipUpdateInput = {
+  handle?: Maybe<Scalars['String']>
+  name?: Maybe<Scalars['String']>
+  avatarUri?: Maybe<Scalars['String']>
+  about?: Maybe<Scalars['String']>
+  controllerAccount?: Maybe<Scalars['String']>
+  rootAccount?: Maybe<Scalars['String']>
+  registeredAtBlockId?: Maybe<Scalars['ID']>
+  registeredAtTime?: Maybe<Scalars['DateTime']>
+  entry?: Maybe<MembershipEntryMethod>
+  isVerified?: Maybe<Scalars['Boolean']>
+  boundAccounts?: Maybe<Array<Scalars['String']>>
+  inviteCount?: Maybe<Scalars['Float']>
+  invitedById?: Maybe<Scalars['ID']>
+  referredById?: Maybe<Scalars['ID']>
+}
+
+export type MembershipWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  handle_eq?: Maybe<Scalars['String']>
+  handle_contains?: Maybe<Scalars['String']>
+  handle_startsWith?: Maybe<Scalars['String']>
+  handle_endsWith?: Maybe<Scalars['String']>
+  handle_in?: Maybe<Array<Scalars['String']>>
+  name_eq?: Maybe<Scalars['String']>
+  name_contains?: Maybe<Scalars['String']>
+  name_startsWith?: Maybe<Scalars['String']>
+  name_endsWith?: Maybe<Scalars['String']>
+  name_in?: Maybe<Array<Scalars['String']>>
+  avatarUri_eq?: Maybe<Scalars['String']>
+  avatarUri_contains?: Maybe<Scalars['String']>
+  avatarUri_startsWith?: Maybe<Scalars['String']>
+  avatarUri_endsWith?: Maybe<Scalars['String']>
+  avatarUri_in?: Maybe<Array<Scalars['String']>>
+  about_eq?: Maybe<Scalars['String']>
+  about_contains?: Maybe<Scalars['String']>
+  about_startsWith?: Maybe<Scalars['String']>
+  about_endsWith?: Maybe<Scalars['String']>
+  about_in?: Maybe<Array<Scalars['String']>>
+  controllerAccount_eq?: Maybe<Scalars['String']>
+  controllerAccount_contains?: Maybe<Scalars['String']>
+  controllerAccount_startsWith?: Maybe<Scalars['String']>
+  controllerAccount_endsWith?: Maybe<Scalars['String']>
+  controllerAccount_in?: Maybe<Array<Scalars['String']>>
+  rootAccount_eq?: Maybe<Scalars['String']>
+  rootAccount_contains?: Maybe<Scalars['String']>
+  rootAccount_startsWith?: Maybe<Scalars['String']>
+  rootAccount_endsWith?: Maybe<Scalars['String']>
+  rootAccount_in?: Maybe<Array<Scalars['String']>>
+  registeredAtBlockId_eq?: Maybe<Scalars['ID']>
+  registeredAtBlockId_in?: Maybe<Array<Scalars['ID']>>
+  registeredAtTime_eq?: Maybe<Scalars['DateTime']>
+  registeredAtTime_lt?: Maybe<Scalars['DateTime']>
+  registeredAtTime_lte?: Maybe<Scalars['DateTime']>
+  registeredAtTime_gt?: Maybe<Scalars['DateTime']>
+  registeredAtTime_gte?: Maybe<Scalars['DateTime']>
+  entry_eq?: Maybe<MembershipEntryMethod>
+  entry_in?: Maybe<Array<MembershipEntryMethod>>
+  isVerified_eq?: Maybe<Scalars['Boolean']>
+  isVerified_in?: Maybe<Array<Scalars['Boolean']>>
+  inviteCount_eq?: Maybe<Scalars['Int']>
+  inviteCount_gt?: Maybe<Scalars['Int']>
+  inviteCount_gte?: Maybe<Scalars['Int']>
+  inviteCount_lt?: Maybe<Scalars['Int']>
+  inviteCount_lte?: Maybe<Scalars['Int']>
+  inviteCount_in?: Maybe<Array<Scalars['Int']>>
+  invitedById_eq?: Maybe<Scalars['ID']>
+  invitedById_in?: Maybe<Array<Scalars['ID']>>
+  referredById_eq?: Maybe<Scalars['ID']>
+  referredById_in?: Maybe<Array<Scalars['ID']>>
+}
+
+export type MembershipWhereUniqueInput = {
+  id?: Maybe<Scalars['ID']>
+  handle?: Maybe<Scalars['String']>
+}
+
+export enum Network {
+  Babylon = 'BABYLON',
+  Alexandria = 'ALEXANDRIA',
+  Rome = 'ROME',
+  Olympia = 'OLYMPIA',
+}
+
+export type PageInfo = {
+  __typename?: 'PageInfo'
+  hasNextPage: Scalars['Boolean']
+  hasPreviousPage: Scalars['Boolean']
+  startCursor?: Maybe<Scalars['String']>
+  endCursor?: Maybe<Scalars['String']>
+}
+
+export type ProcessorState = {
+  __typename?: 'ProcessorState'
+  lastCompleteBlock: Scalars['Float']
+  lastProcessedEvent: Scalars['String']
+  indexerHead: Scalars['Float']
+  chainHead: Scalars['Float']
+}
+
+export type Query = {
+  __typename?: 'Query'
+  blocks: Array<Block>
+  block?: Maybe<Block>
+  blocksConnection: BlockConnection
+  membershipSystems: Array<MembershipSystem>
+  membershipSystem?: Maybe<MembershipSystem>
+  membershipSystemsConnection: MembershipSystemConnection
+  memberships: Array<Membership>
+  membership?: Maybe<Membership>
+  membershipsConnection: MembershipConnection
+  membersByHandle: Array<MembersByHandleFtsOutput>
+}
+
+export type QueryBlocksArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<BlockWhereInput>
+  orderBy?: Maybe<BlockOrderByInput>
+}
+
+export type QueryBlockArgs = {
+  where: BlockWhereUniqueInput
+}
+
+export type QueryBlocksConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<BlockWhereInput>
+  orderBy?: Maybe<BlockOrderByInput>
+}
+
+export type QueryMembershipSystemsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<MembershipSystemWhereInput>
+  orderBy?: Maybe<MembershipSystemOrderByInput>
+}
+
+export type QueryMembershipSystemArgs = {
+  where: MembershipSystemWhereUniqueInput
+}
+
+export type QueryMembershipSystemsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<MembershipSystemWhereInput>
+  orderBy?: Maybe<MembershipSystemOrderByInput>
+}
+
+export type QueryMembershipsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<MembershipWhereInput>
+  orderBy?: Maybe<MembershipOrderByInput>
+}
+
+export type QueryMembershipArgs = {
+  where: MembershipWhereUniqueInput
+}
+
+export type QueryMembershipsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<MembershipWhereInput>
+  orderBy?: Maybe<MembershipOrderByInput>
+}
+
+export type QueryMembersByHandleArgs = {
+  whereMembership?: Maybe<MembershipWhereInput>
+  skip?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  text: Scalars['String']
+}
+
+export type StandardDeleteResponse = {
+  __typename?: 'StandardDeleteResponse'
+  id: Scalars['ID']
+}
+
+export type Subscription = {
+  __typename?: 'Subscription'
+  stateSubscription: ProcessorState
+}

cli/src/Types.ts

@@ -1,14 +1,13 @@
-import BN from 'bn.js'
-import { ElectionStage, Seat } from '@joystream/types/council'
-import { Option } from '@polkadot/types'
 import { Codec } from '@polkadot/types/types'
-import { BlockNumber, Balance, AccountId } from '@polkadot/types/interfaces'
+import { Balance, AccountId } from '@polkadot/types/interfaces'
 import { DeriveBalancesAll } from '@polkadot/api-derive/types'
 import { KeyringPair } from '@polkadot/keyring/types'
 import { WorkerId, OpeningType } from '@joystream/types/working-group'
-import { Membership, MemberId } from '@joystream/types/members'
-import { Opening, StakingPolicy, ApplicationStageKeys } from '@joystream/types/hiring'
+import { Membership } from '@joystream/types/members'
+import { MemberId } from '@joystream/types/common'
 import { Validator } from 'inquirer'
+import { ApiPromise } from '@polkadot/api'
+import { SubmittableModuleExtrinsics, QueryableModuleStorage, QueryableModuleConsts } from '@polkadot/api/types'
 
 // KeyringPair type extended with mandatory "meta.name"
 // It's used for accounts/keys management within CLI.
@@ -24,44 +23,6 @@ export type AccountSummary = {
   balances: DeriveBalancesAll
 }
 
-// This function allows us to easily transform the tuple into the object
-// and simplifies the creation of consitent Object and Tuple types (seen below).
-export function createCouncilInfoObj(
-  activeCouncil: Seat[],
-  termEndsAt: BlockNumber,
-  autoStart: boolean,
-  newTermDuration: BN,
-  candidacyLimit: BN,
-  councilSize: BN,
-  minCouncilStake: Balance,
-  minVotingStake: Balance,
-  announcingPeriod: BlockNumber,
-  votingPeriod: BlockNumber,
-  revealingPeriod: BlockNumber,
-  round: BN,
-  stage: Option<ElectionStage>
-) {
-  return {
-    activeCouncil,
-    termEndsAt,
-    autoStart,
-    newTermDuration,
-    candidacyLimit,
-    councilSize,
-    minCouncilStake,
-    minVotingStake,
-    announcingPeriod,
-    votingPeriod,
-    revealingPeriod,
-    round,
-    stage,
-  }
-}
-// Object/Tuple containing council/councilElection information (council:info).
-// The tuple is useful, because that's how api.queryMulti returns the results.
-export type CouncilInfoTuple = Parameters<typeof createCouncilInfoObj>
-export type CouncilInfoObj = ReturnType<typeof createCouncilInfoObj>
-
 // Object with "name" and "value" properties, used for rendering simple CLI tables like:
 // Total balance:   100 JOY
 // Free calance:     50 JOY
@@ -71,19 +32,21 @@ export type NameValueObj = { name: string; value: string }
 export enum WorkingGroups {
   StorageProviders = 'storageProviders',
   Curators = 'curators',
+  Forum = 'forum',
+  Membership = 'membership',
 }
 
 // In contrast to Pioneer, currently only StorageProviders group is available in CLI
 export const AvailableGroups: readonly WorkingGroups[] = [
   WorkingGroups.StorageProviders,
   WorkingGroups.Curators,
+  WorkingGroups.Forum,
+  WorkingGroups.Membership,
 ] as const
 
 export type Reward = {
-  totalRecieved: Balance
-  value: Balance
-  interval?: number
-  nextPaymentBlock: number // 0 = no incoming payment
+  totalMissed?: Balance
+  valuePerBlock?: Balance
 }
 
 // Compound working group types
@@ -91,83 +54,40 @@ export type GroupMember = {
   workerId: WorkerId
   memberId: MemberId
   roleAccount: AccountId
-  profile: Membership
-  stake?: Balance
-  reward?: Reward
+  stakingAccount: AccountId
+  profile: MemberDetails
+  stake: Balance
+  reward: Reward
 }
 
-export type GroupApplication = {
-  wgApplicationId: number
+export type ApplicationDetails = {
   applicationId: number
-  wgOpeningId: number
-  member: Membership | null
+  member: MemberDetails
   roleAccout: AccountId
-  stakes: {
-    application: number
-    role: number
-  }
-  humanReadableText: string
-  stage: ApplicationStageKeys
-}
-
-export enum OpeningStatus {
-  WaitingToBegin = 'WaitingToBegin',
-  AcceptingApplications = 'AcceptingApplications',
-  InReview = 'InReview',
-  Complete = 'Complete',
-  Cancelled = 'Cancelled',
-  Unknown = 'Unknown',
-}
-
-export type GroupOpeningStage = {
-  status: OpeningStatus
-  block?: number
-  date?: Date
-}
-
-export type GroupOpeningStakes = {
-  application?: StakingPolicy
-  role?: StakingPolicy
-}
-
-export const stakingPolicyUnstakingPeriodKeys = [
-  'crowded_out_unstaking_period_length',
-  'review_period_expired_unstaking_period_length',
-] as const
-
-export type StakingPolicyUnstakingPeriodKey = typeof stakingPolicyUnstakingPeriodKeys[number]
-
-export const openingPolicyUnstakingPeriodsKeys = [
-  'fill_opening_failed_applicant_application_stake_unstaking_period',
-  'fill_opening_failed_applicant_role_stake_unstaking_period',
-  'fill_opening_successful_applicant_application_stake_unstaking_period',
-  'terminate_application_stake_unstaking_period',
-  'terminate_role_stake_unstaking_period',
-  'exit_role_application_stake_unstaking_period',
-  'exit_role_stake_unstaking_period',
-] as const
-
-export type OpeningPolicyUnstakingPeriodsKey = typeof openingPolicyUnstakingPeriodsKeys[number]
-export type UnstakingPeriodsKey =
-  | OpeningPolicyUnstakingPeriodsKey
-  | 'crowded_out_application_stake_unstaking_period_length'
-  | 'crowded_out_role_stake_unstaking_period_length'
-  | 'review_period_expired_application_stake_unstaking_period_length'
-  | 'review_period_expired_role_stake_unstaking_period_length'
-
-export type UnstakingPeriods = {
-  [k in UnstakingPeriodsKey]: number
+  stakingAccount: AccountId
+  rewardAccount: AccountId
+  descriptionHash: string
+  openingId: number
 }
 
-export type GroupOpening = {
-  wgOpeningId: number
+export type OpeningDetails = {
   openingId: number
-  stage: GroupOpeningStage
-  opening: Opening
-  stakes: GroupOpeningStakes
-  applications: GroupApplication[]
+  stake: {
+    value: Balance
+    unstakingPeriod: number
+  }
+  applications: ApplicationDetails[]
   type: OpeningType
-  unstakingPeriods: UnstakingPeriods
+  createdAtBlock: number
+  rewardPerBlock?: Balance
+}
+
+// Extended membership information (including optional query node data)
+export type MemberDetails = {
+  id: MemberId
+  name?: string | null
+  handle?: string
+  membership: Membership
 }
 
 // Api-related
@@ -193,3 +113,10 @@ export type ApiMethodNamedArg = {
   value: ApiMethodArg
 }
 export type ApiMethodNamedArgs = ApiMethodNamedArg[]
+
+// Api without TypeScript augmentations for "query", "tx" and "consts" (useful when more type flexibility is needed)
+export type UnaugmentedApiPromise = Omit<ApiPromise, 'query' | 'tx' | 'consts'> & {
+  query: { [key: string]: QueryableModuleStorage<'promise'> }
+  tx: { [key: string]: SubmittableModuleExtrinsics<'promise'> }
+  consts: { [key: string]: QueryableModuleConsts }
+}

cli/src/base/AccountsCommandBase.ts

@@ -1,18 +1,31 @@
 import fs from 'fs'
 import path from 'path'
-import slug from 'slug'
 import inquirer from 'inquirer'
 import ExitCodes from '../ExitCodes'
 import { CLIError } from '@oclif/errors'
 import ApiCommandBase from './ApiCommandBase'
 import { Keyring } from '@polkadot/api'
 import { formatBalance } from '@polkadot/util'
-import { NamedKeyringPair } from '../Types'
+import { MemberDetails, NamedKeyringPair } from '../Types'
 import { DeriveBalancesAll } from '@polkadot/api-derive/types'
-import { toFixedLength } from '../helpers/display'
+import { memberHandle, toFixedLength } from '../helpers/display'
+import { AccountId, MemberId } from '@joystream/types/common'
+import { KeyringPair, KeyringInstance, KeyringOptions } from '@polkadot/keyring/types'
+import { KeypairType } from '@polkadot/util-crypto/types'
+import createDevelopmentKeyring from '@polkadot/keyring/testing'
+import chalk from 'chalk'
+import { mnemonicGenerate } from '@polkadot/util-crypto'
+import { validateAddress } from '../helpers/validation'
+import slug from 'slug'
+import { Membership } from '@joystream/types/members'
+import BN from 'bn.js'
 
 const ACCOUNTS_DIRNAME = 'accounts'
-const SPECIAL_ACCOUNT_POSTFIX = '__DEV'
+export const DEFAULT_ACCOUNT_TYPE = 'sr25519'
+export const KEYRING_OPTIONS: KeyringOptions = {
+  type: DEFAULT_ACCOUNT_TYPE,
+}
+export const STAKING_ACCOUNT_CANDIDATE_STAKE = new BN(200)
 
 /**
  * Abstract base class for account-related commands.
@@ -22,16 +35,37 @@ const SPECIAL_ACCOUNT_POSTFIX = '__DEV'
  * Where: APP_DATA_PATH is provided by StateAwareCommandBase and ACCOUNTS_DIRNAME is a const (see above).
  */
 export default abstract class AccountsCommandBase extends ApiCommandBase {
+  private keyring: KeyringInstance | undefined
+
+  getKeyring(): KeyringInstance {
+    if (!this.keyring) {
+      this.error('Trying to access Keyring before AccountsCommandBase initialization', {
+        exit: ExitCodes.UnexpectedException,
+      })
+    }
+    return this.keyring
+  }
+
+  isKeyAvailable(key: AccountId | string): boolean {
+    return this.getKeyring()
+      .getPairs()
+      .some((p) => p.address === key.toString())
+  }
+
   getAccountsDirPath(): string {
     return path.join(this.getAppDataPath(), ACCOUNTS_DIRNAME)
   }
 
-  getAccountFilePath(account: NamedKeyringPair, isSpecial = false): string {
-    return path.join(this.getAccountsDirPath(), this.generateAccountFilename(account, isSpecial))
+  getAccountFileName(accountName: string): string {
+    return `${slug(accountName)}.json`
+  }
+
+  getAccountFilePath(accountName: string): string {
+    return path.join(this.getAccountsDirPath(), this.getAccountFileName(accountName))
   }
 
-  generateAccountFilename(account: NamedKeyringPair, isSpecial = false): string {
-    return `${slug(account.meta.name, '_')}__${account.address}${isSpecial ? SPECIAL_ACCOUNT_POSTFIX : ''}.json`
+  isAccountNameTaken(accountName: string): boolean {
+    return this.getPairs().some((p) => this.getAccountFileName(p.meta.name) === this.getAccountFileName(accountName))
   }
 
   private initAccountsFs(): void {
@@ -40,23 +74,59 @@ export default abstract class AccountsCommandBase extends ApiCommandBase {
     }
   }
 
-  saveAccount(account: NamedKeyringPair, password: string, isSpecial = false): void {
-    try {
-      const destPath = this.getAccountFilePath(account, isSpecial)
-      fs.writeFileSync(destPath, JSON.stringify(account.toJson(password)))
-    } catch (e) {
-      throw this.createDataWriteError()
+  async createAccount(
+    name?: string,
+    masterKey?: KeyringPair,
+    password?: string,
+    type?: KeypairType
+  ): Promise<NamedKeyringPair> {
+    while (!name || this.isAccountNameTaken(name)) {
+      if (name) {
+        this.warn(`Account ${chalk.white(name)} already exists... Try different name`)
+      }
+      name = await this.simplePrompt({ message: 'New account name' })
     }
-  }
 
-  // Add dev "Alice" and "Bob" accounts
-  initSpecialAccounts() {
-    const keyring = new Keyring({ type: 'sr25519' })
-    keyring.addFromUri('//Alice', { name: 'Alice' })
-    keyring.addFromUri('//Bob', { name: 'Bob' })
-    keyring
-      .getPairs()
-      .forEach((pair) => this.saveAccount({ ...pair, meta: { name: pair.meta.name as string } }, '', true))
+    if (!masterKey) {
+      const keyring = new Keyring(KEYRING_OPTIONS)
+      const mnemonic = mnemonicGenerate()
+      keyring.addFromMnemonic(mnemonic, { name, whenCreated: Date.now() }, type)
+      masterKey = keyring.getPairs()[0]
+      this.log(chalk.white(`${chalk.bold('New account memonic: ')}${mnemonic}`))
+    } else {
+      const existingAcc = this.getPairs().find((p) => p.address === masterKey!.address)
+      if (existingAcc) {
+        this.error(`Account with this key already exists (${chalk.white(existingAcc.meta.name)})`, {
+          exit: ExitCodes.InvalidInput,
+        })
+      }
+      await this.requestPairDecoding(masterKey, 'Current account password')
+      if (!masterKey.meta.name) {
+        masterKey.meta.name = name
+      }
+    }
+
+    while (password === undefined) {
+      password = await this.promptForPassword("Set new account's password")
+      const password2 = await this.promptForPassword("Confirm new account's password")
+
+      if (password !== password2) {
+        this.warn('Passwords are not the same!')
+        password = undefined
+      }
+    }
+    if (!password) {
+      this.warn('Using empty password is not recommended!')
+    }
+
+    const destPath = this.getAccountFilePath(name)
+    fs.writeFileSync(destPath, JSON.stringify(masterKey.toJson(password)))
+
+    this.getKeyring().addPair(masterKey)
+
+    this.log(chalk.greenBright(`\nNew account succesfully created!`))
+
+    return masterKey as NamedKeyringPair
   }
 
   fetchAccountFromJsonFile(jsonBackupFilePath: string): NamedKeyringPair {
@@ -76,18 +146,20 @@ export default abstract class AccountsCommandBase extends ApiCommandBase {
       throw new CLIError('Provided backup file is not valid', { exit: ExitCodes.InvalidFile })
     }
 
-    // Force some default account name if none is provided in the original backup
     if (!accountJsonObj.meta) accountJsonObj.meta = {}
-    if (!accountJsonObj.meta.name) accountJsonObj.meta.name = 'Unnamed Account'
+    // Normalize the CLI account name based on file name
+    // (makes sure getFilePath(name) will always point to the correct file, preserving backward-compatibility
+    // with older CLI versions)
+    accountJsonObj.meta.name = path.basename(jsonBackupFilePath, '.json')
 
-    const keyring = new Keyring()
+    const keyring = new Keyring(KEYRING_OPTIONS)
     let account: NamedKeyringPair
     try {
       // Try adding and retrieving the keys in order to validate that the backup file is correct
       keyring.addFromJson(accountJsonObj)
       account = keyring.getPair(accountJsonObj.address) as NamedKeyringPair // We can be sure it's named, because we forced it before
     } catch (e) {
-      throw new CLIError('Provided backup file is not valid', { exit: ExitCodes.InvalidFile })
+      throw new CLIError(`Provided backup file is not valid (${e.message})`, { exit: ExitCodes.InvalidFile })
     }
 
     return account
@@ -103,7 +175,7 @@ export default abstract class AccountsCommandBase extends ApiCommandBase {
     }
   }
 
-  fetchAccounts(includeSpecial = false): NamedKeyringPair[] {
+  fetchAccounts(): NamedKeyringPair[] {
     let files: string[] = []
     const accountDir = this.getAccountsDirPath()
     try {
@@ -116,151 +188,276 @@ export default abstract class AccountsCommandBase extends ApiCommandBase {
     return files
       .map((fileName) => {
         const filePath = path.join(accountDir, fileName)
-        if (!includeSpecial && filePath.includes(SPECIAL_ACCOUNT_POSTFIX + '.')) return null
         return this.fetchAccountOrNullFromFile(filePath)
       })
-      .filter((accObj) => accObj !== null) as NamedKeyringPair[]
+      .filter((account) => account !== null) as NamedKeyringPair[]
   }
 
-  getSelectedAccountFilename(): string {
-    return this.getPreservedState().selectedAccountFilename
+  getPairs(includeDevAccounts = true): NamedKeyringPair[] {
+    return this.getKeyring()
+      .getPairs()
+      .filter((p) => includeDevAccounts || !p.meta.isTesting) as NamedKeyringPair[]
   }
 
-  getSelectedAccount(): NamedKeyringPair | null {
-    const selectedAccountFilename = this.getSelectedAccountFilename()
-
-    if (!selectedAccountFilename) {
-      return null
-    }
+  getPair(key: string): NamedKeyringPair {
+    return this.getKeyring().getPair(key) as NamedKeyringPair
+  }
 
-    const account = this.fetchAccountOrNullFromFile(path.join(this.getAccountsDirPath(), selectedAccountFilename))
+  async getDecodedPair(key: string): Promise<NamedKeyringPair> {
+    const pair = this.getPair(key)
 
-    return account
+    return (await this.requestPairDecoding(pair)) as NamedKeyringPair
   }
 
-  // Use when account usage is required in given command
-  async getRequiredSelectedAccount(promptIfMissing = true): Promise<NamedKeyringPair> {
-    let selectedAccount: NamedKeyringPair | null = this.getSelectedAccount()
-    if (!selectedAccount) {
-      if (!promptIfMissing) {
-        this.error('No default account selected! Use account:choose to set the default account.', {
-          exit: ExitCodes.NoAccountSelected,
-        })
-      }
+  async requestPairDecoding(pair: KeyringPair, message?: string): Promise<KeyringPair> {
+    // Skip if pair already unlocked
+    if (!pair.isLocked) {
+      return pair
+    }
 
-      const accounts: NamedKeyringPair[] = this.fetchAccounts()
-      if (!accounts.length) {
-        this.error('No accounts available! Use account:import in order to import accounts into the CLI.', {
-          exit: ExitCodes.NoAccountFound,
-        })
-      }
+    // First - try decoding using empty string
+    try {
+      pair.decodePkcs8('')
+      return pair
+    } catch (e) {
+      // Continue...
+    }
 
-      this.warn('No default account selected!')
-      selectedAccount = await this.promptForAccount(accounts)
-      await this.setSelectedAccount(selectedAccount)
+    let isPassValid = false
+    while (!isPassValid) {
+      try {
+        const password = await this.promptForPassword(
+          message || `Enter ${pair.meta.name ? pair.meta.name : pair.address} account password`
+        )
+        pair.decodePkcs8(password)
+        isPassValid = true
+      } catch (e) {
+        this.warn('Invalid password... Try again.')
+      }
     }
 
-    return selectedAccount
+    return pair
   }
 
-  async setSelectedAccount(account: NamedKeyringPair): Promise<void> {
-    const accountFilename = fs.existsSync(this.getAccountFilePath(account, true))
-      ? this.generateAccountFilename(account, true)
-      : this.generateAccountFilename(account)
-
-    await this.setPreservedState({ selectedAccountFilename: accountFilename })
+  initKeyring(): void {
+    this.keyring = this.getApi().isDevelopment
+      ? createDevelopmentKeyring(KEYRING_OPTIONS)
+      : new Keyring(KEYRING_OPTIONS)
+    const accounts = this.fetchAccounts()
+    accounts.forEach((a) => this.getKeyring().addPair(a))
   }
 
-  async promptForPassword(message = "Your account's password") {
-    const { password } = await inquirer.prompt([{ name: 'password', type: 'password', message }])
+  async promptForPassword(message = "Your account's password"): Promise<string> {
+    const { password } = await inquirer.prompt([
+      {
+        name: 'password',
+        type: 'password',
+        message,
+      },
+    ])
 
     return password
   }
 
-  async requireConfirmation(
-    message = 'Are you sure you want to execute this action?',
-    defaultVal = false
-  ): Promise<void> {
-    const { confirmed } = await inquirer.prompt([{ type: 'confirm', name: 'confirmed', message, default: defaultVal }])
-    if (!confirmed) this.exit(ExitCodes.OK)
-  }
-
   async promptForAccount(
-    accounts: NamedKeyringPair[],
-    defaultAccount: NamedKeyringPair | null = null,
     message = 'Select an account',
+    createIfUnavailable = true,
+    includeDevAccounts = true,
     showBalances = true
-  ): Promise<NamedKeyringPair> {
-    let balances: DeriveBalancesAll[]
+  ): Promise<string> {
+    const pairs = this.getPairs(includeDevAccounts)
+
+    if (!pairs.length) {
+      this.warn('No accounts available!')
+      if (createIfUnavailable) {
+        await this.requireConfirmation('Do you want to create a new account?', true)
+        pairs.push(await this.createAccount())
+      } else {
+        this.exit()
+      }
+    }
+
+    let balances: DeriveBalancesAll[] = []
     if (showBalances) {
-      balances = await this.getApi().getAccountsBalancesInfo(accounts.map((acc) => acc.address))
+      balances = await this.getApi().getAccountsBalancesInfo(pairs.map((p) => p.address))
     }
-    const longestAccNameLength: number = accounts.reduce((prev, curr) => Math.max(curr.meta.name.length, prev), 0)
-    const accNameColLength: number = Math.min(longestAccNameLength + 1, 20)
-    const { chosenAccountFilename } = await inquirer.prompt([
-      {
-        name: 'chosenAccountFilename',
-        message,
-        type: 'list',
-        choices: accounts.map((account: NamedKeyringPair, i) => ({
-          name:
-            `${toFixedLength(account.meta.name, accNameColLength)} | ` +
-            `${account.address} | ` +
-            ((showBalances || '') &&
-              `${formatBalance(balances[i].availableBalance)} / ` + `${formatBalance(balances[i].votingBalance)}`),
-          value: this.generateAccountFilename(account),
-          short: `${account.meta.name} (${account.address})`,
-        })),
-        default: defaultAccount && this.generateAccountFilename(defaultAccount),
-      },
-    ])
 
-    return accounts.find((acc) => this.generateAccountFilename(acc) === chosenAccountFilename) as NamedKeyringPair
+    const longestNameLen: number = pairs.reduce((prev, curr) => Math.max(curr.meta.name.length, prev), 0)
+    const nameColLength: number = Math.min(longestNameLen + 1, 20)
+    const chosenKey = await this.simplePrompt({
+      message,
+      type: 'list',
+      choices: pairs.map((p, i) => ({
+        name:
+          `${toFixedLength(p.meta.name, nameColLength)} | ` +
+          `${p.address} | ` +
+          ((showBalances || '') &&
+            `${formatBalance(balances[i].availableBalance)} / ` + `${formatBalance(balances[i].votingBalance)}`),
+        value: p.address,
+      })),
+    })
+
+    return chosenKey
   }
 
-  async requestAccountDecoding(account: NamedKeyringPair): Promise<void> {
-    // Skip if account already unlocked
-    if (!account.isLocked) {
-      return
-    }
+  promptForCustomAddress(): Promise<string> {
+    return this.simplePrompt({
+      message: 'Provide custom address',
+      validate: (a) => validateAddress(a),
+    })
+  }
 
-    // First - try decoding using empty string
-    try {
-      account.decodePkcs8('')
-      return
-    } catch (e) {
-      // Continue...
+  async promptForAnyAddress(message = 'Select an address'): Promise<string> {
+    const type: 'available' | 'new' | 'custom' = await this.simplePrompt({
+      message,
+      type: 'list',
+      choices: [
+        { name: 'Available account', value: 'available' },
+        { name: 'New account', value: 'new' },
+        { name: 'Custom address', value: 'custom' },
+      ],
+    })
+
+    if (type === 'available') {
+      return this.promptForAccount()
+    } else if (type === 'new') {
+      return (await this.createAccount()).address
+    } else {
+      return this.promptForCustomAddress()
     }
+  }
 
-    let isPassValid = false
-    while (!isPassValid) {
-      try {
-        const password = await this.promptForPassword()
-        account.decodePkcs8(password)
-        isPassValid = true
-      } catch (e) {
-        this.warn('Invalid password... Try again.')
-      }
+  async getRequiredMemberContext(): Promise<MemberDetails> {
+    // TODO: Limit only to a set of members provided by the user?
+    const allMembers = await this.getApi().allMembers()
+    const availableMembers = await Promise.all(
+      allMembers
+        .filter(([, m]) => this.isKeyAvailable(m.controller_account.toString()))
+        .map(([id, m]) => this.getApi().memberDetails(id, m))
+    )
+
+    if (!availableMembers.length) {
+      this.error('No member controller key available!', { exit: ExitCodes.AccessDenied })
+    } else if (availableMembers.length === 1) {
+      return availableMembers[0]
+    } else {
+      return this.promptForMember(availableMembers, 'Choose member context')
     }
   }
 
-  async getRequiredMemberId(): Promise<number> {
-    const account = await this.getRequiredSelectedAccount()
-    const memberIds = await this.getApi().getMemberIdsByControllerAccount(account.address)
-    if (!memberIds.length) {
-      this.error('Membership required to access this command!', { exit: ExitCodes.AccessDenied })
+  async promptForMember(availableMembers: MemberDetails[], message = 'Choose a member'): Promise<MemberDetails> {
+    const memberIndex = await this.simplePrompt({
+      type: 'list',
+      message,
+      choices: availableMembers.map((m, i) => ({
+        name: memberHandle(m),
+        value: i,
+      })),
+    })
+
+    return availableMembers[memberIndex]
+  }
+
+  async promptForStakingAccount(stakeValue: BN, memberId: MemberId, member: Membership): Promise<string> {
+    this.log(`Required stake: ${formatBalance(stakeValue)}`)
+    let stakingAccount: string
+    while (true) {
+      stakingAccount = await this.promptForAnyAddress('Choose staking account')
+      const { balances } = await this.getApi().getAccountSummary(stakingAccount)
+      const stakingStatus = await this.getApi().stakingAccountStatus(stakingAccount)
+
+      if (balances.lockedBalance.gtn(0)) {
+        this.warn('This account is already used for other staking purposes, choose different account...')
+        continue
+      }
+
+      if (stakingStatus && !stakingStatus.member_id.eq(memberId)) {
+        this.warn('This account is already used as staking accout by other member, choose different account...')
+        continue
+      }
+
+      let additionalStakingAccountCosts = new BN(0)
+      if (!stakingStatus || (stakingStatus && stakingStatus.confirmed.isFalse)) {
+        if (!this.isKeyAvailable(stakingAccount)) {
+          this.warn(
+            'Account is not a confirmed staking account and cannot be directly accessed via CLI, choose different account...'
+          )
+          continue
+        }
+        this.warn(
+          `This account is not a confirmed staking account. ` +
+            `Additional funds (fees) may be required to set it as a staking account.`
+        )
+        if (!stakingStatus) {
+          additionalStakingAccountCosts = await this.getApi().estimateFee(
+            await this.getDecodedPair(stakingAccount),
+            this.getOriginalApi().tx.members.addStakingAccountCandidate(memberId)
+          )
+          additionalStakingAccountCosts = additionalStakingAccountCosts.add(STAKING_ACCOUNT_CANDIDATE_STAKE)
+        }
+      }
+
+      const requiredStakingAccountBalance = stakeValue.add(additionalStakingAccountCosts)
+      const missingStakingAccountBalance = requiredStakingAccountBalance.sub(balances.availableBalance)
+      if (missingStakingAccountBalance.gtn(0)) {
+        this.warn(
+          `Not enough available staking account balance! Missing: ${chalk.cyan(
+            formatBalance(missingStakingAccountBalance)
+          )}.` +
+            (additionalStakingAccountCosts.gtn(0)
+              ? ` (includes ${formatBalance(
+                  additionalStakingAccountCosts
+                )} which is a required fee and candidate stake for adding a new staking account)`
+              : '')
+        )
+        const transferTokens = await this.simplePrompt({
+          type: 'confirm',
+          message: `Do you want to transfer ${chalk.cyan(
+            formatBalance(missingStakingAccountBalance)
+          )} from another account?`,
+        })
+        if (transferTokens) {
+          const key = await this.promptForAccount('Choose source account')
+          await this.sendAndFollowNamedTx(await this.getDecodedPair(key), 'balances', 'transferKeepAlive', [
+            stakingAccount,
+            missingStakingAccountBalance,
+          ])
+        } else {
+          continue
+        }
+      }
+
+      if (!stakingStatus) {
+        await this.sendAndFollowNamedTx(
+          await this.getDecodedPair(stakingAccount),
+          'members',
+          'addStakingAccountCandidate',
+          [memberId]
+        )
+      }
+
+      if (!stakingStatus || stakingStatus.confirmed.isFalse) {
+        await this.sendAndFollowNamedTx(
+          await this.getDecodedPair(member.controller_account.toString()),
+          'members',
+          'confirmStakingAccount',
+          [memberId, stakingAccount]
+        )
+      }
+
+      break
     }
 
-    return memberIds[0].toNumber() // FIXME: Temporary solution (just using the first one)
+    return stakingAccount
   }
 
   async init() {
     await super.init()
     try {
       this.initAccountsFs()
-      this.initSpecialAccounts()
     } catch (e) {
       throw this.createDataDirInitError()
     }
+    await this.initKeyring()
   }
 }

cli/src/base/ApiCommandBase.ts

@@ -2,20 +2,22 @@ import ExitCodes from '../ExitCodes'
 import { CLIError } from '@oclif/errors'
 import StateAwareCommandBase from './StateAwareCommandBase'
 import Api from '../Api'
-import { getTypeDef, Option, Tuple, TypeRegistry } from '@polkadot/types'
-import { Registry, Codec, CodecArg, TypeDef, TypeDefInfo } from '@polkadot/types/types'
-
+import { getTypeDef, Option, Tuple } from '@polkadot/types'
+import { Registry, Codec, TypeDef, TypeDefInfo } from '@polkadot/types/types'
 import { Vec, Struct, Enum } from '@polkadot/types/codec'
-import { ApiPromise, WsProvider } from '@polkadot/api'
+import { WsProvider } from '@polkadot/api'
 import { KeyringPair } from '@polkadot/keyring/types'
 import chalk from 'chalk'
 import { InterfaceTypes } from '@polkadot/types/types/registry'
 import { ApiMethodArg, ApiMethodNamedArgs, ApiParamsOptions, ApiParamOptions } from '../Types'
 import { createParamOptions } from '../helpers/promptOptions'
-import { SubmittableExtrinsic } from '@polkadot/api/types'
+import { AugmentedSubmittables, SubmittableExtrinsic } from '@polkadot/api/types'
 import { DistinctQuestion } from 'inquirer'
 import { BOOL_PROMPT_OPTIONS } from '../helpers/prompting'
 import { DispatchError } from '@polkadot/types/interfaces/system'
+import { formatBalance } from '@polkadot/util'
+import BN from 'bn.js'
+import _ from 'lodash'
 
 export class ExtrinsicFailedError extends Error {}
 
@@ -24,18 +26,21 @@ export class ExtrinsicFailedError extends Error {}
  */
 export default abstract class ApiCommandBase extends StateAwareCommandBase {
   private api: Api | null = null
-  forceSkipApiUriPrompt = false
 
   getApi(): Api {
     if (!this.api) throw new CLIError('Tried to get API before initialization.', { exit: ExitCodes.ApiError })
     return this.api
   }
 
-  // Get original api for lower-level api calls
-  getOriginalApi(): ApiPromise {
+  // Shortcuts
+  getOriginalApi() {
     return this.getApi().getOriginalApi()
   }
 
+  getUnaugmentedApi() {
+    return this.getApi().getUnaugmentedApi()
+  }
+
   getTypesRegistry(): Registry {
     return this.getOriginalApi().registry
   }
@@ -47,13 +52,20 @@ export default abstract class ApiCommandBase extends StateAwareCommandBase {
   async init() {
     await super.init()
     let apiUri: string = this.getPreservedState().apiUri
+
     if (!apiUri) {
-      this.warn("You haven't provided a node/endpoint for the CLI to connect to yet!")
+      this.warn("You haven't provided a Joystream node websocket api uri for the CLI to connect to yet!")
       apiUri = await this.promptForApiUri()
     }
 
+    let queryNodeUri: string = this.getPreservedState().queryNodeUri
+    if (!queryNodeUri) {
+      this.warn("You haven't provided a Joystream query node uri for the CLI to connect to yet!")
+      queryNodeUri = await this.promptForQueryNodeUri()
+    }
+
     const { metadataCache } = this.getPreservedState()
-    this.api = await Api.create(apiUri, metadataCache)
+    this.api = await Api.create(apiUri, metadataCache, queryNodeUri === 'none' ? undefined : queryNodeUri)
 
     const { genesisHash, runtimeVersion } = this.getOriginalApi()
     const metadataKey = `${genesisHash}-${runtimeVersion.specVersion}`
@@ -67,7 +79,7 @@ export default abstract class ApiCommandBase extends StateAwareCommandBase {
   async promptForApiUri(): Promise<string> {
     let selectedNodeUri = await this.simplePrompt({
       type: 'list',
-      message: 'Choose a node/endpoint:',
+      message: 'Choose a node websocket api uri:',
       choices: [
         {
           name: 'Local node (ws://localhost:9944)',
@@ -101,6 +113,47 @@ export default abstract class ApiCommandBase extends StateAwareCommandBase {
     return selectedNodeUri
   }
 
+  async promptForQueryNodeUri(): Promise<string> {
+    let selectedUri = await this.simplePrompt({
+      type: 'list',
+      message: 'Choose a query node endpoint:',
+      choices: [
+        {
+          name: 'Local query node (http://localhost:8081/graphql)',
+          value: 'http://localhost:8081/graphql',
+        },
+        {
+          name: 'Jsgenesis-hosted query node (https://hydra.joystream.org/graphql)',
+          value: 'https://hydra.joystream.org/graphql',
+        },
+        {
+          name: 'Custom endpoint',
+          value: '',
+        },
+        {
+          name: "No endpoint (if you don't use query node some features will not be available)",
+          value: 'none',
+        },
+      ],
+    })
+
+    if (!selectedUri) {
+      do {
+        selectedUri = await this.simplePrompt({
+          type: 'input',
+          message: 'Provide a query node endpoint',
+        })
+        if (!this.isApiUriValid(selectedUri)) {
+          this.warn('Provided uri seems incorrect! Please try again...')
+        }
+      } while (!this.isApiUriValid(selectedUri))
+    }
+
+    await this.setPreservedState({ queryNodeUri: selectedUri })
+
+    return selectedUri
+  }
+
   isApiUriValid(uri: string) {
     try {
       // eslint-disable-next-line no-new
@@ -111,6 +164,17 @@ export default abstract class ApiCommandBase extends StateAwareCommandBase {
     return true
   }
 
+  isQueryNodeUriValid(uri: string) {
+    let url: URL
+    try {
+      url = new URL(uri)
+    } catch (_) {
+      return false
+    }
+
+    return url.protocol === 'http:' || url.protocol === 'https:'
+  }
+
   // This is needed to correctly handle some structs, enums etc.
   // Where the main typeDef doesn't provide enough information
   protected getRawTypeDef(type: keyof InterfaceTypes) {
@@ -332,7 +396,7 @@ export default abstract class ApiCommandBase extends StateAwareCommandBase {
     method: string,
     paramsOptions?: ApiParamsOptions
   ): Promise<ApiMethodArg[]> {
-    const extrinsicMethod = this.getOriginalApi().tx[module][method]
+    const extrinsicMethod = (await this.getUnaugmentedApi().tx)[module][method]
     const values: ApiMethodArg[] = []
 
     this.openIndentGroup()
@@ -350,7 +414,7 @@ export default abstract class ApiCommandBase extends StateAwareCommandBase {
     return values
   }
 
-  sendExtrinsic(account: KeyringPair, tx: SubmittableExtrinsic<'promise'>) {
+  sendExtrinsic(account: KeyringPair, tx: SubmittableExtrinsic<'promise'>): Promise<void> {
     return new Promise((resolve, reject) => {
       let unsubscribe: () => void
       tx.signAndSend(account, {}, (result) => {
@@ -369,11 +433,7 @@ export default abstract class ApiCommandBase extends StateAwareCommandBase {
                 let errorMsg = dispatchError.toString()
                 if (dispatchError.isModule) {
                   try {
-                    // Need to assert that registry is of TypeRegistry type, since Registry intefrace
-                    // seems outdated and doesn't include DispatchErrorModule as possible argument for "findMetaError"
-                    const { name, documentation } = (this.getOriginalApi().registry as TypeRegistry).findMetaError(
-                      dispatchError.asModule
-                    )
+                    const { name, documentation } = this.getOriginalApi().registry.findMetaError(dispatchError.asModule)
                     errorMsg = `${name} (${documentation})`
                   } catch (e) {
                     // This probably means we don't have this error in the metadata
@@ -401,6 +461,13 @@ export default abstract class ApiCommandBase extends StateAwareCommandBase {
     tx: SubmittableExtrinsic<'promise'>,
     warnOnly = false // If specified - only warning will be displayed in case of failure (instead of error beeing thrown)
   ): Promise<boolean> {
+    // Calculate fee and ask for confirmation
+    const fee = await this.getApi().estimateFee(account, tx)
+
+    await this.requireConfirmation(
+      `Tx fee of ${chalk.cyan(formatBalance(fee))} will be deduced from you account, do you confirm the transfer?`
+    )
+
     try {
       await this.sendExtrinsic(account, tx)
       this.log(chalk.green(`Extrinsic successful!`))
@@ -417,27 +484,55 @@ export default abstract class ApiCommandBase extends StateAwareCommandBase {
     }
   }
 
-  async sendAndFollowNamedTx(
+  private humanize(p: unknown): any {
+    if (Array.isArray(p)) {
+      return p.map((v) => this.humanize(v))
+    } else if (typeof p === 'object' && p !== null) {
+      if ((p as any).toHuman) {
+        return (p as Codec).toHuman()
+      } else if (p instanceof BN) {
+        return p.toString()
+      } else {
+        return _.mapValues(p, this.humanize.bind(this))
+      }
+    }
+
+    return p
+  }
+
+  async sendAndFollowNamedTx<
+    Module extends keyof AugmentedSubmittables<'promise'>,
+    Method extends keyof AugmentedSubmittables<'promise'>[Module] & string,
+    Submittable extends AugmentedSubmittables<'promise'>[Module][Method]
+  >(
     account: KeyringPair,
-    module: string,
-    method: string,
-    params: CodecArg[],
+    module: Module,
+    method: Method,
+    params: Submittable extends (...args: any[]) => any ? Parameters<Submittable> : [],
     warnOnly = false
   ): Promise<boolean> {
-    this.log(chalk.white(`\nSending ${module}.${method} extrinsic...`))
-    const tx = await this.getOriginalApi().tx[module][method](...params)
+    this.log(
+      chalk.white(
+        `\nSending ${module}.${method} extrinsic from ${account.meta.name ? account.meta.name : account.address}...`
+      )
+    )
+    console.log('Params:', this.humanize(params))
+    const tx = await this.getUnaugmentedApi().tx[module][method](...params)
     return await this.sendAndFollowTx(account, tx, warnOnly)
   }
 
-  async buildAndSendExtrinsic(
+  async buildAndSendExtrinsic<
+    Module extends keyof AugmentedSubmittables<'promise'>,
+    Method extends keyof AugmentedSubmittables<'promise'>[Module] & string
+  >(
     account: KeyringPair,
-    module: string,
-    method: string,
+    module: Module,
+    method: Method,
     paramsOptions?: ApiParamsOptions,
     warnOnly = false // If specified - only warning will be displayed (instead of error beeing thrown)
   ): Promise<ApiMethodArg[]> {
     const params = await this.promptForExtrinsicParams(module, method, paramsOptions)
-    await this.sendAndFollowNamedTx(account, module, method, params, warnOnly)
+    await this.sendAndFollowNamedTx(account, module, method, params as any, warnOnly)
 
     return params
   }
@@ -445,7 +540,7 @@ export default abstract class ApiCommandBase extends StateAwareCommandBase {
   extrinsicArgsFromDraft(module: string, method: string, draftFilePath: string): ApiMethodNamedArgs {
     let draftJSONObj
     const parsedArgs: ApiMethodNamedArgs = []
-    const extrinsicMethod = this.getOriginalApi().tx[module][method]
+    const extrinsicMethod = this.getUnaugmentedApi().tx[module][method]
     try {
       // eslint-disable-next-line @typescript-eslint/no-var-requires
       draftJSONObj = require(draftFilePath)

cli/src/base/ContentDirectoryCommandBase.ts

@@ -25,6 +25,7 @@ import { createType } from '@joystream/types'
 import chalk from 'chalk'
 import { flags } from '@oclif/command'
 import { DistinctQuestion } from 'inquirer'
+import { memberHandle } from '../helpers/display'
 
 const CONTEXTS = ['Member', 'Curator', 'Lead'] as const
 type Context = typeof CONTEXTS[number]
@@ -54,11 +55,11 @@ export default abstract class ContentDirectoryCommandBase extends RolesCommandBa
 
   // Use when lead access is required in given command
   async requireLead(): Promise<void> {
-    await this.getRequiredLead()
+    await this.getRequiredLeadContext()
   }
 
   async getCuratorContext(classNames: string[] = []): Promise<Actor> {
-    const curator = await this.getRequiredWorker()
+    const curator = await this.getRequiredWorkerContext()
     const classes = await Promise.all(classNames.map(async (cName) => (await this.classEntryByNameOrId(cName))[1]))
     const classMaintainers = classes.map(({ class_permissions: permissions }) => permissions.maintainers.toArray())
 
@@ -157,7 +158,7 @@ export default abstract class ContentDirectoryCommandBase extends RolesCommandBa
     const choices = curators
       .filter((c) => (ids ? ids.includes(c.workerId.toNumber()) : true))
       .map((c) => ({
-        name: `${c.profile.handle.toString()} (Worker ID: ${c.workerId})`,
+        name: `${memberHandle(c.profile)} (Worker ID: ${c.workerId})`,
         value: c.workerId.toNumber(),
       }))
 
@@ -382,12 +383,12 @@ export default abstract class ContentDirectoryCommandBase extends RolesCommandBa
   async getActor(context: typeof CONTEXTS[number], pickedClass: Class) {
     let actor: Actor
     if (context === 'Member') {
-      const memberId = await this.getRequiredMemberId()
-      actor = this.createType('Actor', { Member: memberId })
+      const { id } = await this.getRequiredMemberContext()
+      actor = this.createType('Actor', { Member: id })
     } else if (context === 'Curator') {
       actor = await this.getCuratorContext([pickedClass.name.toString()])
     } else {
-      await this.getRequiredLead()
+      await this.getRequiredLeadContext()
 
       actor = this.createType('Actor', { Lead: null })
     }

cli/src/base/DefaultCommandBase.ts

@@ -38,6 +38,14 @@ export default abstract class DefaultCommandBase extends Command {
     return result
   }
 
+  async requireConfirmation(
+    message = 'Are you sure you want to execute this action?',
+    defaultVal = false
+  ): Promise<void> {
+    const { confirmed } = await inquirer.prompt([{ type: 'confirm', name: 'confirmed', message, default: defaultVal }])
+    if (!confirmed) this.exit(ExitCodes.OK)
+  }
+
   private jsonPrettyIndented(line: string) {
     return `${this.jsonPrettyIdent}${line}`
   }

cli/src/base/StateAwareCommandBase.ts

@@ -10,16 +10,16 @@ import { WorkingGroups } from '../Types'
 
 // Type for the state object (which is preserved as json in the state file)
 type StateObject = {
-  selectedAccountFilename: string
   apiUri: string
+  queryNodeUri: string
   defaultWorkingGroup: WorkingGroups
   metadataCache: Record<string, any>
 }
 
 // State object default values
 const DEFAULT_STATE: StateObject = {
-  selectedAccountFilename: '',
   apiUri: '',
+  queryNodeUri: '',
   defaultWorkingGroup: WorkingGroups.StorageProviders,
   metadataCache: {},
 }
@@ -91,7 +91,7 @@ export default abstract class StateAwareCommandBase extends DefaultCommandBase {
       fs.mkdirSync(this.getAppDataPath())
     }
     if (!fs.existsSync(this.getStateFilePath())) {
-      fs.writeFileSync(this.getStateFilePath(), JSON.stringify(DEFAULT_STATE))
+      fs.writeFileSync(this.getStateFilePath(), JSON.stringify(DEFAULT_STATE, null, 4))
     }
   }
 
@@ -117,7 +117,7 @@ export default abstract class StateAwareCommandBase extends DefaultCommandBase {
     const oldState: StateObject = this.getPreservedState()
     const newState: StateObject = { ...oldState, ...modifiedState }
     try {
-      fs.writeFileSync(stateFilePath, JSON.stringify(newState))
+      fs.writeFileSync(stateFilePath, JSON.stringify(newState, null, 4))
     } catch (e) {
       await unlock()
       throw this.createDataWriteError()

cli/src/base/WorkingGroupsCommandBase.ts

@@ -1,19 +1,11 @@
 import ExitCodes from '../ExitCodes'
 import AccountsCommandBase from './AccountsCommandBase'
 import { flags } from '@oclif/command'
-import {
-  WorkingGroups,
-  AvailableGroups,
-  NamedKeyringPair,
-  GroupMember,
-  GroupOpening,
-  OpeningStatus,
-  GroupApplication,
-} from '../Types'
+import { WorkingGroups, AvailableGroups, GroupMember, OpeningDetails, ApplicationDetails } from '../Types'
 import _ from 'lodash'
-import { ApplicationStageKeys } from '@joystream/types/hiring'
 import chalk from 'chalk'
 import { IConfig } from '@oclif/config'
+import { memberHandle } from '../helpers/display'
 
 /**
  * Abstract base class for commands that need to use gates based on user's roles
@@ -28,11 +20,10 @@ export abstract class RolesCommandBase extends AccountsCommandBase {
   }
 
   // Use when lead access is required in given command
-  async getRequiredLead(): Promise<GroupMember> {
-    const selectedAccount: NamedKeyringPair = await this.getRequiredSelectedAccount()
+  async getRequiredLeadContext(): Promise<GroupMember> {
     const lead = await this.getApi().groupLead(this.group)
 
-    if (!lead || lead.roleAccount.toString() !== selectedAccount.address) {
+    if (!lead || !this.isKeyAvailable(lead.roleAccount)) {
       this.error(`${_.startCase(this.group)} Group Lead access required for this command!`, {
         exit: ExitCodes.AccessDenied,
       })
@@ -42,38 +33,22 @@ export abstract class RolesCommandBase extends AccountsCommandBase {
   }
 
   // Use when worker access is required in given command
-  async getRequiredWorker(): Promise<GroupMember> {
-    const selectedAccount: NamedKeyringPair = await this.getRequiredSelectedAccount()
+  async getRequiredWorkerContext(expectedKeyType: 'Role' | 'MemberController' = 'Role'): Promise<GroupMember> {
     const groupMembers = await this.getApi().groupMembers(this.group)
-    const groupMembersByAccount = groupMembers.filter((m) => m.roleAccount.toString() === selectedAccount.address)
-
-    if (!groupMembersByAccount.length) {
-      this.error(`${_.startCase(this.group)} Group Worker access required for this command!`, {
-        exit: ExitCodes.AccessDenied,
-      })
-    } else if (groupMembersByAccount.length === 1) {
-      return groupMembersByAccount[0]
-    } else {
-      return await this.promptForWorker(groupMembersByAccount)
-    }
-  }
-
-  // Use when member controller access is required, but one of the associated roles is expected to be selected
-  async getRequiredWorkerByMemberController(): Promise<GroupMember> {
-    const selectedAccount: NamedKeyringPair = await this.getRequiredSelectedAccount()
-    const memberIds = await this.getApi().getMemberIdsByControllerAccount(selectedAccount.address)
-    const controlledWorkers = (await this.getApi().groupMembers(this.group)).filter((groupMember) =>
-      memberIds.some((memberId) => groupMember.memberId.eq(memberId))
+    const availableGroupMemberContexts = groupMembers.filter((m) =>
+      expectedKeyType === 'Role'
+        ? this.isKeyAvailable(m.roleAccount.toString())
+        : this.isKeyAvailable(m.profile.membership.controller_account.toString())
     )
 
-    if (!controlledWorkers.length) {
-      this.error(`Member controller account with some associated ${this.group} group roles needs to be selected!`, {
+    if (!availableGroupMemberContexts.length) {
+      this.error(`No ${_.startCase(this.group)} Group Worker ${_.startCase(expectedKeyType)} key available!`, {
         exit: ExitCodes.AccessDenied,
       })
-    } else if (controlledWorkers.length === 1) {
-      return controlledWorkers[0]
+    } else if (availableGroupMemberContexts.length === 1) {
+      return availableGroupMemberContexts[0]
     } else {
-      return await this.promptForWorker(controlledWorkers)
+      return await this.promptForWorker(availableGroupMemberContexts)
     }
   }
 
@@ -113,33 +88,24 @@ export default abstract class WorkingGroupsCommandBase extends RolesCommandBase
     }),
   }
 
-  async promptForApplicationsToAccept(opening: GroupOpening): Promise<number[]> {
-    const acceptableApplications = opening.applications.filter((a) => a.stage === ApplicationStageKeys.Active)
+  async promptForApplicationsToAccept(opening: OpeningDetails): Promise<number[]> {
     const acceptedApplications = await this.simplePrompt({
       message: 'Select succesful applicants',
       type: 'checkbox',
-      choices: acceptableApplications.map((a) => ({
-        name: ` ${a.wgApplicationId}: ${a.member?.handle.toString()}`,
-        value: a.wgApplicationId,
+      choices: opening.applications.map((a) => ({
+        name: ` ${a.applicationId}: ${memberHandle(a.member)}`,
+        value: a.applicationId,
       })),
     })
 
     return acceptedApplications
   }
 
-  async getOpeningForLeadAction(id: number, requiredStatus?: OpeningStatus): Promise<GroupOpening> {
+  async getOpeningForLeadAction(id: number): Promise<OpeningDetails> {
     const opening = await this.getApi().groupOpening(this.group, id)
 
-    if (!opening.type.isOfType('Worker')) {
-      this.error('A lead can only manage Worker openings!', { exit: ExitCodes.AccessDenied })
-    }
-
-    if (requiredStatus && opening.stage.status !== requiredStatus) {
-      this.error(
-        `The opening needs to be in "${_.startCase(requiredStatus)}" stage! ` +
-          `This one is: "${_.startCase(opening.stage.status)}"`,
-        { exit: ExitCodes.InvalidInput }
-      )
+    if (!opening.type.isOfType('Regular')) {
+      this.error('A lead can only manage Regular openings!', { exit: ExitCodes.AccessDenied })
     }
 
     return opening
@@ -148,20 +114,12 @@ export default abstract class WorkingGroupsCommandBase extends RolesCommandBase
   // An alias for better code readibility in case we don't need the actual return value
   validateOpeningForLeadAction = this.getOpeningForLeadAction
 
-  async getApplicationForLeadAction(id: number, requiredStatus?: ApplicationStageKeys): Promise<GroupApplication> {
+  async getApplicationForLeadAction(id: number): Promise<ApplicationDetails> {
     const application = await this.getApi().groupApplication(this.group, id)
-    const opening = await this.getApi().groupOpening(this.group, application.wgOpeningId)
-
-    if (!opening.type.isOfType('Worker')) {
-      this.error('A lead can only manage Worker opening applications!', { exit: ExitCodes.AccessDenied })
-    }
+    const opening = await this.getApi().groupOpening(this.group, application.openingId)
 
-    if (requiredStatus && application.stage !== requiredStatus) {
-      this.error(
-        `The application needs to have "${_.startCase(requiredStatus)}" status! ` +
-          `This one has: "${_.startCase(application.stage)}"`,
-        { exit: ExitCodes.InvalidInput }
-      )
+    if (!opening.type.isOfType('Regular')) {
+      this.error('A lead can only manage Regular opening applications!', { exit: ExitCodes.AccessDenied })
     }
 
     return application

cli/src/commands/account/choose.ts

@@ -1,48 +0,0 @@
-import AccountsCommandBase from '../../base/AccountsCommandBase'
-import chalk from 'chalk'
-import ExitCodes from '../../ExitCodes'
-import { NamedKeyringPair } from '../../Types'
-import { flags } from '@oclif/command'
-
-export default class AccountChoose extends AccountsCommandBase {
-  static description = 'Choose default account to use in the CLI'
-  static flags = {
-    showSpecial: flags.boolean({
-      description: 'Whether to show special (DEV chain) accounts',
-      char: 'S',
-      required: false,
-    }),
-    address: flags.string({
-      description: 'Select account by address (if available)',
-      char: 'a',
-      required: false,
-    }),
-  }
-
-  async run() {
-    const { showSpecial, address } = this.parse(AccountChoose).flags
-    const accounts: NamedKeyringPair[] = this.fetchAccounts(!!address || showSpecial)
-    const selectedAccount: NamedKeyringPair | null = this.getSelectedAccount()
-
-    this.log(chalk.white(`Found ${accounts.length} existing accounts...\n`))
-
-    if (accounts.length === 0) {
-      this.warn('No account to choose from. Add accont using account:import or account:create.')
-      this.exit(ExitCodes.NoAccountFound)
-    }
-
-    let choosenAccount: NamedKeyringPair
-    if (address) {
-      const matchingAccount = accounts.find((a) => a.address === address)
-      if (!matchingAccount) {
-        this.error(`No matching account found by address: ${address}`, { exit: ExitCodes.InvalidInput })
-      }
-      choosenAccount = matchingAccount
-    } else {
-      choosenAccount = await this.promptForAccount(accounts, selectedAccount)
-    }
-
-    await this.setSelectedAccount(choosenAccount)
-    this.log(chalk.greenBright(`\nAccount switched to ${chalk.white(choosenAccount.address)}!`))
-  }
-}

cli/src/commands/account/create.ts

@@ -1,47 +1,24 @@
-import chalk from 'chalk'
-import ExitCodes from '../../ExitCodes'
-import AccountsCommandBase from '../../base/AccountsCommandBase'
-import { Keyring } from '@polkadot/api'
-import { mnemonicGenerate } from '@polkadot/util-crypto'
-import { NamedKeyringPair } from '../../Types'
-
-type AccountCreateArgs = {
-  name: string
-}
+import AccountsCommandBase, { DEFAULT_ACCOUNT_TYPE } from '../../base/AccountsCommandBase'
+import { KeypairType } from '@polkadot/util-crypto/types'
+import { flags } from '@oclif/command'
 
 export default class AccountCreate extends AccountsCommandBase {
-  static description = 'Create new account'
+  static description = 'Create a new account'
 
-  static args = [
-    {
-      name: 'name',
-      required: true,
+  static flags = {
+    name: flags.string({
+      required: false,
       description: 'Account name',
-    },
-  ]
-
-  validatePass(password: string, password2: string): void {
-    if (password !== password2) this.error('Passwords are not the same!', { exit: ExitCodes.InvalidInput })
-    if (!password) this.error("You didn't provide a password", { exit: ExitCodes.InvalidInput })
+    }),
+    type: flags.enum<KeypairType>({
+      required: false,
+      description: `Account type (defaults to ${DEFAULT_ACCOUNT_TYPE})`,
+      options: ['sr25519', 'ed25519'],
+    }),
   }
 
   async run() {
-    const args: AccountCreateArgs = this.parse(AccountCreate).args as AccountCreateArgs
-    const keyring: Keyring = new Keyring()
-    const mnemonic: string = mnemonicGenerate()
-
-    keyring.addFromMnemonic(mnemonic, { name: args.name, whenCreated: Date.now() })
-    const keys: NamedKeyringPair = keyring.pairs[0] as NamedKeyringPair // We assigned the name above
-
-    const password = await this.promptForPassword("Set your account's password")
-    const password2 = await this.promptForPassword('Confirm your password')
-
-    this.validatePass(password, password2)
-
-    this.saveAccount(keys, password)
-
-    this.log(chalk.greenBright(`\nAccount succesfully created!`))
-    this.log(chalk.white(`${chalk.bold('Name:    ')}${args.name}`))
-    this.log(chalk.white(`${chalk.bold('Address: ')}${keys.address}`))
+    const { name, type } = this.parse(AccountCreate).flags
+    await this.createAccount(name, undefined, undefined, type)
   }
 }

cli/src/commands/account/current.ts

@@ -1,40 +0,0 @@
-import AccountsCommandBase from '../../base/AccountsCommandBase'
-import { AccountSummary, NameValueObj, NamedKeyringPair } from '../../Types'
-import { displayHeader, displayNameValueTable } from '../../helpers/display'
-import { formatBalance } from '@polkadot/util'
-import moment from 'moment'
-
-export default class AccountCurrent extends AccountsCommandBase {
-  static description = 'Display information about currently choosen default account'
-  static aliases = ['account:info', 'account:default']
-
-  async run() {
-    const currentAccount: NamedKeyringPair = await this.getRequiredSelectedAccount(false)
-    const summary: AccountSummary = await this.getApi().getAccountSummary(currentAccount.address)
-
-    displayHeader('Account information')
-    const creationDate: string = currentAccount.meta.whenCreated
-      ? moment(currentAccount.meta.whenCreated as string | number).format('YYYY-MM-DD HH:mm:ss')
-      : '?'
-    const accountRows: NameValueObj[] = [
-      { name: 'Account name:', value: currentAccount.meta.name },
-      { name: 'Address:', value: currentAccount.address },
-      { name: 'Created:', value: creationDate },
-    ]
-    displayNameValueTable(accountRows)
-
-    displayHeader('Balances')
-    const balances = summary.balances
-    const balancesRows: NameValueObj[] = [
-      { name: 'Total balance:', value: formatBalance(balances.votingBalance) },
-      { name: 'Transferable balance:', value: formatBalance(balances.availableBalance) },
-    ]
-    if (balances.lockedBalance.gtn(0)) {
-      balancesRows.push({ name: 'Locked balance:', value: formatBalance(balances.lockedBalance) })
-    }
-    if (balances.reservedBalance.gtn(0)) {
-      balancesRows.push({ name: 'Reserved balance:', value: formatBalance(balances.reservedBalance) })
-    }
-    displayNameValueTable(balancesRows)
-  }
-}

cli/src/commands/account/export.ts

@@ -4,10 +4,8 @@ import path from 'path'
 import ExitCodes from '../../ExitCodes'
 import AccountsCommandBase from '../../base/AccountsCommandBase'
 import { flags } from '@oclif/command'
-import { NamedKeyringPair } from '../../Types'
 
-type AccountExportFlags = { all: boolean }
-type AccountExportArgs = { path: string }
+type AccountExportArgs = { destPath: string }
 
 export default class AccountExport extends AccountsCommandBase {
   static description = 'Export account(s) to given location'
@@ -15,22 +13,30 @@ export default class AccountExport extends AccountsCommandBase {
 
   static args = [
     {
-      name: 'path',
+      name: 'destPath',
       required: true,
       description: 'Path where the exported files should be placed',
     },
   ]
 
   static flags = {
+    name: flags.string({
+      char: 'n',
+      description: 'Name of the account to export',
+      required: false,
+      exclusive: ['all'],
+    }),
     all: flags.boolean({
       char: 'a',
       description: `If provided, exports all existing accounts into "${AccountExport.MULTI_EXPORT_FOLDER_NAME}" folder inside given path`,
+      required: false,
+      exclusive: ['name'],
     }),
   }
 
-  exportAccount(account: NamedKeyringPair, destPath: string): string {
-    const sourceFilePath: string = this.getAccountFilePath(account)
-    const destFilePath: string = path.join(destPath, this.generateAccountFilename(account))
+  exportAccount(name: string, destPath: string): string {
+    const sourceFilePath: string = this.getAccountFilePath(name)
+    const destFilePath: string = path.join(destPath, this.getAccountFileName(name))
     try {
       fs.copyFileSync(sourceFilePath, destFilePath)
     } catch (e) {
@@ -43,31 +49,26 @@ export default class AccountExport extends AccountsCommandBase {
   }
 
   async run() {
-    const args: AccountExportArgs = this.parse(AccountExport).args as AccountExportArgs
-    const flags: AccountExportFlags = this.parse(AccountExport).flags as AccountExportFlags
-    const accounts: NamedKeyringPair[] = this.fetchAccounts()
-
-    if (!accounts.length) {
-      this.error('No accounts found!', { exit: ExitCodes.NoAccountFound })
-    }
+    const { destPath } = this.parse(AccountExport).args as AccountExportArgs
+    let { name, all } = this.parse(AccountExport).flags
+    const accounts = this.fetchAccounts()
 
-    if (flags.all) {
-      const destPath: string = path.join(args.path, AccountExport.MULTI_EXPORT_FOLDER_NAME)
+    if (all) {
+      const exportPath: string = path.join(destPath, AccountExport.MULTI_EXPORT_FOLDER_NAME)
       try {
-        if (!fs.existsSync(destPath)) fs.mkdirSync(destPath)
+        if (!fs.existsSync(exportPath)) fs.mkdirSync(exportPath)
       } catch (e) {
-        this.error(`Failed to create the export folder (${destPath})`, { exit: ExitCodes.FsOperationFailed })
+        this.error(`Failed to create the export folder (${exportPath})`, { exit: ExitCodes.FsOperationFailed })
       }
-      for (const account of accounts) this.exportAccount(account, destPath)
-      this.log(chalk.greenBright(`All accounts succesfully exported succesfully to: ${chalk.white(destPath)}!`))
+      for (const acc of accounts) {
+        this.exportAccount(acc.meta.name, exportPath)
+      }
+      this.log(chalk.greenBright(`All accounts succesfully exported to: ${chalk.white(exportPath)}!`))
     } else {
-      const destPath: string = args.path
-      const choosenAccount: NamedKeyringPair = await this.promptForAccount(
-        accounts,
-        null,
-        'Select an account to export'
-      )
-      const exportedFilePath: string = this.exportAccount(choosenAccount, destPath)
+      if (!name) {
+        name = await this.promptForAccount()
+      }
+      const exportedFilePath: string = this.exportAccount(name, destPath)
       this.log(chalk.greenBright(`Account succesfully exported to: ${chalk.white(exportedFilePath)}`))
     }
   }

cli/src/commands/account/forget.ts

@@ -2,22 +2,16 @@ import fs from 'fs'
 import chalk from 'chalk'
 import ExitCodes from '../../ExitCodes'
 import AccountsCommandBase from '../../base/AccountsCommandBase'
-import { NamedKeyringPair } from '../../Types'
 
 export default class AccountForget extends AccountsCommandBase {
   static description = 'Forget (remove) account from the list of available accounts'
 
   async run() {
-    const accounts: NamedKeyringPair[] = this.fetchAccounts()
+    const selecteKey = await this.promptForAccount('Select an account to forget', false, false)
+    await this.requireConfirmation('Are you sure you want to PERMANENTLY FORGET this account?')
 
-    if (!accounts.length) {
-      this.error('No accounts found!', { exit: ExitCodes.NoAccountFound })
-    }
-
-    const choosenAccount: NamedKeyringPair = await this.promptForAccount(accounts, null, 'Select an account to forget')
-    await this.requireConfirmation('Are you sure you want this account to be forgotten?')
+    const accountFilePath = this.getAccountFilePath(this.getPair(selecteKey).meta.name)
 
-    const accountFilePath: string = this.getAccountFilePath(choosenAccount)
     try {
       fs.unlinkSync(accountFilePath)
     } catch (e) {

cli/src/commands/account/import.ts

@@ -1,44 +1,63 @@
-import fs from 'fs'
-import chalk from 'chalk'
-import path from 'path'
-import ExitCodes from '../../ExitCodes'
-import AccountsCommandBase from '../../base/AccountsCommandBase'
-import { NamedKeyringPair } from '../../Types'
-
-type AccountImportArgs = {
-  backupFilePath: string
-}
+import AccountsCommandBase, { DEFAULT_ACCOUNT_TYPE, KEYRING_OPTIONS } from '../../base/AccountsCommandBase'
+import { flags } from '@oclif/command'
+import Keyring from '@polkadot/keyring'
+import { KeypairType } from '@polkadot/util-crypto/types'
 
 export default class AccountImport extends AccountsCommandBase {
-  static description = 'Import account using JSON backup file'
+  static description = 'Import account using mnemonic phrase, seed, suri or json backup file'
 
-  static args = [
-    {
-      name: 'backupFilePath',
-      required: true,
+  static flags = {
+    name: flags.string({
+      required: false,
+      description: 'Account name',
+    }),
+    mnemonic: flags.string({
+      required: false,
+      description: 'Mnemonic phrase',
+      exclusive: ['backupFilePath', 'seed', 'suri'],
+    }),
+    seed: flags.string({
+      required: false,
+      description: 'Secret seed',
+      exclusive: ['backupFilePath', 'mnemonic', 'suri'],
+    }),
+    backupFilePath: flags.string({
+      required: false,
       description: 'Path to account backup JSON file',
-    },
-  ]
+      exclusive: ['mnemonic', 'seed', 'suri'],
+    }),
+    suri: flags.string({
+      required: false,
+      description: 'Substrate uri',
+      exclusive: ['mnemonic', 'seed', 'backupFilePath'],
+    }),
+    type: flags.enum<KeypairType>({
+      required: false,
+      description: `Account type (defaults to ${DEFAULT_ACCOUNT_TYPE})`,
+      options: ['sr25519', 'ed25519'],
+      exclusive: ['backupFilePath'],
+    }),
+  }
 
   async run() {
-    const args: AccountImportArgs = this.parse(AccountImport).args as AccountImportArgs
-    const backupAcc: NamedKeyringPair = this.fetchAccountFromJsonFile(args.backupFilePath)
-    const accountName: string = backupAcc.meta.name
-    const accountAddress: string = backupAcc.address
+    const { name, mnemonic, seed, backupFilePath, suri, type } = this.parse(AccountImport).flags
 
-    const sourcePath: string = args.backupFilePath
-    const destPath: string = path.join(this.getAccountsDirPath(), this.generateAccountFilename(backupAcc))
+    const keyring = new Keyring(KEYRING_OPTIONS)
 
-    try {
-      fs.copyFileSync(sourcePath, destPath)
-    } catch (e) {
-      this.error('Unexpected error while trying to copy input file! Permissions issue?', {
-        exit: ExitCodes.FsOperationFailed,
-      })
+    if (mnemonic) {
+      keyring.addFromMnemonic(mnemonic, {}, type)
+    } else if (seed) {
+      keyring.addFromSeed(Buffer.from(seed), {}, type)
+    } else if (suri) {
+      keyring.addFromUri(suri, {}, type)
+    } else if (backupFilePath) {
+      const pair = this.fetchAccountFromJsonFile(backupFilePath)
+      keyring.addPair(pair)
+    } else {
+      this._help()
+      return
     }
 
-    this.log(chalk.bold.greenBright(`ACCOUNT IMPORTED SUCCESFULLY!`))
-    this.log(chalk.bold.white(`NAME:    `), accountName)
-    this.log(chalk.bold.white(`ADDRESS: `), accountAddress)
+    await this.createAccount(name, keyring.getPairs()[0])
   }
 }

cli/src/commands/account/info.ts

@@ -0,0 +1,56 @@
+import AccountsCommandBase from '../../base/AccountsCommandBase'
+import ExitCodes from '../../ExitCodes'
+import { validateAddress } from '../../helpers/validation'
+import { NameValueObj } from '../../Types'
+import { displayHeader, displayNameValueTable } from '../../helpers/display'
+import { formatBalance } from '@polkadot/util'
+import moment from 'moment'
+
+export default class AccountInfo extends AccountsCommandBase {
+  static description = 'Display detailed information about specified account'
+  static aliases = ['account:inspect']
+  static args = [
+    { name: 'address', required: false, description: 'An address to inspect (can also be provided interavtively)' },
+  ]
+
+  async run() {
+    let { address } = this.parse(AccountInfo).args
+
+    if (!address) {
+      address = await this.promptForAnyAddress()
+    } else if (validateAddress(address) !== true) {
+      this.error('Invalid address', { exit: ExitCodes.InvalidInput })
+    }
+
+    const summary = await this.getApi().getAccountSummary(address)
+
+    displayHeader('Account information')
+    const accountRows: NameValueObj[] = [{ name: 'Address:', value: address }]
+    if (this.isKeyAvailable(address)) {
+      const pair = this.getPair(address)
+      accountRows.push({ name: 'Account name', value: pair.meta.name })
+      accountRows.push({ name: 'Type', value: pair.type })
+      const creationDate = pair.meta.whenCreated
+        ? moment(pair.meta.whenCreated as string | number).format('YYYY-MM-DD HH:mm:ss')
+        : null
+      if (creationDate) {
+        accountRows.push({ name: 'Creation date', value: creationDate })
+      }
+    }
+    displayNameValueTable(accountRows)
+
+    displayHeader('Balances')
+    const balances = summary.balances
+    const balancesRows: NameValueObj[] = [
+      { name: 'Total balance:', value: formatBalance(balances.votingBalance) },
+      { name: 'Transferable balance:', value: formatBalance(balances.availableBalance) },
+    ]
+    if (balances.lockedBalance.gtn(0)) {
+      balancesRows.push({ name: 'Locked balance:', value: formatBalance(balances.lockedBalance) })
+    }
+    if (balances.reservedBalance.gtn(0)) {
+      balancesRows.push({ name: 'Reserved balance:', value: formatBalance(balances.reservedBalance) })
+    }
+    displayNameValueTable(balancesRows)
+  }
+}

cli/src/commands/account/list.ts

@@ -0,0 +1,22 @@
+import AccountsCommandBase from '../../base/AccountsCommandBase'
+import { displayTable } from '../../helpers/display'
+import { formatBalance } from '@polkadot/util'
+
+export default class AccountList extends AccountsCommandBase {
+  static description = 'List all available accounts'
+
+  async run() {
+    const pairs = this.getPairs()
+    const balances = await this.getApi().getAccountsBalancesInfo(pairs.map((p) => p.address))
+
+    displayTable(
+      pairs.map((p, i) => ({
+        'Name': p.meta.name,
+        'Address': p.address,
+        'Available balance': formatBalance(balances[i].availableBalance),
+        'Total balance': formatBalance(balances[i].votingBalance),
+      })),
+      3
+    )
+  }
+}

cli/src/commands/account/transferTokens.ts

@@ -1,67 +1,50 @@
+import { flags } from '@oclif/command'
 import BN from 'bn.js'
 import AccountsCommandBase from '../../base/AccountsCommandBase'
-import chalk from 'chalk'
 import ExitCodes from '../../ExitCodes'
-import { formatBalance } from '@polkadot/util'
-import { Hash } from '@polkadot/types/interfaces'
-import { NamedKeyringPair } from '../../Types'
-import { checkBalance, validateAddress } from '../../helpers/validation'
-
-type AccountTransferArgs = {
-  recipient: string
-  amount: string
-}
+import { checkBalance, isValidBalance, validateAddress } from '../../helpers/validation'
 
 export default class AccountTransferTokens extends AccountsCommandBase {
-  static description = 'Transfer tokens from currently choosen account'
-
-  static args = [
-    {
-      name: 'recipient',
-      required: true,
-      description: 'Address of the transfer recipient',
-    },
-    {
-      name: 'amount',
+  static description = 'Transfer tokens from any of the available accounts'
+
+  static flags = {
+    from: flags.string({
+      required: false,
+      description: 'Address of the sender (can also be provided interactively)',
+    }),
+    to: flags.string({
+      required: false,
+      description: 'Address of the recipient (can also be provided interactively)',
+    }),
+    amount: flags.string({
       required: true,
       description: 'Amount of tokens to transfer',
-    },
-  ]
+    }),
+  }
 
   async run() {
-    const args: AccountTransferArgs = this.parse(AccountTransferTokens).args as AccountTransferArgs
-    const selectedAccount: NamedKeyringPair = await this.getRequiredSelectedAccount()
-    const amountBN: BN = new BN(args.amount)
+    let { from, to, amount } = this.parse(AccountTransferTokens).flags
 
-    // Initial validation
-    validateAddress(args.recipient, 'Invalid recipient address')
-    const accBalances = (await this.getApi().getAccountsBalancesInfo([selectedAccount.address]))[0]
-    checkBalance(accBalances, amountBN)
-
-    await this.requestAccountDecoding(selectedAccount)
+    if (!isValidBalance(amount)) {
+      this.error('Invalid transfer amount', { exit: ExitCodes.InvalidInput })
+    }
 
-    this.log(chalk.white('Estimating fee...'))
-    const tx = await this.getApi().createTransferTx(args.recipient, amountBN)
-    let estimatedFee: BN
-    try {
-      estimatedFee = await this.getApi().estimateFee(selectedAccount, tx)
-    } catch (e) {
-      this.error('Could not estimate the fee.', { exit: ExitCodes.UnexpectedException })
+    // Initial validation
+    if (!from) {
+      from = await this.promptForAccount('Select sender account')
+    } else if (!this.isKeyAvailable(from)) {
+      this.error('Sender key not available', { exit: ExitCodes.InvalidInput })
     }
-    const totalAmount: BN = amountBN.add(estimatedFee)
-    this.log(chalk.white('Estimated fee:', formatBalance(estimatedFee)))
-    this.log(chalk.white('Total transfer amount:', formatBalance(totalAmount)))
 
-    checkBalance(accBalances, totalAmount)
+    if (!to) {
+      to = await this.promptForAnyAddress('Select recipient')
+    } else if (validateAddress(to) !== true) {
+      this.error('Invalid recipient address', { exit: ExitCodes.InvalidInput })
+    }
 
-    await this.requireConfirmation('Do you confirm the transfer?')
+    const accBalances = (await this.getApi().getAccountsBalancesInfo([from]))[0]
+    checkBalance(accBalances, new BN(amount))
 
-    try {
-      const txHash: Hash = await tx.signAndSend(selectedAccount)
-      this.log(chalk.greenBright('Transaction succesfully sent!'))
-      this.log(chalk.white('Hash:', txHash.toString()))
-    } catch (e) {
-      this.error('Could not send the transaction.', { exit: ExitCodes.UnexpectedException })
-    }
+    await this.sendAndFollowNamedTx(await this.getDecodedPair(from), 'balances', 'transferKeepAlive', [to, amount])
   }
 }

cli/src/commands/api/getQueryNodeEndpoint.ts

@@ -0,0 +1,11 @@
+import StateAwareCommandBase from '../../base/StateAwareCommandBase'
+import chalk from 'chalk'
+
+export default class ApiGetQueryNodeEndpoint extends StateAwareCommandBase {
+  static description = 'Get current query node endpoint'
+
+  async run() {
+    const currentEndpoint: string = this.getPreservedState().queryNodeUri
+    this.log(chalk.green(currentEndpoint))
+  }
+}

cli/src/commands/api/inspect.ts

@@ -1,13 +1,12 @@
 import { flags } from '@oclif/command'
 import { CLIError } from '@oclif/errors'
 import { displayNameValueTable } from '../../helpers/display'
-import { ApiPromise } from '@polkadot/api'
 import { Codec } from '@polkadot/types/types'
-import { ConstantCodec } from '@polkadot/metadata/Decorated/consts/types'
 import ExitCodes from '../../ExitCodes'
 import chalk from 'chalk'
-import { NameValueObj, ApiMethodArg } from '../../Types'
+import { NameValueObj, ApiMethodArg, UnaugmentedApiPromise } from '../../Types'
 import ApiCommandBase from '../../base/ApiCommandBase'
+import { AugmentedConst } from '@polkadot/api/types'
 
 // Command flags type
 type ApiInspectFlags = {
@@ -78,10 +77,10 @@ export default class ApiInspect extends ApiCommandBase {
 
   getMethodMeta(apiType: ApiType, apiModule: string, apiMethod: string) {
     if (apiType === 'query') {
-      return this.getOriginalApi().query[apiModule][apiMethod].creator.meta
+      return this.getUnaugmentedApi().query[apiModule][apiMethod].creator.meta
     } else {
       // Currently the only other optoin is api.consts
-      const method: ConstantCodec = this.getOriginalApi().consts[apiModule][apiMethod] as ConstantCodec
+      const method = (this.getUnaugmentedApi().consts[apiModule][apiMethod] as unknown) as AugmentedConst<'promise'>
       return method.meta
     }
   }
@@ -92,7 +91,7 @@ export default class ApiInspect extends ApiCommandBase {
   }
 
   getQueryMethodParamsTypes(apiModule: string, apiMethod: string): string[] {
-    const method = this.getOriginalApi().query[apiModule][apiMethod]
+    const method = this.getUnaugmentedApi().query[apiModule][apiMethod]
     const { type } = method.creator.meta
     if (type.isDoubleMap) {
       return [type.asDoubleMap.key1.toString(), type.asDoubleMap.key2.toString()]
@@ -105,7 +104,7 @@ export default class ApiInspect extends ApiCommandBase {
 
   getMethodReturnType(apiType: ApiType, apiModule: string, apiMethod: string): string {
     if (apiType === 'query') {
-      const method = this.getOriginalApi().query[apiModule][apiMethod]
+      const method = this.getUnaugmentedApi().query[apiModule][apiMethod]
       const {
         meta: { type, modifier },
       } = method.creator
@@ -126,7 +125,7 @@ export default class ApiInspect extends ApiCommandBase {
   // Validate the flags - throws an error if flags.type, flags.module or flags.method is invalid / does not exist in the api.
   // Returns type, module and method which validity we can be sure about (notice they may still be "undefined" if weren't provided).
   validateFlags(
-    api: ApiPromise,
+    api: UnaugmentedApiPromise,
     flags: ApiInspectFlags
   ): { apiType: ApiType | undefined; apiModule: string | undefined; apiMethod: string | undefined } {
     let apiType: ApiType | undefined
@@ -164,7 +163,7 @@ export default class ApiInspect extends ApiCommandBase {
   }
 
   async run() {
-    const api: ApiPromise = this.getOriginalApi()
+    const api: UnaugmentedApiPromise = this.getUnaugmentedApi()
     const flags: ApiInspectFlags = this.parse(ApiInspect).flags as ApiInspectFlags
     const availableTypes: readonly string[] = TYPES_AVAILABLE
     const { apiType, apiModule, apiMethod } = this.validateFlags(api, flags)

cli/src/commands/api/setQueryNodeEndpoint.ts

@@ -0,0 +1,37 @@
+import chalk from 'chalk'
+import ApiCommandBase from '../../base/ApiCommandBase'
+import ExitCodes from '../../ExitCodes'
+
+type ApiSetQueryNodeEndpointArgs = { endpoint: string }
+
+export default class ApiSetQueryNodeEndpoint extends ApiCommandBase {
+  static description = 'Set query node endpoint'
+  static args = [
+    {
+      name: 'endpoint',
+      required: false,
+      description: 'Query node endpoint for the CLI to use',
+    },
+  ]
+
+  async init() {
+    await super.init()
+  }
+
+  async run() {
+    const { endpoint }: ApiSetQueryNodeEndpointArgs = this.parse(ApiSetQueryNodeEndpoint)
+      .args as ApiSetQueryNodeEndpointArgs
+    let newEndpoint = ''
+    if (endpoint) {
+      if (this.isQueryNodeUriValid(endpoint)) {
+        await this.setPreservedState({ queryNodeUri: endpoint })
+        newEndpoint = endpoint
+      } else {
+        this.error('Provided endpoint seems to be incorrect!', { exit: ExitCodes.InvalidInput })
+      }
+    } else {
+      newEndpoint = await this.promptForQueryNodeUri()
+    }
+    this.log(chalk.greenBright('Query node endpoint successfuly changed! New endpoint: ') + chalk.white(newEndpoint))
+  }
+}

cli/src/commands/api/setUri.ts

@@ -15,7 +15,6 @@ export default class ApiSetUri extends ApiCommandBase {
   ]
 
   async init() {
-    this.forceSkipApiUriPrompt = true
     await super.init()
   }
 

cli/src/commands/content-directory/createCuratorGroup.ts

@@ -12,7 +12,7 @@ export default class AddCuratorGroupCommand extends ContentDirectoryCommandBase
     await this.requestAccountDecoding(account)
     await this.buildAndSendExtrinsic(account, 'contentDirectory', 'addCuratorGroup')
 
-    const newGroupId = (await this.getApi().nextCuratorGroupId()) - 1
-    console.log(chalk.green(`New group succesfully created! (ID: ${chalk.white(newGroupId)})`))
+    // TODO: Get id from event?
+    console.log(chalk.green(`New group succesfully created!`))
   }
 }

cli/src/commands/content-directory/curatorGroup.ts

@@ -1,7 +1,7 @@
 import { WorkingGroups } from '../../Types'
 import ContentDirectoryCommandBase from '../../base/ContentDirectoryCommandBase'
 import chalk from 'chalk'
-import { displayCollapsedRow, displayHeader } from '../../helpers/display'
+import { displayCollapsedRow, displayHeader, memberHandle } from '../../helpers/display'
 
 export default class CuratorGroupCommand extends ContentDirectoryCommandBase {
   static description = 'Show Curator Group details by ID.'
@@ -32,7 +32,7 @@ export default class CuratorGroupCommand extends ContentDirectoryCommandBase {
     displayHeader(`Group Members (${members.length})`)
     this.log(
       members
-        .map((curator) => chalk.white(`${curator.profile.handle} (WorkerID: ${curator.workerId.toString()})`))
+        .map((curator) => chalk.white(`${memberHandle(curator.profile)} (WorkerID: ${curator.workerId.toString()})`))
         .join(', ')
     )
   }

cli/src/commands/content-directory/updateClassPermissions.ts

@@ -43,10 +43,10 @@ export default class UpdateClassPermissionsCommand extends ContentDirectoryComma
     await this.requestAccountDecoding(account)
     await this.sendAndFollowNamedTx(account, 'contentDirectory', 'updateClassPermissions', [
       classId,
-      newPermissions.any_member,
-      newPermissions.entity_creation_blocked,
-      newPermissions.all_entity_property_values_locked,
-      newPermissions.maintainers,
+      this.createType('Option<bool>', newPermissions.any_member || null),
+      this.createType('Option<bool>', newPermissions.entity_creation_blocked || null),
+      this.createType('Option<bool>', newPermissions.all_entity_property_values_locked || null),
+      this.createType('Option<bool>', newPermissions.maintainers || null),
     ])
 
     console.log(chalk.green(`${chalk.white(className)} class permissions updated to:`))

cli/src/commands/council/info.ts

@@ -1,56 +0,0 @@
-import { ElectionStage } from '@joystream/types/council'
-import { formatNumber, formatBalance } from '@polkadot/util'
-import { BlockNumber } from '@polkadot/types/interfaces'
-import { CouncilInfoObj, NameValueObj } from '../../Types'
-import { displayHeader, displayNameValueTable } from '../../helpers/display'
-import ApiCommandBase from '../../base/ApiCommandBase'
-
-export default class CouncilInfo extends ApiCommandBase {
-  static description = 'Get current council and council elections information'
-
-  displayInfo(infoObj: CouncilInfoObj) {
-    const { activeCouncil = [], round, stage } = infoObj
-
-    displayHeader('Council')
-    const councilRows: NameValueObj[] = [
-      { name: 'Elected:', value: activeCouncil.length ? 'YES' : 'NO' },
-      { name: 'Members:', value: activeCouncil.length.toString() },
-      { name: 'Term ends at block:', value: `#${formatNumber(infoObj.termEndsAt)}` },
-    ]
-    displayNameValueTable(councilRows)
-
-    displayHeader('Election')
-    const electionTableRows: NameValueObj[] = [
-      { name: 'Running:', value: stage && stage.isSome ? 'YES' : 'NO' },
-      { name: 'Election round:', value: formatNumber(round) },
-    ]
-    if (stage && stage.isSome) {
-      const stageValue = stage.value as ElectionStage
-      const stageName: string = stageValue.type
-      const stageEndsAt = stageValue.value as BlockNumber
-      electionTableRows.push({ name: 'Stage:', value: stageName })
-      electionTableRows.push({ name: 'Stage ends at block:', value: `#${stageEndsAt}` })
-    }
-    displayNameValueTable(electionTableRows)
-
-    displayHeader('Configuration')
-    const isAutoStart = (infoObj.autoStart || false).valueOf()
-    const configTableRows: NameValueObj[] = [
-      { name: 'Auto-start elections:', value: isAutoStart ? 'YES' : 'NO' },
-      { name: 'New term duration:', value: formatNumber(infoObj.newTermDuration) },
-      { name: 'Candidacy limit:', value: formatNumber(infoObj.candidacyLimit) },
-      { name: 'Council size:', value: formatNumber(infoObj.councilSize) },
-      { name: 'Min. council stake:', value: formatBalance(infoObj.minCouncilStake) },
-      { name: 'Min. voting stake:', value: formatBalance(infoObj.minVotingStake) },
-      { name: 'Announcing period:', value: `${formatNumber(infoObj.announcingPeriod)} blocks` },
-      { name: 'Voting period:', value: `${formatNumber(infoObj.votingPeriod)} blocks` },
-      { name: 'Revealing period:', value: `${formatNumber(infoObj.revealingPeriod)} blocks` },
-    ]
-    displayNameValueTable(configTableRows)
-  }
-
-  async run() {
-    const infoObj = await this.getApi().getCouncilInfo()
-    this.displayInfo(infoObj)
-  }
-}

cli/src/commands/media/setFeaturedVideos.ts

@@ -26,7 +26,7 @@ export default class SetFeaturedVideosCommand extends ContentDirectoryCommandBas
     const account = await this.getRequiredSelectedAccount()
     let actor = createType('Actor', { Lead: null })
     try {
-      await this.getRequiredLead()
+      await this.getRequiredLeadContext()
     } catch (e) {
       actor = await this.getCuratorContext(['FeaturedVideo'])
     }

cli/src/commands/working-groups/application.ts

@@ -1,6 +1,5 @@
 import WorkingGroupsCommandBase from '../../base/WorkingGroupsCommandBase'
-import { displayCollapsedRow, displayHeader } from '../../helpers/display'
-import chalk from 'chalk'
+import { displayCollapsedRow, displayHeader, memberHandle } from '../../helpers/display'
 
 export default class WorkingGroupsApplication extends WorkingGroupsCommandBase {
   static description = 'Shows an overview of given application by Working Group Application ID'
@@ -21,19 +20,15 @@ export default class WorkingGroupsApplication extends WorkingGroupsCommandBase {
 
     const application = await this.getApi().groupApplication(this.group, parseInt(args.wgApplicationId))
 
-    displayHeader('Human readable text')
-    this.jsonPrettyPrint(application.humanReadableText)
-
     displayHeader(`Details`)
     const applicationRow = {
-      'WG application ID': application.wgApplicationId,
       'Application ID': application.applicationId,
-      'Member handle': application.member?.handle.toString() || chalk.red('NONE'),
+      'Member handle': memberHandle(application.member),
       'Role account': application.roleAccout.toString(),
-      Stage: application.stage,
-      'Application stake': application.stakes.application,
-      'Role stake': application.stakes.role,
-      'Total stake': Object.values(application.stakes).reduce((a, b) => a + b),
+      'Reward account': application.rewardAccount.toString(),
+      'Staking account': application.stakingAccount.toString(),
+      'Description': application.descriptionHash.toString(),
+      'Opening ID': application.openingId.toString(),
     }
     displayCollapsedRow(applicationRow)
   }

cli/src/commands/working-groups/apply.ts

@@ -0,0 +1,61 @@
+import WorkingGroupsCommandBase from '../../base/WorkingGroupsCommandBase'
+import { Option } from '@polkadot/types'
+import { apiModuleByGroup } from '../../Api'
+import { CreateInterface } from '@joystream/types'
+import { StakeParameters } from '@joystream/types/working-group'
+
+export default class WorkingGroupsApply extends WorkingGroupsCommandBase {
+  static description = 'Apply to a working group opening (requires a membership)'
+  static args = [
+    {
+      name: 'openingId',
+      description: 'Opening ID',
+      required: false,
+    },
+  ]
+
+  async run() {
+    const { openingId } = this.parse(WorkingGroupsApply).args
+    const memberContext = await this.getRequiredMemberContext()
+
+    const opening = await this.getApi().groupOpening(this.group, parseInt(openingId))
+
+    const roleAccount = await this.promptForAnyAddress('Choose role account')
+    const rewardAccount = await this.promptForAnyAddress('Choose reward account')
+
+    let stakeParams: CreateInterface<Option<StakeParameters>> = null
+    if (opening.stake) {
+      const stakingAccount = await this.promptForStakingAccount(
+        opening.stake.value,
+        memberContext.id,
+        memberContext.membership
+      )
+
+      stakeParams = {
+        stake: opening.stake.value,
+        staking_account_id: stakingAccount,
+      }
+    }
+
+    // TODO: Custom json?
+    const description = await this.simplePrompt({
+      message: 'Application description',
+    })
+
+    await this.sendAndFollowNamedTx(
+      await this.getDecodedPair(memberContext.membership.controller_account.toString()),
+      apiModuleByGroup[this.group],
+      'applyOnOpening',
+      [
+        this.createType('ApplyOnOpeningParameters', {
+          member_id: memberContext.id,
+          opening_id: openingId,
+          role_account_id: roleAccount,
+          reward_account_id: rewardAccount,
+          stake_parameters: stakeParams,
+          description,
+        }),
+      ]
+    )
+  }
+}

cli/src/commands/working-groups/cancelOpening.ts

@@ -0,0 +1,33 @@
+import WorkingGroupsCommandBase from '../../base/WorkingGroupsCommandBase'
+import { apiModuleByGroup } from '../../Api'
+import chalk from 'chalk'
+
+export default class WorkingGroupsCancelOpening extends WorkingGroupsCommandBase {
+  static description = 'Cancels (removes) an active opening'
+  static args = [
+    {
+      name: 'openingId',
+      required: true,
+      description: 'Opening ID',
+    },
+  ]
+
+  async run() {
+    const { args } = this.parse(WorkingGroupsCancelOpening)
+
+    // Lead-only gate
+    const lead = await this.getRequiredLeadContext()
+
+    const openingId = parseInt(args.openingId)
+    await this.validateOpeningForLeadAction(openingId)
+
+    await this.sendAndFollowNamedTx(
+      await this.getDecodedPair(lead.roleAccount.toString()),
+      apiModuleByGroup[this.group],
+      'cancelOpening',
+      [openingId]
+    )
+
+    this.log(chalk.green(`Opening ${chalk.white(openingId.toString())} has been cancelled!`))
+  }
+}

cli/src/commands/working-groups/createOpening.ts

@@ -2,18 +2,18 @@ import WorkingGroupsCommandBase from '../../base/WorkingGroupsCommandBase'
 import { GroupMember } from '../../Types'
 import chalk from 'chalk'
 import { apiModuleByGroup } from '../../Api'
-import HRTSchema from '@joystream/types/hiring/schemas/role.schema.json'
-import { GenericJoyStreamRoleSchema as HRTJson } from '@joystream/types/hiring/schemas/role.schema.typings'
 import { JsonSchemaPrompter } from '../../helpers/JsonSchemaPrompt'
 import { JSONSchema } from '@apidevtools/json-schema-ref-parser'
-import WGOpeningSchema from '../../json-schemas/WorkingGroupOpening.schema.json'
-import { WorkingGroupOpening as WGOpeningJson } from '../../json-schemas/typings/WorkingGroupOpening.schema'
-import _ from 'lodash'
+import OpeningParamsSchema from '../../json-schemas/WorkingGroupOpening.schema.json'
+import { WorkingGroupOpening as OpeningParamsJson } from '../../json-schemas/typings/WorkingGroupOpening.schema'
 import { IOFlags, getInputJson, ensureOutputFileIsWriteable, saveOutputJsonToFile } from '../../helpers/InputOutput'
-import Ajv from 'ajv'
 import ExitCodes from '../../ExitCodes'
 import { flags } from '@oclif/command'
-import { createType } from '@joystream/types'
+import { AugmentedSubmittables } from '@polkadot/api/types'
+import { formatBalance } from '@polkadot/util'
+import BN from 'bn.js'
+
+const OPENING_STAKE = new BN(2000)
 
 export default class WorkingGroupsCreateOpening extends WorkingGroupsCommandBase {
   static description = 'Create working group opening (requires lead access)'
@@ -41,125 +41,60 @@ export default class WorkingGroupsCreateOpening extends WorkingGroupsCommandBase
     }),
   }
 
-  getHRTDefaults(memberHandle: string): HRTJson {
-    const groupName = _.startCase(this.group)
-    return {
-      version: 1,
-      headline: `Looking for ${groupName}!`,
-      job: {
-        title: groupName,
-        description: `Become part of the ${groupName} Group! This is a great opportunity to support Joystream!`,
-      },
-      application: {
-        sections: [
-          {
-            title: 'About you',
-            questions: [
-              {
-                title: 'Your name',
-                type: 'text',
-              },
-              {
-                title: 'What makes you a good fit for the job?',
-                type: 'text area',
-              },
-            ],
-          },
-        ],
-      },
-      reward: '10k JOY per 3600 blocks',
-      creator: {
-        membership: {
-          handle: memberHandle,
-        },
-      },
-    }
-  }
-
-  createTxParams(wgOpeningJson: WGOpeningJson, hrtJson: HRTJson) {
+  createTxParams(
+    openingParamsJson: OpeningParamsJson
+  ): Parameters<AugmentedSubmittables<'promise'>['membershipWorkingGroup']['addOpening']> {
     return [
-      wgOpeningJson.activateAt,
-      createType('WorkingGroupOpeningPolicyCommitment', {
-        max_review_period_length: wgOpeningJson.maxReviewPeriodLength,
-        application_rationing_policy: wgOpeningJson.maxActiveApplicants
-          ? { max_active_applicants: wgOpeningJson.maxActiveApplicants }
-          : null,
-        application_staking_policy: wgOpeningJson.applicationStake
-          ? {
-              amount: wgOpeningJson.applicationStake.value,
-              amount_mode: wgOpeningJson.applicationStake.mode,
-            }
-          : null,
-        role_staking_policy: wgOpeningJson.roleStake
-          ? {
-              amount: wgOpeningJson.roleStake.value,
-              amount_mode: wgOpeningJson.roleStake.mode,
-            }
-          : null,
-        terminate_role_stake_unstaking_period: wgOpeningJson.terminateRoleUnstakingPeriod,
-        exit_role_stake_unstaking_period: wgOpeningJson.leaveRoleUnstakingPeriod,
-      }),
-      JSON.stringify(hrtJson),
-      createType('OpeningType', 'Worker'),
+      openingParamsJson.description,
+      'Regular',
+      {
+        stake_amount: openingParamsJson.stakingPolicy.amount,
+        leaving_unstaking_period: openingParamsJson.stakingPolicy.unstakingPeriod,
+      },
+      // TODO: Proper bigint handling?
+      openingParamsJson.rewardPerBlock?.toString() || null,
     ]
   }
 
-  async promptForData(
-    lead: GroupMember,
-    rememberedInput?: [WGOpeningJson, HRTJson]
-  ): Promise<[WGOpeningJson, HRTJson]> {
-    const openingDefaults = rememberedInput?.[0]
-    const openingPrompt = new JsonSchemaPrompter<WGOpeningJson>(
-      (WGOpeningSchema as unknown) as JSONSchema,
+  async promptForData(lead: GroupMember, rememberedInput?: OpeningParamsJson): Promise<OpeningParamsJson> {
+    const openingDefaults = rememberedInput
+    const openingPrompt = new JsonSchemaPrompter<OpeningParamsJson>(
+      (OpeningParamsSchema as unknown) as JSONSchema,
       openingDefaults
     )
-    const wgOpeningJson = await openingPrompt.promptAll()
-
-    const hrtDefaults = rememberedInput?.[1] || this.getHRTDefaults(lead.profile.handle.toString())
-    this.log(`Values for ${chalk.greenBright('human_readable_text')} json:`)
-    const hrtPropmpt = new JsonSchemaPrompter<HRTJson>((HRTSchema as unknown) as JSONSchema, hrtDefaults)
-    // Prompt only for 'headline', 'job', 'application', 'reward' and 'process', leave the rest default
-    const headline = await hrtPropmpt.promptSingleProp('headline')
-    this.log('General information about the job:')
-    const job = await hrtPropmpt.promptSingleProp('job')
-    this.log('Application form sections and questions:')
-    const application = await hrtPropmpt.promptSingleProp('application')
-    this.log('Reward displayed in the opening box:')
-    const reward = await hrtPropmpt.promptSingleProp('reward')
-    this.log('Hiring process details (additional information)')
-    const process = await hrtPropmpt.promptSingleProp('process')
-
-    const hrtJson = { ...hrtDefaults, job, headline, application, reward, process }
-
-    return [wgOpeningJson, hrtJson]
+    const openingParamsJson = await openingPrompt.promptAll()
+
+    return openingParamsJson
   }
 
-  async getInputFromFile(filePath: string): Promise<[WGOpeningJson, HRTJson]> {
-    const ajv = new Ajv({ allErrors: true })
-    const inputParams = await getInputJson<[WGOpeningJson, HRTJson]>(filePath)
-    if (!Array.isArray(inputParams) || inputParams.length !== 2) {
-      this.error('Invalid input file', { exit: ExitCodes.InvalidInput })
-    }
-    const [openingJson, hrtJson] = inputParams
-    if (!ajv.validate(WGOpeningSchema, openingJson)) {
-      this.error(`Invalid input file:\n${ajv.errorsText(undefined, { dataVar: 'openingJson', separator: '\n' })}`, {
-        exit: ExitCodes.InvalidInput,
-      })
-    }
-    if (!ajv.validate(HRTSchema, hrtJson)) {
-      this.error(`Invalid input file:\n${ajv.errorsText(undefined, { dataVar: 'hrtJson', separator: '\n' })}`, {
-        exit: ExitCodes.InvalidInput,
-      })
-    }
+  async getInputFromFile(filePath: string): Promise<OpeningParamsJson> {
+    const inputParams = await getInputJson<OpeningParamsJson>(filePath, (OpeningParamsSchema as unknown) as JSONSchema)
+
+    return inputParams as OpeningParamsJson
+  }
+
+  async promptForStakeTopUp(stakingAccount: string): Promise<void> {
+    this.log(`You need to stake ${chalk.bold(formatBalance(OPENING_STAKE))} in order to create a new opening.`)
 
-    return [openingJson, hrtJson]
+    const [balances] = await this.getApi().getAccountsBalancesInfo([stakingAccount])
+    const missingBalance = OPENING_STAKE.sub(balances.availableBalance)
+    if (missingBalance.gtn(0)) {
+      await this.requireConfirmation(
+        `Do you wish to transfer remaining ${chalk.bold(
+          formatBalance(missingBalance)
+        )} to your staking account? (${stakingAccount})`
+      )
+      const account = await this.promptForAccount('Choose account to transfer the funds from')
+      await this.sendAndFollowNamedTx(await this.getDecodedPair(account), 'balances', 'transferKeepAlive', [
+        stakingAccount,
+        missingBalance,
+      ])
+    }
   }
 
   async run() {
-    const account = await this.getRequiredSelectedAccount()
     // lead-only gate
-    const lead = await this.getRequiredLead()
-    await this.requestAccountDecoding(account) // Prompt for password
+    const lead = await this.getRequiredLeadContext()
 
     const {
       flags: { input, output, edit, dryRun },
@@ -168,22 +103,24 @@ export default class WorkingGroupsCreateOpening extends WorkingGroupsCommandBase
     ensureOutputFileIsWriteable(output)
 
     let tryAgain = false
-    let rememberedInput: [WGOpeningJson, HRTJson] | undefined
+    let rememberedInput: OpeningParamsJson | undefined
     do {
       if (edit) {
         rememberedInput = await this.getInputFromFile(input as string)
       }
       // Either prompt for the data or get it from input file
-      const [openingJson, hrtJson] =
+      const openingJson =
         !input || edit || tryAgain
           ? await this.promptForData(lead, rememberedInput)
           : await this.getInputFromFile(input)
 
       // Remember the provided/fetched data in a variable
-      rememberedInput = [openingJson, hrtJson]
+      rememberedInput = openingJson
+
+      await this.promptForStakeTopUp(lead.stakingAccount.toString())
 
       // Generate and ask to confirm tx params
-      const txParams = this.createTxParams(openingJson, hrtJson)
+      const txParams = this.createTxParams(openingJson)
       this.jsonPrettyPrint(JSON.stringify(txParams))
       const confirmed = await this.simplePrompt({
         type: 'confirm',
@@ -209,10 +146,11 @@ export default class WorkingGroupsCreateOpening extends WorkingGroupsCommandBase
       }
 
       // Send the tx
-      this.log(chalk.white('Sending the extrinsic...'))
-      const txSuccess = await this.sendAndFollowTx(
-        account,
-        this.getOriginalApi().tx[apiModuleByGroup[this.group]].addOpening(...txParams),
+      const txSuccess = await this.sendAndFollowNamedTx(
+        await this.getDecodedPair(lead.roleAccount.toString()),
+        apiModuleByGroup[this.group],
+        'addOpening',
+        txParams,
         true // warnOnly
       )
 

cli/src/commands/working-groups/decreaseWorkerStake.ts

@@ -1,10 +1,10 @@
 import WorkingGroupsCommandBase from '../../base/WorkingGroupsCommandBase'
 import { apiModuleByGroup } from '../../Api'
-import { Balance } from '@polkadot/types/interfaces'
 import { formatBalance } from '@polkadot/util'
-import { minMaxInt } from '../../validators/common'
 import chalk from 'chalk'
-import { createParamOptions } from '../../helpers/promptOptions'
+import { isValidBalance } from '../../helpers/validation'
+import ExitCodes from '../../ExitCodes'
+import BN from 'bn.js'
 
 export default class WorkingGroupsDecreaseWorkerStake extends WorkingGroupsCommandBase {
   static description =
@@ -17,6 +17,11 @@ export default class WorkingGroupsDecreaseWorkerStake extends WorkingGroupsComma
       required: true,
       description: 'Worker ID',
     },
+    {
+      name: 'amount',
+      required: true,
+      description: 'Amount of JOY to decrease the current worker stake by',
+    },
   ]
 
   static flags = {
@@ -24,29 +29,31 @@ export default class WorkingGroupsDecreaseWorkerStake extends WorkingGroupsComma
   }
 
   async run() {
-    const { args } = this.parse(WorkingGroupsDecreaseWorkerStake)
+    const {
+      args: { workerId, amount },
+    } = this.parse(WorkingGroupsDecreaseWorkerStake)
 
-    const account = await this.getRequiredSelectedAccount()
     // Lead-only gate
-    await this.getRequiredLead()
+    const lead = await this.getRequiredLeadContext()
 
-    const workerId = parseInt(args.workerId)
-    const groupMember = await this.getWorkerWithStakeForLeadAction(workerId)
+    const groupMember = await this.getWorkerWithStakeForLeadAction(parseInt(workerId))
 
     this.log(chalk.white('Current worker stake: ', formatBalance(groupMember.stake)))
-    const balanceValidator = minMaxInt(1, groupMember.stake.toNumber())
-    const balance = (await this.promptForParam(
-      'Balance',
-      createParamOptions('amount', undefined, balanceValidator)
-    )) as Balance
 
-    await this.requestAccountDecoding(account)
+    if (!isValidBalance(amount) || groupMember.stake.lt(new BN(amount))) {
+      this.error('Invalid amount', { exit: ExitCodes.InvalidInput })
+    }
 
-    await this.sendAndFollowNamedTx(account, apiModuleByGroup[this.group], 'decreaseStake', [workerId, balance])
+    await this.sendAndFollowNamedTx(
+      await this.getDecodedPair(lead.roleAccount.toString()),
+      apiModuleByGroup[this.group],
+      'decreaseStake',
+      [workerId, amount]
+    )
 
     this.log(
       chalk.green(
-        `${chalk.white(formatBalance(balance))} from worker ${chalk.white(workerId)} stake ` +
+        `${chalk.white(formatBalance(amount))} from worker ${chalk.white(workerId)} stake ` +
           `has been returned to worker's role account (${chalk.white(groupMember.roleAccount.toString())})!`
       )
     )

cli/src/commands/working-groups/evictWorker.ts

@@ -2,7 +2,10 @@ import WorkingGroupsCommandBase from '../../base/WorkingGroupsCommandBase'
 import { apiModuleByGroup } from '../../Api'
 import { formatBalance } from '@polkadot/util'
 import chalk from 'chalk'
-import { createParamOptions } from '../../helpers/promptOptions'
+import { flags } from '@oclif/command'
+import { isValidBalance } from '../../helpers/validation'
+import ExitCodes from '../../ExitCodes'
+import BN from 'bn.js'
 
 export default class WorkingGroupsEvictWorker extends WorkingGroupsCommandBase {
   static description = 'Evicts given worker. Requires lead access.'
@@ -16,40 +19,46 @@ export default class WorkingGroupsEvictWorker extends WorkingGroupsCommandBase {
 
   static flags = {
     ...WorkingGroupsCommandBase.flags,
+    penalty: flags.string({
+      description: 'Optional penalty in JOY',
+      required: false,
+    }),
+    rationale: flags.string({
+      description: 'Optional rationale',
+      required: false,
+    }),
   }
 
   async run() {
-    const { args } = this.parse(WorkingGroupsEvictWorker)
+    const {
+      args,
+      flags: { penalty, rationale },
+    } = this.parse(WorkingGroupsEvictWorker)
 
-    const account = await this.getRequiredSelectedAccount()
-    // Lead-only gate
-    await this.getRequiredLead()
+    const lead = await this.getRequiredLeadContext()
 
     const workerId = parseInt(args.workerId)
     // This will also make sure the worker is valid
     const groupMember = await this.getWorkerForLeadAction(workerId)
 
-    // TODO: Terminate worker text limits? (minMaxStr)
-    const rationale = await this.promptForParam('Bytes', createParamOptions('rationale'))
-    const shouldSlash = groupMember.stake
-      ? await this.simplePrompt({
-          message: `Should the worker stake (${formatBalance(groupMember.stake)}) be slashed?`,
-          type: 'confirm',
-          default: false,
-        })
-      : false
-
-    await this.requestAccountDecoding(account)
-
-    await this.sendAndFollowNamedTx(account, apiModuleByGroup[this.group], 'terminateRole', [
-      workerId,
-      rationale,
-      shouldSlash,
-    ])
-
-    this.log(chalk.green(`Worker ${chalk.white(workerId)} has been evicted!`))
-    if (shouldSlash) {
-      this.log(chalk.green(`Worker stake totalling ${chalk.white(formatBalance(groupMember.stake))} has been slashed!`))
+    if (penalty && !isValidBalance(penalty)) {
+      this.error('Invalid penalty amount', { exit: ExitCodes.InvalidInput })
+    }
+
+    if (penalty && (!groupMember.stake || groupMember.stake.lt(new BN(penalty)))) {
+      this.error('Penalty cannot exceed worker stake', { exit: ExitCodes.InvalidInput })
+    }
+
+    await this.sendAndFollowNamedTx(
+      await this.getDecodedPair(lead.roleAccount.toString()),
+      apiModuleByGroup[this.group],
+      'terminateRole',
+      [workerId, penalty || null, rationale || null]
+    )
+
+    this.log(chalk.green(`Worker ${chalk.white(workerId.toString())} has been evicted!`))
+    if (penalty) {
+      this.log(chalk.green(`${chalk.white(formatBalance(penalty))} of worker's stake has been slashed!`))
     }
   }
 }

cli/src/commands/working-groups/fillOpening.ts

@@ -1,8 +1,8 @@
 import WorkingGroupsCommandBase from '../../base/WorkingGroupsCommandBase'
-import { OpeningStatus } from '../../Types'
 import { apiModuleByGroup } from '../../Api'
 import chalk from 'chalk'
-import { createParamOptions } from '../../helpers/promptOptions'
+import { JoyBTreeSet } from '@joystream/types/common'
+import { ApplicationId } from '@joystream/types/working-group'
 
 export default class WorkingGroupsFillOpening extends WorkingGroupsCommandBase {
   static description = "Allows filling working group opening that's currently in review. Requires lead access."
@@ -21,25 +21,22 @@ export default class WorkingGroupsFillOpening extends WorkingGroupsCommandBase {
   async run() {
     const { args } = this.parse(WorkingGroupsFillOpening)
 
-    const account = await this.getRequiredSelectedAccount()
     // Lead-only gate
-    await this.getRequiredLead()
+    const lead = await this.getRequiredLeadContext()
 
     const openingId = parseInt(args.wgOpeningId)
-    const opening = await this.getOpeningForLeadAction(openingId, OpeningStatus.InReview)
+    const opening = await this.getOpeningForLeadAction(openingId)
 
     const applicationIds = await this.promptForApplicationsToAccept(opening)
-    const rewardPolicyOpt = await this.promptForParam(`Option<RewardPolicy>`, createParamOptions('RewardPolicy'))
 
-    await this.requestAccountDecoding(account)
-
-    await this.sendAndFollowNamedTx(account, apiModuleByGroup[this.group], 'fillOpening', [
-      openingId,
-      applicationIds,
-      rewardPolicyOpt,
-    ])
+    await this.sendAndFollowNamedTx(
+      await this.getDecodedPair(lead.roleAccount.toString()),
+      apiModuleByGroup[this.group],
+      'fillOpening',
+      [openingId, new (JoyBTreeSet(ApplicationId))(this.getTypesRegistry(), applicationIds)]
+    )
 
-    this.log(chalk.green(`Opening ${chalk.white(openingId)} succesfully filled!`))
+    this.log(chalk.green(`Opening ${chalk.white(openingId.toString())} succesfully filled!`))
     this.log(
       chalk.green('Accepted working group application IDs: ') +
         chalk.white(applicationIds.length ? applicationIds.join(chalk.green(', ')) : 'NONE')

cli/src/commands/working-groups/increaseStake.ts

@@ -1,41 +1,47 @@
 import WorkingGroupsCommandBase from '../../base/WorkingGroupsCommandBase'
 import { apiModuleByGroup } from '../../Api'
-import { Balance } from '@polkadot/types/interfaces'
 import { formatBalance } from '@polkadot/util'
-import { positiveInt } from '../../validators/common'
 import chalk from 'chalk'
 import ExitCodes from '../../ExitCodes'
-import { createParamOptions } from '../../helpers/promptOptions'
+import { isValidBalance } from '../../helpers/validation'
 
 export default class WorkingGroupsIncreaseStake extends WorkingGroupsCommandBase {
   static description = 'Increases current role (lead/worker) stake. Requires active role account to be selected.'
+  static args = [
+    {
+      name: 'amount',
+      required: true,
+      description: 'Amount of JOY to increase the current stake by',
+    },
+  ]
+
   static flags = {
     ...WorkingGroupsCommandBase.flags,
   }
 
   async run() {
-    const account = await this.getRequiredSelectedAccount()
     // Worker-only gate
-    const worker = await this.getRequiredWorker()
-
-    if (!worker.stake) {
-      this.error('Cannot increase stake. No associated role stake profile found!', { exit: ExitCodes.InvalidInput })
-    }
+    const worker = await this.getRequiredWorkerContext()
 
-    this.log(chalk.white('Current stake: ', formatBalance(worker.stake)))
-    const balance = (await this.promptForParam(
-      'Balance',
-      createParamOptions('amount', undefined, positiveInt())
-    )) as Balance
+    const {
+      args: { amount },
+    } = this.parse(WorkingGroupsIncreaseStake)
 
-    await this.requestAccountDecoding(account)
+    if (!isValidBalance(amount)) {
+      this.error('Invalid stake amount!', { exit: ExitCodes.InvalidInput })
+    }
 
-    await this.sendAndFollowNamedTx(account, apiModuleByGroup[this.group], 'increaseStake', [worker.workerId, balance])
+    await this.sendAndFollowNamedTx(
+      await this.getDecodedPair(worker.roleAccount.toString()),
+      apiModuleByGroup[this.group],
+      'increaseStake',
+      [worker.workerId, amount]
+    )
 
     this.log(
       chalk.green(
-        `Worker ${chalk.white(worker.workerId.toNumber())} stake has been increased by ${chalk.white(
-          formatBalance(balance)
+        `Worker ${chalk.white(worker.workerId.toString())} stake has been increased by ${chalk.white(
+          formatBalance(amount)
         )}`
       )
     )

cli/src/commands/working-groups/leaveRole.ts

@@ -1,28 +1,33 @@
 import WorkingGroupsCommandBase from '../../base/WorkingGroupsCommandBase'
 import { apiModuleByGroup } from '../../Api'
-import { minMaxStr } from '../../validators/common'
 import chalk from 'chalk'
-import { createParamOptions } from '../../helpers/promptOptions'
+import { flags } from '@oclif/command'
 
 export default class WorkingGroupsLeaveRole extends WorkingGroupsCommandBase {
   static description = 'Leave the worker or lead role associated with currently selected account.'
   static flags = {
     ...WorkingGroupsCommandBase.flags,
+    rationale: flags.string({
+      name: 'Optional rationale',
+      required: false,
+    }),
   }
 
   async run() {
-    const account = await this.getRequiredSelectedAccount()
     // Worker-only gate
-    const worker = await this.getRequiredWorker()
+    const worker = await this.getRequiredWorkerContext()
 
-    const constraint = await this.getApi().workerExitRationaleConstraint(this.group)
-    const rationaleValidator = minMaxStr(constraint.min.toNumber(), constraint.max.toNumber())
-    const rationale = await this.promptForParam('Bytes', createParamOptions('rationale', undefined, rationaleValidator))
+    const {
+      flags: { rationale },
+    } = this.parse(WorkingGroupsLeaveRole)
 
-    await this.requestAccountDecoding(account)
+    await this.sendAndFollowNamedTx(
+      await this.getDecodedPair(worker.roleAccount.toString()),
+      apiModuleByGroup[this.group],
+      'leaveRole',
+      [worker.workerId, rationale || null]
+    )
 
-    await this.sendAndFollowNamedTx(account, apiModuleByGroup[this.group], 'leaveRole', [worker.workerId, rationale])
-
-    this.log(chalk.green(`Succesfully left the role! (worker id: ${chalk.white(worker.workerId.toNumber())})`))
+    this.log(chalk.green(`Succesfully left the role! (worker id: ${chalk.white(worker.workerId.toString())})`))
   }
 }

cli/src/commands/working-groups/opening.ts

@@ -1,10 +1,6 @@
 import WorkingGroupsCommandBase from '../../base/WorkingGroupsCommandBase'
-import { displayTable, displayCollapsedRow, displayHeader } from '../../helpers/display'
-import _ from 'lodash'
-import { OpeningStatus, GroupOpeningStage, GroupOpeningStakes, UnstakingPeriodsKey } from '../../Types'
-import { StakingAmountLimitModeKeys, StakingPolicy } from '@joystream/types/hiring'
+import { displayTable, displayCollapsedRow, displayHeader, shortAddress, memberHandle } from '../../helpers/display'
 import { formatBalance } from '@polkadot/util'
-import chalk from 'chalk'
 
 export default class WorkingGroupsOpening extends WorkingGroupsCommandBase {
   static description = 'Shows an overview of given working group opening by Working Group Opening ID'
@@ -20,69 +16,40 @@ export default class WorkingGroupsOpening extends WorkingGroupsCommandBase {
     ...WorkingGroupsCommandBase.flags,
   }
 
-  stageColumns(stage: GroupOpeningStage) {
-    const { status, date, block } = stage
-    const statusTimeHeader = status === OpeningStatus.WaitingToBegin ? 'Starts at' : 'Last status change'
-    return {
-      Stage: _.startCase(status),
-      [statusTimeHeader]:
-        date && block
-          ? `~ ${date.toLocaleTimeString()} ${date.toLocaleDateString()} (#${block})`
-          : (block && `#${block}`) || '?',
-    }
-  }
-
-  formatStake(stake: StakingPolicy | undefined) {
-    if (!stake) return 'NONE'
-    const { amount, amount_mode: amountMode } = stake
-    return amountMode.type === StakingAmountLimitModeKeys.AtLeast
-      ? `>= ${formatBalance(amount)}`
-      : `== ${formatBalance(amount)}`
-  }
-
-  stakeColumns(stakes: GroupOpeningStakes) {
-    const { role, application } = stakes
-    return {
-      'Application stake': this.formatStake(application),
-      'Role stake': this.formatStake(role),
-    }
-  }
-
   async run() {
     const { args } = this.parse(WorkingGroupsOpening)
 
     const opening = await this.getApi().groupOpening(this.group, parseInt(args.wgOpeningId))
 
-    displayHeader('Human readable text')
-    this.jsonPrettyPrint(opening.opening.human_readable_text.toString())
+    // TODO: Opening desc?
 
     displayHeader('Opening details')
     const openingRow = {
-      'WG Opening ID': opening.wgOpeningId,
       'Opening ID': opening.openingId,
-      Type: opening.type.type,
-      ...this.stageColumns(opening.stage),
-      ...this.stakeColumns(opening.stakes),
+      'Opening type': opening.type.type,
+      'Created': `#${opening.createdAtBlock}`,
+      'Reward per block': formatBalance(opening.rewardPerBlock),
     }
     displayCollapsedRow(openingRow)
 
-    displayHeader('Unstaking periods')
-    const periodsRow: { [k: string]: string } = {}
-    for (const key of Object.keys(opening.unstakingPeriods).sort()) {
-      const displayKey = _.startCase(key) + ':  '
-      periodsRow[displayKey] = opening.unstakingPeriods[key as UnstakingPeriodsKey].toLocaleString() + ' blocks'
+    displayHeader('Staking policy')
+    if (opening.stake) {
+      const stakingRow = {
+        'Stake amount': formatBalance(opening.stake.value),
+        'Unstaking period': opening.stake.unstakingPeriod.toLocaleString() + ' blocks',
+      }
+      displayCollapsedRow(stakingRow)
+    } else {
+      this.log('NONE')
     }
-    displayCollapsedRow(periodsRow)
 
     displayHeader(`Applications (${opening.applications.length})`)
     const applicationsRows = opening.applications.map((a) => ({
-      'WG appl. ID': a.wgApplicationId,
-      'Appl. ID': a.applicationId,
-      Member: a.member?.handle.toString() || chalk.red('NONE'),
-      Stage: a.stage,
-      'Appl. stake': a.stakes.application,
-      'Role stake': a.stakes.role,
-      'Total stake': Object.values(a.stakes).reduce((a, b) => a + b),
+      'ID': a.applicationId,
+      Member: memberHandle(a.member),
+      'Role Acc': shortAddress(a.roleAccout),
+      'Reward Acc': shortAddress(a.rewardAccount),
+      'Staking Acc': a.stakingAccount ? shortAddress(a.stakingAccount) : 'NONE',
     }))
     displayTable(applicationsRows, 5)
   }

cli/src/commands/working-groups/openings.ts

@@ -1,6 +1,5 @@
 import WorkingGroupsCommandBase from '../../base/WorkingGroupsCommandBase'
 import { displayTable } from '../../helpers/display'
-import _ from 'lodash'
 
 export default class WorkingGroupsOpenings extends WorkingGroupsCommandBase {
   static description = 'Shows an overview of given working group openings'
@@ -12,9 +11,8 @@ export default class WorkingGroupsOpenings extends WorkingGroupsCommandBase {
     const openings = await this.getApi().openingsByGroup(this.group)
 
     const openingsRows = openings.map((o) => ({
-      'WG Opening ID': o.wgOpeningId,
+      'Opening ID': o.openingId,
       Type: o.type.type,
-      Stage: `${_.startCase(o.stage.status)}${o.stage.block ? ` (#${o.stage.block})` : ''}`,
       Applications: o.applications.length,
     }))
     displayTable(openingsRows, 5)

cli/src/commands/working-groups/overview.ts

@@ -1,5 +1,5 @@
 import WorkingGroupsCommandBase from '../../base/WorkingGroupsCommandBase'
-import { displayHeader, displayNameValueTable, displayTable, shortAddress } from '../../helpers/display'
+import { displayHeader, displayNameValueTable, displayTable, memberHandle, shortAddress } from '../../helpers/display'
 import { formatBalance } from '@polkadot/util'
 
 import chalk from 'chalk'
@@ -18,27 +18,28 @@ export default class WorkingGroupsOverview extends WorkingGroupsCommandBase {
     if (lead) {
       displayNameValueTable([
         { name: 'Member id:', value: lead.memberId.toString() },
-        { name: 'Member handle:', value: lead.profile.handle.toString() },
+        { name: 'Member handle:', value: memberHandle(lead.profile) },
         { name: 'Role account:', value: lead.roleAccount.toString() },
       ])
     } else {
       this.log(chalk.yellow('No lead assigned!'))
     }
 
-    const accounts = this.fetchAccounts()
+    const pairs = this.getPairs()
 
     displayHeader('Members')
     const membersRows = members.map((m) => ({
       'Worker id': m.workerId.toString(),
       'Member id': m.memberId.toString(),
-      'Member handle': m.profile.handle.toString(),
+      'Member handle': memberHandle(m.profile),
       Stake: formatBalance(m.stake),
-      Earned: formatBalance(m.reward?.totalRecieved),
+      'Reward': formatBalance(m.reward?.valuePerBlock),
+      'Missed reward': formatBalance(m.reward?.totalMissed),
       'Role account': shortAddress(m.roleAccount),
       '':
         (lead?.workerId.eq(m.workerId) ? '\u{2B50}' : '  ') +
         ' ' +
-        (accounts.some((a) => a.address === m.roleAccount.toString()) ? '\u{1F511}' : '  '),
+        (pairs.some((p) => p.address === m.roleAccount.toString()) ? '\u{1F511}' : '  '),
     }))
     displayTable(membersRows, 5)
 

cli/src/commands/working-groups/slashWorker.ts

@@ -1,10 +1,11 @@
 import WorkingGroupsCommandBase from '../../base/WorkingGroupsCommandBase'
 import { apiModuleByGroup } from '../../Api'
-import { Balance } from '@polkadot/types/interfaces'
 import { formatBalance } from '@polkadot/util'
-import { minMaxInt } from '../../validators/common'
 import chalk from 'chalk'
-import { createParamOptions } from '../../helpers/promptOptions'
+import { flags } from '@oclif/command'
+import { isValidBalance } from '../../helpers/validation'
+import ExitCodes from '../../ExitCodes'
+import BN from 'bn.js'
 
 export default class WorkingGroupsSlashWorker extends WorkingGroupsCommandBase {
   static description = 'Slashes given worker stake. Requires lead access.'
@@ -14,37 +15,49 @@ export default class WorkingGroupsSlashWorker extends WorkingGroupsCommandBase {
       required: true,
       description: 'Worker ID',
     },
+    {
+      name: 'amount',
+      required: true,
+      description: 'Slash amount',
+    },
   ]
 
   static flags = {
     ...WorkingGroupsCommandBase.flags,
+    rationale: flags.string({
+      name: 'Optional rationale',
+      required: false,
+    }),
   }
 
   async run() {
-    const { args } = this.parse(WorkingGroupsSlashWorker)
+    const {
+      args: { amount, workerId },
+      flags: { rationale },
+    } = this.parse(WorkingGroupsSlashWorker)
 
-    const account = await this.getRequiredSelectedAccount()
     // Lead-only gate
-    await this.getRequiredLead()
+    const lead = await this.getRequiredLeadContext()
 
-    const workerId = parseInt(args.workerId)
-    const groupMember = await this.getWorkerWithStakeForLeadAction(workerId)
+    const groupMember = await this.getWorkerWithStakeForLeadAction(parseInt(workerId))
 
     this.log(chalk.white('Current worker stake: ', formatBalance(groupMember.stake)))
-    const balanceValidator = minMaxInt(1, groupMember.stake.toNumber())
-    const balance = (await this.promptForParam(
-      'Balance',
-      createParamOptions('amount', undefined, balanceValidator)
-    )) as Balance
 
-    await this.requestAccountDecoding(account)
+    if (!isValidBalance(amount) || groupMember.stake.lt(new BN(amount))) {
+      this.error('Invalid slash amount', { exit: ExitCodes.InvalidInput })
+    }
 
-    await this.sendAndFollowNamedTx(account, apiModuleByGroup[this.group], 'slashStake', [workerId, balance])
+    await this.sendAndFollowNamedTx(
+      await this.getDecodedPair(lead.roleAccount.toString()),
+      apiModuleByGroup[this.group],
+      'slashStake',
+      [workerId, amount, rationale || null]
+    )
 
     this.log(
       chalk.green(
-        `${chalk.white(formatBalance(balance))} from worker ${chalk.white(
-          workerId
+        `${chalk.white(formatBalance(amount))} from worker ${chalk.white(
+          workerId.toString()
         )} stake has been succesfully slashed!`
       )
     )

cli/src/commands/working-groups/startAcceptingApplications.ts

@@ -1,38 +0,0 @@
-import WorkingGroupsCommandBase from '../../base/WorkingGroupsCommandBase'
-import { OpeningStatus } from '../../Types'
-import { apiModuleByGroup } from '../../Api'
-import chalk from 'chalk'
-
-export default class WorkingGroupsStartAcceptingApplications extends WorkingGroupsCommandBase {
-  static description = 'Changes the status of pending opening to "Accepting applications". Requires lead access.'
-  static args = [
-    {
-      name: 'wgOpeningId',
-      required: true,
-      description: 'Working Group Opening ID',
-    },
-  ]
-
-  static flags = {
-    ...WorkingGroupsCommandBase.flags,
-  }
-
-  async run() {
-    const { args } = this.parse(WorkingGroupsStartAcceptingApplications)
-
-    const account = await this.getRequiredSelectedAccount()
-    // Lead-only gate
-    await this.getRequiredLead()
-
-    const openingId = parseInt(args.wgOpeningId)
-    await this.validateOpeningForLeadAction(openingId, OpeningStatus.WaitingToBegin)
-
-    await this.requestAccountDecoding(account)
-
-    await this.sendAndFollowNamedTx(account, apiModuleByGroup[this.group], 'acceptApplications', [openingId])
-
-    this.log(
-      chalk.green(`Opening ${chalk.white(openingId)} status changed to: ${chalk.white('Accepting Applications')}`)
-    )
-  }
-}

cli/src/commands/working-groups/startReviewPeriod.ts

@@ -1,36 +0,0 @@
-import WorkingGroupsCommandBase from '../../base/WorkingGroupsCommandBase'
-import { OpeningStatus } from '../../Types'
-import { apiModuleByGroup } from '../../Api'
-import chalk from 'chalk'
-
-export default class WorkingGroupsStartReviewPeriod extends WorkingGroupsCommandBase {
-  static description = 'Changes the status of active opening to "In review". Requires lead access.'
-  static args = [
-    {
-      name: 'wgOpeningId',
-      required: true,
-      description: 'Working Group Opening ID',
-    },
-  ]
-
-  static flags = {
-    ...WorkingGroupsCommandBase.flags,
-  }
-
-  async run() {
-    const { args } = this.parse(WorkingGroupsStartReviewPeriod)
-
-    const account = await this.getRequiredSelectedAccount()
-    // Lead-only gate
-    await this.getRequiredLead()
-
-    const openingId = parseInt(args.wgOpeningId)
-    await this.validateOpeningForLeadAction(openingId, OpeningStatus.AcceptingApplications)
-
-    await this.requestAccountDecoding(account)
-
-    await this.sendAndFollowNamedTx(account, apiModuleByGroup[this.group], 'beginApplicantReview', [openingId])
-
-    this.log(chalk.green(`Opening ${chalk.white(openingId)} status changed to: ${chalk.white('In Review')}`))
-  }
-}

cli/src/commands/working-groups/terminateApplication.ts

@@ -1,37 +0,0 @@
-import WorkingGroupsCommandBase from '../../base/WorkingGroupsCommandBase'
-import { apiModuleByGroup } from '../../Api'
-import { ApplicationStageKeys } from '@joystream/types/hiring'
-import chalk from 'chalk'
-
-export default class WorkingGroupsTerminateApplication extends WorkingGroupsCommandBase {
-  static description = 'Terminates given working group application. Requires lead access.'
-  static args = [
-    {
-      name: 'wgApplicationId',
-      required: true,
-      description: 'Working Group Application ID',
-    },
-  ]
-
-  static flags = {
-    ...WorkingGroupsCommandBase.flags,
-  }
-
-  async run() {
-    const { args } = this.parse(WorkingGroupsTerminateApplication)
-
-    const account = await this.getRequiredSelectedAccount()
-    // Lead-only gate
-    await this.getRequiredLead()
-
-    const applicationId = parseInt(args.wgApplicationId)
-    // We don't really need the application itself here, so this one is just for validation purposes
-    await this.getApplicationForLeadAction(applicationId, ApplicationStageKeys.Active)
-
-    await this.requestAccountDecoding(account)
-
-    await this.sendAndFollowNamedTx(account, apiModuleByGroup[this.group], 'terminateApplication', [applicationId])
-
-    this.log(chalk.green(`Application ${chalk.white(applicationId)} has been succesfully terminated!`))
-  }
-}

cli/src/commands/working-groups/updateRewardAccount.ts

@@ -8,7 +8,7 @@ export default class WorkingGroupsUpdateRewardAccount extends WorkingGroupsComma
   static description = 'Updates the worker/lead reward account (requires current role account to be selected)'
   static args = [
     {
-      name: 'accountAddress',
+      name: 'address',
       required: false,
       description: 'New reward account address (if omitted, one of the existing CLI accounts can be selected)',
     },
@@ -19,30 +19,28 @@ export default class WorkingGroupsUpdateRewardAccount extends WorkingGroupsComma
   }
 
   async run() {
-    const { args } = this.parse(WorkingGroupsUpdateRewardAccount)
+    let { address } = this.parse(WorkingGroupsUpdateRewardAccount).args
 
-    const account = await this.getRequiredSelectedAccount()
     // Worker-only gate
-    const worker = await this.getRequiredWorker()
+    const worker = await this.getRequiredWorkerContext()
 
-    if (!worker.reward) {
+    if (!worker.reward.valuePerBlock) {
       this.error('There is no reward relationship associated with this role!', { exit: ExitCodes.InvalidInput })
     }
 
-    let newRewardAccount: string = args.accountAddress
-    if (!newRewardAccount) {
-      const accounts = await this.fetchAccounts()
-      newRewardAccount = (await this.promptForAccount(accounts, undefined, 'Choose the new reward account')).address
+    if (!address) {
+      address = await this.promptForAnyAddress('Select new reward account')
+    } else if (validateAddress(address) !== true) {
+      this.error('Invalid address', { exit: ExitCodes.InvalidInput })
     }
-    validateAddress(newRewardAccount)
 
-    await this.requestAccountDecoding(account)
+    await this.sendAndFollowNamedTx(
+      await this.getDecodedPair(worker.roleAccount.toString()),
+      apiModuleByGroup[this.group],
+      'updateRewardAccount',
+      [worker.workerId, address]
+    )
 
-    await this.sendAndFollowNamedTx(account, apiModuleByGroup[this.group], 'updateRewardAccount', [
-      worker.workerId,
-      newRewardAccount,
-    ])
-
-    this.log(chalk.green(`Succesfully updated the reward account to: ${chalk.white(newRewardAccount)})`))
+    this.log(chalk.green(`Succesfully updated the reward account to: ${chalk.white(address)})`))
   }
 }

cli/src/commands/working-groups/updateRoleAccount.ts

@@ -2,14 +2,15 @@ import WorkingGroupsCommandBase from '../../base/WorkingGroupsCommandBase'
 import { apiModuleByGroup } from '../../Api'
 import { validateAddress } from '../../helpers/validation'
 import chalk from 'chalk'
+import ExitCodes from '../../ExitCodes'
 
 export default class WorkingGroupsUpdateRoleAccount extends WorkingGroupsCommandBase {
   static description = 'Updates the worker/lead role account. Requires member controller account to be selected'
   static args = [
     {
-      name: 'accountAddress',
+      name: 'address',
       required: false,
-      description: 'New role account address (if omitted, one of the existing CLI accounts can be selected)',
+      description: 'New role account address (if omitted, can be provided interactively)',
     },
   ]
 
@@ -18,41 +19,23 @@ export default class WorkingGroupsUpdateRoleAccount extends WorkingGroupsCommand
   }
 
   async run() {
-    const { args } = this.parse(WorkingGroupsUpdateRoleAccount)
+    let { address } = this.parse(WorkingGroupsUpdateRoleAccount).args
 
-    const account = await this.getRequiredSelectedAccount()
-    const worker = await this.getRequiredWorkerByMemberController()
+    const worker = await this.getRequiredWorkerContext('MemberController')
 
-    const cliAccounts = await this.fetchAccounts()
-    let newRoleAccount: string = args.accountAddress
-    if (!newRoleAccount) {
-      newRoleAccount = (await this.promptForAccount(cliAccounts, undefined, 'Choose the new role account')).address
+    if (!address) {
+      address = await this.promptForAnyAddress('Select new role account')
+    } else if (validateAddress(address) !== true) {
+      this.error('Invalid address', { exit: ExitCodes.InvalidInput })
     }
-    validateAddress(newRoleAccount)
 
-    await this.requestAccountDecoding(account)
+    await this.sendAndFollowNamedTx(
+      await this.getDecodedPair(worker.profile.membership.controller_account.toString()),
+      apiModuleByGroup[this.group],
+      'updateRoleAccount',
+      [worker.workerId, address]
+    )
 
-    await this.sendAndFollowNamedTx(account, apiModuleByGroup[this.group], 'updateRoleAccount', [
-      worker.workerId,
-      newRoleAccount,
-    ])
-
-    this.log(chalk.green(`Succesfully updated the role account to: ${chalk.white(newRoleAccount)})`))
-
-    const matchingAccount = cliAccounts.find((account) => account.address === newRoleAccount)
-    if (matchingAccount) {
-      const switchAccount = await this.simplePrompt({
-        type: 'confirm',
-        message: 'Do you want to switch the currenly selected CLI account to the new role account?',
-        default: false,
-      })
-      if (switchAccount) {
-        await this.setSelectedAccount(matchingAccount)
-        this.log(
-          chalk.green('Account switched to: ') +
-            chalk.white(`${matchingAccount.meta.name} (${matchingAccount.address})`)
-        )
-      }
-    }
+    this.log(chalk.green(`Succesfully updated the role account to: ${chalk.white(address)})`))
   }
 }

cli/src/commands/working-groups/updateWorkerReward.ts

@@ -3,9 +3,8 @@ import { apiModuleByGroup } from '../../Api'
 import { formatBalance } from '@polkadot/util'
 import chalk from 'chalk'
 import { Reward } from '../../Types'
-import { positiveInt } from '../../validators/common'
-import { createParamOptions } from '../../helpers/promptOptions'
 import ExitCodes from '../../ExitCodes'
+import { isValidBalance } from '../../helpers/validation'
 
 export default class WorkingGroupsUpdateWorkerReward extends WorkingGroupsCommandBase {
   static description = "Change given worker's reward (amount only). Requires lead access."
@@ -15,53 +14,48 @@ export default class WorkingGroupsUpdateWorkerReward extends WorkingGroupsComman
       required: true,
       description: 'Worker ID',
     },
+    {
+      name: 'newReward',
+      required: true,
+      description: 'New reward',
+    },
   ]
 
   static flags = {
     ...WorkingGroupsCommandBase.flags,
   }
 
-  formatReward(reward?: Reward) {
-    return reward
-      ? formatBalance(reward.value) +
-          (reward.interval ? ` / ${reward.interval} block(s)` : '') +
-          (reward.nextPaymentBlock ? ` (next payment: #${reward.nextPaymentBlock})` : '')
-      : 'NONE'
+  formatReward(reward?: Reward): string {
+    return reward ? formatBalance(reward.valuePerBlock) + ' / block' : 'NONE'
   }
 
   async run() {
-    const { args } = this.parse(WorkingGroupsUpdateWorkerReward)
+    const {
+      args: { workerId, newReward },
+    } = this.parse(WorkingGroupsUpdateWorkerReward)
+
+    if (!isValidBalance(newReward)) {
+      this.error('Invalid reward', { exit: ExitCodes.InvalidInput })
+    }
 
-    const account = await this.getRequiredSelectedAccount()
-    // Lead-only gate
-    await this.getRequiredLead()
+    const lead = await this.getRequiredLeadContext()
 
-    const workerId = parseInt(args.workerId)
     // This will also make sure the worker is valid
     const groupMember = await this.getWorkerForLeadAction(workerId)
 
     const { reward } = groupMember
 
-    if (!reward) {
-      this.error('There is no reward relationship associated with this worker!', { exit: ExitCodes.InvalidInput })
-    }
-
-    console.log(chalk.white(`Current worker reward: ${this.formatReward(reward)}`))
+    this.log(chalk.white(`Current worker reward: ${this.formatReward(reward)}`))
 
-    const newRewardValue = await this.promptForParam(
-      'BalanceOfMint',
-      createParamOptions('new_amount', undefined, positiveInt())
+    await this.sendAndFollowNamedTx(
+      await this.getDecodedPair(lead.roleAccount.toString()),
+      apiModuleByGroup[this.group],
+      'updateRewardAmount',
+      [workerId, newReward]
     )
 
-    await this.requestAccountDecoding(account)
-
-    await this.sendAndFollowNamedTx(account, apiModuleByGroup[this.group], 'updateRewardAmount', [
-      workerId,
-      newRewardValue,
-    ])
-
     const updatedGroupMember = await this.getApi().groupMember(this.group, workerId)
-    this.log(chalk.green(`Worker ${chalk.white(workerId)} reward has been updated!`))
+    this.log(chalk.green(`Worker ${chalk.white(workerId.toString())} reward has been updated!`))
     this.log(chalk.green(`New worker reward: ${chalk.white(this.formatReward(updatedGroupMember.reward))}`))
   }
 }

cli/src/graphql/generated/queries.ts

@@ -0,0 +1,37 @@
+import * as Types from './schema'
+
+import gql from 'graphql-tag'
+export type MemberMetadataFieldsFragment = { name?: Types.Maybe<string>; about?: Types.Maybe<string> }
+
+export type MembershipFieldsFragment = { id: string; handle: string; metadata: MemberMetadataFieldsFragment }
+
+export type GetMemberByIdQueryVariables = Types.Exact<{
+  id: Types.Scalars['ID']
+}>
+
+export type GetMemberByIdQuery = { membershipByUniqueInput?: Types.Maybe<MembershipFieldsFragment> }
+
+export const MemberMetadataFields = gql`
+  fragment MemberMetadataFields on MemberMetadata {
+    name
+    about
+  }
+`
+export const MembershipFields = gql`
+  fragment MembershipFields on Membership {
+    id
+    handle
+    metadata {
+      ...MemberMetadataFields
+    }
+  }
+  ${MemberMetadataFields}
+`
+export const GetMemberById = gql`
+  query getMemberById($id: ID!) {
+    membershipByUniqueInput(where: { id: $id }) {
+      ...MembershipFields
+    }
+  }
+  ${MembershipFields}
+`

cli/src/graphql/generated/schema.ts

@@ -0,0 +1,9255 @@
+export type Maybe<T> = T | null
+export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] }
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> }
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> }
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+  ID: string
+  String: string
+  Boolean: boolean
+  Int: number
+  Float: number
+  /** The javascript `Date` as string. Type represents date and time as the ISO Date string. */
+  DateTime: any
+  /** GraphQL representation of BigInt */
+  BigInt: any
+  /** The `JSONObject` scalar type represents JSON objects as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
+  JSONObject: any
+}
+
+export type ApplicationFormQuestion = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  openingMetadata: WorkingGroupOpeningMetadata
+  openingMetadataId: Scalars['String']
+  /** The question itself */
+  question?: Maybe<Scalars['String']>
+  /** Type of the question (UI answer input type) */
+  type: ApplicationFormQuestionType
+  /** Index of the question */
+  index: Scalars['Int']
+  applicationformquestionanswerquestion?: Maybe<Array<ApplicationFormQuestionAnswer>>
+}
+
+export type ApplicationFormQuestionAnswer = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  application: WorkingGroupApplication
+  applicationId: Scalars['String']
+  question: ApplicationFormQuestion
+  questionId: Scalars['String']
+  /** Applicant's answer */
+  answer: Scalars['String']
+}
+
+export type ApplicationFormQuestionAnswerConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<ApplicationFormQuestionAnswerEdge>
+  pageInfo: PageInfo
+}
+
+export type ApplicationFormQuestionAnswerCreateInput = {
+  application: Scalars['ID']
+  question: Scalars['ID']
+  answer: Scalars['String']
+}
+
+export type ApplicationFormQuestionAnswerEdge = {
+  node: ApplicationFormQuestionAnswer
+  cursor: Scalars['String']
+}
+
+export enum ApplicationFormQuestionAnswerOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  ApplicationAsc = 'application_ASC',
+  ApplicationDesc = 'application_DESC',
+  QuestionAsc = 'question_ASC',
+  QuestionDesc = 'question_DESC',
+  AnswerAsc = 'answer_ASC',
+  AnswerDesc = 'answer_DESC',
+}
+
+export type ApplicationFormQuestionAnswerUpdateInput = {
+  application?: Maybe<Scalars['ID']>
+  question?: Maybe<Scalars['ID']>
+  answer?: Maybe<Scalars['String']>
+}
+
+export type ApplicationFormQuestionAnswerWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  application_eq?: Maybe<Scalars['ID']>
+  application_in?: Maybe<Array<Scalars['ID']>>
+  question_eq?: Maybe<Scalars['ID']>
+  question_in?: Maybe<Array<Scalars['ID']>>
+  answer_eq?: Maybe<Scalars['String']>
+  answer_contains?: Maybe<Scalars['String']>
+  answer_startsWith?: Maybe<Scalars['String']>
+  answer_endsWith?: Maybe<Scalars['String']>
+  answer_in?: Maybe<Array<Scalars['String']>>
+  application?: Maybe<WorkingGroupApplicationWhereInput>
+  question?: Maybe<ApplicationFormQuestionWhereInput>
+  AND?: Maybe<Array<ApplicationFormQuestionAnswerWhereInput>>
+  OR?: Maybe<Array<ApplicationFormQuestionAnswerWhereInput>>
+}
+
+export type ApplicationFormQuestionAnswerWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type ApplicationFormQuestionConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<ApplicationFormQuestionEdge>
+  pageInfo: PageInfo
+}
+
+export type ApplicationFormQuestionCreateInput = {
+  openingMetadata: Scalars['ID']
+  question?: Maybe<Scalars['String']>
+  type: ApplicationFormQuestionType
+  index: Scalars['Float']
+}
+
+export type ApplicationFormQuestionEdge = {
+  node: ApplicationFormQuestion
+  cursor: Scalars['String']
+}
+
+export enum ApplicationFormQuestionOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  OpeningMetadataAsc = 'openingMetadata_ASC',
+  OpeningMetadataDesc = 'openingMetadata_DESC',
+  QuestionAsc = 'question_ASC',
+  QuestionDesc = 'question_DESC',
+  TypeAsc = 'type_ASC',
+  TypeDesc = 'type_DESC',
+  IndexAsc = 'index_ASC',
+  IndexDesc = 'index_DESC',
+}
+
+export enum ApplicationFormQuestionType {
+  Text = 'TEXT',
+  Textarea = 'TEXTAREA',
+}
+
+export type ApplicationFormQuestionUpdateInput = {
+  openingMetadata?: Maybe<Scalars['ID']>
+  question?: Maybe<Scalars['String']>
+  type?: Maybe<ApplicationFormQuestionType>
+  index?: Maybe<Scalars['Float']>
+}
+
+export type ApplicationFormQuestionWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  openingMetadata_eq?: Maybe<Scalars['ID']>
+  openingMetadata_in?: Maybe<Array<Scalars['ID']>>
+  question_eq?: Maybe<Scalars['String']>
+  question_contains?: Maybe<Scalars['String']>
+  question_startsWith?: Maybe<Scalars['String']>
+  question_endsWith?: Maybe<Scalars['String']>
+  question_in?: Maybe<Array<Scalars['String']>>
+  type_eq?: Maybe<ApplicationFormQuestionType>
+  type_in?: Maybe<Array<ApplicationFormQuestionType>>
+  index_eq?: Maybe<Scalars['Int']>
+  index_gt?: Maybe<Scalars['Int']>
+  index_gte?: Maybe<Scalars['Int']>
+  index_lt?: Maybe<Scalars['Int']>
+  index_lte?: Maybe<Scalars['Int']>
+  index_in?: Maybe<Array<Scalars['Int']>>
+  openingMetadata?: Maybe<WorkingGroupOpeningMetadataWhereInput>
+  applicationformquestionanswerquestion_none?: Maybe<ApplicationFormQuestionAnswerWhereInput>
+  applicationformquestionanswerquestion_some?: Maybe<ApplicationFormQuestionAnswerWhereInput>
+  applicationformquestionanswerquestion_every?: Maybe<ApplicationFormQuestionAnswerWhereInput>
+  AND?: Maybe<Array<ApplicationFormQuestionWhereInput>>
+  OR?: Maybe<Array<ApplicationFormQuestionWhereInput>>
+}
+
+export type ApplicationFormQuestionWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type ApplicationStatusAccepted = {
+  /** Related OpeningFilled event */
+  openingFilledEvent?: Maybe<OpeningFilledEvent>
+}
+
+export type ApplicationStatusCancelled = {
+  /** Related OpeningCanceled event */
+  openingCanceledEvent?: Maybe<OpeningCanceledEvent>
+}
+
+export type ApplicationStatusPending = {
+  phantom?: Maybe<Scalars['Int']>
+}
+
+export type ApplicationStatusPendingCreateInput = {
+  phantom?: Maybe<Scalars['Float']>
+}
+
+export type ApplicationStatusPendingUpdateInput = {
+  phantom?: Maybe<Scalars['Float']>
+}
+
+export type ApplicationStatusPendingWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  phantom_eq?: Maybe<Scalars['Int']>
+  phantom_gt?: Maybe<Scalars['Int']>
+  phantom_gte?: Maybe<Scalars['Int']>
+  phantom_lt?: Maybe<Scalars['Int']>
+  phantom_lte?: Maybe<Scalars['Int']>
+  phantom_in?: Maybe<Array<Scalars['Int']>>
+  AND?: Maybe<Array<ApplicationStatusPendingWhereInput>>
+  OR?: Maybe<Array<ApplicationStatusPendingWhereInput>>
+}
+
+export type ApplicationStatusPendingWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type ApplicationStatusRejected = {
+  /** Related OpeningFilled event */
+  openingFilledEvent?: Maybe<OpeningFilledEvent>
+}
+
+export type ApplicationStatusWithdrawn = {
+  /** Related ApplicationWithdrawn event */
+  applicationWithdrawnEvent?: Maybe<ApplicationWithdrawnEvent>
+}
+
+export type ApplicationWithdrawnEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  application: WorkingGroupApplication
+  applicationId: Scalars['String']
+}
+
+export type ApplicationWithdrawnEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<ApplicationWithdrawnEventEdge>
+  pageInfo: PageInfo
+}
+
+export type ApplicationWithdrawnEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  application: Scalars['ID']
+}
+
+export type ApplicationWithdrawnEventEdge = {
+  node: ApplicationWithdrawnEvent
+  cursor: Scalars['String']
+}
+
+export enum ApplicationWithdrawnEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  ApplicationAsc = 'application_ASC',
+  ApplicationDesc = 'application_DESC',
+}
+
+export type ApplicationWithdrawnEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  application?: Maybe<Scalars['ID']>
+}
+
+export type ApplicationWithdrawnEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  application_eq?: Maybe<Scalars['ID']>
+  application_in?: Maybe<Array<Scalars['ID']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  application?: Maybe<WorkingGroupApplicationWhereInput>
+  AND?: Maybe<Array<ApplicationWithdrawnEventWhereInput>>
+  OR?: Maybe<Array<ApplicationWithdrawnEventWhereInput>>
+}
+
+export type ApplicationWithdrawnEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type AppliedOnOpeningEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  opening: WorkingGroupOpening
+  openingId: Scalars['String']
+  application: WorkingGroupApplication
+  applicationId: Scalars['String']
+}
+
+export type AppliedOnOpeningEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<AppliedOnOpeningEventEdge>
+  pageInfo: PageInfo
+}
+
+export type AppliedOnOpeningEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  opening: Scalars['ID']
+  application: Scalars['ID']
+}
+
+export type AppliedOnOpeningEventEdge = {
+  node: AppliedOnOpeningEvent
+  cursor: Scalars['String']
+}
+
+export enum AppliedOnOpeningEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  OpeningAsc = 'opening_ASC',
+  OpeningDesc = 'opening_DESC',
+  ApplicationAsc = 'application_ASC',
+  ApplicationDesc = 'application_DESC',
+}
+
+export type AppliedOnOpeningEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  opening?: Maybe<Scalars['ID']>
+  application?: Maybe<Scalars['ID']>
+}
+
+export type AppliedOnOpeningEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  opening_eq?: Maybe<Scalars['ID']>
+  opening_in?: Maybe<Array<Scalars['ID']>>
+  application_eq?: Maybe<Scalars['ID']>
+  application_in?: Maybe<Array<Scalars['ID']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  opening?: Maybe<WorkingGroupOpeningWhereInput>
+  application?: Maybe<WorkingGroupApplicationWhereInput>
+  AND?: Maybe<Array<AppliedOnOpeningEventWhereInput>>
+  OR?: Maybe<Array<AppliedOnOpeningEventWhereInput>>
+}
+
+export type AppliedOnOpeningEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type BaseGraphQlObject = {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+}
+
+export type BaseModel = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+}
+
+export type BaseModelUuid = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+}
+
+export type BaseWhereInput = {
+  id_eq?: Maybe<Scalars['String']>
+  id_in?: Maybe<Array<Scalars['String']>>
+  createdAt_eq?: Maybe<Scalars['String']>
+  createdAt_lt?: Maybe<Scalars['String']>
+  createdAt_lte?: Maybe<Scalars['String']>
+  createdAt_gt?: Maybe<Scalars['String']>
+  createdAt_gte?: Maybe<Scalars['String']>
+  createdById_eq?: Maybe<Scalars['String']>
+  updatedAt_eq?: Maybe<Scalars['String']>
+  updatedAt_lt?: Maybe<Scalars['String']>
+  updatedAt_lte?: Maybe<Scalars['String']>
+  updatedAt_gt?: Maybe<Scalars['String']>
+  updatedAt_gte?: Maybe<Scalars['String']>
+  updatedById_eq?: Maybe<Scalars['String']>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['String']>
+  deletedAt_lt?: Maybe<Scalars['String']>
+  deletedAt_lte?: Maybe<Scalars['String']>
+  deletedAt_gt?: Maybe<Scalars['String']>
+  deletedAt_gte?: Maybe<Scalars['String']>
+  deletedById_eq?: Maybe<Scalars['String']>
+}
+
+export type BudgetSetEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  /** New working group budget */
+  newBudget: Scalars['BigInt']
+}
+
+export type BudgetSetEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<BudgetSetEventEdge>
+  pageInfo: PageInfo
+}
+
+export type BudgetSetEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  newBudget: Scalars['BigInt']
+}
+
+export type BudgetSetEventEdge = {
+  node: BudgetSetEvent
+  cursor: Scalars['String']
+}
+
+export enum BudgetSetEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  NewBudgetAsc = 'newBudget_ASC',
+  NewBudgetDesc = 'newBudget_DESC',
+}
+
+export type BudgetSetEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  newBudget?: Maybe<Scalars['BigInt']>
+}
+
+export type BudgetSetEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  newBudget_eq?: Maybe<Scalars['BigInt']>
+  newBudget_gt?: Maybe<Scalars['BigInt']>
+  newBudget_gte?: Maybe<Scalars['BigInt']>
+  newBudget_lt?: Maybe<Scalars['BigInt']>
+  newBudget_lte?: Maybe<Scalars['BigInt']>
+  newBudget_in?: Maybe<Array<Scalars['BigInt']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  AND?: Maybe<Array<BudgetSetEventWhereInput>>
+  OR?: Maybe<Array<BudgetSetEventWhereInput>>
+}
+
+export type BudgetSetEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type BudgetSpendingEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  /** Reciever account address */
+  reciever: Scalars['String']
+  /** Amount beeing spent */
+  amount: Scalars['BigInt']
+  /** Optional rationale */
+  rationale?: Maybe<Scalars['String']>
+}
+
+export type BudgetSpendingEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<BudgetSpendingEventEdge>
+  pageInfo: PageInfo
+}
+
+export type BudgetSpendingEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  reciever: Scalars['String']
+  amount: Scalars['BigInt']
+  rationale?: Maybe<Scalars['String']>
+}
+
+export type BudgetSpendingEventEdge = {
+  node: BudgetSpendingEvent
+  cursor: Scalars['String']
+}
+
+export enum BudgetSpendingEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  RecieverAsc = 'reciever_ASC',
+  RecieverDesc = 'reciever_DESC',
+  AmountAsc = 'amount_ASC',
+  AmountDesc = 'amount_DESC',
+  RationaleAsc = 'rationale_ASC',
+  RationaleDesc = 'rationale_DESC',
+}
+
+export type BudgetSpendingEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  reciever?: Maybe<Scalars['String']>
+  amount?: Maybe<Scalars['BigInt']>
+  rationale?: Maybe<Scalars['String']>
+}
+
+export type BudgetSpendingEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  reciever_eq?: Maybe<Scalars['String']>
+  reciever_contains?: Maybe<Scalars['String']>
+  reciever_startsWith?: Maybe<Scalars['String']>
+  reciever_endsWith?: Maybe<Scalars['String']>
+  reciever_in?: Maybe<Array<Scalars['String']>>
+  amount_eq?: Maybe<Scalars['BigInt']>
+  amount_gt?: Maybe<Scalars['BigInt']>
+  amount_gte?: Maybe<Scalars['BigInt']>
+  amount_lt?: Maybe<Scalars['BigInt']>
+  amount_lte?: Maybe<Scalars['BigInt']>
+  amount_in?: Maybe<Array<Scalars['BigInt']>>
+  rationale_eq?: Maybe<Scalars['String']>
+  rationale_contains?: Maybe<Scalars['String']>
+  rationale_startsWith?: Maybe<Scalars['String']>
+  rationale_endsWith?: Maybe<Scalars['String']>
+  rationale_in?: Maybe<Array<Scalars['String']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  AND?: Maybe<Array<BudgetSpendingEventWhereInput>>
+  OR?: Maybe<Array<BudgetSpendingEventWhereInput>>
+}
+
+export type BudgetSpendingEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+/** Manages content ids, type and storage provider decision about it */
+export type DataObject = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Content owner */
+  owner: DataObjectOwner
+  /** Content added at */
+  addedAt: Scalars['Int']
+  /** Content type id */
+  typeId: Scalars['Int']
+  /** Content size in bytes */
+  size: Scalars['BigInt']
+  /** Storage provider id of the liaison */
+  liaisonId: Scalars['BigInt']
+  /** Storage provider as liaison judgment */
+  liaisonJudgement: LiaisonJudgement
+  /** IPFS content id */
+  ipfsContentId: Scalars['String']
+  /** Joystream runtime content */
+  joystreamContentId: Scalars['String']
+  membermetadataavatar?: Maybe<Array<MemberMetadata>>
+}
+
+export type DataObjectConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<DataObjectEdge>
+  pageInfo: PageInfo
+}
+
+export type DataObjectCreateInput = {
+  owner: Scalars['JSONObject']
+  addedAt: Scalars['Float']
+  typeId: Scalars['Float']
+  size: Scalars['BigInt']
+  liaisonId: Scalars['BigInt']
+  liaisonJudgement: LiaisonJudgement
+  ipfsContentId: Scalars['String']
+  joystreamContentId: Scalars['String']
+}
+
+export type DataObjectEdge = {
+  node: DataObject
+  cursor: Scalars['String']
+}
+
+export enum DataObjectOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  AddedAtAsc = 'addedAt_ASC',
+  AddedAtDesc = 'addedAt_DESC',
+  TypeIdAsc = 'typeId_ASC',
+  TypeIdDesc = 'typeId_DESC',
+  SizeAsc = 'size_ASC',
+  SizeDesc = 'size_DESC',
+  LiaisonIdAsc = 'liaisonId_ASC',
+  LiaisonIdDesc = 'liaisonId_DESC',
+  LiaisonJudgementAsc = 'liaisonJudgement_ASC',
+  LiaisonJudgementDesc = 'liaisonJudgement_DESC',
+  IpfsContentIdAsc = 'ipfsContentId_ASC',
+  IpfsContentIdDesc = 'ipfsContentId_DESC',
+  JoystreamContentIdAsc = 'joystreamContentId_ASC',
+  JoystreamContentIdDesc = 'joystreamContentId_DESC',
+}
+
+export type DataObjectOwner =
+  | DataObjectOwnerMember
+  | DataObjectOwnerChannel
+  | DataObjectOwnerDao
+  | DataObjectOwnerCouncil
+  | DataObjectOwnerWorkingGroup
+
+export type DataObjectOwnerChannel = {
+  /** Channel identifier */
+  channel: Scalars['BigInt']
+  /** Variant needs to have at least one property. This value is not used. */
+  dummy?: Maybe<Scalars['Int']>
+}
+
+export type DataObjectOwnerChannelCreateInput = {
+  channel: Scalars['BigInt']
+  dummy?: Maybe<Scalars['Float']>
+}
+
+export type DataObjectOwnerChannelUpdateInput = {
+  channel?: Maybe<Scalars['BigInt']>
+  dummy?: Maybe<Scalars['Float']>
+}
+
+export type DataObjectOwnerChannelWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  channel_eq?: Maybe<Scalars['BigInt']>
+  channel_gt?: Maybe<Scalars['BigInt']>
+  channel_gte?: Maybe<Scalars['BigInt']>
+  channel_lt?: Maybe<Scalars['BigInt']>
+  channel_lte?: Maybe<Scalars['BigInt']>
+  channel_in?: Maybe<Array<Scalars['BigInt']>>
+  dummy_eq?: Maybe<Scalars['Int']>
+  dummy_gt?: Maybe<Scalars['Int']>
+  dummy_gte?: Maybe<Scalars['Int']>
+  dummy_lt?: Maybe<Scalars['Int']>
+  dummy_lte?: Maybe<Scalars['Int']>
+  dummy_in?: Maybe<Array<Scalars['Int']>>
+  AND?: Maybe<Array<DataObjectOwnerChannelWhereInput>>
+  OR?: Maybe<Array<DataObjectOwnerChannelWhereInput>>
+}
+
+export type DataObjectOwnerChannelWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type DataObjectOwnerCouncil = {
+  /** Variant needs to have at least one property. This value is not used. */
+  dummy?: Maybe<Scalars['Int']>
+}
+
+export type DataObjectOwnerCouncilCreateInput = {
+  dummy?: Maybe<Scalars['Float']>
+}
+
+export type DataObjectOwnerCouncilUpdateInput = {
+  dummy?: Maybe<Scalars['Float']>
+}
+
+export type DataObjectOwnerCouncilWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  dummy_eq?: Maybe<Scalars['Int']>
+  dummy_gt?: Maybe<Scalars['Int']>
+  dummy_gte?: Maybe<Scalars['Int']>
+  dummy_lt?: Maybe<Scalars['Int']>
+  dummy_lte?: Maybe<Scalars['Int']>
+  dummy_in?: Maybe<Array<Scalars['Int']>>
+  AND?: Maybe<Array<DataObjectOwnerCouncilWhereInput>>
+  OR?: Maybe<Array<DataObjectOwnerCouncilWhereInput>>
+}
+
+export type DataObjectOwnerCouncilWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type DataObjectOwnerDao = {
+  /** DAO identifier */
+  dao: Scalars['BigInt']
+}
+
+export type DataObjectOwnerDaoCreateInput = {
+  dao: Scalars['BigInt']
+}
+
+export type DataObjectOwnerDaoUpdateInput = {
+  dao?: Maybe<Scalars['BigInt']>
+}
+
+export type DataObjectOwnerDaoWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  dao_eq?: Maybe<Scalars['BigInt']>
+  dao_gt?: Maybe<Scalars['BigInt']>
+  dao_gte?: Maybe<Scalars['BigInt']>
+  dao_lt?: Maybe<Scalars['BigInt']>
+  dao_lte?: Maybe<Scalars['BigInt']>
+  dao_in?: Maybe<Array<Scalars['BigInt']>>
+  AND?: Maybe<Array<DataObjectOwnerDaoWhereInput>>
+  OR?: Maybe<Array<DataObjectOwnerDaoWhereInput>>
+}
+
+export type DataObjectOwnerDaoWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type DataObjectOwnerMember = {
+  /** Member identifier */
+  member: Scalars['BigInt']
+  /** Variant needs to have at least one property. This value is not used. */
+  dummy?: Maybe<Scalars['Int']>
+}
+
+export type DataObjectOwnerMemberCreateInput = {
+  member: Scalars['BigInt']
+  dummy?: Maybe<Scalars['Float']>
+}
+
+export type DataObjectOwnerMemberUpdateInput = {
+  member?: Maybe<Scalars['BigInt']>
+  dummy?: Maybe<Scalars['Float']>
+}
+
+export type DataObjectOwnerMemberWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  member_eq?: Maybe<Scalars['BigInt']>
+  member_gt?: Maybe<Scalars['BigInt']>
+  member_gte?: Maybe<Scalars['BigInt']>
+  member_lt?: Maybe<Scalars['BigInt']>
+  member_lte?: Maybe<Scalars['BigInt']>
+  member_in?: Maybe<Array<Scalars['BigInt']>>
+  dummy_eq?: Maybe<Scalars['Int']>
+  dummy_gt?: Maybe<Scalars['Int']>
+  dummy_gte?: Maybe<Scalars['Int']>
+  dummy_lt?: Maybe<Scalars['Int']>
+  dummy_lte?: Maybe<Scalars['Int']>
+  dummy_in?: Maybe<Array<Scalars['Int']>>
+  AND?: Maybe<Array<DataObjectOwnerMemberWhereInput>>
+  OR?: Maybe<Array<DataObjectOwnerMemberWhereInput>>
+}
+
+export type DataObjectOwnerMemberWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type DataObjectOwnerWorkingGroup = {
+  /** Variant needs to have at least one property. This value is not used. */
+  dummy?: Maybe<Scalars['Int']>
+}
+
+export type DataObjectOwnerWorkingGroupCreateInput = {
+  dummy?: Maybe<Scalars['Float']>
+}
+
+export type DataObjectOwnerWorkingGroupUpdateInput = {
+  dummy?: Maybe<Scalars['Float']>
+}
+
+export type DataObjectOwnerWorkingGroupWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  dummy_eq?: Maybe<Scalars['Int']>
+  dummy_gt?: Maybe<Scalars['Int']>
+  dummy_gte?: Maybe<Scalars['Int']>
+  dummy_lt?: Maybe<Scalars['Int']>
+  dummy_lte?: Maybe<Scalars['Int']>
+  dummy_in?: Maybe<Array<Scalars['Int']>>
+  AND?: Maybe<Array<DataObjectOwnerWorkingGroupWhereInput>>
+  OR?: Maybe<Array<DataObjectOwnerWorkingGroupWhereInput>>
+}
+
+export type DataObjectOwnerWorkingGroupWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type DataObjectUpdateInput = {
+  owner?: Maybe<Scalars['JSONObject']>
+  addedAt?: Maybe<Scalars['Float']>
+  typeId?: Maybe<Scalars['Float']>
+  size?: Maybe<Scalars['BigInt']>
+  liaisonId?: Maybe<Scalars['BigInt']>
+  liaisonJudgement?: Maybe<LiaisonJudgement>
+  ipfsContentId?: Maybe<Scalars['String']>
+  joystreamContentId?: Maybe<Scalars['String']>
+}
+
+export type DataObjectWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  owner_json?: Maybe<Scalars['JSONObject']>
+  addedAt_eq?: Maybe<Scalars['Int']>
+  addedAt_gt?: Maybe<Scalars['Int']>
+  addedAt_gte?: Maybe<Scalars['Int']>
+  addedAt_lt?: Maybe<Scalars['Int']>
+  addedAt_lte?: Maybe<Scalars['Int']>
+  addedAt_in?: Maybe<Array<Scalars['Int']>>
+  typeId_eq?: Maybe<Scalars['Int']>
+  typeId_gt?: Maybe<Scalars['Int']>
+  typeId_gte?: Maybe<Scalars['Int']>
+  typeId_lt?: Maybe<Scalars['Int']>
+  typeId_lte?: Maybe<Scalars['Int']>
+  typeId_in?: Maybe<Array<Scalars['Int']>>
+  size_eq?: Maybe<Scalars['BigInt']>
+  size_gt?: Maybe<Scalars['BigInt']>
+  size_gte?: Maybe<Scalars['BigInt']>
+  size_lt?: Maybe<Scalars['BigInt']>
+  size_lte?: Maybe<Scalars['BigInt']>
+  size_in?: Maybe<Array<Scalars['BigInt']>>
+  liaisonId_eq?: Maybe<Scalars['BigInt']>
+  liaisonId_gt?: Maybe<Scalars['BigInt']>
+  liaisonId_gte?: Maybe<Scalars['BigInt']>
+  liaisonId_lt?: Maybe<Scalars['BigInt']>
+  liaisonId_lte?: Maybe<Scalars['BigInt']>
+  liaisonId_in?: Maybe<Array<Scalars['BigInt']>>
+  liaisonJudgement_eq?: Maybe<LiaisonJudgement>
+  liaisonJudgement_in?: Maybe<Array<LiaisonJudgement>>
+  ipfsContentId_eq?: Maybe<Scalars['String']>
+  ipfsContentId_contains?: Maybe<Scalars['String']>
+  ipfsContentId_startsWith?: Maybe<Scalars['String']>
+  ipfsContentId_endsWith?: Maybe<Scalars['String']>
+  ipfsContentId_in?: Maybe<Array<Scalars['String']>>
+  joystreamContentId_eq?: Maybe<Scalars['String']>
+  joystreamContentId_contains?: Maybe<Scalars['String']>
+  joystreamContentId_startsWith?: Maybe<Scalars['String']>
+  joystreamContentId_endsWith?: Maybe<Scalars['String']>
+  joystreamContentId_in?: Maybe<Array<Scalars['String']>>
+  membermetadataavatar_none?: Maybe<MemberMetadataWhereInput>
+  membermetadataavatar_some?: Maybe<MemberMetadataWhereInput>
+  membermetadataavatar_every?: Maybe<MemberMetadataWhereInput>
+  AND?: Maybe<Array<DataObjectWhereInput>>
+  OR?: Maybe<Array<DataObjectWhereInput>>
+}
+
+export type DataObjectWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type DeleteResponse = {
+  id: Scalars['ID']
+}
+
+export type Event = {
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+}
+
+export type EventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+}
+
+export enum EventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+}
+
+export type EventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+}
+
+export type EventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  AND?: Maybe<Array<EventWhereInput>>
+  OR?: Maybe<Array<EventWhereInput>>
+}
+
+export type EventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type InitialInvitationBalanceUpdatedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  /** New initial invitation balance. */
+  newInitialBalance: Scalars['BigInt']
+}
+
+export type InitialInvitationBalanceUpdatedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<InitialInvitationBalanceUpdatedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type InitialInvitationBalanceUpdatedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  newInitialBalance: Scalars['BigInt']
+}
+
+export type InitialInvitationBalanceUpdatedEventEdge = {
+  node: InitialInvitationBalanceUpdatedEvent
+  cursor: Scalars['String']
+}
+
+export enum InitialInvitationBalanceUpdatedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  NewInitialBalanceAsc = 'newInitialBalance_ASC',
+  NewInitialBalanceDesc = 'newInitialBalance_DESC',
+}
+
+export type InitialInvitationBalanceUpdatedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  newInitialBalance?: Maybe<Scalars['BigInt']>
+}
+
+export type InitialInvitationBalanceUpdatedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  newInitialBalance_eq?: Maybe<Scalars['BigInt']>
+  newInitialBalance_gt?: Maybe<Scalars['BigInt']>
+  newInitialBalance_gte?: Maybe<Scalars['BigInt']>
+  newInitialBalance_lt?: Maybe<Scalars['BigInt']>
+  newInitialBalance_lte?: Maybe<Scalars['BigInt']>
+  newInitialBalance_in?: Maybe<Array<Scalars['BigInt']>>
+  AND?: Maybe<Array<InitialInvitationBalanceUpdatedEventWhereInput>>
+  OR?: Maybe<Array<InitialInvitationBalanceUpdatedEventWhereInput>>
+}
+
+export type InitialInvitationBalanceUpdatedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type InitialInvitationCountUpdatedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  /** New initial invitation count for members. */
+  newInitialInvitationCount: Scalars['Int']
+}
+
+export type InitialInvitationCountUpdatedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<InitialInvitationCountUpdatedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type InitialInvitationCountUpdatedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  newInitialInvitationCount: Scalars['Float']
+}
+
+export type InitialInvitationCountUpdatedEventEdge = {
+  node: InitialInvitationCountUpdatedEvent
+  cursor: Scalars['String']
+}
+
+export enum InitialInvitationCountUpdatedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  NewInitialInvitationCountAsc = 'newInitialInvitationCount_ASC',
+  NewInitialInvitationCountDesc = 'newInitialInvitationCount_DESC',
+}
+
+export type InitialInvitationCountUpdatedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  newInitialInvitationCount?: Maybe<Scalars['Float']>
+}
+
+export type InitialInvitationCountUpdatedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  newInitialInvitationCount_eq?: Maybe<Scalars['Int']>
+  newInitialInvitationCount_gt?: Maybe<Scalars['Int']>
+  newInitialInvitationCount_gte?: Maybe<Scalars['Int']>
+  newInitialInvitationCount_lt?: Maybe<Scalars['Int']>
+  newInitialInvitationCount_lte?: Maybe<Scalars['Int']>
+  newInitialInvitationCount_in?: Maybe<Array<Scalars['Int']>>
+  AND?: Maybe<Array<InitialInvitationCountUpdatedEventWhereInput>>
+  OR?: Maybe<Array<InitialInvitationCountUpdatedEventWhereInput>>
+}
+
+export type InitialInvitationCountUpdatedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type InvalidActionMetadata = {
+  /** Reason why the action metadata was considered invalid */
+  reason: Scalars['String']
+}
+
+export type InvalidActionMetadataCreateInput = {
+  reason: Scalars['String']
+}
+
+export type InvalidActionMetadataUpdateInput = {
+  reason?: Maybe<Scalars['String']>
+}
+
+export type InvalidActionMetadataWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  reason_eq?: Maybe<Scalars['String']>
+  reason_contains?: Maybe<Scalars['String']>
+  reason_startsWith?: Maybe<Scalars['String']>
+  reason_endsWith?: Maybe<Scalars['String']>
+  reason_in?: Maybe<Array<Scalars['String']>>
+  AND?: Maybe<Array<InvalidActionMetadataWhereInput>>
+  OR?: Maybe<Array<InvalidActionMetadataWhereInput>>
+}
+
+export type InvalidActionMetadataWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type InvitesTransferredEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  sourceMember: Membership
+  sourceMemberId: Scalars['String']
+  targetMember: Membership
+  targetMemberId: Scalars['String']
+  /** Number of invites transferred. */
+  numberOfInvites: Scalars['Int']
+}
+
+export type InvitesTransferredEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<InvitesTransferredEventEdge>
+  pageInfo: PageInfo
+}
+
+export type InvitesTransferredEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  sourceMember: Scalars['ID']
+  targetMember: Scalars['ID']
+  numberOfInvites: Scalars['Float']
+}
+
+export type InvitesTransferredEventEdge = {
+  node: InvitesTransferredEvent
+  cursor: Scalars['String']
+}
+
+export enum InvitesTransferredEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  SourceMemberAsc = 'sourceMember_ASC',
+  SourceMemberDesc = 'sourceMember_DESC',
+  TargetMemberAsc = 'targetMember_ASC',
+  TargetMemberDesc = 'targetMember_DESC',
+  NumberOfInvitesAsc = 'numberOfInvites_ASC',
+  NumberOfInvitesDesc = 'numberOfInvites_DESC',
+}
+
+export type InvitesTransferredEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  sourceMember?: Maybe<Scalars['ID']>
+  targetMember?: Maybe<Scalars['ID']>
+  numberOfInvites?: Maybe<Scalars['Float']>
+}
+
+export type InvitesTransferredEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  sourceMember_eq?: Maybe<Scalars['ID']>
+  sourceMember_in?: Maybe<Array<Scalars['ID']>>
+  targetMember_eq?: Maybe<Scalars['ID']>
+  targetMember_in?: Maybe<Array<Scalars['ID']>>
+  numberOfInvites_eq?: Maybe<Scalars['Int']>
+  numberOfInvites_gt?: Maybe<Scalars['Int']>
+  numberOfInvites_gte?: Maybe<Scalars['Int']>
+  numberOfInvites_lt?: Maybe<Scalars['Int']>
+  numberOfInvites_lte?: Maybe<Scalars['Int']>
+  numberOfInvites_in?: Maybe<Array<Scalars['Int']>>
+  sourceMember?: Maybe<MembershipWhereInput>
+  targetMember?: Maybe<MembershipWhereInput>
+  AND?: Maybe<Array<InvitesTransferredEventWhereInput>>
+  OR?: Maybe<Array<InvitesTransferredEventWhereInput>>
+}
+
+export type InvitesTransferredEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type LeaderInvitationQuotaUpdatedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  /** New quota. */
+  newInvitationQuota: Scalars['Int']
+}
+
+export type LeaderInvitationQuotaUpdatedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<LeaderInvitationQuotaUpdatedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type LeaderInvitationQuotaUpdatedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  newInvitationQuota: Scalars['Float']
+}
+
+export type LeaderInvitationQuotaUpdatedEventEdge = {
+  node: LeaderInvitationQuotaUpdatedEvent
+  cursor: Scalars['String']
+}
+
+export enum LeaderInvitationQuotaUpdatedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  NewInvitationQuotaAsc = 'newInvitationQuota_ASC',
+  NewInvitationQuotaDesc = 'newInvitationQuota_DESC',
+}
+
+export type LeaderInvitationQuotaUpdatedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  newInvitationQuota?: Maybe<Scalars['Float']>
+}
+
+export type LeaderInvitationQuotaUpdatedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  newInvitationQuota_eq?: Maybe<Scalars['Int']>
+  newInvitationQuota_gt?: Maybe<Scalars['Int']>
+  newInvitationQuota_gte?: Maybe<Scalars['Int']>
+  newInvitationQuota_lt?: Maybe<Scalars['Int']>
+  newInvitationQuota_lte?: Maybe<Scalars['Int']>
+  newInvitationQuota_in?: Maybe<Array<Scalars['Int']>>
+  AND?: Maybe<Array<LeaderInvitationQuotaUpdatedEventWhereInput>>
+  OR?: Maybe<Array<LeaderInvitationQuotaUpdatedEventWhereInput>>
+}
+
+export type LeaderInvitationQuotaUpdatedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type LeaderSetEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  worker?: Maybe<Worker>
+  workerId?: Maybe<Scalars['String']>
+}
+
+export type LeaderSetEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<LeaderSetEventEdge>
+  pageInfo: PageInfo
+}
+
+export type LeaderSetEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  worker?: Maybe<Scalars['ID']>
+}
+
+export type LeaderSetEventEdge = {
+  node: LeaderSetEvent
+  cursor: Scalars['String']
+}
+
+export enum LeaderSetEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  WorkerAsc = 'worker_ASC',
+  WorkerDesc = 'worker_DESC',
+}
+
+export type LeaderSetEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  worker?: Maybe<Scalars['ID']>
+}
+
+export type LeaderSetEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  worker_eq?: Maybe<Scalars['ID']>
+  worker_in?: Maybe<Array<Scalars['ID']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  worker?: Maybe<WorkerWhereInput>
+  AND?: Maybe<Array<LeaderSetEventWhereInput>>
+  OR?: Maybe<Array<LeaderSetEventWhereInput>>
+}
+
+export type LeaderSetEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type LeaderUnsetEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  leader: Worker
+  leaderId: Scalars['String']
+}
+
+export type LeaderUnsetEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<LeaderUnsetEventEdge>
+  pageInfo: PageInfo
+}
+
+export type LeaderUnsetEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  leader: Scalars['ID']
+}
+
+export type LeaderUnsetEventEdge = {
+  node: LeaderUnsetEvent
+  cursor: Scalars['String']
+}
+
+export enum LeaderUnsetEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  LeaderAsc = 'leader_ASC',
+  LeaderDesc = 'leader_DESC',
+}
+
+export type LeaderUnsetEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  leader?: Maybe<Scalars['ID']>
+}
+
+export type LeaderUnsetEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  leader_eq?: Maybe<Scalars['ID']>
+  leader_in?: Maybe<Array<Scalars['ID']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  leader?: Maybe<WorkerWhereInput>
+  AND?: Maybe<Array<LeaderUnsetEventWhereInput>>
+  OR?: Maybe<Array<LeaderUnsetEventWhereInput>>
+}
+
+export type LeaderUnsetEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export enum LiaisonJudgement {
+  Pending = 'PENDING',
+  Accepted = 'ACCEPTED',
+  Rejected = 'REJECTED',
+}
+
+export type MemberAccountsUpdatedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  member: Membership
+  memberId: Scalars['String']
+  /** New member root account in SS58 encoding. Null means no new value was provided. */
+  newRootAccount?: Maybe<Scalars['String']>
+  /** New member controller in SS58 encoding. Null means no new value was provided. */
+  newControllerAccount?: Maybe<Scalars['String']>
+}
+
+export type MemberAccountsUpdatedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<MemberAccountsUpdatedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type MemberAccountsUpdatedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  member: Scalars['ID']
+  newRootAccount?: Maybe<Scalars['String']>
+  newControllerAccount?: Maybe<Scalars['String']>
+}
+
+export type MemberAccountsUpdatedEventEdge = {
+  node: MemberAccountsUpdatedEvent
+  cursor: Scalars['String']
+}
+
+export enum MemberAccountsUpdatedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  MemberAsc = 'member_ASC',
+  MemberDesc = 'member_DESC',
+  NewRootAccountAsc = 'newRootAccount_ASC',
+  NewRootAccountDesc = 'newRootAccount_DESC',
+  NewControllerAccountAsc = 'newControllerAccount_ASC',
+  NewControllerAccountDesc = 'newControllerAccount_DESC',
+}
+
+export type MemberAccountsUpdatedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  member?: Maybe<Scalars['ID']>
+  newRootAccount?: Maybe<Scalars['String']>
+  newControllerAccount?: Maybe<Scalars['String']>
+}
+
+export type MemberAccountsUpdatedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  member_eq?: Maybe<Scalars['ID']>
+  member_in?: Maybe<Array<Scalars['ID']>>
+  newRootAccount_eq?: Maybe<Scalars['String']>
+  newRootAccount_contains?: Maybe<Scalars['String']>
+  newRootAccount_startsWith?: Maybe<Scalars['String']>
+  newRootAccount_endsWith?: Maybe<Scalars['String']>
+  newRootAccount_in?: Maybe<Array<Scalars['String']>>
+  newControllerAccount_eq?: Maybe<Scalars['String']>
+  newControllerAccount_contains?: Maybe<Scalars['String']>
+  newControllerAccount_startsWith?: Maybe<Scalars['String']>
+  newControllerAccount_endsWith?: Maybe<Scalars['String']>
+  newControllerAccount_in?: Maybe<Array<Scalars['String']>>
+  member?: Maybe<MembershipWhereInput>
+  AND?: Maybe<Array<MemberAccountsUpdatedEventWhereInput>>
+  OR?: Maybe<Array<MemberAccountsUpdatedEventWhereInput>>
+}
+
+export type MemberAccountsUpdatedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type MemberInvitedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  invitingMember: Membership
+  invitingMemberId: Scalars['String']
+  newMember: Membership
+  newMemberId: Scalars['String']
+  /** New member root account in SS58 encoding. */
+  rootAccount: Scalars['String']
+  /** New member controller in SS58 encoding. */
+  controllerAccount: Scalars['String']
+  /** New member handle. */
+  handle: Scalars['String']
+  metadata: MemberMetadata
+  metadataId: Scalars['String']
+}
+
+export type MemberInvitedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<MemberInvitedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type MemberInvitedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  invitingMember: Scalars['ID']
+  newMember: Scalars['ID']
+  rootAccount: Scalars['String']
+  controllerAccount: Scalars['String']
+  handle: Scalars['String']
+  metadata: Scalars['ID']
+}
+
+export type MemberInvitedEventEdge = {
+  node: MemberInvitedEvent
+  cursor: Scalars['String']
+}
+
+export enum MemberInvitedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  InvitingMemberAsc = 'invitingMember_ASC',
+  InvitingMemberDesc = 'invitingMember_DESC',
+  NewMemberAsc = 'newMember_ASC',
+  NewMemberDesc = 'newMember_DESC',
+  RootAccountAsc = 'rootAccount_ASC',
+  RootAccountDesc = 'rootAccount_DESC',
+  ControllerAccountAsc = 'controllerAccount_ASC',
+  ControllerAccountDesc = 'controllerAccount_DESC',
+  HandleAsc = 'handle_ASC',
+  HandleDesc = 'handle_DESC',
+  MetadataAsc = 'metadata_ASC',
+  MetadataDesc = 'metadata_DESC',
+}
+
+export type MemberInvitedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  invitingMember?: Maybe<Scalars['ID']>
+  newMember?: Maybe<Scalars['ID']>
+  rootAccount?: Maybe<Scalars['String']>
+  controllerAccount?: Maybe<Scalars['String']>
+  handle?: Maybe<Scalars['String']>
+  metadata?: Maybe<Scalars['ID']>
+}
+
+export type MemberInvitedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  invitingMember_eq?: Maybe<Scalars['ID']>
+  invitingMember_in?: Maybe<Array<Scalars['ID']>>
+  newMember_eq?: Maybe<Scalars['ID']>
+  newMember_in?: Maybe<Array<Scalars['ID']>>
+  rootAccount_eq?: Maybe<Scalars['String']>
+  rootAccount_contains?: Maybe<Scalars['String']>
+  rootAccount_startsWith?: Maybe<Scalars['String']>
+  rootAccount_endsWith?: Maybe<Scalars['String']>
+  rootAccount_in?: Maybe<Array<Scalars['String']>>
+  controllerAccount_eq?: Maybe<Scalars['String']>
+  controllerAccount_contains?: Maybe<Scalars['String']>
+  controllerAccount_startsWith?: Maybe<Scalars['String']>
+  controllerAccount_endsWith?: Maybe<Scalars['String']>
+  controllerAccount_in?: Maybe<Array<Scalars['String']>>
+  handle_eq?: Maybe<Scalars['String']>
+  handle_contains?: Maybe<Scalars['String']>
+  handle_startsWith?: Maybe<Scalars['String']>
+  handle_endsWith?: Maybe<Scalars['String']>
+  handle_in?: Maybe<Array<Scalars['String']>>
+  metadata_eq?: Maybe<Scalars['ID']>
+  metadata_in?: Maybe<Array<Scalars['ID']>>
+  invitingMember?: Maybe<MembershipWhereInput>
+  newMember?: Maybe<MembershipWhereInput>
+  metadata?: Maybe<MemberMetadataWhereInput>
+  AND?: Maybe<Array<MemberInvitedEventWhereInput>>
+  OR?: Maybe<Array<MemberInvitedEventWhereInput>>
+}
+
+export type MemberInvitedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type MemberMetadata = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Member's name */
+  name?: Maybe<Scalars['String']>
+  avatar?: Maybe<DataObject>
+  avatarId?: Maybe<Scalars['String']>
+  /** Short text chosen by member to share information about themselves */
+  about?: Maybe<Scalars['String']>
+  memberinvitedeventmetadata?: Maybe<Array<MemberInvitedEvent>>
+  memberprofileupdatedeventnewMetadata?: Maybe<Array<MemberProfileUpdatedEvent>>
+  membershipmetadata?: Maybe<Array<Membership>>
+  membershipboughteventmetadata?: Maybe<Array<MembershipBoughtEvent>>
+}
+
+export type MemberMetadataConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<MemberMetadataEdge>
+  pageInfo: PageInfo
+}
+
+export type MemberMetadataCreateInput = {
+  name?: Maybe<Scalars['String']>
+  avatar?: Maybe<Scalars['ID']>
+  about?: Maybe<Scalars['String']>
+}
+
+export type MemberMetadataEdge = {
+  node: MemberMetadata
+  cursor: Scalars['String']
+}
+
+export enum MemberMetadataOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  NameAsc = 'name_ASC',
+  NameDesc = 'name_DESC',
+  AvatarAsc = 'avatar_ASC',
+  AvatarDesc = 'avatar_DESC',
+  AboutAsc = 'about_ASC',
+  AboutDesc = 'about_DESC',
+}
+
+export type MemberMetadataUpdateInput = {
+  name?: Maybe<Scalars['String']>
+  avatar?: Maybe<Scalars['ID']>
+  about?: Maybe<Scalars['String']>
+}
+
+export type MemberMetadataWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  name_eq?: Maybe<Scalars['String']>
+  name_contains?: Maybe<Scalars['String']>
+  name_startsWith?: Maybe<Scalars['String']>
+  name_endsWith?: Maybe<Scalars['String']>
+  name_in?: Maybe<Array<Scalars['String']>>
+  avatar_eq?: Maybe<Scalars['ID']>
+  avatar_in?: Maybe<Array<Scalars['ID']>>
+  about_eq?: Maybe<Scalars['String']>
+  about_contains?: Maybe<Scalars['String']>
+  about_startsWith?: Maybe<Scalars['String']>
+  about_endsWith?: Maybe<Scalars['String']>
+  about_in?: Maybe<Array<Scalars['String']>>
+  avatar?: Maybe<DataObjectWhereInput>
+  memberinvitedeventmetadata_none?: Maybe<MemberInvitedEventWhereInput>
+  memberinvitedeventmetadata_some?: Maybe<MemberInvitedEventWhereInput>
+  memberinvitedeventmetadata_every?: Maybe<MemberInvitedEventWhereInput>
+  memberprofileupdatedeventnewMetadata_none?: Maybe<MemberProfileUpdatedEventWhereInput>
+  memberprofileupdatedeventnewMetadata_some?: Maybe<MemberProfileUpdatedEventWhereInput>
+  memberprofileupdatedeventnewMetadata_every?: Maybe<MemberProfileUpdatedEventWhereInput>
+  membershipmetadata_none?: Maybe<MembershipWhereInput>
+  membershipmetadata_some?: Maybe<MembershipWhereInput>
+  membershipmetadata_every?: Maybe<MembershipWhereInput>
+  membershipboughteventmetadata_none?: Maybe<MembershipBoughtEventWhereInput>
+  membershipboughteventmetadata_some?: Maybe<MembershipBoughtEventWhereInput>
+  membershipboughteventmetadata_every?: Maybe<MembershipBoughtEventWhereInput>
+  AND?: Maybe<Array<MemberMetadataWhereInput>>
+  OR?: Maybe<Array<MemberMetadataWhereInput>>
+}
+
+export type MemberMetadataWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type MemberProfileUpdatedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  member: Membership
+  memberId: Scalars['String']
+  /** New member handle. Null means no new value was provided. */
+  newHandle?: Maybe<Scalars['String']>
+  newMetadata: MemberMetadata
+  newMetadataId: Scalars['String']
+}
+
+export type MemberProfileUpdatedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<MemberProfileUpdatedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type MemberProfileUpdatedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  member: Scalars['ID']
+  newHandle?: Maybe<Scalars['String']>
+  newMetadata: Scalars['ID']
+}
+
+export type MemberProfileUpdatedEventEdge = {
+  node: MemberProfileUpdatedEvent
+  cursor: Scalars['String']
+}
+
+export enum MemberProfileUpdatedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  MemberAsc = 'member_ASC',
+  MemberDesc = 'member_DESC',
+  NewHandleAsc = 'newHandle_ASC',
+  NewHandleDesc = 'newHandle_DESC',
+  NewMetadataAsc = 'newMetadata_ASC',
+  NewMetadataDesc = 'newMetadata_DESC',
+}
+
+export type MemberProfileUpdatedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  member?: Maybe<Scalars['ID']>
+  newHandle?: Maybe<Scalars['String']>
+  newMetadata?: Maybe<Scalars['ID']>
+}
+
+export type MemberProfileUpdatedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  member_eq?: Maybe<Scalars['ID']>
+  member_in?: Maybe<Array<Scalars['ID']>>
+  newHandle_eq?: Maybe<Scalars['String']>
+  newHandle_contains?: Maybe<Scalars['String']>
+  newHandle_startsWith?: Maybe<Scalars['String']>
+  newHandle_endsWith?: Maybe<Scalars['String']>
+  newHandle_in?: Maybe<Array<Scalars['String']>>
+  newMetadata_eq?: Maybe<Scalars['ID']>
+  newMetadata_in?: Maybe<Array<Scalars['ID']>>
+  member?: Maybe<MembershipWhereInput>
+  newMetadata?: Maybe<MemberMetadataWhereInput>
+  AND?: Maybe<Array<MemberProfileUpdatedEventWhereInput>>
+  OR?: Maybe<Array<MemberProfileUpdatedEventWhereInput>>
+}
+
+export type MemberProfileUpdatedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type MembersByHandleFtsOutput = {
+  item: MembersByHandleSearchResult
+  rank: Scalars['Float']
+  isTypeOf: Scalars['String']
+  highlight: Scalars['String']
+}
+
+export type MembersByHandleSearchResult = Membership
+
+/** Stored information about a registered user */
+export type Membership = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** The unique handle chosen by member */
+  handle: Scalars['String']
+  metadata: MemberMetadata
+  metadataId: Scalars['String']
+  /** Member's controller account id */
+  controllerAccount: Scalars['String']
+  /** Member's root account id */
+  rootAccount: Scalars['String']
+  /** How the member was registered */
+  entry: MembershipEntryMethod
+  /** Whether member has been verified by membership working group. */
+  isVerified: Scalars['Boolean']
+  /** Staking accounts bounded to membership. */
+  boundAccounts: Array<Scalars['String']>
+  /** Current count of invites left to send. */
+  inviteCount: Scalars['Int']
+  invitees: Array<Membership>
+  invitedBy?: Maybe<Membership>
+  invitedById?: Maybe<Scalars['String']>
+  referredMembers: Array<Membership>
+  referredBy?: Maybe<Membership>
+  referredById?: Maybe<Scalars['String']>
+  /** Whether member is founding member. */
+  isFoundingMember: Scalars['Boolean']
+  roles: Array<Worker>
+  invitestransferredeventsourceMember?: Maybe<Array<InvitesTransferredEvent>>
+  invitestransferredeventtargetMember?: Maybe<Array<InvitesTransferredEvent>>
+  memberaccountsupdatedeventmember?: Maybe<Array<MemberAccountsUpdatedEvent>>
+  memberinvitedeventinvitingMember?: Maybe<Array<MemberInvitedEvent>>
+  memberinvitedeventnewMember?: Maybe<Array<MemberInvitedEvent>>
+  memberprofileupdatedeventmember?: Maybe<Array<MemberProfileUpdatedEvent>>
+  memberverificationstatusupdatedeventmember?: Maybe<Array<MemberVerificationStatusUpdatedEvent>>
+  membershipboughteventnewMember?: Maybe<Array<MembershipBoughtEvent>>
+  membershipboughteventreferrer?: Maybe<Array<MembershipBoughtEvent>>
+  stakingaccountaddedeventmember?: Maybe<Array<StakingAccountAddedEvent>>
+  stakingaccountconfirmedeventmember?: Maybe<Array<StakingAccountConfirmedEvent>>
+  stakingaccountremovedeventmember?: Maybe<Array<StakingAccountRemovedEvent>>
+  workinggroupapplicationapplicant?: Maybe<Array<WorkingGroupApplication>>
+}
+
+export type MembershipBoughtEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  newMember: Membership
+  newMemberId: Scalars['String']
+  /** New member root account in SS58 encoding. */
+  rootAccount: Scalars['String']
+  /** New member controller in SS58 encoding. */
+  controllerAccount: Scalars['String']
+  /** New member handle. */
+  handle: Scalars['String']
+  metadata: MemberMetadata
+  metadataId: Scalars['String']
+  referrer?: Maybe<Membership>
+  referrerId?: Maybe<Scalars['String']>
+}
+
+export type MembershipBoughtEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<MembershipBoughtEventEdge>
+  pageInfo: PageInfo
+}
+
+export type MembershipBoughtEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  newMember: Scalars['ID']
+  rootAccount: Scalars['String']
+  controllerAccount: Scalars['String']
+  handle: Scalars['String']
+  metadata: Scalars['ID']
+  referrer?: Maybe<Scalars['ID']>
+}
+
+export type MembershipBoughtEventEdge = {
+  node: MembershipBoughtEvent
+  cursor: Scalars['String']
+}
+
+export enum MembershipBoughtEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  NewMemberAsc = 'newMember_ASC',
+  NewMemberDesc = 'newMember_DESC',
+  RootAccountAsc = 'rootAccount_ASC',
+  RootAccountDesc = 'rootAccount_DESC',
+  ControllerAccountAsc = 'controllerAccount_ASC',
+  ControllerAccountDesc = 'controllerAccount_DESC',
+  HandleAsc = 'handle_ASC',
+  HandleDesc = 'handle_DESC',
+  MetadataAsc = 'metadata_ASC',
+  MetadataDesc = 'metadata_DESC',
+  ReferrerAsc = 'referrer_ASC',
+  ReferrerDesc = 'referrer_DESC',
+}
+
+export type MembershipBoughtEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  newMember?: Maybe<Scalars['ID']>
+  rootAccount?: Maybe<Scalars['String']>
+  controllerAccount?: Maybe<Scalars['String']>
+  handle?: Maybe<Scalars['String']>
+  metadata?: Maybe<Scalars['ID']>
+  referrer?: Maybe<Scalars['ID']>
+}
+
+export type MembershipBoughtEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  newMember_eq?: Maybe<Scalars['ID']>
+  newMember_in?: Maybe<Array<Scalars['ID']>>
+  rootAccount_eq?: Maybe<Scalars['String']>
+  rootAccount_contains?: Maybe<Scalars['String']>
+  rootAccount_startsWith?: Maybe<Scalars['String']>
+  rootAccount_endsWith?: Maybe<Scalars['String']>
+  rootAccount_in?: Maybe<Array<Scalars['String']>>
+  controllerAccount_eq?: Maybe<Scalars['String']>
+  controllerAccount_contains?: Maybe<Scalars['String']>
+  controllerAccount_startsWith?: Maybe<Scalars['String']>
+  controllerAccount_endsWith?: Maybe<Scalars['String']>
+  controllerAccount_in?: Maybe<Array<Scalars['String']>>
+  handle_eq?: Maybe<Scalars['String']>
+  handle_contains?: Maybe<Scalars['String']>
+  handle_startsWith?: Maybe<Scalars['String']>
+  handle_endsWith?: Maybe<Scalars['String']>
+  handle_in?: Maybe<Array<Scalars['String']>>
+  metadata_eq?: Maybe<Scalars['ID']>
+  metadata_in?: Maybe<Array<Scalars['ID']>>
+  referrer_eq?: Maybe<Scalars['ID']>
+  referrer_in?: Maybe<Array<Scalars['ID']>>
+  newMember?: Maybe<MembershipWhereInput>
+  metadata?: Maybe<MemberMetadataWhereInput>
+  referrer?: Maybe<MembershipWhereInput>
+  AND?: Maybe<Array<MembershipBoughtEventWhereInput>>
+  OR?: Maybe<Array<MembershipBoughtEventWhereInput>>
+}
+
+export type MembershipBoughtEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type MembershipConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<MembershipEdge>
+  pageInfo: PageInfo
+}
+
+export type MembershipCreateInput = {
+  handle: Scalars['String']
+  metadata: Scalars['ID']
+  controllerAccount: Scalars['String']
+  rootAccount: Scalars['String']
+  entry: Scalars['JSONObject']
+  isVerified: Scalars['Boolean']
+  boundAccounts: Array<Scalars['String']>
+  inviteCount: Scalars['Float']
+  invitedBy?: Maybe<Scalars['ID']>
+  referredBy?: Maybe<Scalars['ID']>
+  isFoundingMember: Scalars['Boolean']
+}
+
+export type MembershipEdge = {
+  node: Membership
+  cursor: Scalars['String']
+}
+
+export type MembershipEntryGenesis = {
+  phantom?: Maybe<Scalars['Int']>
+}
+
+export type MembershipEntryGenesisCreateInput = {
+  phantom?: Maybe<Scalars['Float']>
+}
+
+export type MembershipEntryGenesisUpdateInput = {
+  phantom?: Maybe<Scalars['Float']>
+}
+
+export type MembershipEntryGenesisWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  phantom_eq?: Maybe<Scalars['Int']>
+  phantom_gt?: Maybe<Scalars['Int']>
+  phantom_gte?: Maybe<Scalars['Int']>
+  phantom_lt?: Maybe<Scalars['Int']>
+  phantom_lte?: Maybe<Scalars['Int']>
+  phantom_in?: Maybe<Array<Scalars['Int']>>
+  AND?: Maybe<Array<MembershipEntryGenesisWhereInput>>
+  OR?: Maybe<Array<MembershipEntryGenesisWhereInput>>
+}
+
+export type MembershipEntryGenesisWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type MembershipEntryInvited = {
+  /** The event the member was invited in */
+  memberInvitedEvent?: Maybe<MemberInvitedEvent>
+}
+
+export type MembershipEntryMethod = MembershipEntryPaid | MembershipEntryInvited | MembershipEntryGenesis
+
+export type MembershipEntryPaid = {
+  /** The event the membership was bought in */
+  membershipBoughtEvent?: Maybe<MembershipBoughtEvent>
+}
+
+export enum MembershipOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  HandleAsc = 'handle_ASC',
+  HandleDesc = 'handle_DESC',
+  MetadataAsc = 'metadata_ASC',
+  MetadataDesc = 'metadata_DESC',
+  ControllerAccountAsc = 'controllerAccount_ASC',
+  ControllerAccountDesc = 'controllerAccount_DESC',
+  RootAccountAsc = 'rootAccount_ASC',
+  RootAccountDesc = 'rootAccount_DESC',
+  IsVerifiedAsc = 'isVerified_ASC',
+  IsVerifiedDesc = 'isVerified_DESC',
+  InviteCountAsc = 'inviteCount_ASC',
+  InviteCountDesc = 'inviteCount_DESC',
+  InvitedByAsc = 'invitedBy_ASC',
+  InvitedByDesc = 'invitedBy_DESC',
+  ReferredByAsc = 'referredBy_ASC',
+  ReferredByDesc = 'referredBy_DESC',
+  IsFoundingMemberAsc = 'isFoundingMember_ASC',
+  IsFoundingMemberDesc = 'isFoundingMember_DESC',
+}
+
+export type MembershipPriceUpdatedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  /** The new membership price. */
+  newPrice: Scalars['BigInt']
+}
+
+export type MembershipPriceUpdatedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<MembershipPriceUpdatedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type MembershipPriceUpdatedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  newPrice: Scalars['BigInt']
+}
+
+export type MembershipPriceUpdatedEventEdge = {
+  node: MembershipPriceUpdatedEvent
+  cursor: Scalars['String']
+}
+
+export enum MembershipPriceUpdatedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  NewPriceAsc = 'newPrice_ASC',
+  NewPriceDesc = 'newPrice_DESC',
+}
+
+export type MembershipPriceUpdatedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  newPrice?: Maybe<Scalars['BigInt']>
+}
+
+export type MembershipPriceUpdatedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  newPrice_eq?: Maybe<Scalars['BigInt']>
+  newPrice_gt?: Maybe<Scalars['BigInt']>
+  newPrice_gte?: Maybe<Scalars['BigInt']>
+  newPrice_lt?: Maybe<Scalars['BigInt']>
+  newPrice_lte?: Maybe<Scalars['BigInt']>
+  newPrice_in?: Maybe<Array<Scalars['BigInt']>>
+  AND?: Maybe<Array<MembershipPriceUpdatedEventWhereInput>>
+  OR?: Maybe<Array<MembershipPriceUpdatedEventWhereInput>>
+}
+
+export type MembershipPriceUpdatedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type MembershipSystemSnapshot = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** The snapshot block number */
+  snapshotBlock: Scalars['Int']
+  /** Initial invitation count of a new member. */
+  defaultInviteCount: Scalars['Int']
+  /** Current price to buy a membership. */
+  membershipPrice: Scalars['BigInt']
+  /** Percentage of tokens diverted to invitor. */
+  referralCut: Scalars['Int']
+  /** The initial, locked, balance credited to controller account of invitee. */
+  invitedInitialBalance: Scalars['BigInt']
+}
+
+export type MembershipSystemSnapshotConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<MembershipSystemSnapshotEdge>
+  pageInfo: PageInfo
+}
+
+export type MembershipSystemSnapshotCreateInput = {
+  snapshotBlock: Scalars['Float']
+  defaultInviteCount: Scalars['Float']
+  membershipPrice: Scalars['BigInt']
+  referralCut: Scalars['Float']
+  invitedInitialBalance: Scalars['BigInt']
+}
+
+export type MembershipSystemSnapshotEdge = {
+  node: MembershipSystemSnapshot
+  cursor: Scalars['String']
+}
+
+export enum MembershipSystemSnapshotOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  SnapshotBlockAsc = 'snapshotBlock_ASC',
+  SnapshotBlockDesc = 'snapshotBlock_DESC',
+  DefaultInviteCountAsc = 'defaultInviteCount_ASC',
+  DefaultInviteCountDesc = 'defaultInviteCount_DESC',
+  MembershipPriceAsc = 'membershipPrice_ASC',
+  MembershipPriceDesc = 'membershipPrice_DESC',
+  ReferralCutAsc = 'referralCut_ASC',
+  ReferralCutDesc = 'referralCut_DESC',
+  InvitedInitialBalanceAsc = 'invitedInitialBalance_ASC',
+  InvitedInitialBalanceDesc = 'invitedInitialBalance_DESC',
+}
+
+export type MembershipSystemSnapshotUpdateInput = {
+  snapshotBlock?: Maybe<Scalars['Float']>
+  defaultInviteCount?: Maybe<Scalars['Float']>
+  membershipPrice?: Maybe<Scalars['BigInt']>
+  referralCut?: Maybe<Scalars['Float']>
+  invitedInitialBalance?: Maybe<Scalars['BigInt']>
+}
+
+export type MembershipSystemSnapshotWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  snapshotBlock_eq?: Maybe<Scalars['Int']>
+  snapshotBlock_gt?: Maybe<Scalars['Int']>
+  snapshotBlock_gte?: Maybe<Scalars['Int']>
+  snapshotBlock_lt?: Maybe<Scalars['Int']>
+  snapshotBlock_lte?: Maybe<Scalars['Int']>
+  snapshotBlock_in?: Maybe<Array<Scalars['Int']>>
+  defaultInviteCount_eq?: Maybe<Scalars['Int']>
+  defaultInviteCount_gt?: Maybe<Scalars['Int']>
+  defaultInviteCount_gte?: Maybe<Scalars['Int']>
+  defaultInviteCount_lt?: Maybe<Scalars['Int']>
+  defaultInviteCount_lte?: Maybe<Scalars['Int']>
+  defaultInviteCount_in?: Maybe<Array<Scalars['Int']>>
+  membershipPrice_eq?: Maybe<Scalars['BigInt']>
+  membershipPrice_gt?: Maybe<Scalars['BigInt']>
+  membershipPrice_gte?: Maybe<Scalars['BigInt']>
+  membershipPrice_lt?: Maybe<Scalars['BigInt']>
+  membershipPrice_lte?: Maybe<Scalars['BigInt']>
+  membershipPrice_in?: Maybe<Array<Scalars['BigInt']>>
+  referralCut_eq?: Maybe<Scalars['Int']>
+  referralCut_gt?: Maybe<Scalars['Int']>
+  referralCut_gte?: Maybe<Scalars['Int']>
+  referralCut_lt?: Maybe<Scalars['Int']>
+  referralCut_lte?: Maybe<Scalars['Int']>
+  referralCut_in?: Maybe<Array<Scalars['Int']>>
+  invitedInitialBalance_eq?: Maybe<Scalars['BigInt']>
+  invitedInitialBalance_gt?: Maybe<Scalars['BigInt']>
+  invitedInitialBalance_gte?: Maybe<Scalars['BigInt']>
+  invitedInitialBalance_lt?: Maybe<Scalars['BigInt']>
+  invitedInitialBalance_lte?: Maybe<Scalars['BigInt']>
+  invitedInitialBalance_in?: Maybe<Array<Scalars['BigInt']>>
+  AND?: Maybe<Array<MembershipSystemSnapshotWhereInput>>
+  OR?: Maybe<Array<MembershipSystemSnapshotWhereInput>>
+}
+
+export type MembershipSystemSnapshotWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type MembershipUpdateInput = {
+  handle?: Maybe<Scalars['String']>
+  metadata?: Maybe<Scalars['ID']>
+  controllerAccount?: Maybe<Scalars['String']>
+  rootAccount?: Maybe<Scalars['String']>
+  entry?: Maybe<Scalars['JSONObject']>
+  isVerified?: Maybe<Scalars['Boolean']>
+  boundAccounts?: Maybe<Array<Scalars['String']>>
+  inviteCount?: Maybe<Scalars['Float']>
+  invitedBy?: Maybe<Scalars['ID']>
+  referredBy?: Maybe<Scalars['ID']>
+  isFoundingMember?: Maybe<Scalars['Boolean']>
+}
+
+export type MembershipWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  handle_eq?: Maybe<Scalars['String']>
+  handle_contains?: Maybe<Scalars['String']>
+  handle_startsWith?: Maybe<Scalars['String']>
+  handle_endsWith?: Maybe<Scalars['String']>
+  handle_in?: Maybe<Array<Scalars['String']>>
+  metadata_eq?: Maybe<Scalars['ID']>
+  metadata_in?: Maybe<Array<Scalars['ID']>>
+  controllerAccount_eq?: Maybe<Scalars['String']>
+  controllerAccount_contains?: Maybe<Scalars['String']>
+  controllerAccount_startsWith?: Maybe<Scalars['String']>
+  controllerAccount_endsWith?: Maybe<Scalars['String']>
+  controllerAccount_in?: Maybe<Array<Scalars['String']>>
+  rootAccount_eq?: Maybe<Scalars['String']>
+  rootAccount_contains?: Maybe<Scalars['String']>
+  rootAccount_startsWith?: Maybe<Scalars['String']>
+  rootAccount_endsWith?: Maybe<Scalars['String']>
+  rootAccount_in?: Maybe<Array<Scalars['String']>>
+  entry_json?: Maybe<Scalars['JSONObject']>
+  isVerified_eq?: Maybe<Scalars['Boolean']>
+  isVerified_in?: Maybe<Array<Scalars['Boolean']>>
+  inviteCount_eq?: Maybe<Scalars['Int']>
+  inviteCount_gt?: Maybe<Scalars['Int']>
+  inviteCount_gte?: Maybe<Scalars['Int']>
+  inviteCount_lt?: Maybe<Scalars['Int']>
+  inviteCount_lte?: Maybe<Scalars['Int']>
+  inviteCount_in?: Maybe<Array<Scalars['Int']>>
+  invitedBy_eq?: Maybe<Scalars['ID']>
+  invitedBy_in?: Maybe<Array<Scalars['ID']>>
+  referredBy_eq?: Maybe<Scalars['ID']>
+  referredBy_in?: Maybe<Array<Scalars['ID']>>
+  isFoundingMember_eq?: Maybe<Scalars['Boolean']>
+  isFoundingMember_in?: Maybe<Array<Scalars['Boolean']>>
+  metadata?: Maybe<MemberMetadataWhereInput>
+  invitees_none?: Maybe<MembershipWhereInput>
+  invitees_some?: Maybe<MembershipWhereInput>
+  invitees_every?: Maybe<MembershipWhereInput>
+  invitedBy?: Maybe<MembershipWhereInput>
+  referredMembers_none?: Maybe<MembershipWhereInput>
+  referredMembers_some?: Maybe<MembershipWhereInput>
+  referredMembers_every?: Maybe<MembershipWhereInput>
+  referredBy?: Maybe<MembershipWhereInput>
+  roles_none?: Maybe<WorkerWhereInput>
+  roles_some?: Maybe<WorkerWhereInput>
+  roles_every?: Maybe<WorkerWhereInput>
+  invitestransferredeventsourceMember_none?: Maybe<InvitesTransferredEventWhereInput>
+  invitestransferredeventsourceMember_some?: Maybe<InvitesTransferredEventWhereInput>
+  invitestransferredeventsourceMember_every?: Maybe<InvitesTransferredEventWhereInput>
+  invitestransferredeventtargetMember_none?: Maybe<InvitesTransferredEventWhereInput>
+  invitestransferredeventtargetMember_some?: Maybe<InvitesTransferredEventWhereInput>
+  invitestransferredeventtargetMember_every?: Maybe<InvitesTransferredEventWhereInput>
+  memberaccountsupdatedeventmember_none?: Maybe<MemberAccountsUpdatedEventWhereInput>
+  memberaccountsupdatedeventmember_some?: Maybe<MemberAccountsUpdatedEventWhereInput>
+  memberaccountsupdatedeventmember_every?: Maybe<MemberAccountsUpdatedEventWhereInput>
+  memberinvitedeventinvitingMember_none?: Maybe<MemberInvitedEventWhereInput>
+  memberinvitedeventinvitingMember_some?: Maybe<MemberInvitedEventWhereInput>
+  memberinvitedeventinvitingMember_every?: Maybe<MemberInvitedEventWhereInput>
+  memberinvitedeventnewMember_none?: Maybe<MemberInvitedEventWhereInput>
+  memberinvitedeventnewMember_some?: Maybe<MemberInvitedEventWhereInput>
+  memberinvitedeventnewMember_every?: Maybe<MemberInvitedEventWhereInput>
+  memberprofileupdatedeventmember_none?: Maybe<MemberProfileUpdatedEventWhereInput>
+  memberprofileupdatedeventmember_some?: Maybe<MemberProfileUpdatedEventWhereInput>
+  memberprofileupdatedeventmember_every?: Maybe<MemberProfileUpdatedEventWhereInput>
+  memberverificationstatusupdatedeventmember_none?: Maybe<MemberVerificationStatusUpdatedEventWhereInput>
+  memberverificationstatusupdatedeventmember_some?: Maybe<MemberVerificationStatusUpdatedEventWhereInput>
+  memberverificationstatusupdatedeventmember_every?: Maybe<MemberVerificationStatusUpdatedEventWhereInput>
+  membershipboughteventnewMember_none?: Maybe<MembershipBoughtEventWhereInput>
+  membershipboughteventnewMember_some?: Maybe<MembershipBoughtEventWhereInput>
+  membershipboughteventnewMember_every?: Maybe<MembershipBoughtEventWhereInput>
+  membershipboughteventreferrer_none?: Maybe<MembershipBoughtEventWhereInput>
+  membershipboughteventreferrer_some?: Maybe<MembershipBoughtEventWhereInput>
+  membershipboughteventreferrer_every?: Maybe<MembershipBoughtEventWhereInput>
+  stakingaccountaddedeventmember_none?: Maybe<StakingAccountAddedEventWhereInput>
+  stakingaccountaddedeventmember_some?: Maybe<StakingAccountAddedEventWhereInput>
+  stakingaccountaddedeventmember_every?: Maybe<StakingAccountAddedEventWhereInput>
+  stakingaccountconfirmedeventmember_none?: Maybe<StakingAccountConfirmedEventWhereInput>
+  stakingaccountconfirmedeventmember_some?: Maybe<StakingAccountConfirmedEventWhereInput>
+  stakingaccountconfirmedeventmember_every?: Maybe<StakingAccountConfirmedEventWhereInput>
+  stakingaccountremovedeventmember_none?: Maybe<StakingAccountRemovedEventWhereInput>
+  stakingaccountremovedeventmember_some?: Maybe<StakingAccountRemovedEventWhereInput>
+  stakingaccountremovedeventmember_every?: Maybe<StakingAccountRemovedEventWhereInput>
+  workinggroupapplicationapplicant_none?: Maybe<WorkingGroupApplicationWhereInput>
+  workinggroupapplicationapplicant_some?: Maybe<WorkingGroupApplicationWhereInput>
+  workinggroupapplicationapplicant_every?: Maybe<WorkingGroupApplicationWhereInput>
+  AND?: Maybe<Array<MembershipWhereInput>>
+  OR?: Maybe<Array<MembershipWhereInput>>
+}
+
+export type MembershipWhereUniqueInput = {
+  id?: Maybe<Scalars['ID']>
+  handle?: Maybe<Scalars['String']>
+}
+
+export type MemberVerificationStatusUpdatedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  member: Membership
+  memberId: Scalars['String']
+  worker: Worker
+  workerId: Scalars['String']
+  /** New status. */
+  isVerified: Scalars['Boolean']
+}
+
+export type MemberVerificationStatusUpdatedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<MemberVerificationStatusUpdatedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type MemberVerificationStatusUpdatedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  member: Scalars['ID']
+  worker: Scalars['ID']
+  isVerified: Scalars['Boolean']
+}
+
+export type MemberVerificationStatusUpdatedEventEdge = {
+  node: MemberVerificationStatusUpdatedEvent
+  cursor: Scalars['String']
+}
+
+export enum MemberVerificationStatusUpdatedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  MemberAsc = 'member_ASC',
+  MemberDesc = 'member_DESC',
+  WorkerAsc = 'worker_ASC',
+  WorkerDesc = 'worker_DESC',
+  IsVerifiedAsc = 'isVerified_ASC',
+  IsVerifiedDesc = 'isVerified_DESC',
+}
+
+export type MemberVerificationStatusUpdatedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  member?: Maybe<Scalars['ID']>
+  worker?: Maybe<Scalars['ID']>
+  isVerified?: Maybe<Scalars['Boolean']>
+}
+
+export type MemberVerificationStatusUpdatedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  member_eq?: Maybe<Scalars['ID']>
+  member_in?: Maybe<Array<Scalars['ID']>>
+  worker_eq?: Maybe<Scalars['ID']>
+  worker_in?: Maybe<Array<Scalars['ID']>>
+  isVerified_eq?: Maybe<Scalars['Boolean']>
+  isVerified_in?: Maybe<Array<Scalars['Boolean']>>
+  member?: Maybe<MembershipWhereInput>
+  worker?: Maybe<WorkerWhereInput>
+  AND?: Maybe<Array<MemberVerificationStatusUpdatedEventWhereInput>>
+  OR?: Maybe<Array<MemberVerificationStatusUpdatedEventWhereInput>>
+}
+
+export type MemberVerificationStatusUpdatedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export enum Network {
+  Babylon = 'BABYLON',
+  Alexandria = 'ALEXANDRIA',
+  Rome = 'ROME',
+  Olympia = 'OLYMPIA',
+}
+
+export type NewMissedRewardLevelReachedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  worker: Worker
+  workerId: Scalars['String']
+  /** New missed reward amount */
+  newMissedRewardAmount: Scalars['BigInt']
+}
+
+export type NewMissedRewardLevelReachedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<NewMissedRewardLevelReachedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type NewMissedRewardLevelReachedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  worker: Scalars['ID']
+  newMissedRewardAmount: Scalars['BigInt']
+}
+
+export type NewMissedRewardLevelReachedEventEdge = {
+  node: NewMissedRewardLevelReachedEvent
+  cursor: Scalars['String']
+}
+
+export enum NewMissedRewardLevelReachedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  WorkerAsc = 'worker_ASC',
+  WorkerDesc = 'worker_DESC',
+  NewMissedRewardAmountAsc = 'newMissedRewardAmount_ASC',
+  NewMissedRewardAmountDesc = 'newMissedRewardAmount_DESC',
+}
+
+export type NewMissedRewardLevelReachedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  worker?: Maybe<Scalars['ID']>
+  newMissedRewardAmount?: Maybe<Scalars['BigInt']>
+}
+
+export type NewMissedRewardLevelReachedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  worker_eq?: Maybe<Scalars['ID']>
+  worker_in?: Maybe<Array<Scalars['ID']>>
+  newMissedRewardAmount_eq?: Maybe<Scalars['BigInt']>
+  newMissedRewardAmount_gt?: Maybe<Scalars['BigInt']>
+  newMissedRewardAmount_gte?: Maybe<Scalars['BigInt']>
+  newMissedRewardAmount_lt?: Maybe<Scalars['BigInt']>
+  newMissedRewardAmount_lte?: Maybe<Scalars['BigInt']>
+  newMissedRewardAmount_in?: Maybe<Array<Scalars['BigInt']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  worker?: Maybe<WorkerWhereInput>
+  AND?: Maybe<Array<NewMissedRewardLevelReachedEventWhereInput>>
+  OR?: Maybe<Array<NewMissedRewardLevelReachedEventWhereInput>>
+}
+
+export type NewMissedRewardLevelReachedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type OpeningAddedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  opening: WorkingGroupOpening
+  openingId: Scalars['String']
+}
+
+export type OpeningAddedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<OpeningAddedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type OpeningAddedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  opening: Scalars['ID']
+}
+
+export type OpeningAddedEventEdge = {
+  node: OpeningAddedEvent
+  cursor: Scalars['String']
+}
+
+export enum OpeningAddedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  OpeningAsc = 'opening_ASC',
+  OpeningDesc = 'opening_DESC',
+}
+
+export type OpeningAddedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  opening?: Maybe<Scalars['ID']>
+}
+
+export type OpeningAddedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  opening_eq?: Maybe<Scalars['ID']>
+  opening_in?: Maybe<Array<Scalars['ID']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  opening?: Maybe<WorkingGroupOpeningWhereInput>
+  AND?: Maybe<Array<OpeningAddedEventWhereInput>>
+  OR?: Maybe<Array<OpeningAddedEventWhereInput>>
+}
+
+export type OpeningAddedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type OpeningCanceledEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  opening: WorkingGroupOpening
+  openingId: Scalars['String']
+}
+
+export type OpeningCanceledEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<OpeningCanceledEventEdge>
+  pageInfo: PageInfo
+}
+
+export type OpeningCanceledEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  opening: Scalars['ID']
+}
+
+export type OpeningCanceledEventEdge = {
+  node: OpeningCanceledEvent
+  cursor: Scalars['String']
+}
+
+export enum OpeningCanceledEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  OpeningAsc = 'opening_ASC',
+  OpeningDesc = 'opening_DESC',
+}
+
+export type OpeningCanceledEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  opening?: Maybe<Scalars['ID']>
+}
+
+export type OpeningCanceledEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  opening_eq?: Maybe<Scalars['ID']>
+  opening_in?: Maybe<Array<Scalars['ID']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  opening?: Maybe<WorkingGroupOpeningWhereInput>
+  AND?: Maybe<Array<OpeningCanceledEventWhereInput>>
+  OR?: Maybe<Array<OpeningCanceledEventWhereInput>>
+}
+
+export type OpeningCanceledEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type OpeningFilledEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  opening: WorkingGroupOpening
+  openingId: Scalars['String']
+  workersHired: Array<Worker>
+}
+
+export type OpeningFilledEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<OpeningFilledEventEdge>
+  pageInfo: PageInfo
+}
+
+export type OpeningFilledEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  opening: Scalars['ID']
+}
+
+export type OpeningFilledEventEdge = {
+  node: OpeningFilledEvent
+  cursor: Scalars['String']
+}
+
+export enum OpeningFilledEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  OpeningAsc = 'opening_ASC',
+  OpeningDesc = 'opening_DESC',
+}
+
+export type OpeningFilledEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  opening?: Maybe<Scalars['ID']>
+}
+
+export type OpeningFilledEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  opening_eq?: Maybe<Scalars['ID']>
+  opening_in?: Maybe<Array<Scalars['ID']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  opening?: Maybe<WorkingGroupOpeningWhereInput>
+  workersHired_none?: Maybe<WorkerWhereInput>
+  workersHired_some?: Maybe<WorkerWhereInput>
+  workersHired_every?: Maybe<WorkerWhereInput>
+  AND?: Maybe<Array<OpeningFilledEventWhereInput>>
+  OR?: Maybe<Array<OpeningFilledEventWhereInput>>
+}
+
+export type OpeningFilledEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type OpeningStatusCancelled = {
+  /** Related event emitted on opening cancellation */
+  openingCanceledEvent?: Maybe<OpeningCanceledEvent>
+}
+
+export type OpeningStatusFilled = {
+  /** Related event emitted after filling the opening */
+  openingFilledEvent?: Maybe<OpeningFilledEvent>
+}
+
+export type OpeningStatusOpen = {
+  phantom?: Maybe<Scalars['Int']>
+}
+
+export type OpeningStatusOpenCreateInput = {
+  phantom?: Maybe<Scalars['Float']>
+}
+
+export type OpeningStatusOpenUpdateInput = {
+  phantom?: Maybe<Scalars['Float']>
+}
+
+export type OpeningStatusOpenWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  phantom_eq?: Maybe<Scalars['Int']>
+  phantom_gt?: Maybe<Scalars['Int']>
+  phantom_gte?: Maybe<Scalars['Int']>
+  phantom_lt?: Maybe<Scalars['Int']>
+  phantom_lte?: Maybe<Scalars['Int']>
+  phantom_in?: Maybe<Array<Scalars['Int']>>
+  AND?: Maybe<Array<OpeningStatusOpenWhereInput>>
+  OR?: Maybe<Array<OpeningStatusOpenWhereInput>>
+}
+
+export type OpeningStatusOpenWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type PageInfo = {
+  hasNextPage: Scalars['Boolean']
+  hasPreviousPage: Scalars['Boolean']
+  startCursor?: Maybe<Scalars['String']>
+  endCursor?: Maybe<Scalars['String']>
+}
+
+export type ProcessorState = {
+  lastCompleteBlock: Scalars['Float']
+  lastProcessedEvent: Scalars['String']
+  indexerHead: Scalars['Float']
+  chainHead: Scalars['Float']
+}
+
+export type Query = {
+  applicationFormQuestionAnswers: Array<ApplicationFormQuestionAnswer>
+  applicationFormQuestionAnswerByUniqueInput?: Maybe<ApplicationFormQuestionAnswer>
+  applicationFormQuestionAnswersConnection: ApplicationFormQuestionAnswerConnection
+  applicationFormQuestions: Array<ApplicationFormQuestion>
+  applicationFormQuestionByUniqueInput?: Maybe<ApplicationFormQuestion>
+  applicationFormQuestionsConnection: ApplicationFormQuestionConnection
+  applicationWithdrawnEvents: Array<ApplicationWithdrawnEvent>
+  applicationWithdrawnEventByUniqueInput?: Maybe<ApplicationWithdrawnEvent>
+  applicationWithdrawnEventsConnection: ApplicationWithdrawnEventConnection
+  appliedOnOpeningEvents: Array<AppliedOnOpeningEvent>
+  appliedOnOpeningEventByUniqueInput?: Maybe<AppliedOnOpeningEvent>
+  appliedOnOpeningEventsConnection: AppliedOnOpeningEventConnection
+  budgetSetEvents: Array<BudgetSetEvent>
+  budgetSetEventByUniqueInput?: Maybe<BudgetSetEvent>
+  budgetSetEventsConnection: BudgetSetEventConnection
+  budgetSpendingEvents: Array<BudgetSpendingEvent>
+  budgetSpendingEventByUniqueInput?: Maybe<BudgetSpendingEvent>
+  budgetSpendingEventsConnection: BudgetSpendingEventConnection
+  dataObjects: Array<DataObject>
+  dataObjectByUniqueInput?: Maybe<DataObject>
+  dataObjectsConnection: DataObjectConnection
+  events: Array<Event>
+  initialInvitationBalanceUpdatedEvents: Array<InitialInvitationBalanceUpdatedEvent>
+  initialInvitationBalanceUpdatedEventByUniqueInput?: Maybe<InitialInvitationBalanceUpdatedEvent>
+  initialInvitationBalanceUpdatedEventsConnection: InitialInvitationBalanceUpdatedEventConnection
+  initialInvitationCountUpdatedEvents: Array<InitialInvitationCountUpdatedEvent>
+  initialInvitationCountUpdatedEventByUniqueInput?: Maybe<InitialInvitationCountUpdatedEvent>
+  initialInvitationCountUpdatedEventsConnection: InitialInvitationCountUpdatedEventConnection
+  invitesTransferredEvents: Array<InvitesTransferredEvent>
+  invitesTransferredEventByUniqueInput?: Maybe<InvitesTransferredEvent>
+  invitesTransferredEventsConnection: InvitesTransferredEventConnection
+  leaderInvitationQuotaUpdatedEvents: Array<LeaderInvitationQuotaUpdatedEvent>
+  leaderInvitationQuotaUpdatedEventByUniqueInput?: Maybe<LeaderInvitationQuotaUpdatedEvent>
+  leaderInvitationQuotaUpdatedEventsConnection: LeaderInvitationQuotaUpdatedEventConnection
+  leaderSetEvents: Array<LeaderSetEvent>
+  leaderSetEventByUniqueInput?: Maybe<LeaderSetEvent>
+  leaderSetEventsConnection: LeaderSetEventConnection
+  leaderUnsetEvents: Array<LeaderUnsetEvent>
+  leaderUnsetEventByUniqueInput?: Maybe<LeaderUnsetEvent>
+  leaderUnsetEventsConnection: LeaderUnsetEventConnection
+  memberAccountsUpdatedEvents: Array<MemberAccountsUpdatedEvent>
+  memberAccountsUpdatedEventByUniqueInput?: Maybe<MemberAccountsUpdatedEvent>
+  memberAccountsUpdatedEventsConnection: MemberAccountsUpdatedEventConnection
+  memberInvitedEvents: Array<MemberInvitedEvent>
+  memberInvitedEventByUniqueInput?: Maybe<MemberInvitedEvent>
+  memberInvitedEventsConnection: MemberInvitedEventConnection
+  memberMetadata: Array<MemberMetadata>
+  memberMetadataByUniqueInput?: Maybe<MemberMetadata>
+  memberMetadataConnection: MemberMetadataConnection
+  memberProfileUpdatedEvents: Array<MemberProfileUpdatedEvent>
+  memberProfileUpdatedEventByUniqueInput?: Maybe<MemberProfileUpdatedEvent>
+  memberProfileUpdatedEventsConnection: MemberProfileUpdatedEventConnection
+  memberVerificationStatusUpdatedEvents: Array<MemberVerificationStatusUpdatedEvent>
+  memberVerificationStatusUpdatedEventByUniqueInput?: Maybe<MemberVerificationStatusUpdatedEvent>
+  memberVerificationStatusUpdatedEventsConnection: MemberVerificationStatusUpdatedEventConnection
+  membershipBoughtEvents: Array<MembershipBoughtEvent>
+  membershipBoughtEventByUniqueInput?: Maybe<MembershipBoughtEvent>
+  membershipBoughtEventsConnection: MembershipBoughtEventConnection
+  membershipPriceUpdatedEvents: Array<MembershipPriceUpdatedEvent>
+  membershipPriceUpdatedEventByUniqueInput?: Maybe<MembershipPriceUpdatedEvent>
+  membershipPriceUpdatedEventsConnection: MembershipPriceUpdatedEventConnection
+  membershipSystemSnapshots: Array<MembershipSystemSnapshot>
+  membershipSystemSnapshotByUniqueInput?: Maybe<MembershipSystemSnapshot>
+  membershipSystemSnapshotsConnection: MembershipSystemSnapshotConnection
+  memberships: Array<Membership>
+  membershipByUniqueInput?: Maybe<Membership>
+  membershipsConnection: MembershipConnection
+  newMissedRewardLevelReachedEvents: Array<NewMissedRewardLevelReachedEvent>
+  newMissedRewardLevelReachedEventByUniqueInput?: Maybe<NewMissedRewardLevelReachedEvent>
+  newMissedRewardLevelReachedEventsConnection: NewMissedRewardLevelReachedEventConnection
+  openingAddedEvents: Array<OpeningAddedEvent>
+  openingAddedEventByUniqueInput?: Maybe<OpeningAddedEvent>
+  openingAddedEventsConnection: OpeningAddedEventConnection
+  openingCanceledEvents: Array<OpeningCanceledEvent>
+  openingCanceledEventByUniqueInput?: Maybe<OpeningCanceledEvent>
+  openingCanceledEventsConnection: OpeningCanceledEventConnection
+  openingFilledEvents: Array<OpeningFilledEvent>
+  openingFilledEventByUniqueInput?: Maybe<OpeningFilledEvent>
+  openingFilledEventsConnection: OpeningFilledEventConnection
+  membersByHandle: Array<MembersByHandleFtsOutput>
+  referralCutUpdatedEvents: Array<ReferralCutUpdatedEvent>
+  referralCutUpdatedEventByUniqueInput?: Maybe<ReferralCutUpdatedEvent>
+  referralCutUpdatedEventsConnection: ReferralCutUpdatedEventConnection
+  rewardPaidEvents: Array<RewardPaidEvent>
+  rewardPaidEventByUniqueInput?: Maybe<RewardPaidEvent>
+  rewardPaidEventsConnection: RewardPaidEventConnection
+  stakeDecreasedEvents: Array<StakeDecreasedEvent>
+  stakeDecreasedEventByUniqueInput?: Maybe<StakeDecreasedEvent>
+  stakeDecreasedEventsConnection: StakeDecreasedEventConnection
+  stakeIncreasedEvents: Array<StakeIncreasedEvent>
+  stakeIncreasedEventByUniqueInput?: Maybe<StakeIncreasedEvent>
+  stakeIncreasedEventsConnection: StakeIncreasedEventConnection
+  stakeSlashedEvents: Array<StakeSlashedEvent>
+  stakeSlashedEventByUniqueInput?: Maybe<StakeSlashedEvent>
+  stakeSlashedEventsConnection: StakeSlashedEventConnection
+  stakingAccountAddedEvents: Array<StakingAccountAddedEvent>
+  stakingAccountAddedEventByUniqueInput?: Maybe<StakingAccountAddedEvent>
+  stakingAccountAddedEventsConnection: StakingAccountAddedEventConnection
+  stakingAccountConfirmedEvents: Array<StakingAccountConfirmedEvent>
+  stakingAccountConfirmedEventByUniqueInput?: Maybe<StakingAccountConfirmedEvent>
+  stakingAccountConfirmedEventsConnection: StakingAccountConfirmedEventConnection
+  stakingAccountRemovedEvents: Array<StakingAccountRemovedEvent>
+  stakingAccountRemovedEventByUniqueInput?: Maybe<StakingAccountRemovedEvent>
+  stakingAccountRemovedEventsConnection: StakingAccountRemovedEventConnection
+  statusTextChangedEvents: Array<StatusTextChangedEvent>
+  statusTextChangedEventByUniqueInput?: Maybe<StatusTextChangedEvent>
+  statusTextChangedEventsConnection: StatusTextChangedEventConnection
+  terminatedLeaderEvents: Array<TerminatedLeaderEvent>
+  terminatedLeaderEventByUniqueInput?: Maybe<TerminatedLeaderEvent>
+  terminatedLeaderEventsConnection: TerminatedLeaderEventConnection
+  terminatedWorkerEvents: Array<TerminatedWorkerEvent>
+  terminatedWorkerEventByUniqueInput?: Maybe<TerminatedWorkerEvent>
+  terminatedWorkerEventsConnection: TerminatedWorkerEventConnection
+  upcomingWorkingGroupOpenings: Array<UpcomingWorkingGroupOpening>
+  upcomingWorkingGroupOpeningByUniqueInput?: Maybe<UpcomingWorkingGroupOpening>
+  upcomingWorkingGroupOpeningsConnection: UpcomingWorkingGroupOpeningConnection
+  workerExitedEvents: Array<WorkerExitedEvent>
+  workerExitedEventByUniqueInput?: Maybe<WorkerExitedEvent>
+  workerExitedEventsConnection: WorkerExitedEventConnection
+  workerRewardAccountUpdatedEvents: Array<WorkerRewardAccountUpdatedEvent>
+  workerRewardAccountUpdatedEventByUniqueInput?: Maybe<WorkerRewardAccountUpdatedEvent>
+  workerRewardAccountUpdatedEventsConnection: WorkerRewardAccountUpdatedEventConnection
+  workerRewardAmountUpdatedEvents: Array<WorkerRewardAmountUpdatedEvent>
+  workerRewardAmountUpdatedEventByUniqueInput?: Maybe<WorkerRewardAmountUpdatedEvent>
+  workerRewardAmountUpdatedEventsConnection: WorkerRewardAmountUpdatedEventConnection
+  workerRoleAccountUpdatedEvents: Array<WorkerRoleAccountUpdatedEvent>
+  workerRoleAccountUpdatedEventByUniqueInput?: Maybe<WorkerRoleAccountUpdatedEvent>
+  workerRoleAccountUpdatedEventsConnection: WorkerRoleAccountUpdatedEventConnection
+  workerStartedLeavingEvents: Array<WorkerStartedLeavingEvent>
+  workerStartedLeavingEventByUniqueInput?: Maybe<WorkerStartedLeavingEvent>
+  workerStartedLeavingEventsConnection: WorkerStartedLeavingEventConnection
+  workers: Array<Worker>
+  workerByUniqueInput?: Maybe<Worker>
+  workersConnection: WorkerConnection
+  workingGroupApplications: Array<WorkingGroupApplication>
+  workingGroupApplicationByUniqueInput?: Maybe<WorkingGroupApplication>
+  workingGroupApplicationsConnection: WorkingGroupApplicationConnection
+  workingGroupMetadata: Array<WorkingGroupMetadata>
+  workingGroupMetadataByUniqueInput?: Maybe<WorkingGroupMetadata>
+  workingGroupMetadataConnection: WorkingGroupMetadataConnection
+  workingGroupOpeningMetadata: Array<WorkingGroupOpeningMetadata>
+  workingGroupOpeningMetadataByUniqueInput?: Maybe<WorkingGroupOpeningMetadata>
+  workingGroupOpeningMetadataConnection: WorkingGroupOpeningMetadataConnection
+  workingGroupOpenings: Array<WorkingGroupOpening>
+  workingGroupOpeningByUniqueInput?: Maybe<WorkingGroupOpening>
+  workingGroupOpeningsConnection: WorkingGroupOpeningConnection
+  workingGroups: Array<WorkingGroup>
+  workingGroupByUniqueInput?: Maybe<WorkingGroup>
+  workingGroupsConnection: WorkingGroupConnection
+}
+
+export type QueryApplicationFormQuestionAnswersArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<ApplicationFormQuestionAnswerWhereInput>
+  orderBy?: Maybe<Array<ApplicationFormQuestionAnswerOrderByInput>>
+}
+
+export type QueryApplicationFormQuestionAnswerByUniqueInputArgs = {
+  where: ApplicationFormQuestionAnswerWhereUniqueInput
+}
+
+export type QueryApplicationFormQuestionAnswersConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<ApplicationFormQuestionAnswerWhereInput>
+  orderBy?: Maybe<Array<ApplicationFormQuestionAnswerOrderByInput>>
+}
+
+export type QueryApplicationFormQuestionsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<ApplicationFormQuestionWhereInput>
+  orderBy?: Maybe<Array<ApplicationFormQuestionOrderByInput>>
+}
+
+export type QueryApplicationFormQuestionByUniqueInputArgs = {
+  where: ApplicationFormQuestionWhereUniqueInput
+}
+
+export type QueryApplicationFormQuestionsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<ApplicationFormQuestionWhereInput>
+  orderBy?: Maybe<Array<ApplicationFormQuestionOrderByInput>>
+}
+
+export type QueryApplicationWithdrawnEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<ApplicationWithdrawnEventWhereInput>
+  orderBy?: Maybe<Array<ApplicationWithdrawnEventOrderByInput>>
+}
+
+export type QueryApplicationWithdrawnEventByUniqueInputArgs = {
+  where: ApplicationWithdrawnEventWhereUniqueInput
+}
+
+export type QueryApplicationWithdrawnEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<ApplicationWithdrawnEventWhereInput>
+  orderBy?: Maybe<Array<ApplicationWithdrawnEventOrderByInput>>
+}
+
+export type QueryAppliedOnOpeningEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<AppliedOnOpeningEventWhereInput>
+  orderBy?: Maybe<Array<AppliedOnOpeningEventOrderByInput>>
+}
+
+export type QueryAppliedOnOpeningEventByUniqueInputArgs = {
+  where: AppliedOnOpeningEventWhereUniqueInput
+}
+
+export type QueryAppliedOnOpeningEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<AppliedOnOpeningEventWhereInput>
+  orderBy?: Maybe<Array<AppliedOnOpeningEventOrderByInput>>
+}
+
+export type QueryBudgetSetEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<BudgetSetEventWhereInput>
+  orderBy?: Maybe<Array<BudgetSetEventOrderByInput>>
+}
+
+export type QueryBudgetSetEventByUniqueInputArgs = {
+  where: BudgetSetEventWhereUniqueInput
+}
+
+export type QueryBudgetSetEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<BudgetSetEventWhereInput>
+  orderBy?: Maybe<Array<BudgetSetEventOrderByInput>>
+}
+
+export type QueryBudgetSpendingEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<BudgetSpendingEventWhereInput>
+  orderBy?: Maybe<Array<BudgetSpendingEventOrderByInput>>
+}
+
+export type QueryBudgetSpendingEventByUniqueInputArgs = {
+  where: BudgetSpendingEventWhereUniqueInput
+}
+
+export type QueryBudgetSpendingEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<BudgetSpendingEventWhereInput>
+  orderBy?: Maybe<Array<BudgetSpendingEventOrderByInput>>
+}
+
+export type QueryDataObjectsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<DataObjectWhereInput>
+  orderBy?: Maybe<Array<DataObjectOrderByInput>>
+}
+
+export type QueryDataObjectByUniqueInputArgs = {
+  where: DataObjectWhereUniqueInput
+}
+
+export type QueryDataObjectsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<DataObjectWhereInput>
+  orderBy?: Maybe<Array<DataObjectOrderByInput>>
+}
+
+export type QueryEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<EventWhereInput>
+  orderBy?: Maybe<Array<EventOrderByInput>>
+}
+
+export type QueryInitialInvitationBalanceUpdatedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<InitialInvitationBalanceUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<InitialInvitationBalanceUpdatedEventOrderByInput>>
+}
+
+export type QueryInitialInvitationBalanceUpdatedEventByUniqueInputArgs = {
+  where: InitialInvitationBalanceUpdatedEventWhereUniqueInput
+}
+
+export type QueryInitialInvitationBalanceUpdatedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<InitialInvitationBalanceUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<InitialInvitationBalanceUpdatedEventOrderByInput>>
+}
+
+export type QueryInitialInvitationCountUpdatedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<InitialInvitationCountUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<InitialInvitationCountUpdatedEventOrderByInput>>
+}
+
+export type QueryInitialInvitationCountUpdatedEventByUniqueInputArgs = {
+  where: InitialInvitationCountUpdatedEventWhereUniqueInput
+}
+
+export type QueryInitialInvitationCountUpdatedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<InitialInvitationCountUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<InitialInvitationCountUpdatedEventOrderByInput>>
+}
+
+export type QueryInvitesTransferredEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<InvitesTransferredEventWhereInput>
+  orderBy?: Maybe<Array<InvitesTransferredEventOrderByInput>>
+}
+
+export type QueryInvitesTransferredEventByUniqueInputArgs = {
+  where: InvitesTransferredEventWhereUniqueInput
+}
+
+export type QueryInvitesTransferredEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<InvitesTransferredEventWhereInput>
+  orderBy?: Maybe<Array<InvitesTransferredEventOrderByInput>>
+}
+
+export type QueryLeaderInvitationQuotaUpdatedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<LeaderInvitationQuotaUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<LeaderInvitationQuotaUpdatedEventOrderByInput>>
+}
+
+export type QueryLeaderInvitationQuotaUpdatedEventByUniqueInputArgs = {
+  where: LeaderInvitationQuotaUpdatedEventWhereUniqueInput
+}
+
+export type QueryLeaderInvitationQuotaUpdatedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<LeaderInvitationQuotaUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<LeaderInvitationQuotaUpdatedEventOrderByInput>>
+}
+
+export type QueryLeaderSetEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<LeaderSetEventWhereInput>
+  orderBy?: Maybe<Array<LeaderSetEventOrderByInput>>
+}
+
+export type QueryLeaderSetEventByUniqueInputArgs = {
+  where: LeaderSetEventWhereUniqueInput
+}
+
+export type QueryLeaderSetEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<LeaderSetEventWhereInput>
+  orderBy?: Maybe<Array<LeaderSetEventOrderByInput>>
+}
+
+export type QueryLeaderUnsetEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<LeaderUnsetEventWhereInput>
+  orderBy?: Maybe<Array<LeaderUnsetEventOrderByInput>>
+}
+
+export type QueryLeaderUnsetEventByUniqueInputArgs = {
+  where: LeaderUnsetEventWhereUniqueInput
+}
+
+export type QueryLeaderUnsetEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<LeaderUnsetEventWhereInput>
+  orderBy?: Maybe<Array<LeaderUnsetEventOrderByInput>>
+}
+
+export type QueryMemberAccountsUpdatedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<MemberAccountsUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<MemberAccountsUpdatedEventOrderByInput>>
+}
+
+export type QueryMemberAccountsUpdatedEventByUniqueInputArgs = {
+  where: MemberAccountsUpdatedEventWhereUniqueInput
+}
+
+export type QueryMemberAccountsUpdatedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<MemberAccountsUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<MemberAccountsUpdatedEventOrderByInput>>
+}
+
+export type QueryMemberInvitedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<MemberInvitedEventWhereInput>
+  orderBy?: Maybe<Array<MemberInvitedEventOrderByInput>>
+}
+
+export type QueryMemberInvitedEventByUniqueInputArgs = {
+  where: MemberInvitedEventWhereUniqueInput
+}
+
+export type QueryMemberInvitedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<MemberInvitedEventWhereInput>
+  orderBy?: Maybe<Array<MemberInvitedEventOrderByInput>>
+}
+
+export type QueryMemberMetadataArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<MemberMetadataWhereInput>
+  orderBy?: Maybe<Array<MemberMetadataOrderByInput>>
+}
+
+export type QueryMemberMetadataByUniqueInputArgs = {
+  where: MemberMetadataWhereUniqueInput
+}
+
+export type QueryMemberMetadataConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<MemberMetadataWhereInput>
+  orderBy?: Maybe<Array<MemberMetadataOrderByInput>>
+}
+
+export type QueryMemberProfileUpdatedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<MemberProfileUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<MemberProfileUpdatedEventOrderByInput>>
+}
+
+export type QueryMemberProfileUpdatedEventByUniqueInputArgs = {
+  where: MemberProfileUpdatedEventWhereUniqueInput
+}
+
+export type QueryMemberProfileUpdatedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<MemberProfileUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<MemberProfileUpdatedEventOrderByInput>>
+}
+
+export type QueryMemberVerificationStatusUpdatedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<MemberVerificationStatusUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<MemberVerificationStatusUpdatedEventOrderByInput>>
+}
+
+export type QueryMemberVerificationStatusUpdatedEventByUniqueInputArgs = {
+  where: MemberVerificationStatusUpdatedEventWhereUniqueInput
+}
+
+export type QueryMemberVerificationStatusUpdatedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<MemberVerificationStatusUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<MemberVerificationStatusUpdatedEventOrderByInput>>
+}
+
+export type QueryMembershipBoughtEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<MembershipBoughtEventWhereInput>
+  orderBy?: Maybe<Array<MembershipBoughtEventOrderByInput>>
+}
+
+export type QueryMembershipBoughtEventByUniqueInputArgs = {
+  where: MembershipBoughtEventWhereUniqueInput
+}
+
+export type QueryMembershipBoughtEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<MembershipBoughtEventWhereInput>
+  orderBy?: Maybe<Array<MembershipBoughtEventOrderByInput>>
+}
+
+export type QueryMembershipPriceUpdatedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<MembershipPriceUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<MembershipPriceUpdatedEventOrderByInput>>
+}
+
+export type QueryMembershipPriceUpdatedEventByUniqueInputArgs = {
+  where: MembershipPriceUpdatedEventWhereUniqueInput
+}
+
+export type QueryMembershipPriceUpdatedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<MembershipPriceUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<MembershipPriceUpdatedEventOrderByInput>>
+}
+
+export type QueryMembershipSystemSnapshotsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<MembershipSystemSnapshotWhereInput>
+  orderBy?: Maybe<Array<MembershipSystemSnapshotOrderByInput>>
+}
+
+export type QueryMembershipSystemSnapshotByUniqueInputArgs = {
+  where: MembershipSystemSnapshotWhereUniqueInput
+}
+
+export type QueryMembershipSystemSnapshotsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<MembershipSystemSnapshotWhereInput>
+  orderBy?: Maybe<Array<MembershipSystemSnapshotOrderByInput>>
+}
+
+export type QueryMembershipsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<MembershipWhereInput>
+  orderBy?: Maybe<Array<MembershipOrderByInput>>
+}
+
+export type QueryMembershipByUniqueInputArgs = {
+  where: MembershipWhereUniqueInput
+}
+
+export type QueryMembershipsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<MembershipWhereInput>
+  orderBy?: Maybe<Array<MembershipOrderByInput>>
+}
+
+export type QueryNewMissedRewardLevelReachedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<NewMissedRewardLevelReachedEventWhereInput>
+  orderBy?: Maybe<Array<NewMissedRewardLevelReachedEventOrderByInput>>
+}
+
+export type QueryNewMissedRewardLevelReachedEventByUniqueInputArgs = {
+  where: NewMissedRewardLevelReachedEventWhereUniqueInput
+}
+
+export type QueryNewMissedRewardLevelReachedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<NewMissedRewardLevelReachedEventWhereInput>
+  orderBy?: Maybe<Array<NewMissedRewardLevelReachedEventOrderByInput>>
+}
+
+export type QueryOpeningAddedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<OpeningAddedEventWhereInput>
+  orderBy?: Maybe<Array<OpeningAddedEventOrderByInput>>
+}
+
+export type QueryOpeningAddedEventByUniqueInputArgs = {
+  where: OpeningAddedEventWhereUniqueInput
+}
+
+export type QueryOpeningAddedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<OpeningAddedEventWhereInput>
+  orderBy?: Maybe<Array<OpeningAddedEventOrderByInput>>
+}
+
+export type QueryOpeningCanceledEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<OpeningCanceledEventWhereInput>
+  orderBy?: Maybe<Array<OpeningCanceledEventOrderByInput>>
+}
+
+export type QueryOpeningCanceledEventByUniqueInputArgs = {
+  where: OpeningCanceledEventWhereUniqueInput
+}
+
+export type QueryOpeningCanceledEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<OpeningCanceledEventWhereInput>
+  orderBy?: Maybe<Array<OpeningCanceledEventOrderByInput>>
+}
+
+export type QueryOpeningFilledEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<OpeningFilledEventWhereInput>
+  orderBy?: Maybe<Array<OpeningFilledEventOrderByInput>>
+}
+
+export type QueryOpeningFilledEventByUniqueInputArgs = {
+  where: OpeningFilledEventWhereUniqueInput
+}
+
+export type QueryOpeningFilledEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<OpeningFilledEventWhereInput>
+  orderBy?: Maybe<Array<OpeningFilledEventOrderByInput>>
+}
+
+export type QueryMembersByHandleArgs = {
+  whereMembership?: Maybe<MembershipWhereInput>
+  skip?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  text: Scalars['String']
+}
+
+export type QueryReferralCutUpdatedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<ReferralCutUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<ReferralCutUpdatedEventOrderByInput>>
+}
+
+export type QueryReferralCutUpdatedEventByUniqueInputArgs = {
+  where: ReferralCutUpdatedEventWhereUniqueInput
+}
+
+export type QueryReferralCutUpdatedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<ReferralCutUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<ReferralCutUpdatedEventOrderByInput>>
+}
+
+export type QueryRewardPaidEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<RewardPaidEventWhereInput>
+  orderBy?: Maybe<Array<RewardPaidEventOrderByInput>>
+}
+
+export type QueryRewardPaidEventByUniqueInputArgs = {
+  where: RewardPaidEventWhereUniqueInput
+}
+
+export type QueryRewardPaidEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<RewardPaidEventWhereInput>
+  orderBy?: Maybe<Array<RewardPaidEventOrderByInput>>
+}
+
+export type QueryStakeDecreasedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<StakeDecreasedEventWhereInput>
+  orderBy?: Maybe<Array<StakeDecreasedEventOrderByInput>>
+}
+
+export type QueryStakeDecreasedEventByUniqueInputArgs = {
+  where: StakeDecreasedEventWhereUniqueInput
+}
+
+export type QueryStakeDecreasedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<StakeDecreasedEventWhereInput>
+  orderBy?: Maybe<Array<StakeDecreasedEventOrderByInput>>
+}
+
+export type QueryStakeIncreasedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<StakeIncreasedEventWhereInput>
+  orderBy?: Maybe<Array<StakeIncreasedEventOrderByInput>>
+}
+
+export type QueryStakeIncreasedEventByUniqueInputArgs = {
+  where: StakeIncreasedEventWhereUniqueInput
+}
+
+export type QueryStakeIncreasedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<StakeIncreasedEventWhereInput>
+  orderBy?: Maybe<Array<StakeIncreasedEventOrderByInput>>
+}
+
+export type QueryStakeSlashedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<StakeSlashedEventWhereInput>
+  orderBy?: Maybe<Array<StakeSlashedEventOrderByInput>>
+}
+
+export type QueryStakeSlashedEventByUniqueInputArgs = {
+  where: StakeSlashedEventWhereUniqueInput
+}
+
+export type QueryStakeSlashedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<StakeSlashedEventWhereInput>
+  orderBy?: Maybe<Array<StakeSlashedEventOrderByInput>>
+}
+
+export type QueryStakingAccountAddedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<StakingAccountAddedEventWhereInput>
+  orderBy?: Maybe<Array<StakingAccountAddedEventOrderByInput>>
+}
+
+export type QueryStakingAccountAddedEventByUniqueInputArgs = {
+  where: StakingAccountAddedEventWhereUniqueInput
+}
+
+export type QueryStakingAccountAddedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<StakingAccountAddedEventWhereInput>
+  orderBy?: Maybe<Array<StakingAccountAddedEventOrderByInput>>
+}
+
+export type QueryStakingAccountConfirmedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<StakingAccountConfirmedEventWhereInput>
+  orderBy?: Maybe<Array<StakingAccountConfirmedEventOrderByInput>>
+}
+
+export type QueryStakingAccountConfirmedEventByUniqueInputArgs = {
+  where: StakingAccountConfirmedEventWhereUniqueInput
+}
+
+export type QueryStakingAccountConfirmedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<StakingAccountConfirmedEventWhereInput>
+  orderBy?: Maybe<Array<StakingAccountConfirmedEventOrderByInput>>
+}
+
+export type QueryStakingAccountRemovedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<StakingAccountRemovedEventWhereInput>
+  orderBy?: Maybe<Array<StakingAccountRemovedEventOrderByInput>>
+}
+
+export type QueryStakingAccountRemovedEventByUniqueInputArgs = {
+  where: StakingAccountRemovedEventWhereUniqueInput
+}
+
+export type QueryStakingAccountRemovedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<StakingAccountRemovedEventWhereInput>
+  orderBy?: Maybe<Array<StakingAccountRemovedEventOrderByInput>>
+}
+
+export type QueryStatusTextChangedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<StatusTextChangedEventWhereInput>
+  orderBy?: Maybe<Array<StatusTextChangedEventOrderByInput>>
+}
+
+export type QueryStatusTextChangedEventByUniqueInputArgs = {
+  where: StatusTextChangedEventWhereUniqueInput
+}
+
+export type QueryStatusTextChangedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<StatusTextChangedEventWhereInput>
+  orderBy?: Maybe<Array<StatusTextChangedEventOrderByInput>>
+}
+
+export type QueryTerminatedLeaderEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<TerminatedLeaderEventWhereInput>
+  orderBy?: Maybe<Array<TerminatedLeaderEventOrderByInput>>
+}
+
+export type QueryTerminatedLeaderEventByUniqueInputArgs = {
+  where: TerminatedLeaderEventWhereUniqueInput
+}
+
+export type QueryTerminatedLeaderEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<TerminatedLeaderEventWhereInput>
+  orderBy?: Maybe<Array<TerminatedLeaderEventOrderByInput>>
+}
+
+export type QueryTerminatedWorkerEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<TerminatedWorkerEventWhereInput>
+  orderBy?: Maybe<Array<TerminatedWorkerEventOrderByInput>>
+}
+
+export type QueryTerminatedWorkerEventByUniqueInputArgs = {
+  where: TerminatedWorkerEventWhereUniqueInput
+}
+
+export type QueryTerminatedWorkerEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<TerminatedWorkerEventWhereInput>
+  orderBy?: Maybe<Array<TerminatedWorkerEventOrderByInput>>
+}
+
+export type QueryUpcomingWorkingGroupOpeningsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<UpcomingWorkingGroupOpeningWhereInput>
+  orderBy?: Maybe<Array<UpcomingWorkingGroupOpeningOrderByInput>>
+}
+
+export type QueryUpcomingWorkingGroupOpeningByUniqueInputArgs = {
+  where: UpcomingWorkingGroupOpeningWhereUniqueInput
+}
+
+export type QueryUpcomingWorkingGroupOpeningsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<UpcomingWorkingGroupOpeningWhereInput>
+  orderBy?: Maybe<Array<UpcomingWorkingGroupOpeningOrderByInput>>
+}
+
+export type QueryWorkerExitedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<WorkerExitedEventWhereInput>
+  orderBy?: Maybe<Array<WorkerExitedEventOrderByInput>>
+}
+
+export type QueryWorkerExitedEventByUniqueInputArgs = {
+  where: WorkerExitedEventWhereUniqueInput
+}
+
+export type QueryWorkerExitedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<WorkerExitedEventWhereInput>
+  orderBy?: Maybe<Array<WorkerExitedEventOrderByInput>>
+}
+
+export type QueryWorkerRewardAccountUpdatedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<WorkerRewardAccountUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<WorkerRewardAccountUpdatedEventOrderByInput>>
+}
+
+export type QueryWorkerRewardAccountUpdatedEventByUniqueInputArgs = {
+  where: WorkerRewardAccountUpdatedEventWhereUniqueInput
+}
+
+export type QueryWorkerRewardAccountUpdatedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<WorkerRewardAccountUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<WorkerRewardAccountUpdatedEventOrderByInput>>
+}
+
+export type QueryWorkerRewardAmountUpdatedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<WorkerRewardAmountUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<WorkerRewardAmountUpdatedEventOrderByInput>>
+}
+
+export type QueryWorkerRewardAmountUpdatedEventByUniqueInputArgs = {
+  where: WorkerRewardAmountUpdatedEventWhereUniqueInput
+}
+
+export type QueryWorkerRewardAmountUpdatedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<WorkerRewardAmountUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<WorkerRewardAmountUpdatedEventOrderByInput>>
+}
+
+export type QueryWorkerRoleAccountUpdatedEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<WorkerRoleAccountUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<WorkerRoleAccountUpdatedEventOrderByInput>>
+}
+
+export type QueryWorkerRoleAccountUpdatedEventByUniqueInputArgs = {
+  where: WorkerRoleAccountUpdatedEventWhereUniqueInput
+}
+
+export type QueryWorkerRoleAccountUpdatedEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<WorkerRoleAccountUpdatedEventWhereInput>
+  orderBy?: Maybe<Array<WorkerRoleAccountUpdatedEventOrderByInput>>
+}
+
+export type QueryWorkerStartedLeavingEventsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<WorkerStartedLeavingEventWhereInput>
+  orderBy?: Maybe<Array<WorkerStartedLeavingEventOrderByInput>>
+}
+
+export type QueryWorkerStartedLeavingEventByUniqueInputArgs = {
+  where: WorkerStartedLeavingEventWhereUniqueInput
+}
+
+export type QueryWorkerStartedLeavingEventsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<WorkerStartedLeavingEventWhereInput>
+  orderBy?: Maybe<Array<WorkerStartedLeavingEventOrderByInput>>
+}
+
+export type QueryWorkersArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<WorkerWhereInput>
+  orderBy?: Maybe<Array<WorkerOrderByInput>>
+}
+
+export type QueryWorkerByUniqueInputArgs = {
+  where: WorkerWhereUniqueInput
+}
+
+export type QueryWorkersConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<WorkerWhereInput>
+  orderBy?: Maybe<Array<WorkerOrderByInput>>
+}
+
+export type QueryWorkingGroupApplicationsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<WorkingGroupApplicationWhereInput>
+  orderBy?: Maybe<Array<WorkingGroupApplicationOrderByInput>>
+}
+
+export type QueryWorkingGroupApplicationByUniqueInputArgs = {
+  where: WorkingGroupApplicationWhereUniqueInput
+}
+
+export type QueryWorkingGroupApplicationsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<WorkingGroupApplicationWhereInput>
+  orderBy?: Maybe<Array<WorkingGroupApplicationOrderByInput>>
+}
+
+export type QueryWorkingGroupMetadataArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<WorkingGroupMetadataWhereInput>
+  orderBy?: Maybe<Array<WorkingGroupMetadataOrderByInput>>
+}
+
+export type QueryWorkingGroupMetadataByUniqueInputArgs = {
+  where: WorkingGroupMetadataWhereUniqueInput
+}
+
+export type QueryWorkingGroupMetadataConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<WorkingGroupMetadataWhereInput>
+  orderBy?: Maybe<Array<WorkingGroupMetadataOrderByInput>>
+}
+
+export type QueryWorkingGroupOpeningMetadataArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<WorkingGroupOpeningMetadataWhereInput>
+  orderBy?: Maybe<Array<WorkingGroupOpeningMetadataOrderByInput>>
+}
+
+export type QueryWorkingGroupOpeningMetadataByUniqueInputArgs = {
+  where: WorkingGroupOpeningMetadataWhereUniqueInput
+}
+
+export type QueryWorkingGroupOpeningMetadataConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<WorkingGroupOpeningMetadataWhereInput>
+  orderBy?: Maybe<Array<WorkingGroupOpeningMetadataOrderByInput>>
+}
+
+export type QueryWorkingGroupOpeningsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<WorkingGroupOpeningWhereInput>
+  orderBy?: Maybe<Array<WorkingGroupOpeningOrderByInput>>
+}
+
+export type QueryWorkingGroupOpeningByUniqueInputArgs = {
+  where: WorkingGroupOpeningWhereUniqueInput
+}
+
+export type QueryWorkingGroupOpeningsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<WorkingGroupOpeningWhereInput>
+  orderBy?: Maybe<Array<WorkingGroupOpeningOrderByInput>>
+}
+
+export type QueryWorkingGroupsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<WorkingGroupWhereInput>
+  orderBy?: Maybe<Array<WorkingGroupOrderByInput>>
+}
+
+export type QueryWorkingGroupByUniqueInputArgs = {
+  where: WorkingGroupWhereUniqueInput
+}
+
+export type QueryWorkingGroupsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<WorkingGroupWhereInput>
+  orderBy?: Maybe<Array<WorkingGroupOrderByInput>>
+}
+
+export type ReferralCutUpdatedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  /** New cut value. */
+  newValue: Scalars['Int']
+}
+
+export type ReferralCutUpdatedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<ReferralCutUpdatedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type ReferralCutUpdatedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  newValue: Scalars['Float']
+}
+
+export type ReferralCutUpdatedEventEdge = {
+  node: ReferralCutUpdatedEvent
+  cursor: Scalars['String']
+}
+
+export enum ReferralCutUpdatedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  NewValueAsc = 'newValue_ASC',
+  NewValueDesc = 'newValue_DESC',
+}
+
+export type ReferralCutUpdatedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  newValue?: Maybe<Scalars['Float']>
+}
+
+export type ReferralCutUpdatedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  newValue_eq?: Maybe<Scalars['Int']>
+  newValue_gt?: Maybe<Scalars['Int']>
+  newValue_gte?: Maybe<Scalars['Int']>
+  newValue_lt?: Maybe<Scalars['Int']>
+  newValue_lte?: Maybe<Scalars['Int']>
+  newValue_in?: Maybe<Array<Scalars['Int']>>
+  AND?: Maybe<Array<ReferralCutUpdatedEventWhereInput>>
+  OR?: Maybe<Array<ReferralCutUpdatedEventWhereInput>>
+}
+
+export type ReferralCutUpdatedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type RewardPaidEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  worker: Worker
+  workerId: Scalars['String']
+  /** The account that recieved the reward */
+  rewardAccount: Scalars['String']
+  /** Amount recieved */
+  amount: Scalars['BigInt']
+  /** Type of the payment (REGULAR/MISSED) */
+  type: RewardPaymentType
+}
+
+export type RewardPaidEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<RewardPaidEventEdge>
+  pageInfo: PageInfo
+}
+
+export type RewardPaidEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  worker: Scalars['ID']
+  rewardAccount: Scalars['String']
+  amount: Scalars['BigInt']
+  type: RewardPaymentType
+}
+
+export type RewardPaidEventEdge = {
+  node: RewardPaidEvent
+  cursor: Scalars['String']
+}
+
+export enum RewardPaidEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  WorkerAsc = 'worker_ASC',
+  WorkerDesc = 'worker_DESC',
+  RewardAccountAsc = 'rewardAccount_ASC',
+  RewardAccountDesc = 'rewardAccount_DESC',
+  AmountAsc = 'amount_ASC',
+  AmountDesc = 'amount_DESC',
+  TypeAsc = 'type_ASC',
+  TypeDesc = 'type_DESC',
+}
+
+export type RewardPaidEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  worker?: Maybe<Scalars['ID']>
+  rewardAccount?: Maybe<Scalars['String']>
+  amount?: Maybe<Scalars['BigInt']>
+  type?: Maybe<RewardPaymentType>
+}
+
+export type RewardPaidEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  worker_eq?: Maybe<Scalars['ID']>
+  worker_in?: Maybe<Array<Scalars['ID']>>
+  rewardAccount_eq?: Maybe<Scalars['String']>
+  rewardAccount_contains?: Maybe<Scalars['String']>
+  rewardAccount_startsWith?: Maybe<Scalars['String']>
+  rewardAccount_endsWith?: Maybe<Scalars['String']>
+  rewardAccount_in?: Maybe<Array<Scalars['String']>>
+  amount_eq?: Maybe<Scalars['BigInt']>
+  amount_gt?: Maybe<Scalars['BigInt']>
+  amount_gte?: Maybe<Scalars['BigInt']>
+  amount_lt?: Maybe<Scalars['BigInt']>
+  amount_lte?: Maybe<Scalars['BigInt']>
+  amount_in?: Maybe<Array<Scalars['BigInt']>>
+  type_eq?: Maybe<RewardPaymentType>
+  type_in?: Maybe<Array<RewardPaymentType>>
+  group?: Maybe<WorkingGroupWhereInput>
+  worker?: Maybe<WorkerWhereInput>
+  AND?: Maybe<Array<RewardPaidEventWhereInput>>
+  OR?: Maybe<Array<RewardPaidEventWhereInput>>
+}
+
+export type RewardPaidEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export enum RewardPaymentType {
+  Regular = 'REGULAR',
+  Missed = 'MISSED',
+}
+
+export type StakeDecreasedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  worker: Worker
+  workerId: Scalars['String']
+  /** The amount of JOY the stake was decreased by */
+  amount: Scalars['BigInt']
+}
+
+export type StakeDecreasedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<StakeDecreasedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type StakeDecreasedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  worker: Scalars['ID']
+  amount: Scalars['BigInt']
+}
+
+export type StakeDecreasedEventEdge = {
+  node: StakeDecreasedEvent
+  cursor: Scalars['String']
+}
+
+export enum StakeDecreasedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  WorkerAsc = 'worker_ASC',
+  WorkerDesc = 'worker_DESC',
+  AmountAsc = 'amount_ASC',
+  AmountDesc = 'amount_DESC',
+}
+
+export type StakeDecreasedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  worker?: Maybe<Scalars['ID']>
+  amount?: Maybe<Scalars['BigInt']>
+}
+
+export type StakeDecreasedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  worker_eq?: Maybe<Scalars['ID']>
+  worker_in?: Maybe<Array<Scalars['ID']>>
+  amount_eq?: Maybe<Scalars['BigInt']>
+  amount_gt?: Maybe<Scalars['BigInt']>
+  amount_gte?: Maybe<Scalars['BigInt']>
+  amount_lt?: Maybe<Scalars['BigInt']>
+  amount_lte?: Maybe<Scalars['BigInt']>
+  amount_in?: Maybe<Array<Scalars['BigInt']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  worker?: Maybe<WorkerWhereInput>
+  AND?: Maybe<Array<StakeDecreasedEventWhereInput>>
+  OR?: Maybe<Array<StakeDecreasedEventWhereInput>>
+}
+
+export type StakeDecreasedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type StakeIncreasedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  worker: Worker
+  workerId: Scalars['String']
+  /** The amount of JOY the stake was increased by */
+  amount: Scalars['BigInt']
+}
+
+export type StakeIncreasedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<StakeIncreasedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type StakeIncreasedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  worker: Scalars['ID']
+  amount: Scalars['BigInt']
+}
+
+export type StakeIncreasedEventEdge = {
+  node: StakeIncreasedEvent
+  cursor: Scalars['String']
+}
+
+export enum StakeIncreasedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  WorkerAsc = 'worker_ASC',
+  WorkerDesc = 'worker_DESC',
+  AmountAsc = 'amount_ASC',
+  AmountDesc = 'amount_DESC',
+}
+
+export type StakeIncreasedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  worker?: Maybe<Scalars['ID']>
+  amount?: Maybe<Scalars['BigInt']>
+}
+
+export type StakeIncreasedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  worker_eq?: Maybe<Scalars['ID']>
+  worker_in?: Maybe<Array<Scalars['ID']>>
+  amount_eq?: Maybe<Scalars['BigInt']>
+  amount_gt?: Maybe<Scalars['BigInt']>
+  amount_gte?: Maybe<Scalars['BigInt']>
+  amount_lt?: Maybe<Scalars['BigInt']>
+  amount_lte?: Maybe<Scalars['BigInt']>
+  amount_in?: Maybe<Array<Scalars['BigInt']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  worker?: Maybe<WorkerWhereInput>
+  AND?: Maybe<Array<StakeIncreasedEventWhereInput>>
+  OR?: Maybe<Array<StakeIncreasedEventWhereInput>>
+}
+
+export type StakeIncreasedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type StakeSlashedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  worker: Worker
+  workerId: Scalars['String']
+  /** Balance that was requested to be slashed */
+  requestedAmount: Scalars['BigInt']
+  /** Balance that was actually slashed */
+  slashedAmount: Scalars['BigInt']
+  /** Optional rationale */
+  rationale?: Maybe<Scalars['String']>
+}
+
+export type StakeSlashedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<StakeSlashedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type StakeSlashedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  worker: Scalars['ID']
+  requestedAmount: Scalars['BigInt']
+  slashedAmount: Scalars['BigInt']
+  rationale?: Maybe<Scalars['String']>
+}
+
+export type StakeSlashedEventEdge = {
+  node: StakeSlashedEvent
+  cursor: Scalars['String']
+}
+
+export enum StakeSlashedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  WorkerAsc = 'worker_ASC',
+  WorkerDesc = 'worker_DESC',
+  RequestedAmountAsc = 'requestedAmount_ASC',
+  RequestedAmountDesc = 'requestedAmount_DESC',
+  SlashedAmountAsc = 'slashedAmount_ASC',
+  SlashedAmountDesc = 'slashedAmount_DESC',
+  RationaleAsc = 'rationale_ASC',
+  RationaleDesc = 'rationale_DESC',
+}
+
+export type StakeSlashedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  worker?: Maybe<Scalars['ID']>
+  requestedAmount?: Maybe<Scalars['BigInt']>
+  slashedAmount?: Maybe<Scalars['BigInt']>
+  rationale?: Maybe<Scalars['String']>
+}
+
+export type StakeSlashedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  worker_eq?: Maybe<Scalars['ID']>
+  worker_in?: Maybe<Array<Scalars['ID']>>
+  requestedAmount_eq?: Maybe<Scalars['BigInt']>
+  requestedAmount_gt?: Maybe<Scalars['BigInt']>
+  requestedAmount_gte?: Maybe<Scalars['BigInt']>
+  requestedAmount_lt?: Maybe<Scalars['BigInt']>
+  requestedAmount_lte?: Maybe<Scalars['BigInt']>
+  requestedAmount_in?: Maybe<Array<Scalars['BigInt']>>
+  slashedAmount_eq?: Maybe<Scalars['BigInt']>
+  slashedAmount_gt?: Maybe<Scalars['BigInt']>
+  slashedAmount_gte?: Maybe<Scalars['BigInt']>
+  slashedAmount_lt?: Maybe<Scalars['BigInt']>
+  slashedAmount_lte?: Maybe<Scalars['BigInt']>
+  slashedAmount_in?: Maybe<Array<Scalars['BigInt']>>
+  rationale_eq?: Maybe<Scalars['String']>
+  rationale_contains?: Maybe<Scalars['String']>
+  rationale_startsWith?: Maybe<Scalars['String']>
+  rationale_endsWith?: Maybe<Scalars['String']>
+  rationale_in?: Maybe<Array<Scalars['String']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  worker?: Maybe<WorkerWhereInput>
+  AND?: Maybe<Array<StakeSlashedEventWhereInput>>
+  OR?: Maybe<Array<StakeSlashedEventWhereInput>>
+}
+
+export type StakeSlashedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type StakingAccountAddedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  member: Membership
+  memberId: Scalars['String']
+  /** New staking account in SS58 encoding. */
+  account: Scalars['String']
+}
+
+export type StakingAccountAddedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<StakingAccountAddedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type StakingAccountAddedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  member: Scalars['ID']
+  account: Scalars['String']
+}
+
+export type StakingAccountAddedEventEdge = {
+  node: StakingAccountAddedEvent
+  cursor: Scalars['String']
+}
+
+export enum StakingAccountAddedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  MemberAsc = 'member_ASC',
+  MemberDesc = 'member_DESC',
+  AccountAsc = 'account_ASC',
+  AccountDesc = 'account_DESC',
+}
+
+export type StakingAccountAddedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  member?: Maybe<Scalars['ID']>
+  account?: Maybe<Scalars['String']>
+}
+
+export type StakingAccountAddedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  member_eq?: Maybe<Scalars['ID']>
+  member_in?: Maybe<Array<Scalars['ID']>>
+  account_eq?: Maybe<Scalars['String']>
+  account_contains?: Maybe<Scalars['String']>
+  account_startsWith?: Maybe<Scalars['String']>
+  account_endsWith?: Maybe<Scalars['String']>
+  account_in?: Maybe<Array<Scalars['String']>>
+  member?: Maybe<MembershipWhereInput>
+  AND?: Maybe<Array<StakingAccountAddedEventWhereInput>>
+  OR?: Maybe<Array<StakingAccountAddedEventWhereInput>>
+}
+
+export type StakingAccountAddedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type StakingAccountConfirmedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  member: Membership
+  memberId: Scalars['String']
+  /** New staking account in SS58 encoding. */
+  account: Scalars['String']
+}
+
+export type StakingAccountConfirmedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<StakingAccountConfirmedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type StakingAccountConfirmedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  member: Scalars['ID']
+  account: Scalars['String']
+}
+
+export type StakingAccountConfirmedEventEdge = {
+  node: StakingAccountConfirmedEvent
+  cursor: Scalars['String']
+}
+
+export enum StakingAccountConfirmedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  MemberAsc = 'member_ASC',
+  MemberDesc = 'member_DESC',
+  AccountAsc = 'account_ASC',
+  AccountDesc = 'account_DESC',
+}
+
+export type StakingAccountConfirmedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  member?: Maybe<Scalars['ID']>
+  account?: Maybe<Scalars['String']>
+}
+
+export type StakingAccountConfirmedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  member_eq?: Maybe<Scalars['ID']>
+  member_in?: Maybe<Array<Scalars['ID']>>
+  account_eq?: Maybe<Scalars['String']>
+  account_contains?: Maybe<Scalars['String']>
+  account_startsWith?: Maybe<Scalars['String']>
+  account_endsWith?: Maybe<Scalars['String']>
+  account_in?: Maybe<Array<Scalars['String']>>
+  member?: Maybe<MembershipWhereInput>
+  AND?: Maybe<Array<StakingAccountConfirmedEventWhereInput>>
+  OR?: Maybe<Array<StakingAccountConfirmedEventWhereInput>>
+}
+
+export type StakingAccountConfirmedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type StakingAccountRemovedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  member: Membership
+  memberId: Scalars['String']
+  /** New staking account in SS58 encoding. */
+  account: Scalars['String']
+}
+
+export type StakingAccountRemovedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<StakingAccountRemovedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type StakingAccountRemovedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  member: Scalars['ID']
+  account: Scalars['String']
+}
+
+export type StakingAccountRemovedEventEdge = {
+  node: StakingAccountRemovedEvent
+  cursor: Scalars['String']
+}
+
+export enum StakingAccountRemovedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  MemberAsc = 'member_ASC',
+  MemberDesc = 'member_DESC',
+  AccountAsc = 'account_ASC',
+  AccountDesc = 'account_DESC',
+}
+
+export type StakingAccountRemovedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  member?: Maybe<Scalars['ID']>
+  account?: Maybe<Scalars['String']>
+}
+
+export type StakingAccountRemovedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  member_eq?: Maybe<Scalars['ID']>
+  member_in?: Maybe<Array<Scalars['ID']>>
+  account_eq?: Maybe<Scalars['String']>
+  account_contains?: Maybe<Scalars['String']>
+  account_startsWith?: Maybe<Scalars['String']>
+  account_endsWith?: Maybe<Scalars['String']>
+  account_in?: Maybe<Array<Scalars['String']>>
+  member?: Maybe<MembershipWhereInput>
+  AND?: Maybe<Array<StakingAccountRemovedEventWhereInput>>
+  OR?: Maybe<Array<StakingAccountRemovedEventWhereInput>>
+}
+
+export type StakingAccountRemovedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type StandardDeleteResponse = {
+  id: Scalars['ID']
+}
+
+export type StatusTextChangedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  /** Original action metadata as hex string */
+  metadata?: Maybe<Scalars['String']>
+  /** Event result depeding on the metadata action type */
+  result: WorkingGroupMetadataActionResult
+  upcomingworkinggroupopeningcreatedInEvent?: Maybe<Array<UpcomingWorkingGroupOpening>>
+  workinggroupmetadatasetInEvent?: Maybe<Array<WorkingGroupMetadata>>
+}
+
+export type StatusTextChangedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<StatusTextChangedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type StatusTextChangedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  metadata?: Maybe<Scalars['String']>
+  result: Scalars['JSONObject']
+}
+
+export type StatusTextChangedEventEdge = {
+  node: StatusTextChangedEvent
+  cursor: Scalars['String']
+}
+
+export enum StatusTextChangedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  MetadataAsc = 'metadata_ASC',
+  MetadataDesc = 'metadata_DESC',
+}
+
+export type StatusTextChangedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  metadata?: Maybe<Scalars['String']>
+  result?: Maybe<Scalars['JSONObject']>
+}
+
+export type StatusTextChangedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  metadata_eq?: Maybe<Scalars['String']>
+  metadata_contains?: Maybe<Scalars['String']>
+  metadata_startsWith?: Maybe<Scalars['String']>
+  metadata_endsWith?: Maybe<Scalars['String']>
+  metadata_in?: Maybe<Array<Scalars['String']>>
+  result_json?: Maybe<Scalars['JSONObject']>
+  group?: Maybe<WorkingGroupWhereInput>
+  upcomingworkinggroupopeningcreatedInEvent_none?: Maybe<UpcomingWorkingGroupOpeningWhereInput>
+  upcomingworkinggroupopeningcreatedInEvent_some?: Maybe<UpcomingWorkingGroupOpeningWhereInput>
+  upcomingworkinggroupopeningcreatedInEvent_every?: Maybe<UpcomingWorkingGroupOpeningWhereInput>
+  workinggroupmetadatasetInEvent_none?: Maybe<WorkingGroupMetadataWhereInput>
+  workinggroupmetadatasetInEvent_some?: Maybe<WorkingGroupMetadataWhereInput>
+  workinggroupmetadatasetInEvent_every?: Maybe<WorkingGroupMetadataWhereInput>
+  AND?: Maybe<Array<StatusTextChangedEventWhereInput>>
+  OR?: Maybe<Array<StatusTextChangedEventWhereInput>>
+}
+
+export type StatusTextChangedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type Subscription = {
+  stateSubscription: ProcessorState
+}
+
+export type TerminatedLeaderEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  worker: Worker
+  workerId: Scalars['String']
+  /** Slash amount (if any) */
+  penalty?: Maybe<Scalars['BigInt']>
+  /** Optional rationale */
+  rationale?: Maybe<Scalars['String']>
+}
+
+export type TerminatedLeaderEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<TerminatedLeaderEventEdge>
+  pageInfo: PageInfo
+}
+
+export type TerminatedLeaderEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  worker: Scalars['ID']
+  penalty?: Maybe<Scalars['BigInt']>
+  rationale?: Maybe<Scalars['String']>
+}
+
+export type TerminatedLeaderEventEdge = {
+  node: TerminatedLeaderEvent
+  cursor: Scalars['String']
+}
+
+export enum TerminatedLeaderEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  WorkerAsc = 'worker_ASC',
+  WorkerDesc = 'worker_DESC',
+  PenaltyAsc = 'penalty_ASC',
+  PenaltyDesc = 'penalty_DESC',
+  RationaleAsc = 'rationale_ASC',
+  RationaleDesc = 'rationale_DESC',
+}
+
+export type TerminatedLeaderEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  worker?: Maybe<Scalars['ID']>
+  penalty?: Maybe<Scalars['BigInt']>
+  rationale?: Maybe<Scalars['String']>
+}
+
+export type TerminatedLeaderEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  worker_eq?: Maybe<Scalars['ID']>
+  worker_in?: Maybe<Array<Scalars['ID']>>
+  penalty_eq?: Maybe<Scalars['BigInt']>
+  penalty_gt?: Maybe<Scalars['BigInt']>
+  penalty_gte?: Maybe<Scalars['BigInt']>
+  penalty_lt?: Maybe<Scalars['BigInt']>
+  penalty_lte?: Maybe<Scalars['BigInt']>
+  penalty_in?: Maybe<Array<Scalars['BigInt']>>
+  rationale_eq?: Maybe<Scalars['String']>
+  rationale_contains?: Maybe<Scalars['String']>
+  rationale_startsWith?: Maybe<Scalars['String']>
+  rationale_endsWith?: Maybe<Scalars['String']>
+  rationale_in?: Maybe<Array<Scalars['String']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  worker?: Maybe<WorkerWhereInput>
+  AND?: Maybe<Array<TerminatedLeaderEventWhereInput>>
+  OR?: Maybe<Array<TerminatedLeaderEventWhereInput>>
+}
+
+export type TerminatedLeaderEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type TerminatedWorkerEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  worker: Worker
+  workerId: Scalars['String']
+  /** Slash amount (if any) */
+  penalty?: Maybe<Scalars['BigInt']>
+  /** Optional rationale */
+  rationale?: Maybe<Scalars['String']>
+}
+
+export type TerminatedWorkerEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<TerminatedWorkerEventEdge>
+  pageInfo: PageInfo
+}
+
+export type TerminatedWorkerEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  worker: Scalars['ID']
+  penalty?: Maybe<Scalars['BigInt']>
+  rationale?: Maybe<Scalars['String']>
+}
+
+export type TerminatedWorkerEventEdge = {
+  node: TerminatedWorkerEvent
+  cursor: Scalars['String']
+}
+
+export enum TerminatedWorkerEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  WorkerAsc = 'worker_ASC',
+  WorkerDesc = 'worker_DESC',
+  PenaltyAsc = 'penalty_ASC',
+  PenaltyDesc = 'penalty_DESC',
+  RationaleAsc = 'rationale_ASC',
+  RationaleDesc = 'rationale_DESC',
+}
+
+export type TerminatedWorkerEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  worker?: Maybe<Scalars['ID']>
+  penalty?: Maybe<Scalars['BigInt']>
+  rationale?: Maybe<Scalars['String']>
+}
+
+export type TerminatedWorkerEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  worker_eq?: Maybe<Scalars['ID']>
+  worker_in?: Maybe<Array<Scalars['ID']>>
+  penalty_eq?: Maybe<Scalars['BigInt']>
+  penalty_gt?: Maybe<Scalars['BigInt']>
+  penalty_gte?: Maybe<Scalars['BigInt']>
+  penalty_lt?: Maybe<Scalars['BigInt']>
+  penalty_lte?: Maybe<Scalars['BigInt']>
+  penalty_in?: Maybe<Array<Scalars['BigInt']>>
+  rationale_eq?: Maybe<Scalars['String']>
+  rationale_contains?: Maybe<Scalars['String']>
+  rationale_startsWith?: Maybe<Scalars['String']>
+  rationale_endsWith?: Maybe<Scalars['String']>
+  rationale_in?: Maybe<Array<Scalars['String']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  worker?: Maybe<WorkerWhereInput>
+  AND?: Maybe<Array<TerminatedWorkerEventWhereInput>>
+  OR?: Maybe<Array<TerminatedWorkerEventWhereInput>>
+}
+
+export type TerminatedWorkerEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type UpcomingOpeningAdded = {
+  upcomingOpeningId: Scalars['String']
+}
+
+export type UpcomingOpeningAddedCreateInput = {
+  upcomingOpeningId: Scalars['String']
+}
+
+export type UpcomingOpeningAddedUpdateInput = {
+  upcomingOpeningId?: Maybe<Scalars['String']>
+}
+
+export type UpcomingOpeningAddedWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  upcomingOpeningId_eq?: Maybe<Scalars['String']>
+  upcomingOpeningId_contains?: Maybe<Scalars['String']>
+  upcomingOpeningId_startsWith?: Maybe<Scalars['String']>
+  upcomingOpeningId_endsWith?: Maybe<Scalars['String']>
+  upcomingOpeningId_in?: Maybe<Array<Scalars['String']>>
+  AND?: Maybe<Array<UpcomingOpeningAddedWhereInput>>
+  OR?: Maybe<Array<UpcomingOpeningAddedWhereInput>>
+}
+
+export type UpcomingOpeningAddedWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type UpcomingOpeningRemoved = {
+  upcomingOpeningId: Scalars['String']
+}
+
+export type UpcomingOpeningRemovedCreateInput = {
+  upcomingOpeningId: Scalars['String']
+}
+
+export type UpcomingOpeningRemovedUpdateInput = {
+  upcomingOpeningId?: Maybe<Scalars['String']>
+}
+
+export type UpcomingOpeningRemovedWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  upcomingOpeningId_eq?: Maybe<Scalars['String']>
+  upcomingOpeningId_contains?: Maybe<Scalars['String']>
+  upcomingOpeningId_startsWith?: Maybe<Scalars['String']>
+  upcomingOpeningId_endsWith?: Maybe<Scalars['String']>
+  upcomingOpeningId_in?: Maybe<Array<Scalars['String']>>
+  AND?: Maybe<Array<UpcomingOpeningRemovedWhereInput>>
+  OR?: Maybe<Array<UpcomingOpeningRemovedWhereInput>>
+}
+
+export type UpcomingOpeningRemovedWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type UpcomingWorkingGroupOpening = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  createdInEvent: StatusTextChangedEvent
+  createdInEventId: Scalars['String']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  /** Expected opening start time */
+  expectedStart?: Maybe<Scalars['DateTime']>
+  /** Expected min. application/role stake amount */
+  stakeAmount?: Maybe<Scalars['BigInt']>
+  /** Expected reward per block */
+  rewardPerBlock?: Maybe<Scalars['BigInt']>
+  metadata: WorkingGroupOpeningMetadata
+  metadataId: Scalars['String']
+}
+
+export type UpcomingWorkingGroupOpeningConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<UpcomingWorkingGroupOpeningEdge>
+  pageInfo: PageInfo
+}
+
+export type UpcomingWorkingGroupOpeningCreateInput = {
+  createdInEvent: Scalars['ID']
+  group: Scalars['ID']
+  expectedStart?: Maybe<Scalars['DateTime']>
+  stakeAmount?: Maybe<Scalars['BigInt']>
+  rewardPerBlock?: Maybe<Scalars['BigInt']>
+  metadata: Scalars['ID']
+}
+
+export type UpcomingWorkingGroupOpeningEdge = {
+  node: UpcomingWorkingGroupOpening
+  cursor: Scalars['String']
+}
+
+export enum UpcomingWorkingGroupOpeningOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  CreatedInEventAsc = 'createdInEvent_ASC',
+  CreatedInEventDesc = 'createdInEvent_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  ExpectedStartAsc = 'expectedStart_ASC',
+  ExpectedStartDesc = 'expectedStart_DESC',
+  StakeAmountAsc = 'stakeAmount_ASC',
+  StakeAmountDesc = 'stakeAmount_DESC',
+  RewardPerBlockAsc = 'rewardPerBlock_ASC',
+  RewardPerBlockDesc = 'rewardPerBlock_DESC',
+  MetadataAsc = 'metadata_ASC',
+  MetadataDesc = 'metadata_DESC',
+}
+
+export type UpcomingWorkingGroupOpeningUpdateInput = {
+  createdInEvent?: Maybe<Scalars['ID']>
+  group?: Maybe<Scalars['ID']>
+  expectedStart?: Maybe<Scalars['DateTime']>
+  stakeAmount?: Maybe<Scalars['BigInt']>
+  rewardPerBlock?: Maybe<Scalars['BigInt']>
+  metadata?: Maybe<Scalars['ID']>
+}
+
+export type UpcomingWorkingGroupOpeningWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  createdInEvent_eq?: Maybe<Scalars['ID']>
+  createdInEvent_in?: Maybe<Array<Scalars['ID']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  expectedStart_eq?: Maybe<Scalars['DateTime']>
+  expectedStart_lt?: Maybe<Scalars['DateTime']>
+  expectedStart_lte?: Maybe<Scalars['DateTime']>
+  expectedStart_gt?: Maybe<Scalars['DateTime']>
+  expectedStart_gte?: Maybe<Scalars['DateTime']>
+  stakeAmount_eq?: Maybe<Scalars['BigInt']>
+  stakeAmount_gt?: Maybe<Scalars['BigInt']>
+  stakeAmount_gte?: Maybe<Scalars['BigInt']>
+  stakeAmount_lt?: Maybe<Scalars['BigInt']>
+  stakeAmount_lte?: Maybe<Scalars['BigInt']>
+  stakeAmount_in?: Maybe<Array<Scalars['BigInt']>>
+  rewardPerBlock_eq?: Maybe<Scalars['BigInt']>
+  rewardPerBlock_gt?: Maybe<Scalars['BigInt']>
+  rewardPerBlock_gte?: Maybe<Scalars['BigInt']>
+  rewardPerBlock_lt?: Maybe<Scalars['BigInt']>
+  rewardPerBlock_lte?: Maybe<Scalars['BigInt']>
+  rewardPerBlock_in?: Maybe<Array<Scalars['BigInt']>>
+  metadata_eq?: Maybe<Scalars['ID']>
+  metadata_in?: Maybe<Array<Scalars['ID']>>
+  createdInEvent?: Maybe<StatusTextChangedEventWhereInput>
+  group?: Maybe<WorkingGroupWhereInput>
+  metadata?: Maybe<WorkingGroupOpeningMetadataWhereInput>
+  AND?: Maybe<Array<UpcomingWorkingGroupOpeningWhereInput>>
+  OR?: Maybe<Array<UpcomingWorkingGroupOpeningWhereInput>>
+}
+
+export type UpcomingWorkingGroupOpeningWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type Worker = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** WorkerId in specific working group module */
+  runtimeId: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  membership: Membership
+  membershipId: Scalars['String']
+  /** Worker's role account */
+  roleAccount: Scalars['String']
+  /** Worker's reward account */
+  rewardAccount: Scalars['String']
+  /** Worker's staking account */
+  stakeAccount: Scalars['String']
+  /** Current worker status */
+  status: WorkerStatus
+  /** Whether the worker is also the working group lead */
+  isLead: Scalars['Boolean']
+  /** Current role stake (in JOY) */
+  stake: Scalars['BigInt']
+  /** Current reward per block */
+  rewardPerBlock: Scalars['BigInt']
+  /** The reward amount the worker is currently missing (due to empty working group budget) */
+  missingRewardAmount?: Maybe<Scalars['BigInt']>
+  payouts: Array<RewardPaidEvent>
+  slashes: Array<StakeSlashedEvent>
+  entry: OpeningFilledEvent
+  entryId: Scalars['String']
+  application: WorkingGroupApplication
+  applicationId: Scalars['String']
+  /** Worker's storage data */
+  storage?: Maybe<Scalars['String']>
+  leaderseteventworker?: Maybe<Array<LeaderSetEvent>>
+  leaderunseteventleader?: Maybe<Array<LeaderUnsetEvent>>
+  memberverificationstatusupdatedeventworker?: Maybe<Array<MemberVerificationStatusUpdatedEvent>>
+  newmissedrewardlevelreachedeventworker?: Maybe<Array<NewMissedRewardLevelReachedEvent>>
+  stakedecreasedeventworker?: Maybe<Array<StakeDecreasedEvent>>
+  stakeincreasedeventworker?: Maybe<Array<StakeIncreasedEvent>>
+  terminatedleadereventworker?: Maybe<Array<TerminatedLeaderEvent>>
+  terminatedworkereventworker?: Maybe<Array<TerminatedWorkerEvent>>
+  workerexitedeventworker?: Maybe<Array<WorkerExitedEvent>>
+  workerrewardaccountupdatedeventworker?: Maybe<Array<WorkerRewardAccountUpdatedEvent>>
+  workerrewardamountupdatedeventworker?: Maybe<Array<WorkerRewardAmountUpdatedEvent>>
+  workerroleaccountupdatedeventworker?: Maybe<Array<WorkerRoleAccountUpdatedEvent>>
+  workerstartedleavingeventworker?: Maybe<Array<WorkerStartedLeavingEvent>>
+  workinggroupleader?: Maybe<Array<WorkingGroup>>
+}
+
+export type WorkerConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<WorkerEdge>
+  pageInfo: PageInfo
+}
+
+export type WorkerCreateInput = {
+  runtimeId: Scalars['Float']
+  group: Scalars['ID']
+  membership: Scalars['ID']
+  roleAccount: Scalars['String']
+  rewardAccount: Scalars['String']
+  stakeAccount: Scalars['String']
+  status: Scalars['JSONObject']
+  isLead: Scalars['Boolean']
+  stake: Scalars['BigInt']
+  rewardPerBlock: Scalars['BigInt']
+  missingRewardAmount?: Maybe<Scalars['BigInt']>
+  entry: Scalars['ID']
+  application: Scalars['ID']
+  storage?: Maybe<Scalars['String']>
+}
+
+export type WorkerEdge = {
+  node: Worker
+  cursor: Scalars['String']
+}
+
+export type WorkerExitedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  worker: Worker
+  workerId: Scalars['String']
+}
+
+export type WorkerExitedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<WorkerExitedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type WorkerExitedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  worker: Scalars['ID']
+}
+
+export type WorkerExitedEventEdge = {
+  node: WorkerExitedEvent
+  cursor: Scalars['String']
+}
+
+export enum WorkerExitedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  WorkerAsc = 'worker_ASC',
+  WorkerDesc = 'worker_DESC',
+}
+
+export type WorkerExitedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  worker?: Maybe<Scalars['ID']>
+}
+
+export type WorkerExitedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  worker_eq?: Maybe<Scalars['ID']>
+  worker_in?: Maybe<Array<Scalars['ID']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  worker?: Maybe<WorkerWhereInput>
+  AND?: Maybe<Array<WorkerExitedEventWhereInput>>
+  OR?: Maybe<Array<WorkerExitedEventWhereInput>>
+}
+
+export type WorkerExitedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export enum WorkerOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  RuntimeIdAsc = 'runtimeId_ASC',
+  RuntimeIdDesc = 'runtimeId_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  MembershipAsc = 'membership_ASC',
+  MembershipDesc = 'membership_DESC',
+  RoleAccountAsc = 'roleAccount_ASC',
+  RoleAccountDesc = 'roleAccount_DESC',
+  RewardAccountAsc = 'rewardAccount_ASC',
+  RewardAccountDesc = 'rewardAccount_DESC',
+  StakeAccountAsc = 'stakeAccount_ASC',
+  StakeAccountDesc = 'stakeAccount_DESC',
+  IsLeadAsc = 'isLead_ASC',
+  IsLeadDesc = 'isLead_DESC',
+  StakeAsc = 'stake_ASC',
+  StakeDesc = 'stake_DESC',
+  RewardPerBlockAsc = 'rewardPerBlock_ASC',
+  RewardPerBlockDesc = 'rewardPerBlock_DESC',
+  MissingRewardAmountAsc = 'missingRewardAmount_ASC',
+  MissingRewardAmountDesc = 'missingRewardAmount_DESC',
+  EntryAsc = 'entry_ASC',
+  EntryDesc = 'entry_DESC',
+  ApplicationAsc = 'application_ASC',
+  ApplicationDesc = 'application_DESC',
+  StorageAsc = 'storage_ASC',
+  StorageDesc = 'storage_DESC',
+}
+
+export type WorkerRewardAccountUpdatedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  worker: Worker
+  workerId: Scalars['String']
+  /** New reward account */
+  newRewardAccount: Scalars['String']
+}
+
+export type WorkerRewardAccountUpdatedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<WorkerRewardAccountUpdatedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type WorkerRewardAccountUpdatedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  worker: Scalars['ID']
+  newRewardAccount: Scalars['String']
+}
+
+export type WorkerRewardAccountUpdatedEventEdge = {
+  node: WorkerRewardAccountUpdatedEvent
+  cursor: Scalars['String']
+}
+
+export enum WorkerRewardAccountUpdatedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  WorkerAsc = 'worker_ASC',
+  WorkerDesc = 'worker_DESC',
+  NewRewardAccountAsc = 'newRewardAccount_ASC',
+  NewRewardAccountDesc = 'newRewardAccount_DESC',
+}
+
+export type WorkerRewardAccountUpdatedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  worker?: Maybe<Scalars['ID']>
+  newRewardAccount?: Maybe<Scalars['String']>
+}
+
+export type WorkerRewardAccountUpdatedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  worker_eq?: Maybe<Scalars['ID']>
+  worker_in?: Maybe<Array<Scalars['ID']>>
+  newRewardAccount_eq?: Maybe<Scalars['String']>
+  newRewardAccount_contains?: Maybe<Scalars['String']>
+  newRewardAccount_startsWith?: Maybe<Scalars['String']>
+  newRewardAccount_endsWith?: Maybe<Scalars['String']>
+  newRewardAccount_in?: Maybe<Array<Scalars['String']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  worker?: Maybe<WorkerWhereInput>
+  AND?: Maybe<Array<WorkerRewardAccountUpdatedEventWhereInput>>
+  OR?: Maybe<Array<WorkerRewardAccountUpdatedEventWhereInput>>
+}
+
+export type WorkerRewardAccountUpdatedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type WorkerRewardAmountUpdatedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  worker: Worker
+  workerId: Scalars['String']
+  /** New worker reward per block */
+  newRewardPerBlock: Scalars['BigInt']
+}
+
+export type WorkerRewardAmountUpdatedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<WorkerRewardAmountUpdatedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type WorkerRewardAmountUpdatedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  worker: Scalars['ID']
+  newRewardPerBlock: Scalars['BigInt']
+}
+
+export type WorkerRewardAmountUpdatedEventEdge = {
+  node: WorkerRewardAmountUpdatedEvent
+  cursor: Scalars['String']
+}
+
+export enum WorkerRewardAmountUpdatedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  WorkerAsc = 'worker_ASC',
+  WorkerDesc = 'worker_DESC',
+  NewRewardPerBlockAsc = 'newRewardPerBlock_ASC',
+  NewRewardPerBlockDesc = 'newRewardPerBlock_DESC',
+}
+
+export type WorkerRewardAmountUpdatedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  worker?: Maybe<Scalars['ID']>
+  newRewardPerBlock?: Maybe<Scalars['BigInt']>
+}
+
+export type WorkerRewardAmountUpdatedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  worker_eq?: Maybe<Scalars['ID']>
+  worker_in?: Maybe<Array<Scalars['ID']>>
+  newRewardPerBlock_eq?: Maybe<Scalars['BigInt']>
+  newRewardPerBlock_gt?: Maybe<Scalars['BigInt']>
+  newRewardPerBlock_gte?: Maybe<Scalars['BigInt']>
+  newRewardPerBlock_lt?: Maybe<Scalars['BigInt']>
+  newRewardPerBlock_lte?: Maybe<Scalars['BigInt']>
+  newRewardPerBlock_in?: Maybe<Array<Scalars['BigInt']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  worker?: Maybe<WorkerWhereInput>
+  AND?: Maybe<Array<WorkerRewardAmountUpdatedEventWhereInput>>
+  OR?: Maybe<Array<WorkerRewardAmountUpdatedEventWhereInput>>
+}
+
+export type WorkerRewardAmountUpdatedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type WorkerRoleAccountUpdatedEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  worker: Worker
+  workerId: Scalars['String']
+  /** New role account */
+  newRoleAccount: Scalars['String']
+}
+
+export type WorkerRoleAccountUpdatedEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<WorkerRoleAccountUpdatedEventEdge>
+  pageInfo: PageInfo
+}
+
+export type WorkerRoleAccountUpdatedEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  worker: Scalars['ID']
+  newRoleAccount: Scalars['String']
+}
+
+export type WorkerRoleAccountUpdatedEventEdge = {
+  node: WorkerRoleAccountUpdatedEvent
+  cursor: Scalars['String']
+}
+
+export enum WorkerRoleAccountUpdatedEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  WorkerAsc = 'worker_ASC',
+  WorkerDesc = 'worker_DESC',
+  NewRoleAccountAsc = 'newRoleAccount_ASC',
+  NewRoleAccountDesc = 'newRoleAccount_DESC',
+}
+
+export type WorkerRoleAccountUpdatedEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  worker?: Maybe<Scalars['ID']>
+  newRoleAccount?: Maybe<Scalars['String']>
+}
+
+export type WorkerRoleAccountUpdatedEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  worker_eq?: Maybe<Scalars['ID']>
+  worker_in?: Maybe<Array<Scalars['ID']>>
+  newRoleAccount_eq?: Maybe<Scalars['String']>
+  newRoleAccount_contains?: Maybe<Scalars['String']>
+  newRoleAccount_startsWith?: Maybe<Scalars['String']>
+  newRoleAccount_endsWith?: Maybe<Scalars['String']>
+  newRoleAccount_in?: Maybe<Array<Scalars['String']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  worker?: Maybe<WorkerWhereInput>
+  AND?: Maybe<Array<WorkerRoleAccountUpdatedEventWhereInput>>
+  OR?: Maybe<Array<WorkerRoleAccountUpdatedEventWhereInput>>
+}
+
+export type WorkerRoleAccountUpdatedEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type WorkerStartedLeavingEvent = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Hash of the extrinsic which caused the event to be emitted */
+  inExtrinsic?: Maybe<Scalars['String']>
+  /** Blocknumber of the block in which the event was emitted. */
+  inBlock: Scalars['Int']
+  /** Network the block was produced in */
+  network: Network
+  /** Index of event in block from which it was emitted. */
+  indexInBlock: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  worker: Worker
+  workerId: Scalars['String']
+  /** Optional rationale */
+  rationale?: Maybe<Scalars['String']>
+}
+
+export type WorkerStartedLeavingEventConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<WorkerStartedLeavingEventEdge>
+  pageInfo: PageInfo
+}
+
+export type WorkerStartedLeavingEventCreateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock: Scalars['Float']
+  network: Network
+  indexInBlock: Scalars['Float']
+  group: Scalars['ID']
+  worker: Scalars['ID']
+  rationale?: Maybe<Scalars['String']>
+}
+
+export type WorkerStartedLeavingEventEdge = {
+  node: WorkerStartedLeavingEvent
+  cursor: Scalars['String']
+}
+
+export enum WorkerStartedLeavingEventOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  InExtrinsicAsc = 'inExtrinsic_ASC',
+  InExtrinsicDesc = 'inExtrinsic_DESC',
+  InBlockAsc = 'inBlock_ASC',
+  InBlockDesc = 'inBlock_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+  IndexInBlockAsc = 'indexInBlock_ASC',
+  IndexInBlockDesc = 'indexInBlock_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  WorkerAsc = 'worker_ASC',
+  WorkerDesc = 'worker_DESC',
+  RationaleAsc = 'rationale_ASC',
+  RationaleDesc = 'rationale_DESC',
+}
+
+export type WorkerStartedLeavingEventUpdateInput = {
+  inExtrinsic?: Maybe<Scalars['String']>
+  inBlock?: Maybe<Scalars['Float']>
+  network?: Maybe<Network>
+  indexInBlock?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  worker?: Maybe<Scalars['ID']>
+  rationale?: Maybe<Scalars['String']>
+}
+
+export type WorkerStartedLeavingEventWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  inExtrinsic_eq?: Maybe<Scalars['String']>
+  inExtrinsic_contains?: Maybe<Scalars['String']>
+  inExtrinsic_startsWith?: Maybe<Scalars['String']>
+  inExtrinsic_endsWith?: Maybe<Scalars['String']>
+  inExtrinsic_in?: Maybe<Array<Scalars['String']>>
+  inBlock_eq?: Maybe<Scalars['Int']>
+  inBlock_gt?: Maybe<Scalars['Int']>
+  inBlock_gte?: Maybe<Scalars['Int']>
+  inBlock_lt?: Maybe<Scalars['Int']>
+  inBlock_lte?: Maybe<Scalars['Int']>
+  inBlock_in?: Maybe<Array<Scalars['Int']>>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+  indexInBlock_eq?: Maybe<Scalars['Int']>
+  indexInBlock_gt?: Maybe<Scalars['Int']>
+  indexInBlock_gte?: Maybe<Scalars['Int']>
+  indexInBlock_lt?: Maybe<Scalars['Int']>
+  indexInBlock_lte?: Maybe<Scalars['Int']>
+  indexInBlock_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  worker_eq?: Maybe<Scalars['ID']>
+  worker_in?: Maybe<Array<Scalars['ID']>>
+  rationale_eq?: Maybe<Scalars['String']>
+  rationale_contains?: Maybe<Scalars['String']>
+  rationale_startsWith?: Maybe<Scalars['String']>
+  rationale_endsWith?: Maybe<Scalars['String']>
+  rationale_in?: Maybe<Array<Scalars['String']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  worker?: Maybe<WorkerWhereInput>
+  AND?: Maybe<Array<WorkerStartedLeavingEventWhereInput>>
+  OR?: Maybe<Array<WorkerStartedLeavingEventWhereInput>>
+}
+
+export type WorkerStartedLeavingEventWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type WorkerStatus = WorkerStatusActive | WorkerStatusLeft | WorkerStatusTerminated
+
+export type WorkerStatusActive = {
+  phantom?: Maybe<Scalars['Int']>
+}
+
+export type WorkerStatusActiveCreateInput = {
+  phantom?: Maybe<Scalars['Float']>
+}
+
+export type WorkerStatusActiveUpdateInput = {
+  phantom?: Maybe<Scalars['Float']>
+}
+
+export type WorkerStatusActiveWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  phantom_eq?: Maybe<Scalars['Int']>
+  phantom_gt?: Maybe<Scalars['Int']>
+  phantom_gte?: Maybe<Scalars['Int']>
+  phantom_lt?: Maybe<Scalars['Int']>
+  phantom_lte?: Maybe<Scalars['Int']>
+  phantom_in?: Maybe<Array<Scalars['Int']>>
+  AND?: Maybe<Array<WorkerStatusActiveWhereInput>>
+  OR?: Maybe<Array<WorkerStatusActiveWhereInput>>
+}
+
+export type WorkerStatusActiveWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type WorkerStatusLeft = {
+  /** Related event emitted on leaving initialization */
+  workerStartedLeavingEvent?: Maybe<WorkerStartedLeavingEvent>
+  /** Related event emitted (and set) when the unstaking period is finished */
+  workerExitedEvent?: Maybe<WorkerExitedEvent>
+}
+
+export type WorkerStatusTerminated = {
+  /** Related event emitted on worker termination */
+  terminatedWorkerEvent?: Maybe<TerminatedWorkerEvent>
+}
+
+export type WorkerUpdateInput = {
+  runtimeId?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  membership?: Maybe<Scalars['ID']>
+  roleAccount?: Maybe<Scalars['String']>
+  rewardAccount?: Maybe<Scalars['String']>
+  stakeAccount?: Maybe<Scalars['String']>
+  status?: Maybe<Scalars['JSONObject']>
+  isLead?: Maybe<Scalars['Boolean']>
+  stake?: Maybe<Scalars['BigInt']>
+  rewardPerBlock?: Maybe<Scalars['BigInt']>
+  missingRewardAmount?: Maybe<Scalars['BigInt']>
+  entry?: Maybe<Scalars['ID']>
+  application?: Maybe<Scalars['ID']>
+  storage?: Maybe<Scalars['String']>
+}
+
+export type WorkerWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  runtimeId_eq?: Maybe<Scalars['Int']>
+  runtimeId_gt?: Maybe<Scalars['Int']>
+  runtimeId_gte?: Maybe<Scalars['Int']>
+  runtimeId_lt?: Maybe<Scalars['Int']>
+  runtimeId_lte?: Maybe<Scalars['Int']>
+  runtimeId_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  membership_eq?: Maybe<Scalars['ID']>
+  membership_in?: Maybe<Array<Scalars['ID']>>
+  roleAccount_eq?: Maybe<Scalars['String']>
+  roleAccount_contains?: Maybe<Scalars['String']>
+  roleAccount_startsWith?: Maybe<Scalars['String']>
+  roleAccount_endsWith?: Maybe<Scalars['String']>
+  roleAccount_in?: Maybe<Array<Scalars['String']>>
+  rewardAccount_eq?: Maybe<Scalars['String']>
+  rewardAccount_contains?: Maybe<Scalars['String']>
+  rewardAccount_startsWith?: Maybe<Scalars['String']>
+  rewardAccount_endsWith?: Maybe<Scalars['String']>
+  rewardAccount_in?: Maybe<Array<Scalars['String']>>
+  stakeAccount_eq?: Maybe<Scalars['String']>
+  stakeAccount_contains?: Maybe<Scalars['String']>
+  stakeAccount_startsWith?: Maybe<Scalars['String']>
+  stakeAccount_endsWith?: Maybe<Scalars['String']>
+  stakeAccount_in?: Maybe<Array<Scalars['String']>>
+  status_json?: Maybe<Scalars['JSONObject']>
+  isLead_eq?: Maybe<Scalars['Boolean']>
+  isLead_in?: Maybe<Array<Scalars['Boolean']>>
+  stake_eq?: Maybe<Scalars['BigInt']>
+  stake_gt?: Maybe<Scalars['BigInt']>
+  stake_gte?: Maybe<Scalars['BigInt']>
+  stake_lt?: Maybe<Scalars['BigInt']>
+  stake_lte?: Maybe<Scalars['BigInt']>
+  stake_in?: Maybe<Array<Scalars['BigInt']>>
+  rewardPerBlock_eq?: Maybe<Scalars['BigInt']>
+  rewardPerBlock_gt?: Maybe<Scalars['BigInt']>
+  rewardPerBlock_gte?: Maybe<Scalars['BigInt']>
+  rewardPerBlock_lt?: Maybe<Scalars['BigInt']>
+  rewardPerBlock_lte?: Maybe<Scalars['BigInt']>
+  rewardPerBlock_in?: Maybe<Array<Scalars['BigInt']>>
+  missingRewardAmount_eq?: Maybe<Scalars['BigInt']>
+  missingRewardAmount_gt?: Maybe<Scalars['BigInt']>
+  missingRewardAmount_gte?: Maybe<Scalars['BigInt']>
+  missingRewardAmount_lt?: Maybe<Scalars['BigInt']>
+  missingRewardAmount_lte?: Maybe<Scalars['BigInt']>
+  missingRewardAmount_in?: Maybe<Array<Scalars['BigInt']>>
+  entry_eq?: Maybe<Scalars['ID']>
+  entry_in?: Maybe<Array<Scalars['ID']>>
+  application_eq?: Maybe<Scalars['ID']>
+  application_in?: Maybe<Array<Scalars['ID']>>
+  storage_eq?: Maybe<Scalars['String']>
+  storage_contains?: Maybe<Scalars['String']>
+  storage_startsWith?: Maybe<Scalars['String']>
+  storage_endsWith?: Maybe<Scalars['String']>
+  storage_in?: Maybe<Array<Scalars['String']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  membership?: Maybe<MembershipWhereInput>
+  payouts_none?: Maybe<RewardPaidEventWhereInput>
+  payouts_some?: Maybe<RewardPaidEventWhereInput>
+  payouts_every?: Maybe<RewardPaidEventWhereInput>
+  slashes_none?: Maybe<StakeSlashedEventWhereInput>
+  slashes_some?: Maybe<StakeSlashedEventWhereInput>
+  slashes_every?: Maybe<StakeSlashedEventWhereInput>
+  entry?: Maybe<OpeningFilledEventWhereInput>
+  application?: Maybe<WorkingGroupApplicationWhereInput>
+  leaderseteventworker_none?: Maybe<LeaderSetEventWhereInput>
+  leaderseteventworker_some?: Maybe<LeaderSetEventWhereInput>
+  leaderseteventworker_every?: Maybe<LeaderSetEventWhereInput>
+  leaderunseteventleader_none?: Maybe<LeaderUnsetEventWhereInput>
+  leaderunseteventleader_some?: Maybe<LeaderUnsetEventWhereInput>
+  leaderunseteventleader_every?: Maybe<LeaderUnsetEventWhereInput>
+  memberverificationstatusupdatedeventworker_none?: Maybe<MemberVerificationStatusUpdatedEventWhereInput>
+  memberverificationstatusupdatedeventworker_some?: Maybe<MemberVerificationStatusUpdatedEventWhereInput>
+  memberverificationstatusupdatedeventworker_every?: Maybe<MemberVerificationStatusUpdatedEventWhereInput>
+  newmissedrewardlevelreachedeventworker_none?: Maybe<NewMissedRewardLevelReachedEventWhereInput>
+  newmissedrewardlevelreachedeventworker_some?: Maybe<NewMissedRewardLevelReachedEventWhereInput>
+  newmissedrewardlevelreachedeventworker_every?: Maybe<NewMissedRewardLevelReachedEventWhereInput>
+  stakedecreasedeventworker_none?: Maybe<StakeDecreasedEventWhereInput>
+  stakedecreasedeventworker_some?: Maybe<StakeDecreasedEventWhereInput>
+  stakedecreasedeventworker_every?: Maybe<StakeDecreasedEventWhereInput>
+  stakeincreasedeventworker_none?: Maybe<StakeIncreasedEventWhereInput>
+  stakeincreasedeventworker_some?: Maybe<StakeIncreasedEventWhereInput>
+  stakeincreasedeventworker_every?: Maybe<StakeIncreasedEventWhereInput>
+  terminatedleadereventworker_none?: Maybe<TerminatedLeaderEventWhereInput>
+  terminatedleadereventworker_some?: Maybe<TerminatedLeaderEventWhereInput>
+  terminatedleadereventworker_every?: Maybe<TerminatedLeaderEventWhereInput>
+  terminatedworkereventworker_none?: Maybe<TerminatedWorkerEventWhereInput>
+  terminatedworkereventworker_some?: Maybe<TerminatedWorkerEventWhereInput>
+  terminatedworkereventworker_every?: Maybe<TerminatedWorkerEventWhereInput>
+  workerexitedeventworker_none?: Maybe<WorkerExitedEventWhereInput>
+  workerexitedeventworker_some?: Maybe<WorkerExitedEventWhereInput>
+  workerexitedeventworker_every?: Maybe<WorkerExitedEventWhereInput>
+  workerrewardaccountupdatedeventworker_none?: Maybe<WorkerRewardAccountUpdatedEventWhereInput>
+  workerrewardaccountupdatedeventworker_some?: Maybe<WorkerRewardAccountUpdatedEventWhereInput>
+  workerrewardaccountupdatedeventworker_every?: Maybe<WorkerRewardAccountUpdatedEventWhereInput>
+  workerrewardamountupdatedeventworker_none?: Maybe<WorkerRewardAmountUpdatedEventWhereInput>
+  workerrewardamountupdatedeventworker_some?: Maybe<WorkerRewardAmountUpdatedEventWhereInput>
+  workerrewardamountupdatedeventworker_every?: Maybe<WorkerRewardAmountUpdatedEventWhereInput>
+  workerroleaccountupdatedeventworker_none?: Maybe<WorkerRoleAccountUpdatedEventWhereInput>
+  workerroleaccountupdatedeventworker_some?: Maybe<WorkerRoleAccountUpdatedEventWhereInput>
+  workerroleaccountupdatedeventworker_every?: Maybe<WorkerRoleAccountUpdatedEventWhereInput>
+  workerstartedleavingeventworker_none?: Maybe<WorkerStartedLeavingEventWhereInput>
+  workerstartedleavingeventworker_some?: Maybe<WorkerStartedLeavingEventWhereInput>
+  workerstartedleavingeventworker_every?: Maybe<WorkerStartedLeavingEventWhereInput>
+  workinggroupleader_none?: Maybe<WorkingGroupWhereInput>
+  workinggroupleader_some?: Maybe<WorkingGroupWhereInput>
+  workinggroupleader_every?: Maybe<WorkingGroupWhereInput>
+  AND?: Maybe<Array<WorkerWhereInput>>
+  OR?: Maybe<Array<WorkerWhereInput>>
+}
+
+export type WorkerWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type WorkingGroup = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Working group name */
+  name: Scalars['String']
+  metadata?: Maybe<WorkingGroupMetadata>
+  metadataId?: Maybe<Scalars['String']>
+  leader?: Maybe<Worker>
+  leaderId?: Maybe<Scalars['String']>
+  workers: Array<Worker>
+  openings: Array<WorkingGroupOpening>
+  /** Current working group budget (JOY) */
+  budget: Scalars['BigInt']
+  applicationwithdrawneventgroup?: Maybe<Array<ApplicationWithdrawnEvent>>
+  appliedonopeningeventgroup?: Maybe<Array<AppliedOnOpeningEvent>>
+  budgetseteventgroup?: Maybe<Array<BudgetSetEvent>>
+  budgetspendingeventgroup?: Maybe<Array<BudgetSpendingEvent>>
+  leaderseteventgroup?: Maybe<Array<LeaderSetEvent>>
+  leaderunseteventgroup?: Maybe<Array<LeaderUnsetEvent>>
+  newmissedrewardlevelreachedeventgroup?: Maybe<Array<NewMissedRewardLevelReachedEvent>>
+  openingaddedeventgroup?: Maybe<Array<OpeningAddedEvent>>
+  openingcanceledeventgroup?: Maybe<Array<OpeningCanceledEvent>>
+  openingfilledeventgroup?: Maybe<Array<OpeningFilledEvent>>
+  rewardpaideventgroup?: Maybe<Array<RewardPaidEvent>>
+  stakedecreasedeventgroup?: Maybe<Array<StakeDecreasedEvent>>
+  stakeincreasedeventgroup?: Maybe<Array<StakeIncreasedEvent>>
+  stakeslashedeventgroup?: Maybe<Array<StakeSlashedEvent>>
+  statustextchangedeventgroup?: Maybe<Array<StatusTextChangedEvent>>
+  terminatedleadereventgroup?: Maybe<Array<TerminatedLeaderEvent>>
+  terminatedworkereventgroup?: Maybe<Array<TerminatedWorkerEvent>>
+  upcomingworkinggroupopeninggroup?: Maybe<Array<UpcomingWorkingGroupOpening>>
+  workerexitedeventgroup?: Maybe<Array<WorkerExitedEvent>>
+  workerrewardaccountupdatedeventgroup?: Maybe<Array<WorkerRewardAccountUpdatedEvent>>
+  workerrewardamountupdatedeventgroup?: Maybe<Array<WorkerRewardAmountUpdatedEvent>>
+  workerroleaccountupdatedeventgroup?: Maybe<Array<WorkerRoleAccountUpdatedEvent>>
+  workerstartedleavingeventgroup?: Maybe<Array<WorkerStartedLeavingEvent>>
+  workinggroupmetadatagroup?: Maybe<Array<WorkingGroupMetadata>>
+}
+
+export type WorkingGroupApplication = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** ApplicationId in specific working group module */
+  runtimeId: Scalars['Int']
+  opening: WorkingGroupOpening
+  openingId: Scalars['String']
+  applicant: Membership
+  applicantId: Scalars['String']
+  /** Application stake */
+  stake: Scalars['BigInt']
+  /** Applicant's initial role account */
+  roleAccount: Scalars['String']
+  /** Applicant's initial reward account */
+  rewardAccount: Scalars['String']
+  /** Applicant's initial staking account */
+  stakingAccount: Scalars['String']
+  answers: Array<ApplicationFormQuestionAnswer>
+  /** Current application status */
+  status: WorkingGroupApplicationStatus
+  createdInEvent: AppliedOnOpeningEvent
+  applicationwithdrawneventapplication?: Maybe<Array<ApplicationWithdrawnEvent>>
+  workerapplication?: Maybe<Array<Worker>>
+}
+
+export type WorkingGroupApplicationConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<WorkingGroupApplicationEdge>
+  pageInfo: PageInfo
+}
+
+export type WorkingGroupApplicationCreateInput = {
+  runtimeId: Scalars['Float']
+  opening: Scalars['ID']
+  applicant: Scalars['ID']
+  stake: Scalars['BigInt']
+  roleAccount: Scalars['String']
+  rewardAccount: Scalars['String']
+  stakingAccount: Scalars['String']
+  status: Scalars['JSONObject']
+}
+
+export type WorkingGroupApplicationEdge = {
+  node: WorkingGroupApplication
+  cursor: Scalars['String']
+}
+
+export enum WorkingGroupApplicationOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  RuntimeIdAsc = 'runtimeId_ASC',
+  RuntimeIdDesc = 'runtimeId_DESC',
+  OpeningAsc = 'opening_ASC',
+  OpeningDesc = 'opening_DESC',
+  ApplicantAsc = 'applicant_ASC',
+  ApplicantDesc = 'applicant_DESC',
+  StakeAsc = 'stake_ASC',
+  StakeDesc = 'stake_DESC',
+  RoleAccountAsc = 'roleAccount_ASC',
+  RoleAccountDesc = 'roleAccount_DESC',
+  RewardAccountAsc = 'rewardAccount_ASC',
+  RewardAccountDesc = 'rewardAccount_DESC',
+  StakingAccountAsc = 'stakingAccount_ASC',
+  StakingAccountDesc = 'stakingAccount_DESC',
+}
+
+export type WorkingGroupApplicationStatus =
+  | ApplicationStatusPending
+  | ApplicationStatusAccepted
+  | ApplicationStatusRejected
+  | ApplicationStatusWithdrawn
+  | ApplicationStatusCancelled
+
+export type WorkingGroupApplicationUpdateInput = {
+  runtimeId?: Maybe<Scalars['Float']>
+  opening?: Maybe<Scalars['ID']>
+  applicant?: Maybe<Scalars['ID']>
+  stake?: Maybe<Scalars['BigInt']>
+  roleAccount?: Maybe<Scalars['String']>
+  rewardAccount?: Maybe<Scalars['String']>
+  stakingAccount?: Maybe<Scalars['String']>
+  status?: Maybe<Scalars['JSONObject']>
+}
+
+export type WorkingGroupApplicationWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  runtimeId_eq?: Maybe<Scalars['Int']>
+  runtimeId_gt?: Maybe<Scalars['Int']>
+  runtimeId_gte?: Maybe<Scalars['Int']>
+  runtimeId_lt?: Maybe<Scalars['Int']>
+  runtimeId_lte?: Maybe<Scalars['Int']>
+  runtimeId_in?: Maybe<Array<Scalars['Int']>>
+  opening_eq?: Maybe<Scalars['ID']>
+  opening_in?: Maybe<Array<Scalars['ID']>>
+  applicant_eq?: Maybe<Scalars['ID']>
+  applicant_in?: Maybe<Array<Scalars['ID']>>
+  stake_eq?: Maybe<Scalars['BigInt']>
+  stake_gt?: Maybe<Scalars['BigInt']>
+  stake_gte?: Maybe<Scalars['BigInt']>
+  stake_lt?: Maybe<Scalars['BigInt']>
+  stake_lte?: Maybe<Scalars['BigInt']>
+  stake_in?: Maybe<Array<Scalars['BigInt']>>
+  roleAccount_eq?: Maybe<Scalars['String']>
+  roleAccount_contains?: Maybe<Scalars['String']>
+  roleAccount_startsWith?: Maybe<Scalars['String']>
+  roleAccount_endsWith?: Maybe<Scalars['String']>
+  roleAccount_in?: Maybe<Array<Scalars['String']>>
+  rewardAccount_eq?: Maybe<Scalars['String']>
+  rewardAccount_contains?: Maybe<Scalars['String']>
+  rewardAccount_startsWith?: Maybe<Scalars['String']>
+  rewardAccount_endsWith?: Maybe<Scalars['String']>
+  rewardAccount_in?: Maybe<Array<Scalars['String']>>
+  stakingAccount_eq?: Maybe<Scalars['String']>
+  stakingAccount_contains?: Maybe<Scalars['String']>
+  stakingAccount_startsWith?: Maybe<Scalars['String']>
+  stakingAccount_endsWith?: Maybe<Scalars['String']>
+  stakingAccount_in?: Maybe<Array<Scalars['String']>>
+  status_json?: Maybe<Scalars['JSONObject']>
+  opening?: Maybe<WorkingGroupOpeningWhereInput>
+  applicant?: Maybe<MembershipWhereInput>
+  answers_none?: Maybe<ApplicationFormQuestionAnswerWhereInput>
+  answers_some?: Maybe<ApplicationFormQuestionAnswerWhereInput>
+  answers_every?: Maybe<ApplicationFormQuestionAnswerWhereInput>
+  createdInEvent?: Maybe<AppliedOnOpeningEventWhereInput>
+  applicationwithdrawneventapplication_none?: Maybe<ApplicationWithdrawnEventWhereInput>
+  applicationwithdrawneventapplication_some?: Maybe<ApplicationWithdrawnEventWhereInput>
+  applicationwithdrawneventapplication_every?: Maybe<ApplicationWithdrawnEventWhereInput>
+  workerapplication_none?: Maybe<WorkerWhereInput>
+  workerapplication_some?: Maybe<WorkerWhereInput>
+  workerapplication_every?: Maybe<WorkerWhereInput>
+  AND?: Maybe<Array<WorkingGroupApplicationWhereInput>>
+  OR?: Maybe<Array<WorkingGroupApplicationWhereInput>>
+}
+
+export type WorkingGroupApplicationWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type WorkingGroupConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<WorkingGroupEdge>
+  pageInfo: PageInfo
+}
+
+export type WorkingGroupCreateInput = {
+  name: Scalars['String']
+  metadata?: Maybe<Scalars['ID']>
+  leader?: Maybe<Scalars['ID']>
+  budget: Scalars['BigInt']
+}
+
+export type WorkingGroupEdge = {
+  node: WorkingGroup
+  cursor: Scalars['String']
+}
+
+export type WorkingGroupMetadata = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Working group status */
+  status?: Maybe<Scalars['String']>
+  /** Working group status message */
+  statusMessage?: Maybe<Scalars['String']>
+  /** Working group about text */
+  about?: Maybe<Scalars['String']>
+  /** Working group description text */
+  description?: Maybe<Scalars['String']>
+  setInEvent: StatusTextChangedEvent
+  setInEventId: Scalars['String']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  workinggroupmetadata?: Maybe<Array<WorkingGroup>>
+}
+
+export type WorkingGroupMetadataActionResult =
+  | UpcomingOpeningAdded
+  | UpcomingOpeningRemoved
+  | WorkingGroupMetadataSet
+  | InvalidActionMetadata
+
+export type WorkingGroupMetadataConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<WorkingGroupMetadataEdge>
+  pageInfo: PageInfo
+}
+
+export type WorkingGroupMetadataCreateInput = {
+  status?: Maybe<Scalars['String']>
+  statusMessage?: Maybe<Scalars['String']>
+  about?: Maybe<Scalars['String']>
+  description?: Maybe<Scalars['String']>
+  setInEvent: Scalars['ID']
+  group: Scalars['ID']
+}
+
+export type WorkingGroupMetadataEdge = {
+  node: WorkingGroupMetadata
+  cursor: Scalars['String']
+}
+
+export enum WorkingGroupMetadataOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  StatusAsc = 'status_ASC',
+  StatusDesc = 'status_DESC',
+  StatusMessageAsc = 'statusMessage_ASC',
+  StatusMessageDesc = 'statusMessage_DESC',
+  AboutAsc = 'about_ASC',
+  AboutDesc = 'about_DESC',
+  DescriptionAsc = 'description_ASC',
+  DescriptionDesc = 'description_DESC',
+  SetInEventAsc = 'setInEvent_ASC',
+  SetInEventDesc = 'setInEvent_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+}
+
+export type WorkingGroupMetadataSet = {
+  /** The new metadata snapshot resulting from the update */
+  metadata?: Maybe<WorkingGroupMetadata>
+}
+
+export type WorkingGroupMetadataUpdateInput = {
+  status?: Maybe<Scalars['String']>
+  statusMessage?: Maybe<Scalars['String']>
+  about?: Maybe<Scalars['String']>
+  description?: Maybe<Scalars['String']>
+  setInEvent?: Maybe<Scalars['ID']>
+  group?: Maybe<Scalars['ID']>
+}
+
+export type WorkingGroupMetadataWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  status_eq?: Maybe<Scalars['String']>
+  status_contains?: Maybe<Scalars['String']>
+  status_startsWith?: Maybe<Scalars['String']>
+  status_endsWith?: Maybe<Scalars['String']>
+  status_in?: Maybe<Array<Scalars['String']>>
+  statusMessage_eq?: Maybe<Scalars['String']>
+  statusMessage_contains?: Maybe<Scalars['String']>
+  statusMessage_startsWith?: Maybe<Scalars['String']>
+  statusMessage_endsWith?: Maybe<Scalars['String']>
+  statusMessage_in?: Maybe<Array<Scalars['String']>>
+  about_eq?: Maybe<Scalars['String']>
+  about_contains?: Maybe<Scalars['String']>
+  about_startsWith?: Maybe<Scalars['String']>
+  about_endsWith?: Maybe<Scalars['String']>
+  about_in?: Maybe<Array<Scalars['String']>>
+  description_eq?: Maybe<Scalars['String']>
+  description_contains?: Maybe<Scalars['String']>
+  description_startsWith?: Maybe<Scalars['String']>
+  description_endsWith?: Maybe<Scalars['String']>
+  description_in?: Maybe<Array<Scalars['String']>>
+  setInEvent_eq?: Maybe<Scalars['ID']>
+  setInEvent_in?: Maybe<Array<Scalars['ID']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  setInEvent?: Maybe<StatusTextChangedEventWhereInput>
+  group?: Maybe<WorkingGroupWhereInput>
+  workinggroupmetadata_none?: Maybe<WorkingGroupWhereInput>
+  workinggroupmetadata_some?: Maybe<WorkingGroupWhereInput>
+  workinggroupmetadata_every?: Maybe<WorkingGroupWhereInput>
+  AND?: Maybe<Array<WorkingGroupMetadataWhereInput>>
+  OR?: Maybe<Array<WorkingGroupMetadataWhereInput>>
+}
+
+export type WorkingGroupMetadataWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type WorkingGroupOpening = BaseGraphQlObject & {
+  id: Scalars['ID']
+  /** Time of opening creation */
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** OpeningId in specific working group module */
+  runtimeId: Scalars['Int']
+  group: WorkingGroup
+  groupId: Scalars['String']
+  applications: Array<WorkingGroupApplication>
+  /** Type of the opening (Leader/Regular) */
+  type: WorkingGroupOpeningType
+  /** Current opening status */
+  status: WorkingGroupOpeningStatus
+  metadata: WorkingGroupOpeningMetadata
+  metadataId: Scalars['String']
+  /** Min. application/role stake amount */
+  stakeAmount: Scalars['BigInt']
+  /** Role stake unstaking period in blocks */
+  unstakingPeriod: Scalars['Int']
+  /** Initial workers' reward per block */
+  rewardPerBlock: Scalars['BigInt']
+  createdInEvent: OpeningAddedEvent
+  appliedonopeningeventopening?: Maybe<Array<AppliedOnOpeningEvent>>
+  openingcanceledeventopening?: Maybe<Array<OpeningCanceledEvent>>
+  openingfilledeventopening?: Maybe<Array<OpeningFilledEvent>>
+}
+
+export type WorkingGroupOpeningConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<WorkingGroupOpeningEdge>
+  pageInfo: PageInfo
+}
+
+export type WorkingGroupOpeningCreateInput = {
+  createdAt: Scalars['DateTime']
+  runtimeId: Scalars['Float']
+  group: Scalars['ID']
+  type: WorkingGroupOpeningType
+  status: Scalars['JSONObject']
+  metadata: Scalars['ID']
+  stakeAmount: Scalars['BigInt']
+  unstakingPeriod: Scalars['Float']
+  rewardPerBlock: Scalars['BigInt']
+}
+
+export type WorkingGroupOpeningEdge = {
+  node: WorkingGroupOpening
+  cursor: Scalars['String']
+}
+
+export type WorkingGroupOpeningMetadata = BaseGraphQlObject & {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Whether the originally provided metadata was valid */
+  originallyValid: Scalars['Boolean']
+  /** Opening short description */
+  shortDescription?: Maybe<Scalars['String']>
+  /** Opening description (md-formatted) */
+  description?: Maybe<Scalars['String']>
+  /** Expected max. number of applicants that will be hired */
+  hiringLimit?: Maybe<Scalars['Int']>
+  /** Expected time when the opening will close */
+  expectedEnding?: Maybe<Scalars['DateTime']>
+  /** Md-formatted text explaining the application process */
+  applicationDetails?: Maybe<Scalars['String']>
+  applicationFormQuestions: Array<ApplicationFormQuestion>
+  upcomingworkinggroupopeningmetadata?: Maybe<Array<UpcomingWorkingGroupOpening>>
+  workinggroupopeningmetadata?: Maybe<Array<WorkingGroupOpening>>
+}
+
+export type WorkingGroupOpeningMetadataConnection = {
+  totalCount: Scalars['Int']
+  edges: Array<WorkingGroupOpeningMetadataEdge>
+  pageInfo: PageInfo
+}
+
+export type WorkingGroupOpeningMetadataCreateInput = {
+  originallyValid: Scalars['Boolean']
+  shortDescription?: Maybe<Scalars['String']>
+  description?: Maybe<Scalars['String']>
+  hiringLimit?: Maybe<Scalars['Float']>
+  expectedEnding?: Maybe<Scalars['DateTime']>
+  applicationDetails?: Maybe<Scalars['String']>
+}
+
+export type WorkingGroupOpeningMetadataEdge = {
+  node: WorkingGroupOpeningMetadata
+  cursor: Scalars['String']
+}
+
+export enum WorkingGroupOpeningMetadataOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  OriginallyValidAsc = 'originallyValid_ASC',
+  OriginallyValidDesc = 'originallyValid_DESC',
+  ShortDescriptionAsc = 'shortDescription_ASC',
+  ShortDescriptionDesc = 'shortDescription_DESC',
+  DescriptionAsc = 'description_ASC',
+  DescriptionDesc = 'description_DESC',
+  HiringLimitAsc = 'hiringLimit_ASC',
+  HiringLimitDesc = 'hiringLimit_DESC',
+  ExpectedEndingAsc = 'expectedEnding_ASC',
+  ExpectedEndingDesc = 'expectedEnding_DESC',
+  ApplicationDetailsAsc = 'applicationDetails_ASC',
+  ApplicationDetailsDesc = 'applicationDetails_DESC',
+}
+
+export type WorkingGroupOpeningMetadataUpdateInput = {
+  originallyValid?: Maybe<Scalars['Boolean']>
+  shortDescription?: Maybe<Scalars['String']>
+  description?: Maybe<Scalars['String']>
+  hiringLimit?: Maybe<Scalars['Float']>
+  expectedEnding?: Maybe<Scalars['DateTime']>
+  applicationDetails?: Maybe<Scalars['String']>
+}
+
+export type WorkingGroupOpeningMetadataWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  originallyValid_eq?: Maybe<Scalars['Boolean']>
+  originallyValid_in?: Maybe<Array<Scalars['Boolean']>>
+  shortDescription_eq?: Maybe<Scalars['String']>
+  shortDescription_contains?: Maybe<Scalars['String']>
+  shortDescription_startsWith?: Maybe<Scalars['String']>
+  shortDescription_endsWith?: Maybe<Scalars['String']>
+  shortDescription_in?: Maybe<Array<Scalars['String']>>
+  description_eq?: Maybe<Scalars['String']>
+  description_contains?: Maybe<Scalars['String']>
+  description_startsWith?: Maybe<Scalars['String']>
+  description_endsWith?: Maybe<Scalars['String']>
+  description_in?: Maybe<Array<Scalars['String']>>
+  hiringLimit_eq?: Maybe<Scalars['Int']>
+  hiringLimit_gt?: Maybe<Scalars['Int']>
+  hiringLimit_gte?: Maybe<Scalars['Int']>
+  hiringLimit_lt?: Maybe<Scalars['Int']>
+  hiringLimit_lte?: Maybe<Scalars['Int']>
+  hiringLimit_in?: Maybe<Array<Scalars['Int']>>
+  expectedEnding_eq?: Maybe<Scalars['DateTime']>
+  expectedEnding_lt?: Maybe<Scalars['DateTime']>
+  expectedEnding_lte?: Maybe<Scalars['DateTime']>
+  expectedEnding_gt?: Maybe<Scalars['DateTime']>
+  expectedEnding_gte?: Maybe<Scalars['DateTime']>
+  applicationDetails_eq?: Maybe<Scalars['String']>
+  applicationDetails_contains?: Maybe<Scalars['String']>
+  applicationDetails_startsWith?: Maybe<Scalars['String']>
+  applicationDetails_endsWith?: Maybe<Scalars['String']>
+  applicationDetails_in?: Maybe<Array<Scalars['String']>>
+  applicationFormQuestions_none?: Maybe<ApplicationFormQuestionWhereInput>
+  applicationFormQuestions_some?: Maybe<ApplicationFormQuestionWhereInput>
+  applicationFormQuestions_every?: Maybe<ApplicationFormQuestionWhereInput>
+  upcomingworkinggroupopeningmetadata_none?: Maybe<UpcomingWorkingGroupOpeningWhereInput>
+  upcomingworkinggroupopeningmetadata_some?: Maybe<UpcomingWorkingGroupOpeningWhereInput>
+  upcomingworkinggroupopeningmetadata_every?: Maybe<UpcomingWorkingGroupOpeningWhereInput>
+  workinggroupopeningmetadata_none?: Maybe<WorkingGroupOpeningWhereInput>
+  workinggroupopeningmetadata_some?: Maybe<WorkingGroupOpeningWhereInput>
+  workinggroupopeningmetadata_every?: Maybe<WorkingGroupOpeningWhereInput>
+  AND?: Maybe<Array<WorkingGroupOpeningMetadataWhereInput>>
+  OR?: Maybe<Array<WorkingGroupOpeningMetadataWhereInput>>
+}
+
+export type WorkingGroupOpeningMetadataWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export enum WorkingGroupOpeningOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  RuntimeIdAsc = 'runtimeId_ASC',
+  RuntimeIdDesc = 'runtimeId_DESC',
+  GroupAsc = 'group_ASC',
+  GroupDesc = 'group_DESC',
+  TypeAsc = 'type_ASC',
+  TypeDesc = 'type_DESC',
+  MetadataAsc = 'metadata_ASC',
+  MetadataDesc = 'metadata_DESC',
+  StakeAmountAsc = 'stakeAmount_ASC',
+  StakeAmountDesc = 'stakeAmount_DESC',
+  UnstakingPeriodAsc = 'unstakingPeriod_ASC',
+  UnstakingPeriodDesc = 'unstakingPeriod_DESC',
+  RewardPerBlockAsc = 'rewardPerBlock_ASC',
+  RewardPerBlockDesc = 'rewardPerBlock_DESC',
+}
+
+export type WorkingGroupOpeningStatus = OpeningStatusOpen | OpeningStatusFilled | OpeningStatusCancelled
+
+export enum WorkingGroupOpeningType {
+  Regular = 'REGULAR',
+  Leader = 'LEADER',
+}
+
+export type WorkingGroupOpeningUpdateInput = {
+  createdAt?: Maybe<Scalars['DateTime']>
+  runtimeId?: Maybe<Scalars['Float']>
+  group?: Maybe<Scalars['ID']>
+  type?: Maybe<WorkingGroupOpeningType>
+  status?: Maybe<Scalars['JSONObject']>
+  metadata?: Maybe<Scalars['ID']>
+  stakeAmount?: Maybe<Scalars['BigInt']>
+  unstakingPeriod?: Maybe<Scalars['Float']>
+  rewardPerBlock?: Maybe<Scalars['BigInt']>
+}
+
+export type WorkingGroupOpeningWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  runtimeId_eq?: Maybe<Scalars['Int']>
+  runtimeId_gt?: Maybe<Scalars['Int']>
+  runtimeId_gte?: Maybe<Scalars['Int']>
+  runtimeId_lt?: Maybe<Scalars['Int']>
+  runtimeId_lte?: Maybe<Scalars['Int']>
+  runtimeId_in?: Maybe<Array<Scalars['Int']>>
+  group_eq?: Maybe<Scalars['ID']>
+  group_in?: Maybe<Array<Scalars['ID']>>
+  type_eq?: Maybe<WorkingGroupOpeningType>
+  type_in?: Maybe<Array<WorkingGroupOpeningType>>
+  status_json?: Maybe<Scalars['JSONObject']>
+  metadata_eq?: Maybe<Scalars['ID']>
+  metadata_in?: Maybe<Array<Scalars['ID']>>
+  stakeAmount_eq?: Maybe<Scalars['BigInt']>
+  stakeAmount_gt?: Maybe<Scalars['BigInt']>
+  stakeAmount_gte?: Maybe<Scalars['BigInt']>
+  stakeAmount_lt?: Maybe<Scalars['BigInt']>
+  stakeAmount_lte?: Maybe<Scalars['BigInt']>
+  stakeAmount_in?: Maybe<Array<Scalars['BigInt']>>
+  unstakingPeriod_eq?: Maybe<Scalars['Int']>
+  unstakingPeriod_gt?: Maybe<Scalars['Int']>
+  unstakingPeriod_gte?: Maybe<Scalars['Int']>
+  unstakingPeriod_lt?: Maybe<Scalars['Int']>
+  unstakingPeriod_lte?: Maybe<Scalars['Int']>
+  unstakingPeriod_in?: Maybe<Array<Scalars['Int']>>
+  rewardPerBlock_eq?: Maybe<Scalars['BigInt']>
+  rewardPerBlock_gt?: Maybe<Scalars['BigInt']>
+  rewardPerBlock_gte?: Maybe<Scalars['BigInt']>
+  rewardPerBlock_lt?: Maybe<Scalars['BigInt']>
+  rewardPerBlock_lte?: Maybe<Scalars['BigInt']>
+  rewardPerBlock_in?: Maybe<Array<Scalars['BigInt']>>
+  group?: Maybe<WorkingGroupWhereInput>
+  applications_none?: Maybe<WorkingGroupApplicationWhereInput>
+  applications_some?: Maybe<WorkingGroupApplicationWhereInput>
+  applications_every?: Maybe<WorkingGroupApplicationWhereInput>
+  metadata?: Maybe<WorkingGroupOpeningMetadataWhereInput>
+  createdInEvent?: Maybe<OpeningAddedEventWhereInput>
+  appliedonopeningeventopening_none?: Maybe<AppliedOnOpeningEventWhereInput>
+  appliedonopeningeventopening_some?: Maybe<AppliedOnOpeningEventWhereInput>
+  appliedonopeningeventopening_every?: Maybe<AppliedOnOpeningEventWhereInput>
+  openingcanceledeventopening_none?: Maybe<OpeningCanceledEventWhereInput>
+  openingcanceledeventopening_some?: Maybe<OpeningCanceledEventWhereInput>
+  openingcanceledeventopening_every?: Maybe<OpeningCanceledEventWhereInput>
+  openingfilledeventopening_none?: Maybe<OpeningFilledEventWhereInput>
+  openingfilledeventopening_some?: Maybe<OpeningFilledEventWhereInput>
+  openingfilledeventopening_every?: Maybe<OpeningFilledEventWhereInput>
+  AND?: Maybe<Array<WorkingGroupOpeningWhereInput>>
+  OR?: Maybe<Array<WorkingGroupOpeningWhereInput>>
+}
+
+export type WorkingGroupOpeningWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export enum WorkingGroupOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  NameAsc = 'name_ASC',
+  NameDesc = 'name_DESC',
+  MetadataAsc = 'metadata_ASC',
+  MetadataDesc = 'metadata_DESC',
+  LeaderAsc = 'leader_ASC',
+  LeaderDesc = 'leader_DESC',
+  BudgetAsc = 'budget_ASC',
+  BudgetDesc = 'budget_DESC',
+}
+
+export type WorkingGroupUpdateInput = {
+  name?: Maybe<Scalars['String']>
+  metadata?: Maybe<Scalars['ID']>
+  leader?: Maybe<Scalars['ID']>
+  budget?: Maybe<Scalars['BigInt']>
+}
+
+export type WorkingGroupWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  name_eq?: Maybe<Scalars['String']>
+  name_contains?: Maybe<Scalars['String']>
+  name_startsWith?: Maybe<Scalars['String']>
+  name_endsWith?: Maybe<Scalars['String']>
+  name_in?: Maybe<Array<Scalars['String']>>
+  metadata_eq?: Maybe<Scalars['ID']>
+  metadata_in?: Maybe<Array<Scalars['ID']>>
+  leader_eq?: Maybe<Scalars['ID']>
+  leader_in?: Maybe<Array<Scalars['ID']>>
+  budget_eq?: Maybe<Scalars['BigInt']>
+  budget_gt?: Maybe<Scalars['BigInt']>
+  budget_gte?: Maybe<Scalars['BigInt']>
+  budget_lt?: Maybe<Scalars['BigInt']>
+  budget_lte?: Maybe<Scalars['BigInt']>
+  budget_in?: Maybe<Array<Scalars['BigInt']>>
+  metadata?: Maybe<WorkingGroupMetadataWhereInput>
+  leader?: Maybe<WorkerWhereInput>
+  workers_none?: Maybe<WorkerWhereInput>
+  workers_some?: Maybe<WorkerWhereInput>
+  workers_every?: Maybe<WorkerWhereInput>
+  openings_none?: Maybe<WorkingGroupOpeningWhereInput>
+  openings_some?: Maybe<WorkingGroupOpeningWhereInput>
+  openings_every?: Maybe<WorkingGroupOpeningWhereInput>
+  applicationwithdrawneventgroup_none?: Maybe<ApplicationWithdrawnEventWhereInput>
+  applicationwithdrawneventgroup_some?: Maybe<ApplicationWithdrawnEventWhereInput>
+  applicationwithdrawneventgroup_every?: Maybe<ApplicationWithdrawnEventWhereInput>
+  appliedonopeningeventgroup_none?: Maybe<AppliedOnOpeningEventWhereInput>
+  appliedonopeningeventgroup_some?: Maybe<AppliedOnOpeningEventWhereInput>
+  appliedonopeningeventgroup_every?: Maybe<AppliedOnOpeningEventWhereInput>
+  budgetseteventgroup_none?: Maybe<BudgetSetEventWhereInput>
+  budgetseteventgroup_some?: Maybe<BudgetSetEventWhereInput>
+  budgetseteventgroup_every?: Maybe<BudgetSetEventWhereInput>
+  budgetspendingeventgroup_none?: Maybe<BudgetSpendingEventWhereInput>
+  budgetspendingeventgroup_some?: Maybe<BudgetSpendingEventWhereInput>
+  budgetspendingeventgroup_every?: Maybe<BudgetSpendingEventWhereInput>
+  leaderseteventgroup_none?: Maybe<LeaderSetEventWhereInput>
+  leaderseteventgroup_some?: Maybe<LeaderSetEventWhereInput>
+  leaderseteventgroup_every?: Maybe<LeaderSetEventWhereInput>
+  leaderunseteventgroup_none?: Maybe<LeaderUnsetEventWhereInput>
+  leaderunseteventgroup_some?: Maybe<LeaderUnsetEventWhereInput>
+  leaderunseteventgroup_every?: Maybe<LeaderUnsetEventWhereInput>
+  newmissedrewardlevelreachedeventgroup_none?: Maybe<NewMissedRewardLevelReachedEventWhereInput>
+  newmissedrewardlevelreachedeventgroup_some?: Maybe<NewMissedRewardLevelReachedEventWhereInput>
+  newmissedrewardlevelreachedeventgroup_every?: Maybe<NewMissedRewardLevelReachedEventWhereInput>
+  openingaddedeventgroup_none?: Maybe<OpeningAddedEventWhereInput>
+  openingaddedeventgroup_some?: Maybe<OpeningAddedEventWhereInput>
+  openingaddedeventgroup_every?: Maybe<OpeningAddedEventWhereInput>
+  openingcanceledeventgroup_none?: Maybe<OpeningCanceledEventWhereInput>
+  openingcanceledeventgroup_some?: Maybe<OpeningCanceledEventWhereInput>
+  openingcanceledeventgroup_every?: Maybe<OpeningCanceledEventWhereInput>
+  openingfilledeventgroup_none?: Maybe<OpeningFilledEventWhereInput>
+  openingfilledeventgroup_some?: Maybe<OpeningFilledEventWhereInput>
+  openingfilledeventgroup_every?: Maybe<OpeningFilledEventWhereInput>
+  rewardpaideventgroup_none?: Maybe<RewardPaidEventWhereInput>
+  rewardpaideventgroup_some?: Maybe<RewardPaidEventWhereInput>
+  rewardpaideventgroup_every?: Maybe<RewardPaidEventWhereInput>
+  stakedecreasedeventgroup_none?: Maybe<StakeDecreasedEventWhereInput>
+  stakedecreasedeventgroup_some?: Maybe<StakeDecreasedEventWhereInput>
+  stakedecreasedeventgroup_every?: Maybe<StakeDecreasedEventWhereInput>
+  stakeincreasedeventgroup_none?: Maybe<StakeIncreasedEventWhereInput>
+  stakeincreasedeventgroup_some?: Maybe<StakeIncreasedEventWhereInput>
+  stakeincreasedeventgroup_every?: Maybe<StakeIncreasedEventWhereInput>
+  stakeslashedeventgroup_none?: Maybe<StakeSlashedEventWhereInput>
+  stakeslashedeventgroup_some?: Maybe<StakeSlashedEventWhereInput>
+  stakeslashedeventgroup_every?: Maybe<StakeSlashedEventWhereInput>
+  statustextchangedeventgroup_none?: Maybe<StatusTextChangedEventWhereInput>
+  statustextchangedeventgroup_some?: Maybe<StatusTextChangedEventWhereInput>
+  statustextchangedeventgroup_every?: Maybe<StatusTextChangedEventWhereInput>
+  terminatedleadereventgroup_none?: Maybe<TerminatedLeaderEventWhereInput>
+  terminatedleadereventgroup_some?: Maybe<TerminatedLeaderEventWhereInput>
+  terminatedleadereventgroup_every?: Maybe<TerminatedLeaderEventWhereInput>
+  terminatedworkereventgroup_none?: Maybe<TerminatedWorkerEventWhereInput>
+  terminatedworkereventgroup_some?: Maybe<TerminatedWorkerEventWhereInput>
+  terminatedworkereventgroup_every?: Maybe<TerminatedWorkerEventWhereInput>
+  upcomingworkinggroupopeninggroup_none?: Maybe<UpcomingWorkingGroupOpeningWhereInput>
+  upcomingworkinggroupopeninggroup_some?: Maybe<UpcomingWorkingGroupOpeningWhereInput>
+  upcomingworkinggroupopeninggroup_every?: Maybe<UpcomingWorkingGroupOpeningWhereInput>
+  workerexitedeventgroup_none?: Maybe<WorkerExitedEventWhereInput>
+  workerexitedeventgroup_some?: Maybe<WorkerExitedEventWhereInput>
+  workerexitedeventgroup_every?: Maybe<WorkerExitedEventWhereInput>
+  workerrewardaccountupdatedeventgroup_none?: Maybe<WorkerRewardAccountUpdatedEventWhereInput>
+  workerrewardaccountupdatedeventgroup_some?: Maybe<WorkerRewardAccountUpdatedEventWhereInput>
+  workerrewardaccountupdatedeventgroup_every?: Maybe<WorkerRewardAccountUpdatedEventWhereInput>
+  workerrewardamountupdatedeventgroup_none?: Maybe<WorkerRewardAmountUpdatedEventWhereInput>
+  workerrewardamountupdatedeventgroup_some?: Maybe<WorkerRewardAmountUpdatedEventWhereInput>
+  workerrewardamountupdatedeventgroup_every?: Maybe<WorkerRewardAmountUpdatedEventWhereInput>
+  workerroleaccountupdatedeventgroup_none?: Maybe<WorkerRoleAccountUpdatedEventWhereInput>
+  workerroleaccountupdatedeventgroup_some?: Maybe<WorkerRoleAccountUpdatedEventWhereInput>
+  workerroleaccountupdatedeventgroup_every?: Maybe<WorkerRoleAccountUpdatedEventWhereInput>
+  workerstartedleavingeventgroup_none?: Maybe<WorkerStartedLeavingEventWhereInput>
+  workerstartedleavingeventgroup_some?: Maybe<WorkerStartedLeavingEventWhereInput>
+  workerstartedleavingeventgroup_every?: Maybe<WorkerStartedLeavingEventWhereInput>
+  workinggroupmetadatagroup_none?: Maybe<WorkingGroupMetadataWhereInput>
+  workinggroupmetadatagroup_some?: Maybe<WorkingGroupMetadataWhereInput>
+  workinggroupmetadatagroup_every?: Maybe<WorkingGroupMetadataWhereInput>
+  AND?: Maybe<Array<WorkingGroupWhereInput>>
+  OR?: Maybe<Array<WorkingGroupWhereInput>>
+}
+
+export type WorkingGroupWhereUniqueInput = {
+  id?: Maybe<Scalars['ID']>
+  name?: Maybe<Scalars['String']>
+}

cli/src/graphql/queries/membership.graphql

@@ -0,0 +1,18 @@
+fragment MemberMetadataFields on MemberMetadata {
+  name
+  about
+}
+
+fragment MembershipFields on Membership {
+  id
+  handle
+  metadata {
+    ...MemberMetadataFields
+  }
+}
+
+query getMemberById($id: ID!) {
+  membershipByUniqueInput(where: { id: $id }) {
+    ...MembershipFields
+  }
+}

cli/src/helpers/InputOutput.ts

@@ -5,12 +5,8 @@ import fs from 'fs'
 import path from 'path'
 import Ajv from 'ajv'
 import $RefParser, { JSONSchema } from '@apidevtools/json-schema-ref-parser'
-import { getSchemasLocation } from '@joystream/cd-schemas'
 import chalk from 'chalk'
 
-// Default schema path for resolving refs
-const DEFAULT_SCHEMA_PATH = getSchemasLocation('entities') + path.sep
-
 export const IOFlags = {
   input: flags.string({
     char: 'i',
@@ -50,7 +46,7 @@ export async function getInputJson<T>(inputPath?: string, schema?: JSONSchema, s
 
 export async function validateInput(input: unknown, schema: JSONSchema, schemaPath?: string): Promise<void> {
   const ajv = new Ajv({ allErrors: true })
-  schema = await $RefParser.dereference(schemaPath || DEFAULT_SCHEMA_PATH, schema, {})
+  schema = await $RefParser.dereference(schemaPath || '.', schema, {})
   const valid = ajv.validate(schema, input) as boolean
   if (!valid) {
     throw new CLIError(`Input JSON file is not valid: ${ajv.errorsText()}`)

cli/src/helpers/JsonSchemaPrompt.ts

@@ -4,8 +4,6 @@ import _ from 'lodash'
 import RefParser, { JSONSchema } from '@apidevtools/json-schema-ref-parser'
 import chalk from 'chalk'
 import { BOOL_PROMPT_OPTIONS } from './prompting'
-import { getSchemasLocation } from '@joystream/cd-schemas'
-import path from 'path'
 
 type CustomPromptMethod = () => Promise<any>
 type CustomPrompt = DistinctQuestion | CustomPromptMethod | { $item: CustomPrompt } | 'skip'
@@ -14,10 +12,6 @@ type CustomPrompt = DistinctQuestion | CustomPromptMethod | { $item: CustomPromp
 // eslint-disable-next-line @typescript-eslint/ban-types
 export type JsonSchemaCustomPrompts<T = Record<string, unknown>> = [keyof T | (string & {}) | RegExp, CustomPrompt][]
 
-// Default schema path for resolving refs
-// TODO: Would be nice to skip the filename part (but without it it doesn't work)
-const DEFAULT_SCHEMA_PATH = getSchemasLocation('entities') + path.sep
-
 export class JsonSchemaPrompter<JsonResult> {
   schema: JSONSchema
   schemaPath: string
@@ -29,7 +23,7 @@ export class JsonSchemaPrompter<JsonResult> {
     schema: JSONSchema,
     defaults?: Partial<JsonResult>,
     customPrompts?: JsonSchemaCustomPrompts,
-    schemaPath: string = DEFAULT_SCHEMA_PATH
+    schemaPath = '.'
   ) {
     this.customPropmpts = customPrompts
     this.schema = schema

cli/src/helpers/display.ts

@@ -1,6 +1,6 @@
 import { cli, Table } from 'cli-ux'
 import chalk from 'chalk'
-import { NameValueObj } from '../Types'
+import { MemberDetails, NameValueObj } from '../Types'
 import { AccountId } from '@polkadot/types/interfaces'
 
 export function displayHeader(caption: string, placeholderSign = '_', size = 50) {
@@ -71,3 +71,7 @@ export function toFixedLength(text: string, length: number, spacesOnLeft = false
 export function shortAddress(address: AccountId | string): string {
   return address.toString().substr(0, 6) + '...' + address.toString().substr(-6)
 }
+
+export function memberHandle(member: MemberDetails): string {
+  return member.handle ? member.handle : member.membership.handle_hash.toHex().substr(0, 10) + '... (hash)'
+}

cli/src/helpers/validation.ts

@@ -4,12 +4,14 @@ import { decodeAddress } from '@polkadot/util-crypto'
 import { DeriveBalancesAll } from '@polkadot/api-derive/types'
 import { CLIError } from '@oclif/errors'
 
-export function validateAddress(address: string, errorMessage = 'Invalid address'): void {
+export function validateAddress(address: string, errorMessage = 'Invalid address'): string | true {
   try {
     decodeAddress(address)
   } catch (e) {
-    throw new CLIError(errorMessage, { exit: ExitCodes.InvalidInput })
+    return errorMessage
   }
+
+  return true
 }
 
 export function checkBalance(accBalances: DeriveBalancesAll, requiredBalance: BN): void {
@@ -17,3 +19,8 @@ export function checkBalance(accBalances: DeriveBalancesAll, requiredBalance: BN
     throw new CLIError('Not enough balance available', { exit: ExitCodes.InvalidInput })
   }
 }
+
+// We assume balance can be bigger than JavaScript integer
+export function isValidBalance(balance: string): boolean {
+  return /^[1-9][0-9]{0,38}$/.test(balance)
+}

cli/src/json-schemas/WorkingGroupOpening.schema.json

@@ -5,67 +5,36 @@
   "description": "JSON schema to describe Joystream working group opening",
   "type": "object",
   "additionalProperties": false,
-  "required": ["activateAt", "maxReviewPeriodLength"],
+  "required": ["stakingPolicy", "description"],
   "properties": {
-    "activateAt": {
-      "oneOf": [
-        {
-          "type": "object",
-          "additionalProperties": false,
-          "required": ["ExactBlock"],
-          "properties": {
-            "ExactBlock": {
-              "type": "integer",
-              "minimum": 1,
-              "description": "Exact block number"
-            }
-          }
-        },
-        {
-          "type": "object",
-          "additionalProperties": false,
-          "required": ["CurrentBlock"],
-          "properties": { "CurrentBlock": { "type": "null" } }
-        }
-      ]
-    },
-    "maxActiveApplicants": {
-      "type": "integer",
-      "description": "Max. number of active applicants",
-      "minimum": 1,
-      "default": 10
-    },
-    "maxReviewPeriodLength": {
+    "stakingPolicy": { "$ref": "#/definitions/StakingPolicy", "description": "Staking policy" },
+    "rewardPerBlock": {
       "type": "integer",
-      "description": "Max. review period length in blocks",
-      "minimum": 1,
-      "default": 432000
+      "description": "Reward per block",
+      "minimum": 1
     },
-    "applicationStake": { "$ref": "#/definitions/StakingPolicy", "description": "Application stake properties" },
-    "roleStake": { "$ref": "#/definitions/StakingPolicy", "description": "Role stake properties" },
-    "terminateRoleUnstakingPeriod": { "$ref": "#/definitions/UnstakingPeriod" },
-    "leaveRoleUnstakingPeriod": { "$ref": "#/definitions/UnstakingPeriod" }
+    "description": {
+      "type": "string",
+      "description": "Opening description",
+      "minLength": 1
+    }
   },
   "definitions": {
-    "UnstakingPeriod": {
-      "type": "integer",
-      "minimum": 1,
-      "default": 100800
-    },
     "StakingPolicy": {
       "type": "object",
       "additionalProperties": false,
-      "required": ["value", "mode"],
+      "required": ["amount", "unstakingPeriod"],
       "properties": {
-        "mode": {
-          "type": "string",
-          "description": "Application stake mode (Exact/AtLeast)",
-          "enum": ["Exact", "AtLeast"]
+        "amount": {
+          "type": "integer",
+          "description": "Stake amount",
+          "minimum": 2000
         },
-        "value": {
+        "unstakingPeriod": {
           "type": "integer",
-          "description": "Required stake value in JOY",
-          "minimum": 1
+          "description": "Unstaking period in blocks",
+          "exclusiveMinimum": 43200,
+          "maximum": 4294967295
         }
       }
     }

cli/src/json-schemas/typings/WorkingGroupOpening.schema.d.ts

@@ -5,56 +5,29 @@
  * and run json-schema-to-typescript to regenerate this file.
  */
 
-export type UnstakingPeriod = number
-
 /**
  * JSON schema to describe Joystream working group opening
  */
 export interface WorkingGroupOpening {
-  activateAt:
-    | {
-        /**
-         * Exact block number
-         */
-        ExactBlock: number
-      }
-    | {
-        CurrentBlock: null
-      }
-  /**
-   * Max. number of active applicants
-   */
-  maxActiveApplicants?: number
   /**
-   * Max. review period length in blocks
+   * Staking policy
    */
-  maxReviewPeriodLength: number
-  /**
-   * Application stake properties
-   */
-  applicationStake?: {
+  stakingPolicy: {
     /**
-     * Application stake mode (Exact/AtLeast)
+     * Stake amount
      */
-    mode: 'Exact' | 'AtLeast'
+    amount: number
     /**
-     * Required stake value in JOY
+     * Unstaking period in blocks
      */
-    value: number
+    unstakingPeriod: number
   }
   /**
-   * Role stake properties
+   * Reward per block
    */
-  roleStake?: {
-    /**
-     * Application stake mode (Exact/AtLeast)
-     */
-    mode: 'Exact' | 'AtLeast'
-    /**
-     * Required stake value in JOY
-     */
-    value: number
-  }
-  terminateRoleUnstakingPeriod?: UnstakingPeriod
-  leaveRoleUnstakingPeriod?: UnstakingPeriod
+  rewardPerBlock?: number
+  /**
+   * Opening description
+   */
+  description: string
 }

cli/tsconfig.json

@@ -13,11 +13,17 @@
     "baseUrl": ".",
     "paths": {
       "@polkadot/types/augment": ["../types/augment-codec/augment-types.ts"],
+      "@polkadot/api/augment": ["../types/augment-codec/augment-api.ts"]
     },
     "resolveJsonModule": true,
     "skipLibCheck": true
   },
   "include": [
     "src/**/*"
+  ],
+  /* Temporary exclude before merging `Sumer` */
+  "exclude": [
+    "src/commands/content-directory/*",
+    "src/commands/media/*"
   ]
 }

metadata-protobuf/compiled/proto/Council_pb.d.ts

@@ -0,0 +1,45 @@
+// package: 
+// file: proto/Council.proto
+
+import * as jspb from "google-protobuf";
+
+export class CouncilCandidacyNoteMetadata extends jspb.Message {
+  hasHeader(): boolean;
+  clearHeader(): void;
+  getHeader(): string | undefined;
+  setHeader(value: string): void;
+
+  clearBulletPointsList(): void;
+  getBulletPointsList(): Array<string>;
+  setBulletPointsList(value: Array<string>): void;
+  addBulletPoints(value: string, index?: number): string;
+
+  hasCoverImage(): boolean;
+  clearCoverImage(): void;
+  getCoverImage(): string | undefined;
+  setCoverImage(value: string): void;
+
+  hasDescription(): boolean;
+  clearDescription(): void;
+  getDescription(): string | undefined;
+  setDescription(value: string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): CouncilCandidacyNoteMetadata.AsObject;
+  static toObject(includeInstance: boolean, msg: CouncilCandidacyNoteMetadata): CouncilCandidacyNoteMetadata.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: CouncilCandidacyNoteMetadata, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CouncilCandidacyNoteMetadata;
+  static deserializeBinaryFromReader(message: CouncilCandidacyNoteMetadata, reader: jspb.BinaryReader): CouncilCandidacyNoteMetadata;
+}
+
+export namespace CouncilCandidacyNoteMetadata {
+  export type AsObject = {
+    header?: string,
+    bulletPointsList: Array<string>,
+    coverImage?: string,
+    description?: string,
+  }
+}
+

metadata-protobuf/compiled/proto/Council_pb.js

@@ -0,0 +1,340 @@
+// source: proto/Council.proto
+/**
+ * @fileoverview
+ * @enhanceable
+ * @suppress {missingRequire} reports error on implicit type usages.
+ * @suppress {messageConventions} JS Compiler reports an error if a variable or
+ *     field starts with 'MSG_' and isn't a translatable message.
+ * @public
+ */
+// GENERATED CODE -- DO NOT EDIT!
+/* eslint-disable */
+// @ts-nocheck
+
+var jspb = require('google-protobuf');
+var goog = jspb;
+var global = Function('return this')();
+
+goog.exportSymbol('proto.CouncilCandidacyNoteMetadata', null, global);
+/**
+ * Generated by JsPbCodeGenerator.
+ * @param {Array=} opt_data Optional initial data array, typically from a
+ * server response, or constructed directly in Javascript. The array is used
+ * in place and becomes part of the constructed object. It is not cloned.
+ * If no data is provided, the constructed object will be empty, but still
+ * valid.
+ * @extends {jspb.Message}
+ * @constructor
+ */
+proto.CouncilCandidacyNoteMetadata = function(opt_data) {
+  jspb.Message.initialize(this, opt_data, 0, -1, proto.CouncilCandidacyNoteMetadata.repeatedFields_, null);
+};
+goog.inherits(proto.CouncilCandidacyNoteMetadata, jspb.Message);
+if (goog.DEBUG && !COMPILED) {
+  /**
+   * @public
+   * @override
+   */
+  proto.CouncilCandidacyNoteMetadata.displayName = 'proto.CouncilCandidacyNoteMetadata';
+}
+
+/**
+ * List of repeated fields within this message type.
+ * @private {!Array<number>}
+ * @const
+ */
+proto.CouncilCandidacyNoteMetadata.repeatedFields_ = [2];
+
+
+
+if (jspb.Message.GENERATE_TO_OBJECT) {
+/**
+ * Creates an object representation of this proto.
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
+ * Optional fields that are not set will be set to undefined.
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
+ * For the list of reserved names please see:
+ *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
+ *     JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @return {!Object}
+ */
+proto.CouncilCandidacyNoteMetadata.prototype.toObject = function(opt_includeInstance) {
+  return proto.CouncilCandidacyNoteMetadata.toObject(opt_includeInstance, this);
+};
+
+
+/**
+ * Static version of the {@see toObject} method.
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
+ *     the JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @param {!proto.CouncilCandidacyNoteMetadata} msg The msg instance to transform.
+ * @return {!Object}
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.CouncilCandidacyNoteMetadata.toObject = function(includeInstance, msg) {
+  var f, obj = {
+    header: (f = jspb.Message.getField(msg, 1)) == null ? undefined : f,
+    bulletPointsList: (f = jspb.Message.getRepeatedField(msg, 2)) == null ? undefined : f,
+    coverImage: (f = jspb.Message.getField(msg, 3)) == null ? undefined : f,
+    description: (f = jspb.Message.getField(msg, 4)) == null ? undefined : f
+  };
+
+  if (includeInstance) {
+    obj.$jspbMessageInstance = msg;
+  }
+  return obj;
+};
+}
+
+
+/**
+ * Deserializes binary data (in protobuf wire format).
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
+ * @return {!proto.CouncilCandidacyNoteMetadata}
+ */
+proto.CouncilCandidacyNoteMetadata.deserializeBinary = function(bytes) {
+  var reader = new jspb.BinaryReader(bytes);
+  var msg = new proto.CouncilCandidacyNoteMetadata;
+  return proto.CouncilCandidacyNoteMetadata.deserializeBinaryFromReader(msg, reader);
+};
+
+
+/**
+ * Deserializes binary data (in protobuf wire format) from the
+ * given reader into the given message object.
+ * @param {!proto.CouncilCandidacyNoteMetadata} msg The message object to deserialize into.
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
+ * @return {!proto.CouncilCandidacyNoteMetadata}
+ */
+proto.CouncilCandidacyNoteMetadata.deserializeBinaryFromReader = function(msg, reader) {
+  while (reader.nextField()) {
+    if (reader.isEndGroup()) {
+      break;
+    }
+    var field = reader.getFieldNumber();
+    switch (field) {
+    case 1:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setHeader(value);
+      break;
+    case 2:
+      var value = /** @type {string} */ (reader.readString());
+      msg.addBulletPoints(value);
+      break;
+    case 3:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setCoverImage(value);
+      break;
+    case 4:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setDescription(value);
+      break;
+    default:
+      reader.skipField();
+      break;
+    }
+  }
+  return msg;
+};
+
+
+/**
+ * Serializes the message to binary data (in protobuf wire format).
+ * @return {!Uint8Array}
+ */
+proto.CouncilCandidacyNoteMetadata.prototype.serializeBinary = function() {
+  var writer = new jspb.BinaryWriter();
+  proto.CouncilCandidacyNoteMetadata.serializeBinaryToWriter(this, writer);
+  return writer.getResultBuffer();
+};
+
+
+/**
+ * Serializes the given message to binary data (in protobuf wire
+ * format), writing to the given BinaryWriter.
+ * @param {!proto.CouncilCandidacyNoteMetadata} message
+ * @param {!jspb.BinaryWriter} writer
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.CouncilCandidacyNoteMetadata.serializeBinaryToWriter = function(message, writer) {
+  var f = undefined;
+  f = /** @type {string} */ (jspb.Message.getField(message, 1));
+  if (f != null) {
+    writer.writeString(
+      1,
+      f
+    );
+  }
+  f = message.getBulletPointsList();
+  if (f.length > 0) {
+    writer.writeRepeatedString(
+      2,
+      f
+    );
+  }
+  f = /** @type {string} */ (jspb.Message.getField(message, 3));
+  if (f != null) {
+    writer.writeString(
+      3,
+      f
+    );
+  }
+  f = /** @type {string} */ (jspb.Message.getField(message, 4));
+  if (f != null) {
+    writer.writeString(
+      4,
+      f
+    );
+  }
+};
+
+
+/**
+ * optional string header = 1;
+ * @return {string}
+ */
+proto.CouncilCandidacyNoteMetadata.prototype.getHeader = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.CouncilCandidacyNoteMetadata} returns this
+ */
+proto.CouncilCandidacyNoteMetadata.prototype.setHeader = function(value) {
+  return jspb.Message.setField(this, 1, value);
+};
+
+
+/**
+ * Clears the field making it undefined.
+ * @return {!proto.CouncilCandidacyNoteMetadata} returns this
+ */
+proto.CouncilCandidacyNoteMetadata.prototype.clearHeader = function() {
+  return jspb.Message.setField(this, 1, undefined);
+};
+
+
+/**
+ * Returns whether this field is set.
+ * @return {boolean}
+ */
+proto.CouncilCandidacyNoteMetadata.prototype.hasHeader = function() {
+  return jspb.Message.getField(this, 1) != null;
+};
+
+
+/**
+ * repeated string bullet_points = 2;
+ * @return {!Array<string>}
+ */
+proto.CouncilCandidacyNoteMetadata.prototype.getBulletPointsList = function() {
+  return /** @type {!Array<string>} */ (jspb.Message.getRepeatedField(this, 2));
+};
+
+
+/**
+ * @param {!Array<string>} value
+ * @return {!proto.CouncilCandidacyNoteMetadata} returns this
+ */
+proto.CouncilCandidacyNoteMetadata.prototype.setBulletPointsList = function(value) {
+  return jspb.Message.setField(this, 2, value || []);
+};
+
+
+/**
+ * @param {string} value
+ * @param {number=} opt_index
+ * @return {!proto.CouncilCandidacyNoteMetadata} returns this
+ */
+proto.CouncilCandidacyNoteMetadata.prototype.addBulletPoints = function(value, opt_index) {
+  return jspb.Message.addToRepeatedField(this, 2, value, opt_index);
+};
+
+
+/**
+ * Clears the list making it empty but non-null.
+ * @return {!proto.CouncilCandidacyNoteMetadata} returns this
+ */
+proto.CouncilCandidacyNoteMetadata.prototype.clearBulletPointsList = function() {
+  return this.setBulletPointsList([]);
+};
+
+
+/**
+ * optional string cover_image = 3;
+ * @return {string}
+ */
+proto.CouncilCandidacyNoteMetadata.prototype.getCoverImage = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.CouncilCandidacyNoteMetadata} returns this
+ */
+proto.CouncilCandidacyNoteMetadata.prototype.setCoverImage = function(value) {
+  return jspb.Message.setField(this, 3, value);
+};
+
+
+/**
+ * Clears the field making it undefined.
+ * @return {!proto.CouncilCandidacyNoteMetadata} returns this
+ */
+proto.CouncilCandidacyNoteMetadata.prototype.clearCoverImage = function() {
+  return jspb.Message.setField(this, 3, undefined);
+};
+
+
+/**
+ * Returns whether this field is set.
+ * @return {boolean}
+ */
+proto.CouncilCandidacyNoteMetadata.prototype.hasCoverImage = function() {
+  return jspb.Message.getField(this, 3) != null;
+};
+
+
+/**
+ * optional string description = 4;
+ * @return {string}
+ */
+proto.CouncilCandidacyNoteMetadata.prototype.getDescription = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.CouncilCandidacyNoteMetadata} returns this
+ */
+proto.CouncilCandidacyNoteMetadata.prototype.setDescription = function(value) {
+  return jspb.Message.setField(this, 4, value);
+};
+
+
+/**
+ * Clears the field making it undefined.
+ * @return {!proto.CouncilCandidacyNoteMetadata} returns this
+ */
+proto.CouncilCandidacyNoteMetadata.prototype.clearDescription = function() {
+  return jspb.Message.setField(this, 4, undefined);
+};
+
+
+/**
+ * Returns whether this field is set.
+ * @return {boolean}
+ */
+proto.CouncilCandidacyNoteMetadata.prototype.hasDescription = function() {
+  return jspb.Message.getField(this, 4) != null;
+};
+
+
+goog.object.extend(exports, proto);

metadata-protobuf/compiled/proto/Membership_pb.d.ts

@@ -0,0 +1,39 @@
+// package: 
+// file: proto/Membership.proto
+
+import * as jspb from "google-protobuf";
+
+export class MembershipMetadata extends jspb.Message {
+  hasName(): boolean;
+  clearName(): void;
+  getName(): string | undefined;
+  setName(value: string): void;
+
+  hasAvatarUri(): boolean;
+  clearAvatarUri(): void;
+  getAvatarUri(): string | undefined;
+  setAvatarUri(value: string): void;
+
+  hasAbout(): boolean;
+  clearAbout(): void;
+  getAbout(): string | undefined;
+  setAbout(value: string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): MembershipMetadata.AsObject;
+  static toObject(includeInstance: boolean, msg: MembershipMetadata): MembershipMetadata.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: MembershipMetadata, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): MembershipMetadata;
+  static deserializeBinaryFromReader(message: MembershipMetadata, reader: jspb.BinaryReader): MembershipMetadata;
+}
+
+export namespace MembershipMetadata {
+  export type AsObject = {
+    name?: string,
+    avatarUri?: string,
+    about?: string,
+  }
+}
+

metadata-protobuf/compiled/proto/Membership_pb.js

@@ -0,0 +1,284 @@
+// source: proto/Membership.proto
+/**
+ * @fileoverview
+ * @enhanceable
+ * @suppress {missingRequire} reports error on implicit type usages.
+ * @suppress {messageConventions} JS Compiler reports an error if a variable or
+ *     field starts with 'MSG_' and isn't a translatable message.
+ * @public
+ */
+// GENERATED CODE -- DO NOT EDIT!
+/* eslint-disable */
+// @ts-nocheck
+
+var jspb = require('google-protobuf');
+var goog = jspb;
+var global = Function('return this')();
+
+goog.exportSymbol('proto.MembershipMetadata', null, global);
+/**
+ * Generated by JsPbCodeGenerator.
+ * @param {Array=} opt_data Optional initial data array, typically from a
+ * server response, or constructed directly in Javascript. The array is used
+ * in place and becomes part of the constructed object. It is not cloned.
+ * If no data is provided, the constructed object will be empty, but still
+ * valid.
+ * @extends {jspb.Message}
+ * @constructor
+ */
+proto.MembershipMetadata = function(opt_data) {
+  jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+};
+goog.inherits(proto.MembershipMetadata, jspb.Message);
+if (goog.DEBUG && !COMPILED) {
+  /**
+   * @public
+   * @override
+   */
+  proto.MembershipMetadata.displayName = 'proto.MembershipMetadata';
+}
+
+
+
+if (jspb.Message.GENERATE_TO_OBJECT) {
+/**
+ * Creates an object representation of this proto.
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
+ * Optional fields that are not set will be set to undefined.
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
+ * For the list of reserved names please see:
+ *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
+ *     JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @return {!Object}
+ */
+proto.MembershipMetadata.prototype.toObject = function(opt_includeInstance) {
+  return proto.MembershipMetadata.toObject(opt_includeInstance, this);
+};
+
+
+/**
+ * Static version of the {@see toObject} method.
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
+ *     the JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @param {!proto.MembershipMetadata} msg The msg instance to transform.
+ * @return {!Object}
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.MembershipMetadata.toObject = function(includeInstance, msg) {
+  var f, obj = {
+    name: (f = jspb.Message.getField(msg, 1)) == null ? undefined : f,
+    avatarUri: (f = jspb.Message.getField(msg, 2)) == null ? undefined : f,
+    about: (f = jspb.Message.getField(msg, 3)) == null ? undefined : f
+  };
+
+  if (includeInstance) {
+    obj.$jspbMessageInstance = msg;
+  }
+  return obj;
+};
+}
+
+
+/**
+ * Deserializes binary data (in protobuf wire format).
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
+ * @return {!proto.MembershipMetadata}
+ */
+proto.MembershipMetadata.deserializeBinary = function(bytes) {
+  var reader = new jspb.BinaryReader(bytes);
+  var msg = new proto.MembershipMetadata;
+  return proto.MembershipMetadata.deserializeBinaryFromReader(msg, reader);
+};
+
+
+/**
+ * Deserializes binary data (in protobuf wire format) from the
+ * given reader into the given message object.
+ * @param {!proto.MembershipMetadata} msg The message object to deserialize into.
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
+ * @return {!proto.MembershipMetadata}
+ */
+proto.MembershipMetadata.deserializeBinaryFromReader = function(msg, reader) {
+  while (reader.nextField()) {
+    if (reader.isEndGroup()) {
+      break;
+    }
+    var field = reader.getFieldNumber();
+    switch (field) {
+    case 1:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setName(value);
+      break;
+    case 2:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setAvatarUri(value);
+      break;
+    case 3:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setAbout(value);
+      break;
+    default:
+      reader.skipField();
+      break;
+    }
+  }
+  return msg;
+};
+
+
+/**
+ * Serializes the message to binary data (in protobuf wire format).
+ * @return {!Uint8Array}
+ */
+proto.MembershipMetadata.prototype.serializeBinary = function() {
+  var writer = new jspb.BinaryWriter();
+  proto.MembershipMetadata.serializeBinaryToWriter(this, writer);
+  return writer.getResultBuffer();
+};
+
+
+/**
+ * Serializes the given message to binary data (in protobuf wire
+ * format), writing to the given BinaryWriter.
+ * @param {!proto.MembershipMetadata} message
+ * @param {!jspb.BinaryWriter} writer
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.MembershipMetadata.serializeBinaryToWriter = function(message, writer) {
+  var f = undefined;
+  f = /** @type {string} */ (jspb.Message.getField(message, 1));
+  if (f != null) {
+    writer.writeString(
+      1,
+      f
+    );
+  }
+  f = /** @type {string} */ (jspb.Message.getField(message, 2));
+  if (f != null) {
+    writer.writeString(
+      2,
+      f
+    );
+  }
+  f = /** @type {string} */ (jspb.Message.getField(message, 3));
+  if (f != null) {
+    writer.writeString(
+      3,
+      f
+    );
+  }
+};
+
+
+/**
+ * optional string name = 1;
+ * @return {string}
+ */
+proto.MembershipMetadata.prototype.getName = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.MembershipMetadata} returns this
+ */
+proto.MembershipMetadata.prototype.setName = function(value) {
+  return jspb.Message.setField(this, 1, value);
+};
+
+
+/**
+ * Clears the field making it undefined.
+ * @return {!proto.MembershipMetadata} returns this
+ */
+proto.MembershipMetadata.prototype.clearName = function() {
+  return jspb.Message.setField(this, 1, undefined);
+};
+
+
+/**
+ * Returns whether this field is set.
+ * @return {boolean}
+ */
+proto.MembershipMetadata.prototype.hasName = function() {
+  return jspb.Message.getField(this, 1) != null;
+};
+
+
+/**
+ * optional string avatar_uri = 2;
+ * @return {string}
+ */
+proto.MembershipMetadata.prototype.getAvatarUri = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.MembershipMetadata} returns this
+ */
+proto.MembershipMetadata.prototype.setAvatarUri = function(value) {
+  return jspb.Message.setField(this, 2, value);
+};
+
+
+/**
+ * Clears the field making it undefined.
+ * @return {!proto.MembershipMetadata} returns this
+ */
+proto.MembershipMetadata.prototype.clearAvatarUri = function() {
+  return jspb.Message.setField(this, 2, undefined);
+};
+
+
+/**
+ * Returns whether this field is set.
+ * @return {boolean}
+ */
+proto.MembershipMetadata.prototype.hasAvatarUri = function() {
+  return jspb.Message.getField(this, 2) != null;
+};
+
+
+/**
+ * optional string about = 3;
+ * @return {string}
+ */
+proto.MembershipMetadata.prototype.getAbout = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.MembershipMetadata} returns this
+ */
+proto.MembershipMetadata.prototype.setAbout = function(value) {
+  return jspb.Message.setField(this, 3, value);
+};
+
+
+/**
+ * Clears the field making it undefined.
+ * @return {!proto.MembershipMetadata} returns this
+ */
+proto.MembershipMetadata.prototype.clearAbout = function() {
+  return jspb.Message.setField(this, 3, undefined);
+};
+
+
+/**
+ * Returns whether this field is set.
+ * @return {boolean}
+ */
+proto.MembershipMetadata.prototype.hasAbout = function() {
+  return jspb.Message.getField(this, 3) != null;
+};
+
+
+goog.object.extend(exports, proto);

metadata-protobuf/compiled/proto/WorkingGroups_pb.d.ts

@@ -0,0 +1,154 @@
+// package: 
+// file: proto/WorkingGroups.proto
+
+import * as jspb from "google-protobuf";
+
+export class OpeningMetadata extends jspb.Message {
+  hasShortDescription(): boolean;
+  clearShortDescription(): void;
+  getShortDescription(): string | undefined;
+  setShortDescription(value: string): void;
+
+  hasDescription(): boolean;
+  clearDescription(): void;
+  getDescription(): string | undefined;
+  setDescription(value: string): void;
+
+  hasHiringLimit(): boolean;
+  clearHiringLimit(): void;
+  getHiringLimit(): number | undefined;
+  setHiringLimit(value: number): void;
+
+  hasExpectedDuration(): boolean;
+  clearExpectedDuration(): void;
+  getExpectedDuration(): number | undefined;
+  setExpectedDuration(value: number): void;
+
+  hasApplicationDetails(): boolean;
+  clearApplicationDetails(): void;
+  getApplicationDetails(): string | undefined;
+  setApplicationDetails(value: string): void;
+
+  clearApplicationFormQuestionsList(): void;
+  getApplicationFormQuestionsList(): Array<OpeningMetadata.ApplicationFormQuestion>;
+  setApplicationFormQuestionsList(value: Array<OpeningMetadata.ApplicationFormQuestion>): void;
+  addApplicationFormQuestions(value?: OpeningMetadata.ApplicationFormQuestion, index?: number): OpeningMetadata.ApplicationFormQuestion;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): OpeningMetadata.AsObject;
+  static toObject(includeInstance: boolean, msg: OpeningMetadata): OpeningMetadata.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: OpeningMetadata, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): OpeningMetadata;
+  static deserializeBinaryFromReader(message: OpeningMetadata, reader: jspb.BinaryReader): OpeningMetadata;
+}
+
+export namespace OpeningMetadata {
+  export type AsObject = {
+    shortDescription?: string,
+    description?: string,
+    hiringLimit?: number,
+    expectedDuration?: number,
+    applicationDetails?: string,
+    applicationFormQuestionsList: Array<OpeningMetadata.ApplicationFormQuestion.AsObject>,
+  }
+
+  export class ApplicationFormQuestion extends jspb.Message {
+    hasQuestion(): boolean;
+    clearQuestion(): void;
+    getQuestion(): string | undefined;
+    setQuestion(value: string): void;
+
+    hasType(): boolean;
+    clearType(): void;
+    getType(): OpeningMetadata.ApplicationFormQuestion.InputTypeMap[keyof OpeningMetadata.ApplicationFormQuestion.InputTypeMap] | undefined;
+    setType(value: OpeningMetadata.ApplicationFormQuestion.InputTypeMap[keyof OpeningMetadata.ApplicationFormQuestion.InputTypeMap]): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): ApplicationFormQuestion.AsObject;
+    static toObject(includeInstance: boolean, msg: ApplicationFormQuestion): ApplicationFormQuestion.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: ApplicationFormQuestion, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): ApplicationFormQuestion;
+    static deserializeBinaryFromReader(message: ApplicationFormQuestion, reader: jspb.BinaryReader): ApplicationFormQuestion;
+  }
+
+  export namespace ApplicationFormQuestion {
+    export type AsObject = {
+      question?: string,
+      type?: OpeningMetadata.ApplicationFormQuestion.InputTypeMap[keyof OpeningMetadata.ApplicationFormQuestion.InputTypeMap],
+    }
+
+    export interface InputTypeMap {
+      TEXT: 1;
+      TEXTAREA: 2;
+    }
+
+    export const InputType: InputTypeMap;
+  }
+}
+
+export class ApplicationMetadata extends jspb.Message {
+  clearAnswersList(): void;
+  getAnswersList(): Array<string>;
+  setAnswersList(value: Array<string>): void;
+  addAnswers(value: string, index?: number): string;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ApplicationMetadata.AsObject;
+  static toObject(includeInstance: boolean, msg: ApplicationMetadata): ApplicationMetadata.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ApplicationMetadata, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ApplicationMetadata;
+  static deserializeBinaryFromReader(message: ApplicationMetadata, reader: jspb.BinaryReader): ApplicationMetadata;
+}
+
+export namespace ApplicationMetadata {
+  export type AsObject = {
+    answersList: Array<string>,
+  }
+}
+
+export class WorkingGroupStatusMetadata extends jspb.Message {
+  hasDescription(): boolean;
+  clearDescription(): void;
+  getDescription(): string | undefined;
+  setDescription(value: string): void;
+
+  hasAbout(): boolean;
+  clearAbout(): void;
+  getAbout(): string | undefined;
+  setAbout(value: string): void;
+
+  hasStatus(): boolean;
+  clearStatus(): void;
+  getStatus(): string | undefined;
+  setStatus(value: string): void;
+
+  hasStatusMessage(): boolean;
+  clearStatusMessage(): void;
+  getStatusMessage(): string | undefined;
+  setStatusMessage(value: string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): WorkingGroupStatusMetadata.AsObject;
+  static toObject(includeInstance: boolean, msg: WorkingGroupStatusMetadata): WorkingGroupStatusMetadata.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: WorkingGroupStatusMetadata, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): WorkingGroupStatusMetadata;
+  static deserializeBinaryFromReader(message: WorkingGroupStatusMetadata, reader: jspb.BinaryReader): WorkingGroupStatusMetadata;
+}
+
+export namespace WorkingGroupStatusMetadata {
+  export type AsObject = {
+    description?: string,
+    about?: string,
+    status?: string,
+    statusMessage?: string,
+  }
+}
+

metadata-protobuf/compiled/proto/WorkingGroups_pb.js

@@ -0,0 +1,1159 @@
+// source: proto/WorkingGroups.proto
+/**
+ * @fileoverview
+ * @enhanceable
+ * @suppress {missingRequire} reports error on implicit type usages.
+ * @suppress {messageConventions} JS Compiler reports an error if a variable or
+ *     field starts with 'MSG_' and isn't a translatable message.
+ * @public
+ */
+// GENERATED CODE -- DO NOT EDIT!
+/* eslint-disable */
+// @ts-nocheck
+
+var jspb = require('google-protobuf');
+var goog = jspb;
+var global = Function('return this')();
+
+goog.exportSymbol('proto.ApplicationMetadata', null, global);
+goog.exportSymbol('proto.OpeningMetadata', null, global);
+goog.exportSymbol('proto.OpeningMetadata.ApplicationFormQuestion', null, global);
+goog.exportSymbol('proto.OpeningMetadata.ApplicationFormQuestion.InputType', null, global);
+goog.exportSymbol('proto.WorkingGroupStatusMetadata', null, global);
+/**
+ * Generated by JsPbCodeGenerator.
+ * @param {Array=} opt_data Optional initial data array, typically from a
+ * server response, or constructed directly in Javascript. The array is used
+ * in place and becomes part of the constructed object. It is not cloned.
+ * If no data is provided, the constructed object will be empty, but still
+ * valid.
+ * @extends {jspb.Message}
+ * @constructor
+ */
+proto.OpeningMetadata = function(opt_data) {
+  jspb.Message.initialize(this, opt_data, 0, -1, proto.OpeningMetadata.repeatedFields_, null);
+};
+goog.inherits(proto.OpeningMetadata, jspb.Message);
+if (goog.DEBUG && !COMPILED) {
+  /**
+   * @public
+   * @override
+   */
+  proto.OpeningMetadata.displayName = 'proto.OpeningMetadata';
+}
+/**
+ * Generated by JsPbCodeGenerator.
+ * @param {Array=} opt_data Optional initial data array, typically from a
+ * server response, or constructed directly in Javascript. The array is used
+ * in place and becomes part of the constructed object. It is not cloned.
+ * If no data is provided, the constructed object will be empty, but still
+ * valid.
+ * @extends {jspb.Message}
+ * @constructor
+ */
+proto.OpeningMetadata.ApplicationFormQuestion = function(opt_data) {
+  jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+};
+goog.inherits(proto.OpeningMetadata.ApplicationFormQuestion, jspb.Message);
+if (goog.DEBUG && !COMPILED) {
+  /**
+   * @public
+   * @override
+   */
+  proto.OpeningMetadata.ApplicationFormQuestion.displayName = 'proto.OpeningMetadata.ApplicationFormQuestion';
+}
+/**
+ * Generated by JsPbCodeGenerator.
+ * @param {Array=} opt_data Optional initial data array, typically from a
+ * server response, or constructed directly in Javascript. The array is used
+ * in place and becomes part of the constructed object. It is not cloned.
+ * If no data is provided, the constructed object will be empty, but still
+ * valid.
+ * @extends {jspb.Message}
+ * @constructor
+ */
+proto.ApplicationMetadata = function(opt_data) {
+  jspb.Message.initialize(this, opt_data, 0, -1, proto.ApplicationMetadata.repeatedFields_, null);
+};
+goog.inherits(proto.ApplicationMetadata, jspb.Message);
+if (goog.DEBUG && !COMPILED) {
+  /**
+   * @public
+   * @override
+   */
+  proto.ApplicationMetadata.displayName = 'proto.ApplicationMetadata';
+}
+/**
+ * Generated by JsPbCodeGenerator.
+ * @param {Array=} opt_data Optional initial data array, typically from a
+ * server response, or constructed directly in Javascript. The array is used
+ * in place and becomes part of the constructed object. It is not cloned.
+ * If no data is provided, the constructed object will be empty, but still
+ * valid.
+ * @extends {jspb.Message}
+ * @constructor
+ */
+proto.WorkingGroupStatusMetadata = function(opt_data) {
+  jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+};
+goog.inherits(proto.WorkingGroupStatusMetadata, jspb.Message);
+if (goog.DEBUG && !COMPILED) {
+  /**
+   * @public
+   * @override
+   */
+  proto.WorkingGroupStatusMetadata.displayName = 'proto.WorkingGroupStatusMetadata';
+}
+
+/**
+ * List of repeated fields within this message type.
+ * @private {!Array<number>}
+ * @const
+ */
+proto.OpeningMetadata.repeatedFields_ = [6];
+
+
+
+if (jspb.Message.GENERATE_TO_OBJECT) {
+/**
+ * Creates an object representation of this proto.
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
+ * Optional fields that are not set will be set to undefined.
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
+ * For the list of reserved names please see:
+ *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
+ *     JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @return {!Object}
+ */
+proto.OpeningMetadata.prototype.toObject = function(opt_includeInstance) {
+  return proto.OpeningMetadata.toObject(opt_includeInstance, this);
+};
+
+
+/**
+ * Static version of the {@see toObject} method.
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
+ *     the JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @param {!proto.OpeningMetadata} msg The msg instance to transform.
+ * @return {!Object}
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.OpeningMetadata.toObject = function(includeInstance, msg) {
+  var f, obj = {
+    shortDescription: (f = jspb.Message.getField(msg, 1)) == null ? undefined : f,
+    description: (f = jspb.Message.getField(msg, 2)) == null ? undefined : f,
+    hiringLimit: (f = jspb.Message.getField(msg, 3)) == null ? undefined : f,
+    expectedDuration: (f = jspb.Message.getField(msg, 4)) == null ? undefined : f,
+    applicationDetails: (f = jspb.Message.getField(msg, 5)) == null ? undefined : f,
+    applicationFormQuestionsList: jspb.Message.toObjectList(msg.getApplicationFormQuestionsList(),
+    proto.OpeningMetadata.ApplicationFormQuestion.toObject, includeInstance)
+  };
+
+  if (includeInstance) {
+    obj.$jspbMessageInstance = msg;
+  }
+  return obj;
+};
+}
+
+
+/**
+ * Deserializes binary data (in protobuf wire format).
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
+ * @return {!proto.OpeningMetadata}
+ */
+proto.OpeningMetadata.deserializeBinary = function(bytes) {
+  var reader = new jspb.BinaryReader(bytes);
+  var msg = new proto.OpeningMetadata;
+  return proto.OpeningMetadata.deserializeBinaryFromReader(msg, reader);
+};
+
+
+/**
+ * Deserializes binary data (in protobuf wire format) from the
+ * given reader into the given message object.
+ * @param {!proto.OpeningMetadata} msg The message object to deserialize into.
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
+ * @return {!proto.OpeningMetadata}
+ */
+proto.OpeningMetadata.deserializeBinaryFromReader = function(msg, reader) {
+  while (reader.nextField()) {
+    if (reader.isEndGroup()) {
+      break;
+    }
+    var field = reader.getFieldNumber();
+    switch (field) {
+    case 1:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setShortDescription(value);
+      break;
+    case 2:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setDescription(value);
+      break;
+    case 3:
+      var value = /** @type {number} */ (reader.readUint32());
+      msg.setHiringLimit(value);
+      break;
+    case 4:
+      var value = /** @type {number} */ (reader.readUint32());
+      msg.setExpectedDuration(value);
+      break;
+    case 5:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setApplicationDetails(value);
+      break;
+    case 6:
+      var value = new proto.OpeningMetadata.ApplicationFormQuestion;
+      reader.readMessage(value,proto.OpeningMetadata.ApplicationFormQuestion.deserializeBinaryFromReader);
+      msg.addApplicationFormQuestions(value);
+      break;
+    default:
+      reader.skipField();
+      break;
+    }
+  }
+  return msg;
+};
+
+
+/**
+ * Serializes the message to binary data (in protobuf wire format).
+ * @return {!Uint8Array}
+ */
+proto.OpeningMetadata.prototype.serializeBinary = function() {
+  var writer = new jspb.BinaryWriter();
+  proto.OpeningMetadata.serializeBinaryToWriter(this, writer);
+  return writer.getResultBuffer();
+};
+
+
+/**
+ * Serializes the given message to binary data (in protobuf wire
+ * format), writing to the given BinaryWriter.
+ * @param {!proto.OpeningMetadata} message
+ * @param {!jspb.BinaryWriter} writer
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.OpeningMetadata.serializeBinaryToWriter = function(message, writer) {
+  var f = undefined;
+  f = /** @type {string} */ (jspb.Message.getField(message, 1));
+  if (f != null) {
+    writer.writeString(
+      1,
+      f
+    );
+  }
+  f = /** @type {string} */ (jspb.Message.getField(message, 2));
+  if (f != null) {
+    writer.writeString(
+      2,
+      f
+    );
+  }
+  f = /** @type {number} */ (jspb.Message.getField(message, 3));
+  if (f != null) {
+    writer.writeUint32(
+      3,
+      f
+    );
+  }
+  f = /** @type {number} */ (jspb.Message.getField(message, 4));
+  if (f != null) {
+    writer.writeUint32(
+      4,
+      f
+    );
+  }
+  f = /** @type {string} */ (jspb.Message.getField(message, 5));
+  if (f != null) {
+    writer.writeString(
+      5,
+      f
+    );
+  }
+  f = message.getApplicationFormQuestionsList();
+  if (f.length > 0) {
+    writer.writeRepeatedMessage(
+      6,
+      f,
+      proto.OpeningMetadata.ApplicationFormQuestion.serializeBinaryToWriter
+    );
+  }
+};
+
+
+
+
+
+if (jspb.Message.GENERATE_TO_OBJECT) {
+/**
+ * Creates an object representation of this proto.
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
+ * Optional fields that are not set will be set to undefined.
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
+ * For the list of reserved names please see:
+ *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
+ *     JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @return {!Object}
+ */
+proto.OpeningMetadata.ApplicationFormQuestion.prototype.toObject = function(opt_includeInstance) {
+  return proto.OpeningMetadata.ApplicationFormQuestion.toObject(opt_includeInstance, this);
+};
+
+
+/**
+ * Static version of the {@see toObject} method.
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
+ *     the JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @param {!proto.OpeningMetadata.ApplicationFormQuestion} msg The msg instance to transform.
+ * @return {!Object}
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.OpeningMetadata.ApplicationFormQuestion.toObject = function(includeInstance, msg) {
+  var f, obj = {
+    question: (f = jspb.Message.getField(msg, 1)) == null ? undefined : f,
+    type: (f = jspb.Message.getField(msg, 2)) == null ? undefined : f
+  };
+
+  if (includeInstance) {
+    obj.$jspbMessageInstance = msg;
+  }
+  return obj;
+};
+}
+
+
+/**
+ * Deserializes binary data (in protobuf wire format).
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
+ * @return {!proto.OpeningMetadata.ApplicationFormQuestion}
+ */
+proto.OpeningMetadata.ApplicationFormQuestion.deserializeBinary = function(bytes) {
+  var reader = new jspb.BinaryReader(bytes);
+  var msg = new proto.OpeningMetadata.ApplicationFormQuestion;
+  return proto.OpeningMetadata.ApplicationFormQuestion.deserializeBinaryFromReader(msg, reader);
+};
+
+
+/**
+ * Deserializes binary data (in protobuf wire format) from the
+ * given reader into the given message object.
+ * @param {!proto.OpeningMetadata.ApplicationFormQuestion} msg The message object to deserialize into.
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
+ * @return {!proto.OpeningMetadata.ApplicationFormQuestion}
+ */
+proto.OpeningMetadata.ApplicationFormQuestion.deserializeBinaryFromReader = function(msg, reader) {
+  while (reader.nextField()) {
+    if (reader.isEndGroup()) {
+      break;
+    }
+    var field = reader.getFieldNumber();
+    switch (field) {
+    case 1:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setQuestion(value);
+      break;
+    case 2:
+      var value = /** @type {!proto.OpeningMetadata.ApplicationFormQuestion.InputType} */ (reader.readEnum());
+      msg.setType(value);
+      break;
+    default:
+      reader.skipField();
+      break;
+    }
+  }
+  return msg;
+};
+
+
+/**
+ * Serializes the message to binary data (in protobuf wire format).
+ * @return {!Uint8Array}
+ */
+proto.OpeningMetadata.ApplicationFormQuestion.prototype.serializeBinary = function() {
+  var writer = new jspb.BinaryWriter();
+  proto.OpeningMetadata.ApplicationFormQuestion.serializeBinaryToWriter(this, writer);
+  return writer.getResultBuffer();
+};
+
+
+/**
+ * Serializes the given message to binary data (in protobuf wire
+ * format), writing to the given BinaryWriter.
+ * @param {!proto.OpeningMetadata.ApplicationFormQuestion} message
+ * @param {!jspb.BinaryWriter} writer
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.OpeningMetadata.ApplicationFormQuestion.serializeBinaryToWriter = function(message, writer) {
+  var f = undefined;
+  f = /** @type {string} */ (jspb.Message.getField(message, 1));
+  if (f != null) {
+    writer.writeString(
+      1,
+      f
+    );
+  }
+  f = /** @type {!proto.OpeningMetadata.ApplicationFormQuestion.InputType} */ (jspb.Message.getField(message, 2));
+  if (f != null) {
+    writer.writeEnum(
+      2,
+      f
+    );
+  }
+};
+
+
+/**
+ * @enum {number}
+ */
+proto.OpeningMetadata.ApplicationFormQuestion.InputType = {
+  TEXT: 1,
+  TEXTAREA: 2
+};
+
+/**
+ * required string question = 1;
+ * @return {string}
+ */
+proto.OpeningMetadata.ApplicationFormQuestion.prototype.getQuestion = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.OpeningMetadata.ApplicationFormQuestion} returns this
+ */
+proto.OpeningMetadata.ApplicationFormQuestion.prototype.setQuestion = function(value) {
+  return jspb.Message.setField(this, 1, value);
+};
+
+
+/**
+ * Clears the field making it undefined.
+ * @return {!proto.OpeningMetadata.ApplicationFormQuestion} returns this
+ */
+proto.OpeningMetadata.ApplicationFormQuestion.prototype.clearQuestion = function() {
+  return jspb.Message.setField(this, 1, undefined);
+};
+
+
+/**
+ * Returns whether this field is set.
+ * @return {boolean}
+ */
+proto.OpeningMetadata.ApplicationFormQuestion.prototype.hasQuestion = function() {
+  return jspb.Message.getField(this, 1) != null;
+};
+
+
+/**
+ * required InputType type = 2;
+ * @return {!proto.OpeningMetadata.ApplicationFormQuestion.InputType}
+ */
+proto.OpeningMetadata.ApplicationFormQuestion.prototype.getType = function() {
+  return /** @type {!proto.OpeningMetadata.ApplicationFormQuestion.InputType} */ (jspb.Message.getFieldWithDefault(this, 2, 1));
+};
+
+
+/**
+ * @param {!proto.OpeningMetadata.ApplicationFormQuestion.InputType} value
+ * @return {!proto.OpeningMetadata.ApplicationFormQuestion} returns this
+ */
+proto.OpeningMetadata.ApplicationFormQuestion.prototype.setType = function(value) {
+  return jspb.Message.setField(this, 2, value);
+};
+
+
+/**
+ * Clears the field making it undefined.
+ * @return {!proto.OpeningMetadata.ApplicationFormQuestion} returns this
+ */
+proto.OpeningMetadata.ApplicationFormQuestion.prototype.clearType = function() {
+  return jspb.Message.setField(this, 2, undefined);
+};
+
+
+/**
+ * Returns whether this field is set.
+ * @return {boolean}
+ */
+proto.OpeningMetadata.ApplicationFormQuestion.prototype.hasType = function() {
+  return jspb.Message.getField(this, 2) != null;
+};
+
+
+/**
+ * required string short_description = 1;
+ * @return {string}
+ */
+proto.OpeningMetadata.prototype.getShortDescription = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.OpeningMetadata} returns this
+ */
+proto.OpeningMetadata.prototype.setShortDescription = function(value) {
+  return jspb.Message.setField(this, 1, value);
+};
+
+
+/**
+ * Clears the field making it undefined.
+ * @return {!proto.OpeningMetadata} returns this
+ */
+proto.OpeningMetadata.prototype.clearShortDescription = function() {
+  return jspb.Message.setField(this, 1, undefined);
+};
+
+
+/**
+ * Returns whether this field is set.
+ * @return {boolean}
+ */
+proto.OpeningMetadata.prototype.hasShortDescription = function() {
+  return jspb.Message.getField(this, 1) != null;
+};
+
+
+/**
+ * required string description = 2;
+ * @return {string}
+ */
+proto.OpeningMetadata.prototype.getDescription = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.OpeningMetadata} returns this
+ */
+proto.OpeningMetadata.prototype.setDescription = function(value) {
+  return jspb.Message.setField(this, 2, value);
+};
+
+
+/**
+ * Clears the field making it undefined.
+ * @return {!proto.OpeningMetadata} returns this
+ */
+proto.OpeningMetadata.prototype.clearDescription = function() {
+  return jspb.Message.setField(this, 2, undefined);
+};
+
+
+/**
+ * Returns whether this field is set.
+ * @return {boolean}
+ */
+proto.OpeningMetadata.prototype.hasDescription = function() {
+  return jspb.Message.getField(this, 2) != null;
+};
+
+
+/**
+ * required uint32 hiring_limit = 3;
+ * @return {number}
+ */
+proto.OpeningMetadata.prototype.getHiringLimit = function() {
+  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0));
+};
+
+
+/**
+ * @param {number} value
+ * @return {!proto.OpeningMetadata} returns this
+ */
+proto.OpeningMetadata.prototype.setHiringLimit = function(value) {
+  return jspb.Message.setField(this, 3, value);
+};
+
+
+/**
+ * Clears the field making it undefined.
+ * @return {!proto.OpeningMetadata} returns this
+ */
+proto.OpeningMetadata.prototype.clearHiringLimit = function() {
+  return jspb.Message.setField(this, 3, undefined);
+};
+
+
+/**
+ * Returns whether this field is set.
+ * @return {boolean}
+ */
+proto.OpeningMetadata.prototype.hasHiringLimit = function() {
+  return jspb.Message.getField(this, 3) != null;
+};
+
+
+/**
+ * required uint32 expected_duration = 4;
+ * @return {number}
+ */
+proto.OpeningMetadata.prototype.getExpectedDuration = function() {
+  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0));
+};
+
+
+/**
+ * @param {number} value
+ * @return {!proto.OpeningMetadata} returns this
+ */
+proto.OpeningMetadata.prototype.setExpectedDuration = function(value) {
+  return jspb.Message.setField(this, 4, value);
+};
+
+
+/**
+ * Clears the field making it undefined.
+ * @return {!proto.OpeningMetadata} returns this
+ */
+proto.OpeningMetadata.prototype.clearExpectedDuration = function() {
+  return jspb.Message.setField(this, 4, undefined);
+};
+
+
+/**
+ * Returns whether this field is set.
+ * @return {boolean}
+ */
+proto.OpeningMetadata.prototype.hasExpectedDuration = function() {
+  return jspb.Message.getField(this, 4) != null;
+};
+
+
+/**
+ * required string application_details = 5;
+ * @return {string}
+ */
+proto.OpeningMetadata.prototype.getApplicationDetails = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 5, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.OpeningMetadata} returns this
+ */
+proto.OpeningMetadata.prototype.setApplicationDetails = function(value) {
+  return jspb.Message.setField(this, 5, value);
+};
+
+
+/**
+ * Clears the field making it undefined.
+ * @return {!proto.OpeningMetadata} returns this
+ */
+proto.OpeningMetadata.prototype.clearApplicationDetails = function() {
+  return jspb.Message.setField(this, 5, undefined);
+};
+
+
+/**
+ * Returns whether this field is set.
+ * @return {boolean}
+ */
+proto.OpeningMetadata.prototype.hasApplicationDetails = function() {
+  return jspb.Message.getField(this, 5) != null;
+};
+
+
+/**
+ * repeated ApplicationFormQuestion application_form_questions = 6;
+ * @return {!Array<!proto.OpeningMetadata.ApplicationFormQuestion>}
+ */
+proto.OpeningMetadata.prototype.getApplicationFormQuestionsList = function() {
+  return /** @type{!Array<!proto.OpeningMetadata.ApplicationFormQuestion>} */ (
+    jspb.Message.getRepeatedWrapperField(this, proto.OpeningMetadata.ApplicationFormQuestion, 6));
+};
+
+
+/**
+ * @param {!Array<!proto.OpeningMetadata.ApplicationFormQuestion>} value
+ * @return {!proto.OpeningMetadata} returns this
+*/
+proto.OpeningMetadata.prototype.setApplicationFormQuestionsList = function(value) {
+  return jspb.Message.setRepeatedWrapperField(this, 6, value);
+};
+
+
+/**
+ * @param {!proto.OpeningMetadata.ApplicationFormQuestion=} opt_value
+ * @param {number=} opt_index
+ * @return {!proto.OpeningMetadata.ApplicationFormQuestion}
+ */
+proto.OpeningMetadata.prototype.addApplicationFormQuestions = function(opt_value, opt_index) {
+  return jspb.Message.addToRepeatedWrapperField(this, 6, opt_value, proto.OpeningMetadata.ApplicationFormQuestion, opt_index);
+};
+
+
+/**
+ * Clears the list making it empty but non-null.
+ * @return {!proto.OpeningMetadata} returns this
+ */
+proto.OpeningMetadata.prototype.clearApplicationFormQuestionsList = function() {
+  return this.setApplicationFormQuestionsList([]);
+};
+
+
+
+/**
+ * List of repeated fields within this message type.
+ * @private {!Array<number>}
+ * @const
+ */
+proto.ApplicationMetadata.repeatedFields_ = [1];
+
+
+
+if (jspb.Message.GENERATE_TO_OBJECT) {
+/**
+ * Creates an object representation of this proto.
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
+ * Optional fields that are not set will be set to undefined.
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
+ * For the list of reserved names please see:
+ *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
+ *     JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @return {!Object}
+ */
+proto.ApplicationMetadata.prototype.toObject = function(opt_includeInstance) {
+  return proto.ApplicationMetadata.toObject(opt_includeInstance, this);
+};
+
+
+/**
+ * Static version of the {@see toObject} method.
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
+ *     the JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @param {!proto.ApplicationMetadata} msg The msg instance to transform.
+ * @return {!Object}
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.ApplicationMetadata.toObject = function(includeInstance, msg) {
+  var f, obj = {
+    answersList: (f = jspb.Message.getRepeatedField(msg, 1)) == null ? undefined : f
+  };
+
+  if (includeInstance) {
+    obj.$jspbMessageInstance = msg;
+  }
+  return obj;
+};
+}
+
+
+/**
+ * Deserializes binary data (in protobuf wire format).
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
+ * @return {!proto.ApplicationMetadata}
+ */
+proto.ApplicationMetadata.deserializeBinary = function(bytes) {
+  var reader = new jspb.BinaryReader(bytes);
+  var msg = new proto.ApplicationMetadata;
+  return proto.ApplicationMetadata.deserializeBinaryFromReader(msg, reader);
+};
+
+
+/**
+ * Deserializes binary data (in protobuf wire format) from the
+ * given reader into the given message object.
+ * @param {!proto.ApplicationMetadata} msg The message object to deserialize into.
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
+ * @return {!proto.ApplicationMetadata}
+ */
+proto.ApplicationMetadata.deserializeBinaryFromReader = function(msg, reader) {
+  while (reader.nextField()) {
+    if (reader.isEndGroup()) {
+      break;
+    }
+    var field = reader.getFieldNumber();
+    switch (field) {
+    case 1:
+      var value = /** @type {string} */ (reader.readString());
+      msg.addAnswers(value);
+      break;
+    default:
+      reader.skipField();
+      break;
+    }
+  }
+  return msg;
+};
+
+
+/**
+ * Serializes the message to binary data (in protobuf wire format).
+ * @return {!Uint8Array}
+ */
+proto.ApplicationMetadata.prototype.serializeBinary = function() {
+  var writer = new jspb.BinaryWriter();
+  proto.ApplicationMetadata.serializeBinaryToWriter(this, writer);
+  return writer.getResultBuffer();
+};
+
+
+/**
+ * Serializes the given message to binary data (in protobuf wire
+ * format), writing to the given BinaryWriter.
+ * @param {!proto.ApplicationMetadata} message
+ * @param {!jspb.BinaryWriter} writer
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.ApplicationMetadata.serializeBinaryToWriter = function(message, writer) {
+  var f = undefined;
+  f = message.getAnswersList();
+  if (f.length > 0) {
+    writer.writeRepeatedString(
+      1,
+      f
+    );
+  }
+};
+
+
+/**
+ * repeated string answers = 1;
+ * @return {!Array<string>}
+ */
+proto.ApplicationMetadata.prototype.getAnswersList = function() {
+  return /** @type {!Array<string>} */ (jspb.Message.getRepeatedField(this, 1));
+};
+
+
+/**
+ * @param {!Array<string>} value
+ * @return {!proto.ApplicationMetadata} returns this
+ */
+proto.ApplicationMetadata.prototype.setAnswersList = function(value) {
+  return jspb.Message.setField(this, 1, value || []);
+};
+
+
+/**
+ * @param {string} value
+ * @param {number=} opt_index
+ * @return {!proto.ApplicationMetadata} returns this
+ */
+proto.ApplicationMetadata.prototype.addAnswers = function(value, opt_index) {
+  return jspb.Message.addToRepeatedField(this, 1, value, opt_index);
+};
+
+
+/**
+ * Clears the list making it empty but non-null.
+ * @return {!proto.ApplicationMetadata} returns this
+ */
+proto.ApplicationMetadata.prototype.clearAnswersList = function() {
+  return this.setAnswersList([]);
+};
+
+
+
+
+
+if (jspb.Message.GENERATE_TO_OBJECT) {
+/**
+ * Creates an object representation of this proto.
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
+ * Optional fields that are not set will be set to undefined.
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
+ * For the list of reserved names please see:
+ *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
+ *     JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @return {!Object}
+ */
+proto.WorkingGroupStatusMetadata.prototype.toObject = function(opt_includeInstance) {
+  return proto.WorkingGroupStatusMetadata.toObject(opt_includeInstance, this);
+};
+
+
+/**
+ * Static version of the {@see toObject} method.
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
+ *     the JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @param {!proto.WorkingGroupStatusMetadata} msg The msg instance to transform.
+ * @return {!Object}
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.WorkingGroupStatusMetadata.toObject = function(includeInstance, msg) {
+  var f, obj = {
+    description: (f = jspb.Message.getField(msg, 1)) == null ? undefined : f,
+    about: (f = jspb.Message.getField(msg, 2)) == null ? undefined : f,
+    status: (f = jspb.Message.getField(msg, 3)) == null ? undefined : f,
+    statusMessage: (f = jspb.Message.getField(msg, 4)) == null ? undefined : f
+  };
+
+  if (includeInstance) {
+    obj.$jspbMessageInstance = msg;
+  }
+  return obj;
+};
+}
+
+
+/**
+ * Deserializes binary data (in protobuf wire format).
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
+ * @return {!proto.WorkingGroupStatusMetadata}
+ */
+proto.WorkingGroupStatusMetadata.deserializeBinary = function(bytes) {
+  var reader = new jspb.BinaryReader(bytes);
+  var msg = new proto.WorkingGroupStatusMetadata;
+  return proto.WorkingGroupStatusMetadata.deserializeBinaryFromReader(msg, reader);
+};
+
+
+/**
+ * Deserializes binary data (in protobuf wire format) from the
+ * given reader into the given message object.
+ * @param {!proto.WorkingGroupStatusMetadata} msg The message object to deserialize into.
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
+ * @return {!proto.WorkingGroupStatusMetadata}
+ */
+proto.WorkingGroupStatusMetadata.deserializeBinaryFromReader = function(msg, reader) {
+  while (reader.nextField()) {
+    if (reader.isEndGroup()) {
+      break;
+    }
+    var field = reader.getFieldNumber();
+    switch (field) {
+    case 1:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setDescription(value);
+      break;
+    case 2:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setAbout(value);
+      break;
+    case 3:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setStatus(value);
+      break;
+    case 4:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setStatusMessage(value);
+      break;
+    default:
+      reader.skipField();
+      break;
+    }
+  }
+  return msg;
+};
+
+
+/**
+ * Serializes the message to binary data (in protobuf wire format).
+ * @return {!Uint8Array}
+ */
+proto.WorkingGroupStatusMetadata.prototype.serializeBinary = function() {
+  var writer = new jspb.BinaryWriter();
+  proto.WorkingGroupStatusMetadata.serializeBinaryToWriter(this, writer);
+  return writer.getResultBuffer();
+};
+
+
+/**
+ * Serializes the given message to binary data (in protobuf wire
+ * format), writing to the given BinaryWriter.
+ * @param {!proto.WorkingGroupStatusMetadata} message
+ * @param {!jspb.BinaryWriter} writer
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.WorkingGroupStatusMetadata.serializeBinaryToWriter = function(message, writer) {
+  var f = undefined;
+  f = /** @type {string} */ (jspb.Message.getField(message, 1));
+  if (f != null) {
+    writer.writeString(
+      1,
+      f
+    );
+  }
+  f = /** @type {string} */ (jspb.Message.getField(message, 2));
+  if (f != null) {
+    writer.writeString(
+      2,
+      f
+    );
+  }
+  f = /** @type {string} */ (jspb.Message.getField(message, 3));
+  if (f != null) {
+    writer.writeString(
+      3,
+      f
+    );
+  }
+  f = /** @type {string} */ (jspb.Message.getField(message, 4));
+  if (f != null) {
+    writer.writeString(
+      4,
+      f
+    );
+  }
+};
+
+
+/**
+ * optional string description = 1;
+ * @return {string}
+ */
+proto.WorkingGroupStatusMetadata.prototype.getDescription = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.WorkingGroupStatusMetadata} returns this
+ */
+proto.WorkingGroupStatusMetadata.prototype.setDescription = function(value) {
+  return jspb.Message.setField(this, 1, value);
+};
+
+
+/**
+ * Clears the field making it undefined.
+ * @return {!proto.WorkingGroupStatusMetadata} returns this
+ */
+proto.WorkingGroupStatusMetadata.prototype.clearDescription = function() {
+  return jspb.Message.setField(this, 1, undefined);
+};
+
+
+/**
+ * Returns whether this field is set.
+ * @return {boolean}
+ */
+proto.WorkingGroupStatusMetadata.prototype.hasDescription = function() {
+  return jspb.Message.getField(this, 1) != null;
+};
+
+
+/**
+ * optional string about = 2;
+ * @return {string}
+ */
+proto.WorkingGroupStatusMetadata.prototype.getAbout = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.WorkingGroupStatusMetadata} returns this
+ */
+proto.WorkingGroupStatusMetadata.prototype.setAbout = function(value) {
+  return jspb.Message.setField(this, 2, value);
+};
+
+
+/**
+ * Clears the field making it undefined.
+ * @return {!proto.WorkingGroupStatusMetadata} returns this
+ */
+proto.WorkingGroupStatusMetadata.prototype.clearAbout = function() {
+  return jspb.Message.setField(this, 2, undefined);
+};
+
+
+/**
+ * Returns whether this field is set.
+ * @return {boolean}
+ */
+proto.WorkingGroupStatusMetadata.prototype.hasAbout = function() {
+  return jspb.Message.getField(this, 2) != null;
+};
+
+
+/**
+ * optional string status = 3;
+ * @return {string}
+ */
+proto.WorkingGroupStatusMetadata.prototype.getStatus = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.WorkingGroupStatusMetadata} returns this
+ */
+proto.WorkingGroupStatusMetadata.prototype.setStatus = function(value) {
+  return jspb.Message.setField(this, 3, value);
+};
+
+
+/**
+ * Clears the field making it undefined.
+ * @return {!proto.WorkingGroupStatusMetadata} returns this
+ */
+proto.WorkingGroupStatusMetadata.prototype.clearStatus = function() {
+  return jspb.Message.setField(this, 3, undefined);
+};
+
+
+/**
+ * Returns whether this field is set.
+ * @return {boolean}
+ */
+proto.WorkingGroupStatusMetadata.prototype.hasStatus = function() {
+  return jspb.Message.getField(this, 3) != null;
+};
+
+
+/**
+ * optional string status_message = 4;
+ * @return {string}
+ */
+proto.WorkingGroupStatusMetadata.prototype.getStatusMessage = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.WorkingGroupStatusMetadata} returns this
+ */
+proto.WorkingGroupStatusMetadata.prototype.setStatusMessage = function(value) {
+  return jspb.Message.setField(this, 4, value);
+};
+
+
+/**
+ * Clears the field making it undefined.
+ * @return {!proto.WorkingGroupStatusMetadata} returns this
+ */
+proto.WorkingGroupStatusMetadata.prototype.clearStatusMessage = function() {
+  return jspb.Message.setField(this, 4, undefined);
+};
+
+
+/**
+ * Returns whether this field is set.
+ * @return {boolean}
+ */
+proto.WorkingGroupStatusMetadata.prototype.hasStatusMessage = function() {
+  return jspb.Message.getField(this, 4) != null;
+};
+
+
+goog.object.extend(exports, proto);

tests/integration-tests/src/QueryNodeApiSchema.generated.ts

@@ -0,0 +1,636 @@
+export type Maybe<T> = T | null
+export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] }
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> }
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> }
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+  ID: string
+  String: string
+  Boolean: boolean
+  Int: number
+  Float: number
+  /** The javascript `Date` as string. Type represents date and time as the ISO Date string. */
+  DateTime: any
+  /** GraphQL representation of BigInt */
+  BigInt: any
+}
+
+export type BaseGraphQlObject = {
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+}
+
+export type BaseModel = BaseGraphQlObject & {
+  __typename?: 'BaseModel'
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+}
+
+export type BaseModelUuid = BaseGraphQlObject & {
+  __typename?: 'BaseModelUUID'
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+}
+
+export type BaseWhereInput = {
+  id_eq?: Maybe<Scalars['String']>
+  id_in?: Maybe<Array<Scalars['String']>>
+  createdAt_eq?: Maybe<Scalars['String']>
+  createdAt_lt?: Maybe<Scalars['String']>
+  createdAt_lte?: Maybe<Scalars['String']>
+  createdAt_gt?: Maybe<Scalars['String']>
+  createdAt_gte?: Maybe<Scalars['String']>
+  createdById_eq?: Maybe<Scalars['String']>
+  updatedAt_eq?: Maybe<Scalars['String']>
+  updatedAt_lt?: Maybe<Scalars['String']>
+  updatedAt_lte?: Maybe<Scalars['String']>
+  updatedAt_gt?: Maybe<Scalars['String']>
+  updatedAt_gte?: Maybe<Scalars['String']>
+  updatedById_eq?: Maybe<Scalars['String']>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['String']>
+  deletedAt_lt?: Maybe<Scalars['String']>
+  deletedAt_lte?: Maybe<Scalars['String']>
+  deletedAt_gt?: Maybe<Scalars['String']>
+  deletedAt_gte?: Maybe<Scalars['String']>
+  deletedById_eq?: Maybe<Scalars['String']>
+}
+
+export type Block = BaseGraphQlObject & {
+  __typename?: 'Block'
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  block: Scalars['Int']
+  executedAt: Scalars['DateTime']
+  network: Network
+  membershipregisteredAtBlock?: Maybe<Array<Membership>>
+}
+
+export type BlockConnection = {
+  __typename?: 'BlockConnection'
+  totalCount: Scalars['Int']
+  edges: Array<BlockEdge>
+  pageInfo: PageInfo
+}
+
+export type BlockCreateInput = {
+  block: Scalars['Float']
+  executedAt: Scalars['DateTime']
+  network: Network
+}
+
+export type BlockEdge = {
+  __typename?: 'BlockEdge'
+  node: Block
+  cursor: Scalars['String']
+}
+
+export enum BlockOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  BlockAsc = 'block_ASC',
+  BlockDesc = 'block_DESC',
+  ExecutedAtAsc = 'executedAt_ASC',
+  ExecutedAtDesc = 'executedAt_DESC',
+  NetworkAsc = 'network_ASC',
+  NetworkDesc = 'network_DESC',
+}
+
+export type BlockUpdateInput = {
+  block?: Maybe<Scalars['Float']>
+  executedAt?: Maybe<Scalars['DateTime']>
+  network?: Maybe<Network>
+}
+
+export type BlockWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  block_eq?: Maybe<Scalars['Int']>
+  block_gt?: Maybe<Scalars['Int']>
+  block_gte?: Maybe<Scalars['Int']>
+  block_lt?: Maybe<Scalars['Int']>
+  block_lte?: Maybe<Scalars['Int']>
+  block_in?: Maybe<Array<Scalars['Int']>>
+  executedAt_eq?: Maybe<Scalars['DateTime']>
+  executedAt_lt?: Maybe<Scalars['DateTime']>
+  executedAt_lte?: Maybe<Scalars['DateTime']>
+  executedAt_gt?: Maybe<Scalars['DateTime']>
+  executedAt_gte?: Maybe<Scalars['DateTime']>
+  network_eq?: Maybe<Network>
+  network_in?: Maybe<Array<Network>>
+}
+
+export type BlockWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type DeleteResponse = {
+  id: Scalars['ID']
+}
+
+export type MembersByHandleFtsOutput = {
+  __typename?: 'MembersByHandleFTSOutput'
+  item: MembersByHandleSearchResult
+  rank: Scalars['Float']
+  isTypeOf: Scalars['String']
+  highlight: Scalars['String']
+}
+
+export type MembersByHandleSearchResult = Membership
+
+/** Stored information about a registered user */
+export type Membership = BaseGraphQlObject & {
+  __typename?: 'Membership'
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** The unique handle chosen by member */
+  handle: Scalars['String']
+  /** Member's name */
+  name?: Maybe<Scalars['String']>
+  /** A Url to member's Avatar image */
+  avatarUri?: Maybe<Scalars['String']>
+  /** Short text chosen by member to share information about themselves */
+  about?: Maybe<Scalars['String']>
+  /** Member's controller account id */
+  controllerAccount: Scalars['String']
+  /** Member's root account id */
+  rootAccount: Scalars['String']
+  registeredAtBlock: Block
+  registeredAtBlockId: Scalars['String']
+  /** Timestamp when member was registered */
+  registeredAtTime: Scalars['DateTime']
+  /** How the member was registered */
+  entry: MembershipEntryMethod
+  /** Whether member has been verified by membership working group. */
+  isVerified: Scalars['Boolean']
+  /** Staking accounts bounded to membership. */
+  boundAccounts: Array<Scalars['String']>
+  /** Current count of invites left to send. */
+  inviteCount: Scalars['Int']
+  invitees: Array<Membership>
+  invitedBy?: Maybe<Membership>
+  invitedById?: Maybe<Scalars['String']>
+  referredMembers: Array<Membership>
+  referredBy?: Maybe<Membership>
+  referredById?: Maybe<Scalars['String']>
+}
+
+export type MembershipConnection = {
+  __typename?: 'MembershipConnection'
+  totalCount: Scalars['Int']
+  edges: Array<MembershipEdge>
+  pageInfo: PageInfo
+}
+
+export type MembershipCreateInput = {
+  handle: Scalars['String']
+  name?: Maybe<Scalars['String']>
+  avatarUri?: Maybe<Scalars['String']>
+  about?: Maybe<Scalars['String']>
+  controllerAccount: Scalars['String']
+  rootAccount: Scalars['String']
+  registeredAtBlockId: Scalars['ID']
+  registeredAtTime: Scalars['DateTime']
+  entry: MembershipEntryMethod
+  isVerified: Scalars['Boolean']
+  boundAccounts: Array<Scalars['String']>
+  inviteCount: Scalars['Float']
+  invitedById?: Maybe<Scalars['ID']>
+  referredById?: Maybe<Scalars['ID']>
+}
+
+export type MembershipEdge = {
+  __typename?: 'MembershipEdge'
+  node: Membership
+  cursor: Scalars['String']
+}
+
+export enum MembershipEntryMethod {
+  Paid = 'PAID',
+  Invited = 'INVITED',
+  Genesis = 'GENESIS',
+}
+
+export enum MembershipOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  HandleAsc = 'handle_ASC',
+  HandleDesc = 'handle_DESC',
+  NameAsc = 'name_ASC',
+  NameDesc = 'name_DESC',
+  AvatarUriAsc = 'avatarUri_ASC',
+  AvatarUriDesc = 'avatarUri_DESC',
+  AboutAsc = 'about_ASC',
+  AboutDesc = 'about_DESC',
+  ControllerAccountAsc = 'controllerAccount_ASC',
+  ControllerAccountDesc = 'controllerAccount_DESC',
+  RootAccountAsc = 'rootAccount_ASC',
+  RootAccountDesc = 'rootAccount_DESC',
+  RegisteredAtBlockIdAsc = 'registeredAtBlockId_ASC',
+  RegisteredAtBlockIdDesc = 'registeredAtBlockId_DESC',
+  RegisteredAtTimeAsc = 'registeredAtTime_ASC',
+  RegisteredAtTimeDesc = 'registeredAtTime_DESC',
+  EntryAsc = 'entry_ASC',
+  EntryDesc = 'entry_DESC',
+  IsVerifiedAsc = 'isVerified_ASC',
+  IsVerifiedDesc = 'isVerified_DESC',
+  InviteCountAsc = 'inviteCount_ASC',
+  InviteCountDesc = 'inviteCount_DESC',
+  InvitedByIdAsc = 'invitedById_ASC',
+  InvitedByIdDesc = 'invitedById_DESC',
+  ReferredByIdAsc = 'referredById_ASC',
+  ReferredByIdDesc = 'referredById_DESC',
+}
+
+export type MembershipSystem = BaseGraphQlObject & {
+  __typename?: 'MembershipSystem'
+  id: Scalars['ID']
+  createdAt: Scalars['DateTime']
+  createdById: Scalars['String']
+  updatedAt?: Maybe<Scalars['DateTime']>
+  updatedById?: Maybe<Scalars['String']>
+  deletedAt?: Maybe<Scalars['DateTime']>
+  deletedById?: Maybe<Scalars['String']>
+  version: Scalars['Int']
+  /** Initial invitation count of a new member. */
+  defaultInviteCount: Scalars['Int']
+  /** Current price to buy a membership. */
+  membershipPrice: Scalars['BigInt']
+  /** Amount of tokens diverted to invitor. */
+  referralCut: Scalars['BigInt']
+  /** The initial, locked, balance credited to controller account of invitee. */
+  invitedInitialBalance: Scalars['BigInt']
+}
+
+export type MembershipSystemConnection = {
+  __typename?: 'MembershipSystemConnection'
+  totalCount: Scalars['Int']
+  edges: Array<MembershipSystemEdge>
+  pageInfo: PageInfo
+}
+
+export type MembershipSystemCreateInput = {
+  defaultInviteCount: Scalars['Float']
+  membershipPrice: Scalars['BigInt']
+  referralCut: Scalars['BigInt']
+  invitedInitialBalance: Scalars['BigInt']
+}
+
+export type MembershipSystemEdge = {
+  __typename?: 'MembershipSystemEdge'
+  node: MembershipSystem
+  cursor: Scalars['String']
+}
+
+export enum MembershipSystemOrderByInput {
+  CreatedAtAsc = 'createdAt_ASC',
+  CreatedAtDesc = 'createdAt_DESC',
+  UpdatedAtAsc = 'updatedAt_ASC',
+  UpdatedAtDesc = 'updatedAt_DESC',
+  DeletedAtAsc = 'deletedAt_ASC',
+  DeletedAtDesc = 'deletedAt_DESC',
+  DefaultInviteCountAsc = 'defaultInviteCount_ASC',
+  DefaultInviteCountDesc = 'defaultInviteCount_DESC',
+  MembershipPriceAsc = 'membershipPrice_ASC',
+  MembershipPriceDesc = 'membershipPrice_DESC',
+  ReferralCutAsc = 'referralCut_ASC',
+  ReferralCutDesc = 'referralCut_DESC',
+  InvitedInitialBalanceAsc = 'invitedInitialBalance_ASC',
+  InvitedInitialBalanceDesc = 'invitedInitialBalance_DESC',
+}
+
+export type MembershipSystemUpdateInput = {
+  defaultInviteCount?: Maybe<Scalars['Float']>
+  membershipPrice?: Maybe<Scalars['BigInt']>
+  referralCut?: Maybe<Scalars['BigInt']>
+  invitedInitialBalance?: Maybe<Scalars['BigInt']>
+}
+
+export type MembershipSystemWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  defaultInviteCount_eq?: Maybe<Scalars['Int']>
+  defaultInviteCount_gt?: Maybe<Scalars['Int']>
+  defaultInviteCount_gte?: Maybe<Scalars['Int']>
+  defaultInviteCount_lt?: Maybe<Scalars['Int']>
+  defaultInviteCount_lte?: Maybe<Scalars['Int']>
+  defaultInviteCount_in?: Maybe<Array<Scalars['Int']>>
+  membershipPrice_eq?: Maybe<Scalars['BigInt']>
+  membershipPrice_gt?: Maybe<Scalars['BigInt']>
+  membershipPrice_gte?: Maybe<Scalars['BigInt']>
+  membershipPrice_lt?: Maybe<Scalars['BigInt']>
+  membershipPrice_lte?: Maybe<Scalars['BigInt']>
+  membershipPrice_in?: Maybe<Array<Scalars['BigInt']>>
+  referralCut_eq?: Maybe<Scalars['BigInt']>
+  referralCut_gt?: Maybe<Scalars['BigInt']>
+  referralCut_gte?: Maybe<Scalars['BigInt']>
+  referralCut_lt?: Maybe<Scalars['BigInt']>
+  referralCut_lte?: Maybe<Scalars['BigInt']>
+  referralCut_in?: Maybe<Array<Scalars['BigInt']>>
+  invitedInitialBalance_eq?: Maybe<Scalars['BigInt']>
+  invitedInitialBalance_gt?: Maybe<Scalars['BigInt']>
+  invitedInitialBalance_gte?: Maybe<Scalars['BigInt']>
+  invitedInitialBalance_lt?: Maybe<Scalars['BigInt']>
+  invitedInitialBalance_lte?: Maybe<Scalars['BigInt']>
+  invitedInitialBalance_in?: Maybe<Array<Scalars['BigInt']>>
+}
+
+export type MembershipSystemWhereUniqueInput = {
+  id: Scalars['ID']
+}
+
+export type MembershipUpdateInput = {
+  handle?: Maybe<Scalars['String']>
+  name?: Maybe<Scalars['String']>
+  avatarUri?: Maybe<Scalars['String']>
+  about?: Maybe<Scalars['String']>
+  controllerAccount?: Maybe<Scalars['String']>
+  rootAccount?: Maybe<Scalars['String']>
+  registeredAtBlockId?: Maybe<Scalars['ID']>
+  registeredAtTime?: Maybe<Scalars['DateTime']>
+  entry?: Maybe<MembershipEntryMethod>
+  isVerified?: Maybe<Scalars['Boolean']>
+  boundAccounts?: Maybe<Array<Scalars['String']>>
+  inviteCount?: Maybe<Scalars['Float']>
+  invitedById?: Maybe<Scalars['ID']>
+  referredById?: Maybe<Scalars['ID']>
+}
+
+export type MembershipWhereInput = {
+  id_eq?: Maybe<Scalars['ID']>
+  id_in?: Maybe<Array<Scalars['ID']>>
+  createdAt_eq?: Maybe<Scalars['DateTime']>
+  createdAt_lt?: Maybe<Scalars['DateTime']>
+  createdAt_lte?: Maybe<Scalars['DateTime']>
+  createdAt_gt?: Maybe<Scalars['DateTime']>
+  createdAt_gte?: Maybe<Scalars['DateTime']>
+  createdById_eq?: Maybe<Scalars['ID']>
+  createdById_in?: Maybe<Array<Scalars['ID']>>
+  updatedAt_eq?: Maybe<Scalars['DateTime']>
+  updatedAt_lt?: Maybe<Scalars['DateTime']>
+  updatedAt_lte?: Maybe<Scalars['DateTime']>
+  updatedAt_gt?: Maybe<Scalars['DateTime']>
+  updatedAt_gte?: Maybe<Scalars['DateTime']>
+  updatedById_eq?: Maybe<Scalars['ID']>
+  updatedById_in?: Maybe<Array<Scalars['ID']>>
+  deletedAt_all?: Maybe<Scalars['Boolean']>
+  deletedAt_eq?: Maybe<Scalars['DateTime']>
+  deletedAt_lt?: Maybe<Scalars['DateTime']>
+  deletedAt_lte?: Maybe<Scalars['DateTime']>
+  deletedAt_gt?: Maybe<Scalars['DateTime']>
+  deletedAt_gte?: Maybe<Scalars['DateTime']>
+  deletedById_eq?: Maybe<Scalars['ID']>
+  deletedById_in?: Maybe<Array<Scalars['ID']>>
+  handle_eq?: Maybe<Scalars['String']>
+  handle_contains?: Maybe<Scalars['String']>
+  handle_startsWith?: Maybe<Scalars['String']>
+  handle_endsWith?: Maybe<Scalars['String']>
+  handle_in?: Maybe<Array<Scalars['String']>>
+  name_eq?: Maybe<Scalars['String']>
+  name_contains?: Maybe<Scalars['String']>
+  name_startsWith?: Maybe<Scalars['String']>
+  name_endsWith?: Maybe<Scalars['String']>
+  name_in?: Maybe<Array<Scalars['String']>>
+  avatarUri_eq?: Maybe<Scalars['String']>
+  avatarUri_contains?: Maybe<Scalars['String']>
+  avatarUri_startsWith?: Maybe<Scalars['String']>
+  avatarUri_endsWith?: Maybe<Scalars['String']>
+  avatarUri_in?: Maybe<Array<Scalars['String']>>
+  about_eq?: Maybe<Scalars['String']>
+  about_contains?: Maybe<Scalars['String']>
+  about_startsWith?: Maybe<Scalars['String']>
+  about_endsWith?: Maybe<Scalars['String']>
+  about_in?: Maybe<Array<Scalars['String']>>
+  controllerAccount_eq?: Maybe<Scalars['String']>
+  controllerAccount_contains?: Maybe<Scalars['String']>
+  controllerAccount_startsWith?: Maybe<Scalars['String']>
+  controllerAccount_endsWith?: Maybe<Scalars['String']>
+  controllerAccount_in?: Maybe<Array<Scalars['String']>>
+  rootAccount_eq?: Maybe<Scalars['String']>
+  rootAccount_contains?: Maybe<Scalars['String']>
+  rootAccount_startsWith?: Maybe<Scalars['String']>
+  rootAccount_endsWith?: Maybe<Scalars['String']>
+  rootAccount_in?: Maybe<Array<Scalars['String']>>
+  registeredAtBlockId_eq?: Maybe<Scalars['ID']>
+  registeredAtBlockId_in?: Maybe<Array<Scalars['ID']>>
+  registeredAtTime_eq?: Maybe<Scalars['DateTime']>
+  registeredAtTime_lt?: Maybe<Scalars['DateTime']>
+  registeredAtTime_lte?: Maybe<Scalars['DateTime']>
+  registeredAtTime_gt?: Maybe<Scalars['DateTime']>
+  registeredAtTime_gte?: Maybe<Scalars['DateTime']>
+  entry_eq?: Maybe<MembershipEntryMethod>
+  entry_in?: Maybe<Array<MembershipEntryMethod>>
+  isVerified_eq?: Maybe<Scalars['Boolean']>
+  isVerified_in?: Maybe<Array<Scalars['Boolean']>>
+  inviteCount_eq?: Maybe<Scalars['Int']>
+  inviteCount_gt?: Maybe<Scalars['Int']>
+  inviteCount_gte?: Maybe<Scalars['Int']>
+  inviteCount_lt?: Maybe<Scalars['Int']>
+  inviteCount_lte?: Maybe<Scalars['Int']>
+  inviteCount_in?: Maybe<Array<Scalars['Int']>>
+  invitedById_eq?: Maybe<Scalars['ID']>
+  invitedById_in?: Maybe<Array<Scalars['ID']>>
+  referredById_eq?: Maybe<Scalars['ID']>
+  referredById_in?: Maybe<Array<Scalars['ID']>>
+}
+
+export type MembershipWhereUniqueInput = {
+  id?: Maybe<Scalars['ID']>
+  handle?: Maybe<Scalars['String']>
+}
+
+export enum Network {
+  Babylon = 'BABYLON',
+  Alexandria = 'ALEXANDRIA',
+  Rome = 'ROME',
+  Olympia = 'OLYMPIA',
+}
+
+export type PageInfo = {
+  __typename?: 'PageInfo'
+  hasNextPage: Scalars['Boolean']
+  hasPreviousPage: Scalars['Boolean']
+  startCursor?: Maybe<Scalars['String']>
+  endCursor?: Maybe<Scalars['String']>
+}
+
+export type ProcessorState = {
+  __typename?: 'ProcessorState'
+  lastCompleteBlock: Scalars['Float']
+  lastProcessedEvent: Scalars['String']
+  indexerHead: Scalars['Float']
+  chainHead: Scalars['Float']
+}
+
+export type Query = {
+  __typename?: 'Query'
+  blocks: Array<Block>
+  block?: Maybe<Block>
+  blocksConnection: BlockConnection
+  membershipSystems: Array<MembershipSystem>
+  membershipSystem?: Maybe<MembershipSystem>
+  membershipSystemsConnection: MembershipSystemConnection
+  memberships: Array<Membership>
+  membership?: Maybe<Membership>
+  membershipsConnection: MembershipConnection
+  membersByHandle: Array<MembersByHandleFtsOutput>
+}
+
+export type QueryBlocksArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<BlockWhereInput>
+  orderBy?: Maybe<BlockOrderByInput>
+}
+
+export type QueryBlockArgs = {
+  where: BlockWhereUniqueInput
+}
+
+export type QueryBlocksConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<BlockWhereInput>
+  orderBy?: Maybe<BlockOrderByInput>
+}
+
+export type QueryMembershipSystemsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<MembershipSystemWhereInput>
+  orderBy?: Maybe<MembershipSystemOrderByInput>
+}
+
+export type QueryMembershipSystemArgs = {
+  where: MembershipSystemWhereUniqueInput
+}
+
+export type QueryMembershipSystemsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<MembershipSystemWhereInput>
+  orderBy?: Maybe<MembershipSystemOrderByInput>
+}
+
+export type QueryMembershipsArgs = {
+  offset?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  where?: Maybe<MembershipWhereInput>
+  orderBy?: Maybe<MembershipOrderByInput>
+}
+
+export type QueryMembershipArgs = {
+  where: MembershipWhereUniqueInput
+}
+
+export type QueryMembershipsConnectionArgs = {
+  first?: Maybe<Scalars['Int']>
+  after?: Maybe<Scalars['String']>
+  last?: Maybe<Scalars['Int']>
+  before?: Maybe<Scalars['String']>
+  where?: Maybe<MembershipWhereInput>
+  orderBy?: Maybe<MembershipOrderByInput>
+}
+
+export type QueryMembersByHandleArgs = {
+  whereMembership?: Maybe<MembershipWhereInput>
+  skip?: Maybe<Scalars['Int']>
+  limit?: Maybe<Scalars['Int']>
+  text: Scalars['String']
+}
+
+export type StandardDeleteResponse = {
+  __typename?: 'StandardDeleteResponse'
+  id: Scalars['ID']
+}
+
+export type Subscription = {
+  __typename?: 'Subscription'
+  stateSubscription: ProcessorState
+}

tests/integration-tests/src/scenarios/olympia.ts

@@ -0,0 +1,16 @@
+import creatingMemberships from '../flows/membership/creatingMemberships'
+import updatingMemberProfile from '../flows/membership/updatingProfile'
+import updatingMemberAccounts from '../flows/membership/updatingAccounts'
+import invitingMebers from '../flows/membership/invitingMembers'
+import transferringInvites from '../flows/membership/transferringInvites'
+import managingStakingAccounts from '../flows/membership/managingStakingAccounts'
+import { scenario } from '../Scenario'
+
+scenario(async ({ job }) => {
+  job('creating members', creatingMemberships)
+  job('updating member profile', updatingMemberProfile)
+  job('updating member accounts', updatingMemberAccounts)
+  job('inviting members', invitingMebers)
+  job('transferring invites', transferringInvites)
+  job('managing staking accounts', managingStakingAccounts)
+})

utils/api-scripts/package.json

@@ -6,7 +6,8 @@
   "scripts": {
     "status": "ts-node src/status",
     "script": "ts-node src/script",
-    "tsnode-strict": "node -r ts-node/register --unhandled-rejections=strict"
+    "tsnode-strict": "node -r ts-node/register --unhandled-rejections=strict",
+    "initialize-content-lead": "ts-node src/initialize-content-lead"
   },
   "dependencies": {
     "@joystream/types": "^0.15.0",

utils/api-scripts/src/helpers/extrinsics.ts

@@ -0,0 +1,91 @@
+import { Keyring } from '@polkadot/keyring'
+import { KeyringPair } from '@polkadot/keyring/types'
+import { ApiPromise } from '@polkadot/api'
+import { SubmittableExtrinsic } from '@polkadot/api/types'
+import { DispatchError } from '@polkadot/types/interfaces/system'
+import { TypeRegistry } from '@polkadot/types'
+import { ISubmittableResult } from '@polkadot/types/types'
+
+// TODO: Move to @joystream/js soon
+
+export function getAlicePair(): KeyringPair {
+  const keyring = new Keyring({ type: 'sr25519' })
+  keyring.addFromUri('//Alice', { name: 'Alice' })
+  const ALICE = keyring.getPairs()[0]
+
+  return ALICE
+}
+
+export function getKeyFromSuri(suri: string): KeyringPair {
+  const keyring = new Keyring({ type: 'sr25519' })
+
+  // Assume a SURI, add to keyring and return keypair
+  return keyring.addFromUri(suri)
+}
+
+export class ExtrinsicsHelper {
+  api: ApiPromise
+  noncesByAddress: Map<string, number>
+
+  constructor(api: ApiPromise, initialNonces?: [string, number][]) {
+    this.api = api
+    this.noncesByAddress = new Map<string, number>(initialNonces)
+  }
+
+  private async nextNonce(address: string): Promise<number> {
+    const nonce = this.noncesByAddress.get(address) || (await this.api.query.system.account(address)).nonce.toNumber()
+    this.noncesByAddress.set(address, nonce + 1)
+
+    return nonce
+  }
+
+  async sendAndCheck(
+    sender: KeyringPair,
+    extrinsics: SubmittableExtrinsic<'promise'>[],
+    errorMessage: string
+  ): Promise<ISubmittableResult[]> {
+    const promises: Promise<ISubmittableResult>[] = []
+    for (const tx of extrinsics) {
+      const nonce = await this.nextNonce(sender.address)
+      promises.push(
+        new Promise<ISubmittableResult>((resolve, reject) => {
+          tx.signAndSend(sender, { nonce }, (result) => {
+            let txError: string | null = null
+            if (result.isError) {
+              txError = `Transaction failed with status: ${result.status.type}`
+              reject(new Error(`${errorMessage} - ${txError}`))
+            }
+
+            if (result.status.isInBlock) {
+              result.events
+                .filter(({ event }) => event.section === 'system')
+                .forEach(({ event }) => {
+                  if (event.method === 'ExtrinsicFailed') {
+                    const dispatchError = event.data[0] as DispatchError
+                    let errorMsg = dispatchError.toString()
+                    if (dispatchError.isModule) {
+                      try {
+                        // Need to assert that registry is of TypeRegistry type, since Registry intefrace
+                        // seems outdated and doesn't include DispatchErrorModule as possible argument for "findMetaError"
+                        const { name, documentation } = (this.api.registry as TypeRegistry).findMetaError(
+                          dispatchError.asModule
+                        )
+                        errorMsg = `${name} (${documentation})`
+                      } catch (e) {
+                        // This probably means we don't have this error in the metadata
+                        // In this case - continue (we'll just display dispatchError.toString())
+                      }
+                    }
+                    reject(new Error(`${errorMessage} - Extrinsic execution error: ${errorMsg}`))
+                  } else if (event.method === 'ExtrinsicSuccess') {
+                    resolve(result)
+                  }
+                })
+            }
+          })
+        })
+      )
+    }
+    return await Promise.all(promises)
+  }
+}

utils/api-scripts/src/initialize-content-lead.ts

@@ -0,0 +1,140 @@
+import { registry, types } from '@joystream/types'
+import { JoyBTreeSet, MemberId } from '@joystream/types/common'
+import { ApplicationId, OpeningId } from '@joystream/types/working-group'
+import { ApiPromise, WsProvider } from '@polkadot/api'
+import { SubmittableExtrinsic } from '@polkadot/api/types'
+import { ExtrinsicsHelper, getAlicePair, getKeyFromSuri } from './helpers/extrinsics'
+import BN from 'bn.js'
+
+const MIN_APPLICATION_STAKE = new BN(2000)
+const STAKING_ACCOUNT_CANDIDATE_STAKE = new BN(200)
+
+async function main() {
+  // Init api
+  const WS_URI = process.env.WS_URI || 'ws://127.0.0.1:9944'
+  console.log(`Initializing the api (${WS_URI})...`)
+  const provider = new WsProvider(WS_URI)
+  const api = await ApiPromise.create({ provider, types })
+
+  const LeadKeyPair = process.env.LEAD_URI ? getKeyFromSuri(process.env.LEAD_URI) : getAlicePair()
+  const SudoKeyPair = process.env.SUDO_URI ? getKeyFromSuri(process.env.SUDO_URI) : getAlicePair()
+  const StakeKeyPair = LeadKeyPair.derive(`//stake${Date.now()}`)
+
+  const txHelper = new ExtrinsicsHelper(api)
+
+  const sudo = (tx: SubmittableExtrinsic<'promise'>) => api.tx.sudo.sudo(tx)
+
+  // Create membership if not already created
+  const memberEntries = await api.query.members.membershipById.entries()
+  const matchingEntry = memberEntries.find(
+    ([storageKey, member]) => member.controller_account.toString() === LeadKeyPair.address
+  )
+  let memberId: MemberId | undefined = matchingEntry?.[0].args[0] as MemberId | undefined
+
+  // Only buy membership if LEAD_URI is not provided - ie for Alice
+  if (!memberId && process.env.LEAD_URI) {
+    throw new Error('Make sure Controller key LEAD_URI is for a member')
+  }
+
+  if (!memberId) {
+    console.log('Buying new membership...')
+    const [memberRes] = await txHelper.sendAndCheck(
+      LeadKeyPair,
+      [
+        api.tx.members.buyMembership({
+          root_account: LeadKeyPair.address,
+          controller_account: LeadKeyPair.address,
+          handle: 'alice',
+        }),
+      ],
+      'Failed to setup member account'
+    )
+    memberId = memberRes.findRecord('members', 'MembershipBought')!.event.data[0] as MemberId
+  }
+
+  // Create a new lead opening
+  if ((await api.query.contentDirectoryWorkingGroup.currentLead()).isSome) {
+    console.log('Curators lead already exists, aborting...')
+  } else {
+    console.log(`Making member id: ${memberId} the content lead.`)
+    // Create curator lead opening
+    console.log('Creating curator lead opening...')
+    const [openingRes] = await txHelper.sendAndCheck(
+      SudoKeyPair,
+      [
+        sudo(
+          api.tx.contentDirectoryWorkingGroup.addOpening(
+            '',
+            'Leader',
+            {
+              stake_amount: MIN_APPLICATION_STAKE,
+              leaving_unstaking_period: 99999,
+            },
+            null
+          )
+        ),
+      ],
+      'Failed to create Content Curators Lead opening!'
+    )
+    const openingId = openingRes.findRecord('contentDirectoryWorkingGroup', 'OpeningAdded')!.event.data[0] as OpeningId
+
+    // Set up stake account
+    const addCandidateTx = api.tx.members.addStakingAccountCandidate(memberId)
+    const addCandidateFee = (await addCandidateTx.paymentInfo(StakeKeyPair.address)).partialFee
+    const stakingAccountBalance = MIN_APPLICATION_STAKE.add(STAKING_ACCOUNT_CANDIDATE_STAKE).add(addCandidateFee)
+    console.log('Setting up staking account...')
+    await txHelper.sendAndCheck(
+      LeadKeyPair,
+      [api.tx.balances.transfer(StakeKeyPair.address, stakingAccountBalance)],
+      `Failed to send funds to staing account (${stakingAccountBalance})`
+    )
+    await txHelper.sendAndCheck(StakeKeyPair, [addCandidateTx], 'Failed to add staking candidate')
+    await txHelper.sendAndCheck(
+      LeadKeyPair,
+      [api.tx.members.confirmStakingAccount(memberId, StakeKeyPair.address)],
+      'Failed to confirm staking account'
+    )
+
+    console.log((await api.query.system.account(StakeKeyPair.address)).toHuman())
+
+    // Apply to lead opening
+    console.log('Applying to curator lead opening...')
+    const [applicationRes] = await txHelper.sendAndCheck(
+      LeadKeyPair,
+      [
+        api.tx.contentDirectoryWorkingGroup.applyOnOpening({
+          member_id: memberId,
+          role_account_id: LeadKeyPair.address,
+          opening_id: openingId,
+          stake_parameters: {
+            stake: MIN_APPLICATION_STAKE,
+            staking_account_id: StakeKeyPair.address,
+          },
+        }),
+      ],
+      'Failed to apply on lead opening!'
+    )
+
+    const applicationId = applicationRes.findRecord('contentDirectoryWorkingGroup', 'AppliedOnOpening')!.event
+      .data[1] as ApplicationId
+
+    // Fill opening
+    console.log('Filling the opening...')
+    await txHelper.sendAndCheck(
+      LeadKeyPair,
+      [
+        sudo(
+          api.tx.contentDirectoryWorkingGroup.fillOpening(
+            openingId,
+            new (JoyBTreeSet(ApplicationId))(registry, [applicationId])
+          )
+        ),
+      ],
+      'Failed to fill the opening'
+    )
+  }
+}
+
+main()
+  .then(() => process.exit())
+  .catch((e) => console.error(e))

yarn.lock

@@ -42,6 +42,25 @@
     tslib "^1.10.0"
     zen-observable "^0.8.14"
 
+"@apollo/client@^3.3.13":
+  version "3.3.13"
+  resolved "https://registry.yarnpkg.com/@apollo/client/-/client-3.3.13.tgz#0aadde13b80ce129d1261161413a9de2b0dec70e"
+  integrity sha512-usiVmXiOq0J/GpyIOIhlF8ItHpiPJObC7zoxLYPoOYj3G3OB0hCIcUKs3aTJ3ATW7u8QxvYgRaJg72NN7E1WOg==
+  dependencies:
+    "@graphql-typed-document-node/core" "^3.0.0"
+    "@types/zen-observable" "^0.8.0"
+    "@wry/context" "^0.6.0"
+    "@wry/equality" "^0.4.0"
+    fast-json-stable-stringify "^2.0.0"
+    graphql-tag "^2.12.0"
+    hoist-non-react-statics "^3.3.2"
+    optimism "^0.15.0"
+    prop-types "^15.7.2"
+    symbol-observable "^2.0.0"
+    ts-invariant "^0.7.0"
+    tslib "^1.10.0"
+    zen-observable "^0.8.14"
+
 "@apollo/protobufjs@^1.0.3":
   version "1.0.5"
   resolved "https://registry.yarnpkg.com/@apollo/protobufjs/-/protobufjs-1.0.5.tgz#a78b726147efc0795e74c8cb8a11aafc6e02f773"
@@ -6420,6 +6439,13 @@
   dependencies:
     tslib "^1.14.1"
 
+"@wry/context@^0.6.0":
+  version "0.6.0"
+  resolved "https://registry.yarnpkg.com/@wry/context/-/context-0.6.0.tgz#f903eceb89d238ef7e8168ed30f4511f92d83e06"
+  integrity sha512-sAgendOXR8dM7stJw3FusRxFHF/ZinU0lffsA2YTyyIOfic86JX02qlPqPVqJNZJPAxFt+2EE8bvq6ZlS0Kf+Q==
+  dependencies:
+    tslib "^2.1.0"
+
 "@wry/equality@^0.1.2":
   version "0.1.11"
   resolved "https://registry.yarnpkg.com/@wry/equality/-/equality-0.1.11.tgz#35cb156e4a96695aa81a9ecc4d03787bc17f1790"
@@ -6434,6 +6460,20 @@
   dependencies:
     tslib "^1.14.1"
 
+"@wry/equality@^0.4.0":
+  version "0.4.0"
+  resolved "https://registry.yarnpkg.com/@wry/equality/-/equality-0.4.0.tgz#474491869a8d0590f4a33fd2a4850a77a0f63408"
+  integrity sha512-DxN/uawWfhRbgYE55zVCPOoe+jvsQ4m7PT1Wlxjyb/LCCLuU1UsucV2BbCxFAX8bjcSueFBbB5Qfj1Zfe8e7Fw==
+  dependencies:
+    tslib "^2.1.0"
+
+"@wry/trie@^0.3.0":
+  version "0.3.0"
+  resolved "https://registry.yarnpkg.com/@wry/trie/-/trie-0.3.0.tgz#3245e74988c4e3033299e479a1bf004430752463"
+  integrity sha512-Yw1akIogPhAT6XPYsRHlZZIS0tIGmAl9EYXHi2scf7LPKKqdqmow/Hu4kEqP2cJR3EjaU/9L0ZlAjFf3hFxmug==
+  dependencies:
+    tslib "^2.1.0"
+
 "@xtuc/ieee754@^1.2.0":
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/@xtuc/ieee754/-/ieee754-1.2.0.tgz#eef014a3145ae477a1cbc00cd1e552336dceb790"
@@ -14557,6 +14597,13 @@ graphql-tag@^2.11.0, graphql-tag@^2.9.2:
   resolved "https://registry.yarnpkg.com/graphql-tag/-/graphql-tag-2.11.0.tgz#1deb53a01c46a7eb401d6cb59dec86fa1cccbffd"
   integrity sha512-VmsD5pJqWJnQZMUeRwrDhfgoyqcfwEkvtpANqcoUG8/tOLkwNgU9mzub/Mc78OJMhHjx7gfAMTxzdG43VGg3bA==
 
+graphql-tag@^2.12.0:
+  version "2.12.3"
+  resolved "https://registry.yarnpkg.com/graphql-tag/-/graphql-tag-2.12.3.tgz#ac47bf9d51c67c68ada8a33fd527143ed15bb647"
+  integrity sha512-5wJMjSvj30yzdciEuk9dPuUBUR56AqDi3xncoYQl1i42pGdSqOJrJsdb/rz5BDoy+qoGvQwABcBeF0xXY3TrKw==
+  dependencies:
+    tslib "^2.1.0"
+
 graphql-tools@4.0.5:
   version "4.0.5"
   resolved "https://registry.yarnpkg.com/graphql-tools/-/graphql-tools-4.0.5.tgz#d2b41ee0a330bfef833e5cdae7e1f0b0d86b1754"
@@ -21349,6 +21396,14 @@ optimism@^0.13.1:
   dependencies:
     "@wry/context" "^0.5.2"
 
+optimism@^0.15.0:
+  version "0.15.0"
+  resolved "https://registry.yarnpkg.com/optimism/-/optimism-0.15.0.tgz#c65e694bec7ce439f41e9cb8fc261a72d798125b"
+  integrity sha512-KLKl3Kb7hH++s9ewRcBhmfpXgXF0xQ+JZ3xQFuPjnoT6ib2TDmYyVkKENmGxivsN2G3VRxpXuauCkB4GYOhtPw==
+  dependencies:
+    "@wry/context" "^0.6.0"
+    "@wry/trie" "^0.3.0"
+
 optimist@~0.3.5:
   version "0.3.7"
   resolved "https://registry.yarnpkg.com/optimist/-/optimist-0.3.7.tgz#c90941ad59e4273328923074d2cf2e7cbc6ec0d9"
@@ -27308,6 +27363,13 @@ ts-invariant@^0.6.0:
     "@ungap/global-this" "^0.4.2"
     tslib "^1.9.3"
 
+ts-invariant@^0.7.0:
+  version "0.7.3"
+  resolved "https://registry.yarnpkg.com/ts-invariant/-/ts-invariant-0.7.3.tgz#13aae22a4a165393aaf5cecdee45ef4128d358b8"
+  integrity sha512-UWDDeovyUTIMWj+45g5nhnl+8oo+GhxL5leTaHn5c8FkQWfh8v66gccLd2/YzVmV5hoQUjCEjhrXnQqVDJdvKA==
+  dependencies:
+    tslib "^2.1.0"
+
 ts-jest@^24.1.0:
   version "24.3.0"
   resolved "https://registry.yarnpkg.com/ts-jest/-/ts-jest-24.3.0.tgz#b97814e3eab359ea840a1ac112deae68aa440869"
@@ -27449,7 +27511,7 @@ tslib@^2, tslib@~2.1.0:
   resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.1.0.tgz#da60860f1c2ecaa5703ab7d39bc05b6bf988b97a"
   integrity sha512-hcVC3wYEziELGGmEEXue7D75zbwIIVUMWAVbHItGPx0ziyXxrOMQx4rQEVEV45Ut/1IotuEvwqPopzIOkDMf0A==
 
-tslib@~2.2.0:
+tslib@^2.1.0, tslib@~2.2.0:
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.2.0.tgz#fb2c475977e35e241311ede2693cee1ec6698f5c"
   integrity sha512-gS9GVHRU+RGn5KQM2rllAlR3dU6m7AcpJKdtH8gFvQiC4Otgk98XnmMU+nZenHt/+VhnBPWwgrJsyrdcw6i23w==