@moneypot/hub 0.0.1

package/dist/src/__generated__/graphql.d.ts

@@ -0,0 +1,3129 @@
+import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+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]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
+};
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    Base64EncodedBinary: {
+        input: any;
+        output: any;
+    };
+    Cursor: {
+        input: string;
+        output: string;
+    };
+    Datetime: {
+        input: string;
+        output: string;
+    };
+    JSON: {
+        input: any;
+        output: any;
+    };
+    UUID: {
+        input: string;
+        output: string;
+    };
+};
+export type Account = {
+    __typename?: 'Account';
+    balance: Scalars['Float']['output'];
+    balanceDraftLimit: Scalars['Float']['output'];
+    currency: Scalars['String']['output'];
+    currencyByCurrency?: Maybe<Currency>;
+    holderByHolderId?: Maybe<Holder>;
+    holderId: Scalars['UUID']['output'];
+    id: Scalars['UUID']['output'];
+    transfersByFromAccountId: TransferConnection;
+    transfersByToAccountId: TransferConnection;
+};
+export type AccountTransfersByFromAccountIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<TransferCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<TransferOrderBy>>;
+};
+export type AccountTransfersByToAccountIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<TransferCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<TransferOrderBy>>;
+};
+export type AccountCondition = {
+    holderId?: InputMaybe<Scalars['UUID']['input']>;
+    id?: InputMaybe<Scalars['UUID']['input']>;
+};
+export type AccountConnection = {
+    __typename?: 'AccountConnection';
+    edges: Array<Maybe<AccountEdge>>;
+    nodes: Array<Maybe<Account>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type AccountEdge = {
+    __typename?: 'AccountEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<Account>;
+};
+export declare enum AccountOrderBy {
+    HolderIdAsc = "HOLDER_ID_ASC",
+    HolderIdDesc = "HOLDER_ID_DESC",
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC"
+}
+export type ActiveSession = {
+    __typename?: 'ActiveSession';
+    expiredAt?: Maybe<Scalars['Datetime']['output']>;
+    id: Scalars['UUID']['output'];
+    key?: Maybe<Scalars['UUID']['output']>;
+    lastUsedAt?: Maybe<Scalars['Datetime']['output']>;
+    revokedAt?: Maybe<Scalars['Datetime']['output']>;
+    trackingId?: Maybe<Scalars['UUID']['output']>;
+    userAgent?: Maybe<Scalars['String']['output']>;
+    userByUserId?: Maybe<User>;
+    userId?: Maybe<Scalars['UUID']['output']>;
+};
+export type ActiveSessionConnection = {
+    __typename?: 'ActiveSessionConnection';
+    edges: Array<Maybe<ActiveSessionEdge>>;
+    nodes: Array<Maybe<ActiveSession>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type ActiveSessionEdge = {
+    __typename?: 'ActiveSessionEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<ActiveSession>;
+};
+export declare enum ActiveSessionOrderBy {
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC"
+}
+export type ApiKey = {
+    __typename?: 'ApiKey';
+    controllerByControllerId?: Maybe<Controller>;
+    controllerId: Scalars['UUID']['output'];
+    id: Scalars['UUID']['output'];
+    key: Scalars['UUID']['output'];
+    lastUsedAt?: Maybe<Scalars['Datetime']['output']>;
+    name?: Maybe<Scalars['String']['output']>;
+    revokedAt?: Maybe<Scalars['Datetime']['output']>;
+};
+export type ApiKeyCondition = {
+    controllerId?: InputMaybe<Scalars['UUID']['input']>;
+    id?: InputMaybe<Scalars['UUID']['input']>;
+    key?: InputMaybe<Scalars['UUID']['input']>;
+};
+export type ApiKeyConnection = {
+    __typename?: 'ApiKeyConnection';
+    edges: Array<Maybe<ApiKeyEdge>>;
+    nodes: Array<Maybe<ApiKey>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type ApiKeyEdge = {
+    __typename?: 'ApiKeyEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<ApiKey>;
+};
+export declare enum ApiKeyOrderBy {
+    ControllerIdAsc = "CONTROLLER_ID_ASC",
+    ControllerIdDesc = "CONTROLLER_ID_DESC",
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    KeyAsc = "KEY_ASC",
+    KeyDesc = "KEY_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC"
+}
+export type AuthnLoginRequest = {
+    __typename?: 'AuthnLoginRequest';
+    authnRequestById?: Maybe<AuthnRequest>;
+    id: Scalars['UUID']['output'];
+    userByUserId?: Maybe<User>;
+    userId: Scalars['UUID']['output'];
+};
+export type AuthnLoginRequestCondition = {
+    id?: InputMaybe<Scalars['UUID']['input']>;
+};
+export type AuthnLoginRequestConnection = {
+    __typename?: 'AuthnLoginRequestConnection';
+    edges: Array<Maybe<AuthnLoginRequestEdge>>;
+    nodes: Array<Maybe<AuthnLoginRequest>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type AuthnLoginRequestEdge = {
+    __typename?: 'AuthnLoginRequestEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<AuthnLoginRequest>;
+};
+export declare enum AuthnLoginRequestOrderBy {
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC"
+}
+export type AuthnRegisterRequest = {
+    __typename?: 'AuthnRegisterRequest';
+    authnRequestById?: Maybe<AuthnRequest>;
+    id: Scalars['UUID']['output'];
+    proposedUname: Scalars['String']['output'];
+};
+export type AuthnRegisterRequestCondition = {
+    id?: InputMaybe<Scalars['UUID']['input']>;
+};
+export type AuthnRegisterRequestConnection = {
+    __typename?: 'AuthnRegisterRequestConnection';
+    edges: Array<Maybe<AuthnRegisterRequestEdge>>;
+    nodes: Array<Maybe<AuthnRegisterRequest>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type AuthnRegisterRequestEdge = {
+    __typename?: 'AuthnRegisterRequestEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<AuthnRegisterRequest>;
+};
+export declare enum AuthnRegisterRequestOrderBy {
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC"
+}
+export type AuthnRequest = {
+    __typename?: 'AuthnRequest';
+    authnLoginRequestById?: Maybe<AuthnLoginRequest>;
+    authnRegisterRequestById?: Maybe<AuthnRegisterRequest>;
+    code: Scalars['String']['output'];
+    codeSentAt?: Maybe<Scalars['Datetime']['output']>;
+    email: Scalars['String']['output'];
+    expiredAt: Scalars['Datetime']['output'];
+    id: Scalars['UUID']['output'];
+    magicToken: Scalars['UUID']['output'];
+    type: AuthnRequestType;
+    usedAt?: Maybe<Scalars['Datetime']['output']>;
+};
+export type AuthnRequestCondition = {
+    id?: InputMaybe<Scalars['UUID']['input']>;
+};
+export type AuthnRequestConnection = {
+    __typename?: 'AuthnRequestConnection';
+    edges: Array<Maybe<AuthnRequestEdge>>;
+    nodes: Array<Maybe<AuthnRequest>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type AuthnRequestEdge = {
+    __typename?: 'AuthnRequestEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<AuthnRequest>;
+};
+export declare enum AuthnRequestOrderBy {
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC"
+}
+export declare enum AuthnRequestType {
+    Login = "LOGIN",
+    Register = "REGISTER"
+}
+export type BalanceAlertPayload = {
+    __typename?: 'BalanceAlertPayload';
+    currencyKey?: Maybe<Scalars['String']['output']>;
+};
+export type CancelPendingEmailChangeRequestInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    id: Scalars['UUID']['input'];
+};
+export type CancelPendingEmailChangeRequestPayload = {
+    __typename?: 'CancelPendingEmailChangeRequestPayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    query?: Maybe<Query>;
+    result?: Maybe<Scalars['Boolean']['output']>;
+};
+export type CancelTransferInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    id: Scalars['UUID']['input'];
+};
+export type CancelTransferPayload = {
+    __typename?: 'CancelTransferPayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    result: CancelTransferResult;
+};
+export type CancelTransferResult = CancelTransferSuccess | InvalidTransferStatus;
+export type CancelTransferSuccess = {
+    __typename?: 'CancelTransferSuccess';
+    transfer: Transfer;
+};
+export type ClaimFaucetInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    currencyKey: Scalars['String']['input'];
+};
+export type ClaimFaucetPayload = {
+    __typename?: 'ClaimFaucetPayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    faucetClaim: FaucetClaim;
+};
+export type ClaimTransferInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    id: Scalars['UUID']['input'];
+};
+export type ClaimTransferPayload = {
+    __typename?: 'ClaimTransferPayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    result: ClaimTransferResult;
+};
+export type ClaimTransferResult = ClaimTransferSuccess | InvalidTransferStatus;
+export type ClaimTransferSuccess = {
+    __typename?: 'ClaimTransferSuccess';
+    transfer: Transfer;
+};
+export type CompleteTransferInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    id: Scalars['UUID']['input'];
+};
+export type CompleteTransferPayload = {
+    __typename?: 'CompleteTransferPayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    result: CompleteTransferResult;
+};
+export type CompleteTransferResult = CompleteTransferSuccess | InvalidTransferStatus;
+export type CompleteTransferSuccess = {
+    __typename?: 'CompleteTransferSuccess';
+    transfer: Transfer;
+};
+export type ConfirmEmailTokenInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    token: Scalars['UUID']['input'];
+};
+export type ConfirmEmailTokenPayload = {
+    __typename?: 'ConfirmEmailTokenPayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    query?: Maybe<Query>;
+    result?: Maybe<EmailStepResult>;
+};
+export type Controller = Holder & {
+    __typename?: 'Controller';
+    accountByCurrency?: Maybe<Account>;
+    accountsByHolderId: AccountConnection;
+    apiKeysByControllerId: ApiKeyConnection;
+    balanceByCurrency?: Maybe<Scalars['Float']['output']>;
+    deletedAt?: Maybe<Scalars['Datetime']['output']>;
+    faucetClaimsByHolderId: FaucetClaimConnection;
+    id: Scalars['UUID']['output'];
+    kind: HolderKind;
+    name: Scalars['String']['output'];
+    transfers: TransferConnection;
+    transfersByFromHolderId: TransferConnection;
+    transfersByToHolderId: TransferConnection;
+    userByUserId?: Maybe<User>;
+    userId: Scalars['UUID']['output'];
+};
+export type ControllerAccountByCurrencyArgs = {
+    currency: Scalars['String']['input'];
+};
+export type ControllerAccountsByHolderIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<AccountCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<AccountOrderBy>>;
+};
+export type ControllerApiKeysByControllerIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<ApiKeyCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    includeRevoked?: InputMaybe<IncludeRevokedOption>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<ApiKeyOrderBy>>;
+};
+export type ControllerBalanceByCurrencyArgs = {
+    currency: Scalars['String']['input'];
+};
+export type ControllerFaucetClaimsByHolderIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<FaucetClaimCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<FaucetClaimOrderBy>>;
+};
+export type ControllerTransfersArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    direction?: InputMaybe<TransferDirection>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    status?: InputMaybe<TransferStatusKind>;
+};
+export type ControllerTransfersByFromHolderIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<TransferCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<TransferOrderBy>>;
+};
+export type ControllerTransfersByToHolderIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<TransferCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<TransferOrderBy>>;
+};
+export type ControllerCondition = {
+    id?: InputMaybe<Scalars['UUID']['input']>;
+    userId?: InputMaybe<Scalars['UUID']['input']>;
+};
+export type ControllerConnection = {
+    __typename?: 'ControllerConnection';
+    edges: Array<Maybe<ControllerEdge>>;
+    nodes: Array<Maybe<Controller>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type ControllerEdge = {
+    __typename?: 'ControllerEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<Controller>;
+};
+export declare enum ControllerOrderBy {
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
+    UserIdAsc = "USER_ID_ASC",
+    UserIdDesc = "USER_ID_DESC"
+}
+export type ControllerPatch = {
+    name?: InputMaybe<Scalars['String']['input']>;
+};
+export type ControllerTransfer = Transfer & {
+    __typename?: 'ControllerTransfer';
+    accountByFromAccountId?: Maybe<Account>;
+    accountByToAccountId?: Maybe<Account>;
+    amount: Scalars['Float']['output'];
+    currency: Scalars['String']['output'];
+    currencyByCurrency?: Maybe<Currency>;
+    expiredAt?: Maybe<Scalars['Datetime']['output']>;
+    fromAccountId: Scalars['UUID']['output'];
+    fromHolderId: Scalars['UUID']['output'];
+    holderByFromHolderId?: Maybe<Holder>;
+    holderByToHolderId?: Maybe<Holder>;
+    id: Scalars['UUID']['output'];
+    metadata: Scalars['JSON']['output'];
+    metadataId?: Maybe<Scalars['String']['output']>;
+    status: TransferStatusKind;
+    statusAt: Scalars['Datetime']['output'];
+    toAccountId: Scalars['UUID']['output'];
+    toHolderId: Scalars['UUID']['output'];
+    transferStatusesByTransferId: TransferStatusConnection;
+    type: TransferType;
+};
+export type ControllerTransferTransferStatusesByTransferIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<TransferStatusCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<TransferStatusOrderBy>>;
+};
+export type ControllerTransferCondition = {
+    currency?: InputMaybe<Scalars['String']['input']>;
+    fromAccountId?: InputMaybe<Scalars['UUID']['input']>;
+    fromHolderId?: InputMaybe<Scalars['UUID']['input']>;
+    id?: InputMaybe<Scalars['UUID']['input']>;
+    toAccountId?: InputMaybe<Scalars['UUID']['input']>;
+    toHolderId?: InputMaybe<Scalars['UUID']['input']>;
+    type?: InputMaybe<TransferType>;
+};
+export type ControllerTransferConnection = {
+    __typename?: 'ControllerTransferConnection';
+    edges: Array<Maybe<ControllerTransferEdge>>;
+    nodes: Array<Maybe<ControllerTransfer>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type ControllerTransferEdge = {
+    __typename?: 'ControllerTransferEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<ControllerTransfer>;
+};
+export declare enum ControllerTransferOrderBy {
+    CurrencyAsc = "CURRENCY_ASC",
+    CurrencyDesc = "CURRENCY_DESC",
+    FromAccountIdAsc = "FROM_ACCOUNT_ID_ASC",
+    FromAccountIdDesc = "FROM_ACCOUNT_ID_DESC",
+    FromHolderIdAsc = "FROM_HOLDER_ID_ASC",
+    FromHolderIdDesc = "FROM_HOLDER_ID_DESC",
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
+    ToAccountIdAsc = "TO_ACCOUNT_ID_ASC",
+    ToAccountIdDesc = "TO_ACCOUNT_ID_DESC",
+    ToHolderIdAsc = "TO_HOLDER_ID_ASC",
+    ToHolderIdDesc = "TO_HOLDER_ID_DESC",
+    TypeAsc = "TYPE_ASC",
+    TypeDesc = "TYPE_DESC"
+}
+export type CreateApiKeyInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    controllerId: Scalars['UUID']['input'];
+    name?: InputMaybe<Scalars['String']['input']>;
+};
+export type CreateApiKeyPayload = {
+    __typename?: 'CreateApiKeyPayload';
+    apiKey?: Maybe<ApiKey>;
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    query?: Maybe<Query>;
+};
+export type CreateControllerInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    name: Scalars['String']['input'];
+};
+export type CreateControllerPayload = {
+    __typename?: 'CreateControllerPayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    controller?: Maybe<Controller>;
+    query?: Maybe<Query>;
+};
+export type CreateExperienceInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    name: Scalars['String']['input'];
+};
+export type CreateExperiencePayload = {
+    __typename?: 'CreateExperiencePayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    experience?: Maybe<Experience>;
+    query?: Maybe<Query>;
+};
+export type CreateUserTokenInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    experienceId: Scalars['UUID']['input'];
+};
+export type CreateUserTokenPayload = {
+    __typename?: 'CreateUserTokenPayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    jwt: Scalars['String']['output'];
+    query?: Maybe<Query>;
+};
+export type Currency = {
+    __typename?: 'Currency';
+    active: Scalars['Boolean']['output'];
+    baseUnitName: Scalars['String']['output'];
+    depositsByCurrencyKey: DepositConnection;
+    displayUnitName: Scalars['String']['output'];
+    displayUnitScale: Scalars['Int']['output'];
+    faucetClaimsByCurrencyKey: FaucetClaimConnection;
+    id: Scalars['String']['output'];
+    invoicesByCurrencyKey: InvoiceConnection;
+    transfersByCurrency: TransferConnection;
+    wholeUnitScale: Scalars['Float']['output'];
+    withdrawalFee: Scalars['Float']['output'];
+};
+export type CurrencyDepositsByCurrencyKeyArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<DepositCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<DepositOrderBy>>;
+};
+export type CurrencyFaucetClaimsByCurrencyKeyArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<FaucetClaimCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<FaucetClaimOrderBy>>;
+};
+export type CurrencyInvoicesByCurrencyKeyArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<InvoiceCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<InvoiceOrderBy>>;
+};
+export type CurrencyTransfersByCurrencyArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<TransferCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<TransferOrderBy>>;
+};
+export type CurrencyCondition = {
+    active?: InputMaybe<Scalars['Boolean']['input']>;
+    id?: InputMaybe<Scalars['String']['input']>;
+};
+export type CurrencyConnection = {
+    __typename?: 'CurrencyConnection';
+    edges: Array<Maybe<CurrencyEdge>>;
+    nodes: Array<Maybe<Currency>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type CurrencyEdge = {
+    __typename?: 'CurrencyEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<Currency>;
+};
+export declare enum CurrencyOrderBy {
+    ActiveAsc = "ACTIVE_ASC",
+    ActiveDesc = "ACTIVE_DESC",
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC"
+}
+export type DeleteApiKeyByIdInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    id: Scalars['UUID']['input'];
+};
+export type DeleteApiKeyByIdPayload = {
+    __typename?: 'DeleteApiKeyByIdPayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    query?: Maybe<Query>;
+};
+export type DeleteControllerByIdInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    id: Scalars['UUID']['input'];
+};
+export type DeleteControllerPayload = {
+    __typename?: 'DeleteControllerPayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    query?: Maybe<Query>;
+};
+export type DeleteExperienceByIdInput = {
+    id: Scalars['UUID']['input'];
+};
+export type DeleteExperiencePayload = {
+    __typename?: 'DeleteExperiencePayload';
+    experience?: Maybe<Experience>;
+    query?: Maybe<Query>;
+};
+export type Deposit = {
+    __typename?: 'Deposit';
+    amount: Scalars['Int']['output'];
+    currencyByCurrencyKey?: Maybe<Currency>;
+    currencyKey: Scalars['String']['output'];
+    depositFee: Scalars['Int']['output'];
+    id: Scalars['UUID']['output'];
+    transactionById?: Maybe<Transaction>;
+};
+export type DepositCondition = {
+    currencyKey?: InputMaybe<Scalars['String']['input']>;
+    id?: InputMaybe<Scalars['UUID']['input']>;
+};
+export type DepositConnection = {
+    __typename?: 'DepositConnection';
+    edges: Array<Maybe<DepositEdge>>;
+    nodes: Array<Maybe<Deposit>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type DepositEdge = {
+    __typename?: 'DepositEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<Deposit>;
+};
+export declare enum DepositOrderBy {
+    CurrencyKeyAsc = "CURRENCY_KEY_ASC",
+    CurrencyKeyDesc = "CURRENCY_KEY_DESC",
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC"
+}
+export type EmailChangeRequest = {
+    __typename?: 'EmailChangeRequest';
+    canceledAt?: Maybe<Scalars['Datetime']['output']>;
+    completedAt?: Maybe<Scalars['Datetime']['output']>;
+    confirmedAt?: Maybe<Scalars['Datetime']['output']>;
+    id: Scalars['UUID']['output'];
+    newEmail: Scalars['String']['output'];
+    oldEmail?: Maybe<Scalars['String']['output']>;
+    userByUserId?: Maybe<User>;
+    userId: Scalars['UUID']['output'];
+    verifiedAt?: Maybe<Scalars['Datetime']['output']>;
+};
+export declare enum EmailStepResult {
+    AllDone = "ALL_DONE",
+    AlreadyDone = "ALREADY_DONE",
+    StepDone = "STEP_DONE"
+}
+export type Experience = {
+    __typename?: 'Experience';
+    controllerByControllerId?: Maybe<Controller>;
+    controllerId?: Maybe<Scalars['UUID']['output']>;
+    deletedAt?: Maybe<Scalars['Datetime']['output']>;
+    experienceTransfersByExperienceId: ExperienceTransferConnection;
+    id: Scalars['UUID']['output'];
+    iframeUrl?: Maybe<Scalars['String']['output']>;
+    name: Scalars['String']['output'];
+    userByUserId?: Maybe<User>;
+    userId: Scalars['UUID']['output'];
+};
+export type ExperienceExperienceTransfersByExperienceIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<ExperienceTransferCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<ExperienceTransferOrderBy>>;
+};
+export type ExperienceCondition = {
+    id?: InputMaybe<Scalars['UUID']['input']>;
+    userId?: InputMaybe<Scalars['UUID']['input']>;
+};
+export type ExperienceConnection = {
+    __typename?: 'ExperienceConnection';
+    edges: Array<Maybe<ExperienceEdge>>;
+    nodes: Array<Maybe<Experience>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type ExperienceEdge = {
+    __typename?: 'ExperienceEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<Experience>;
+};
+export declare enum ExperienceOrderBy {
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
+    UserIdAsc = "USER_ID_ASC",
+    UserIdDesc = "USER_ID_DESC"
+}
+export type ExperiencePatch = {
+    controllerId?: InputMaybe<Scalars['UUID']['input']>;
+    iframeUrl?: InputMaybe<Scalars['String']['input']>;
+    name?: InputMaybe<Scalars['String']['input']>;
+};
+export type ExperienceTransfer = Transfer & {
+    __typename?: 'ExperienceTransfer';
+    accountByFromAccountId?: Maybe<Account>;
+    accountByToAccountId?: Maybe<Account>;
+    amount: Scalars['Float']['output'];
+    currency: Scalars['String']['output'];
+    currencyByCurrency?: Maybe<Currency>;
+    experienceByExperienceId?: Maybe<Experience>;
+    experienceId: Scalars['UUID']['output'];
+    expiredAt?: Maybe<Scalars['Datetime']['output']>;
+    fromAccountId: Scalars['UUID']['output'];
+    fromHolderId: Scalars['UUID']['output'];
+    holderByFromHolderId?: Maybe<Holder>;
+    holderByToHolderId?: Maybe<Holder>;
+    id: Scalars['UUID']['output'];
+    metadata: Scalars['JSON']['output'];
+    metadataId?: Maybe<Scalars['String']['output']>;
+    status: TransferStatusKind;
+    statusAt: Scalars['Datetime']['output'];
+    toAccountId: Scalars['UUID']['output'];
+    toHolderId: Scalars['UUID']['output'];
+    transferStatusesByTransferId: TransferStatusConnection;
+    type: TransferType;
+};
+export type ExperienceTransferTransferStatusesByTransferIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<TransferStatusCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<TransferStatusOrderBy>>;
+};
+export type ExperienceTransferCondition = {
+    currency?: InputMaybe<Scalars['String']['input']>;
+    experienceId?: InputMaybe<Scalars['UUID']['input']>;
+    fromAccountId?: InputMaybe<Scalars['UUID']['input']>;
+    fromHolderId?: InputMaybe<Scalars['UUID']['input']>;
+    id?: InputMaybe<Scalars['UUID']['input']>;
+    toAccountId?: InputMaybe<Scalars['UUID']['input']>;
+    toHolderId?: InputMaybe<Scalars['UUID']['input']>;
+    type?: InputMaybe<TransferType>;
+};
+export type ExperienceTransferConnection = {
+    __typename?: 'ExperienceTransferConnection';
+    edges: Array<Maybe<ExperienceTransferEdge>>;
+    nodes: Array<Maybe<ExperienceTransfer>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type ExperienceTransferEdge = {
+    __typename?: 'ExperienceTransferEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<ExperienceTransfer>;
+};
+export declare enum ExperienceTransferOrderBy {
+    CurrencyAsc = "CURRENCY_ASC",
+    CurrencyDesc = "CURRENCY_DESC",
+    ExperienceIdAsc = "EXPERIENCE_ID_ASC",
+    ExperienceIdDesc = "EXPERIENCE_ID_DESC",
+    FromAccountIdAsc = "FROM_ACCOUNT_ID_ASC",
+    FromAccountIdDesc = "FROM_ACCOUNT_ID_DESC",
+    FromHolderIdAsc = "FROM_HOLDER_ID_ASC",
+    FromHolderIdDesc = "FROM_HOLDER_ID_DESC",
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
+    ToAccountIdAsc = "TO_ACCOUNT_ID_ASC",
+    ToAccountIdDesc = "TO_ACCOUNT_ID_DESC",
+    ToHolderIdAsc = "TO_HOLDER_ID_ASC",
+    ToHolderIdDesc = "TO_HOLDER_ID_DESC",
+    TypeAsc = "TYPE_ASC",
+    TypeDesc = "TYPE_DESC"
+}
+export type FaucetClaim = {
+    __typename?: 'FaucetClaim';
+    amount: Scalars['Float']['output'];
+    currencyByCurrencyKey?: Maybe<Currency>;
+    currencyKey: Scalars['String']['output'];
+    holderByHolderId?: Maybe<Holder>;
+    holderId: Scalars['UUID']['output'];
+    id: Scalars['UUID']['output'];
+};
+export type FaucetClaimCondition = {
+    currencyKey?: InputMaybe<Scalars['String']['input']>;
+    holderId?: InputMaybe<Scalars['UUID']['input']>;
+    id?: InputMaybe<Scalars['UUID']['input']>;
+};
+export type FaucetClaimConnection = {
+    __typename?: 'FaucetClaimConnection';
+    edges: Array<Maybe<FaucetClaimEdge>>;
+    nodes: Array<Maybe<FaucetClaim>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type FaucetClaimEdge = {
+    __typename?: 'FaucetClaimEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<FaucetClaim>;
+};
+export declare enum FaucetClaimOrderBy {
+    CurrencyKeyAsc = "CURRENCY_KEY_ASC",
+    CurrencyKeyDesc = "CURRENCY_KEY_DESC",
+    HolderIdAsc = "HOLDER_ID_ASC",
+    HolderIdDesc = "HOLDER_ID_DESC",
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC"
+}
+export type GeneralTransfer = Transfer & {
+    __typename?: 'GeneralTransfer';
+    accountByFromAccountId?: Maybe<Account>;
+    accountByToAccountId?: Maybe<Account>;
+    amount: Scalars['Float']['output'];
+    currency: Scalars['String']['output'];
+    currencyByCurrency?: Maybe<Currency>;
+    expiredAt?: Maybe<Scalars['Datetime']['output']>;
+    fromAccountId: Scalars['UUID']['output'];
+    fromHolderId: Scalars['UUID']['output'];
+    holderByFromHolderId?: Maybe<Holder>;
+    holderByToHolderId?: Maybe<Holder>;
+    id: Scalars['UUID']['output'];
+    metadata: Scalars['JSON']['output'];
+    metadataId?: Maybe<Scalars['String']['output']>;
+    status: TransferStatusKind;
+    statusAt: Scalars['Datetime']['output'];
+    toAccountId: Scalars['UUID']['output'];
+    toHolderId: Scalars['UUID']['output'];
+    transferStatusesByTransferId: TransferStatusConnection;
+    type: TransferType;
+};
+export type GeneralTransferTransferStatusesByTransferIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<TransferStatusCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<TransferStatusOrderBy>>;
+};
+export type GeneralTransferCondition = {
+    currency?: InputMaybe<Scalars['String']['input']>;
+    fromAccountId?: InputMaybe<Scalars['UUID']['input']>;
+    fromHolderId?: InputMaybe<Scalars['UUID']['input']>;
+    id?: InputMaybe<Scalars['UUID']['input']>;
+    toAccountId?: InputMaybe<Scalars['UUID']['input']>;
+    toHolderId?: InputMaybe<Scalars['UUID']['input']>;
+    type?: InputMaybe<TransferType>;
+};
+export type GeneralTransferConnection = {
+    __typename?: 'GeneralTransferConnection';
+    edges: Array<Maybe<GeneralTransferEdge>>;
+    nodes: Array<Maybe<GeneralTransfer>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type GeneralTransferEdge = {
+    __typename?: 'GeneralTransferEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<GeneralTransfer>;
+};
+export declare enum GeneralTransferOrderBy {
+    CurrencyAsc = "CURRENCY_ASC",
+    CurrencyDesc = "CURRENCY_DESC",
+    FromAccountIdAsc = "FROM_ACCOUNT_ID_ASC",
+    FromAccountIdDesc = "FROM_ACCOUNT_ID_DESC",
+    FromHolderIdAsc = "FROM_HOLDER_ID_ASC",
+    FromHolderIdDesc = "FROM_HOLDER_ID_DESC",
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
+    ToAccountIdAsc = "TO_ACCOUNT_ID_ASC",
+    ToAccountIdDesc = "TO_ACCOUNT_ID_DESC",
+    ToHolderIdAsc = "TO_HOLDER_ID_ASC",
+    ToHolderIdDesc = "TO_HOLDER_ID_DESC",
+    TypeAsc = "TYPE_ASC",
+    TypeDesc = "TYPE_DESC"
+}
+export type GenerateKeyPairError = {
+    __typename?: 'GenerateKeyPairError';
+    message: Scalars['String']['output'];
+};
+export type GenerateKeyPairInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+};
+export type GenerateKeyPairPayload = {
+    __typename?: 'GenerateKeyPairPayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    result: GenerateKeyPairResult;
+};
+export type GenerateKeyPairResult = GenerateKeyPairError | GenerateKeyPairSuccess;
+export type GenerateKeyPairSuccess = {
+    __typename?: 'GenerateKeyPairSuccess';
+    keyPair: KeyPair;
+};
+export type GetDepositInvoiceInput = {
+    currency: Scalars['String']['input'];
+};
+export type GetDepositInvoicePayload = {
+    __typename?: 'GetDepositInvoicePayload';
+    address: Scalars['String']['output'];
+    chillId: Scalars['UUID']['output'];
+};
+export type Holder = {
+    accountByCurrency?: Maybe<Account>;
+    accountsByHolderId: AccountConnection;
+    balanceByCurrency?: Maybe<Scalars['Float']['output']>;
+    deletedAt?: Maybe<Scalars['Datetime']['output']>;
+    faucetClaimsByHolderId: FaucetClaimConnection;
+    id: Scalars['UUID']['output'];
+    kind: HolderKind;
+    transfersByFromHolderId: TransferConnection;
+    transfersByToHolderId: TransferConnection;
+};
+export type HolderAccountByCurrencyArgs = {
+    currency: Scalars['String']['input'];
+};
+export type HolderAccountsByHolderIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+};
+export type HolderBalanceByCurrencyArgs = {
+    currency: Scalars['String']['input'];
+};
+export type HolderFaucetClaimsByHolderIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+};
+export type HolderTransfersByFromHolderIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+};
+export type HolderTransfersByToHolderIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+};
+export type HolderCondition = {
+    id?: InputMaybe<Scalars['UUID']['input']>;
+};
+export type HolderConnection = {
+    __typename?: 'HolderConnection';
+    edges: Array<Maybe<HolderEdge>>;
+    nodes: Array<Maybe<Holder>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type HolderEdge = {
+    __typename?: 'HolderEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<Holder>;
+};
+export declare enum HolderKind {
+    Controller = "CONTROLLER",
+    User = "USER"
+}
+export declare enum HolderOrderBy {
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC"
+}
+export declare enum IncludeDeletedOption {
+    Exclusively = "EXCLUSIVELY",
+    Inherit = "INHERIT",
+    No = "NO",
+    Yes = "YES"
+}
+export declare enum IncludeExpiredOption {
+    Exclusively = "EXCLUSIVELY",
+    Inherit = "INHERIT",
+    No = "NO",
+    Yes = "YES"
+}
+export declare enum IncludeRevokedOption {
+    Exclusively = "EXCLUSIVELY",
+    Inherit = "INHERIT",
+    No = "NO",
+    Yes = "YES"
+}
+export type InvalidTransferStatus = {
+    __typename?: 'InvalidTransferStatus';
+    currentStatus: TransferStatusKind;
+    message: Scalars['String']['output'];
+};
+export type Invoice = {
+    __typename?: 'Invoice';
+    address: Scalars['String']['output'];
+    chillId: Scalars['UUID']['output'];
+    createdAt: Scalars['Datetime']['output'];
+    currencyByCurrencyKey?: Maybe<Currency>;
+    currencyKey: Scalars['String']['output'];
+    expiredAt: Scalars['Datetime']['output'];
+    id: Scalars['UUID']['output'];
+    json: Scalars['JSON']['output'];
+    profileId: Scalars['String']['output'];
+    transactionsByInvoiceId: TransactionConnection;
+    userByUserId?: Maybe<User>;
+    userId: Scalars['UUID']['output'];
+};
+export type InvoiceTransactionsByInvoiceIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<TransactionCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<TransactionOrderBy>>;
+};
+export type InvoiceCondition = {
+    chillId?: InputMaybe<Scalars['UUID']['input']>;
+    currencyKey?: InputMaybe<Scalars['String']['input']>;
+    id?: InputMaybe<Scalars['UUID']['input']>;
+    userId?: InputMaybe<Scalars['UUID']['input']>;
+};
+export type InvoiceConnection = {
+    __typename?: 'InvoiceConnection';
+    edges: Array<Maybe<InvoiceEdge>>;
+    nodes: Array<Maybe<Invoice>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type InvoiceEdge = {
+    __typename?: 'InvoiceEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<Invoice>;
+};
+export declare enum InvoiceOrderBy {
+    ChillIdAsc = "CHILL_ID_ASC",
+    ChillIdDesc = "CHILL_ID_DESC",
+    CurrencyKeyAsc = "CURRENCY_KEY_ASC",
+    CurrencyKeyDesc = "CURRENCY_KEY_DESC",
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
+    UserIdAsc = "USER_ID_ASC",
+    UserIdDesc = "USER_ID_DESC"
+}
+export type KeyPair = {
+    __typename?: 'KeyPair';
+    id: Scalars['UUID']['output'];
+    publicKey: Scalars['Base64EncodedBinary']['output'];
+    revokedAt?: Maybe<Scalars['Datetime']['output']>;
+};
+export type KeyPairCondition = {
+    id?: InputMaybe<Scalars['UUID']['input']>;
+};
+export type KeyPairConnection = {
+    __typename?: 'KeyPairConnection';
+    edges: Array<Maybe<KeyPairEdge>>;
+    nodes: Array<Maybe<KeyPair>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type KeyPairEdge = {
+    __typename?: 'KeyPairEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<KeyPair>;
+};
+export declare enum KeyPairOrderBy {
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC"
+}
+export type LoginMagicTokenInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    token: Scalars['UUID']['input'];
+};
+export type LoginMagicTokenPayload = {
+    __typename?: 'LoginMagicTokenPayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    query?: Maybe<Query>;
+    sessionKey?: Maybe<Scalars['UUID']['output']>;
+};
+export type LoginOneTimeCodeInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    code: Scalars['String']['input'];
+    email: Scalars['String']['input'];
+};
+export type LoginOneTimeCodePayload = {
+    __typename?: 'LoginOneTimeCodePayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    query?: Maybe<Query>;
+    sessionKey?: Maybe<Scalars['UUID']['output']>;
+};
+export type Mutation = {
+    __typename?: 'Mutation';
+    cancelPendingEmailChangeRequest?: Maybe<CancelPendingEmailChangeRequestPayload>;
+    cancelTransfer?: Maybe<CancelTransferPayload>;
+    claimFaucet?: Maybe<ClaimFaucetPayload>;
+    claimTransfer?: Maybe<ClaimTransferPayload>;
+    completeTransfer?: Maybe<CompleteTransferPayload>;
+    confirmEmailToken?: Maybe<ConfirmEmailTokenPayload>;
+    createApiKey?: Maybe<CreateApiKeyPayload>;
+    createController?: Maybe<CreateControllerPayload>;
+    createExperience?: Maybe<CreateExperiencePayload>;
+    createMatrixLoginToken?: Maybe<Scalars['String']['output']>;
+    createOidcAuthorizationCode?: Maybe<Scalars['String']['output']>;
+    createUserToken?: Maybe<CreateUserTokenPayload>;
+    deleteApiKeyById: DeleteApiKeyByIdPayload;
+    deleteControllerById?: Maybe<DeleteControllerPayload>;
+    deleteExperienceById?: Maybe<DeleteExperiencePayload>;
+    generateKeyPair?: Maybe<GenerateKeyPairPayload>;
+    loginMagicToken?: Maybe<LoginMagicTokenPayload>;
+    loginOneTimeCode?: Maybe<LoginOneTimeCodePayload>;
+    registerUser?: Maybe<RegisterUserPayload>;
+    resendEmailConfirmation?: Maybe<ResendEmailConfirmationPayload>;
+    resendEmailVerification?: Maybe<ResendEmailVerificationPayload>;
+    revokeKeyPair?: Maybe<RevokeKeyPairPayload>;
+    revokeSession?: Maybe<RevokeSessionPayload>;
+    sendOneTimeLoginCode?: Maybe<SendOneTimeLoginCodePayload>;
+    startEmailChange?: Maybe<StartEmailChangePayload>;
+    startLogin?: Maybe<StartLoginPayload>;
+    startPayout: StartPayoutPayload;
+    toyLogin?: Maybe<ToyLoginPayload>;
+    transferCurrencyExperienceToUser?: Maybe<TransferCurrencyExperienceToUserPayload>;
+    transferCurrencyFromController?: Maybe<TransferCurrencyFromControllerPayload>;
+    transferCurrencyToController?: Maybe<TransferCurrencyToControllerPayload>;
+    transferCurrencyToExperience?: Maybe<TransferCurrencyToExperiencePayload>;
+    transferCurrencyUserToUname?: Maybe<TransferCurrencyUserToUnamePayload>;
+    updateControllerById?: Maybe<UpdateControllerPayload>;
+    updateExperienceById?: Maybe<UpdateExperiencePayload>;
+    userFromUserToken?: Maybe<UserFromUserTokenPayload>;
+    verifyEmailToken?: Maybe<VerifyEmailTokenPayload>;
+};
+export type MutationCancelPendingEmailChangeRequestArgs = {
+    input: CancelPendingEmailChangeRequestInput;
+};
+export type MutationCancelTransferArgs = {
+    input: CancelTransferInput;
+};
+export type MutationClaimFaucetArgs = {
+    input: ClaimFaucetInput;
+};
+export type MutationClaimTransferArgs = {
+    input: ClaimTransferInput;
+};
+export type MutationCompleteTransferArgs = {
+    input: CompleteTransferInput;
+};
+export type MutationConfirmEmailTokenArgs = {
+    input: ConfirmEmailTokenInput;
+};
+export type MutationCreateApiKeyArgs = {
+    input: CreateApiKeyInput;
+};
+export type MutationCreateControllerArgs = {
+    input: CreateControllerInput;
+};
+export type MutationCreateExperienceArgs = {
+    input: CreateExperienceInput;
+};
+export type MutationCreateMatrixLoginTokenArgs = {
+    userId: Scalars['UUID']['input'];
+};
+export type MutationCreateOidcAuthorizationCodeArgs = {
+    nonce?: InputMaybe<Scalars['String']['input']>;
+    userId: Scalars['UUID']['input'];
+};
+export type MutationCreateUserTokenArgs = {
+    input: CreateUserTokenInput;
+};
+export type MutationDeleteApiKeyByIdArgs = {
+    input?: InputMaybe<DeleteApiKeyByIdInput>;
+};
+export type MutationDeleteControllerByIdArgs = {
+    input: DeleteControllerByIdInput;
+};
+export type MutationDeleteExperienceByIdArgs = {
+    input: DeleteExperienceByIdInput;
+};
+export type MutationGenerateKeyPairArgs = {
+    input?: InputMaybe<GenerateKeyPairInput>;
+};
+export type MutationLoginMagicTokenArgs = {
+    input: LoginMagicTokenInput;
+};
+export type MutationLoginOneTimeCodeArgs = {
+    input: LoginOneTimeCodeInput;
+};
+export type MutationRegisterUserArgs = {
+    input: RegisterUserInput;
+};
+export type MutationResendEmailConfirmationArgs = {
+    input?: InputMaybe<ResendEmailConfirmationInput>;
+};
+export type MutationResendEmailVerificationArgs = {
+    input?: InputMaybe<ResendEmailVerificationInput>;
+};
+export type MutationRevokeKeyPairArgs = {
+    input: RevokeKeyPairInput;
+};
+export type MutationRevokeSessionArgs = {
+    input: RevokeSessionInput;
+};
+export type MutationSendOneTimeLoginCodeArgs = {
+    input: SendOneTimeLoginCodeInput;
+};
+export type MutationStartEmailChangeArgs = {
+    input: StartEmailChangeInput;
+};
+export type MutationStartLoginArgs = {
+    input: StartLoginInput;
+};
+export type MutationStartPayoutArgs = {
+    input: StartPayoutInput;
+};
+export type MutationToyLoginArgs = {
+    input: ToyLoginInput;
+};
+export type MutationTransferCurrencyExperienceToUserArgs = {
+    input: TransferCurrencyExperienceToUserInput;
+};
+export type MutationTransferCurrencyFromControllerArgs = {
+    input: TransferCurrencyFromControllerInput;
+};
+export type MutationTransferCurrencyToControllerArgs = {
+    input: TransferCurrencyToControllerInput;
+};
+export type MutationTransferCurrencyToExperienceArgs = {
+    input: TransferCurrencyToExperienceInput;
+};
+export type MutationTransferCurrencyUserToUnameArgs = {
+    input: TransferCurrencyUserToUnameInput;
+};
+export type MutationUpdateControllerByIdArgs = {
+    input: UpdateControllerByIdInput;
+};
+export type MutationUpdateExperienceByIdArgs = {
+    input: UpdateExperienceByIdInput;
+};
+export type MutationUserFromUserTokenArgs = {
+    input: UserFromUserTokenInput;
+};
+export type MutationVerifyEmailTokenArgs = {
+    input: VerifyEmailTokenInput;
+};
+export declare enum Network {
+    Mainnet = "mainnet",
+    Testnet = "testnet"
+}
+export type PageInfo = {
+    __typename?: 'PageInfo';
+    endCursor?: Maybe<Scalars['Cursor']['output']>;
+    hasNextPage: Scalars['Boolean']['output'];
+    hasPreviousPage: Scalars['Boolean']['output'];
+    startCursor?: Maybe<Scalars['Cursor']['output']>;
+};
+export type Payout = {
+    __typename?: 'Payout';
+    chillId: Scalars['UUID']['output'];
+    createdAt: Scalars['Datetime']['output'];
+    id: Scalars['UUID']['output'];
+    json: Scalars['JSON']['output'];
+    lastFetchAt: Scalars['Datetime']['output'];
+    pendingPayoutByReferenceId?: Maybe<PendingPayout>;
+    profileId: Scalars['UUID']['output'];
+    referenceId: Scalars['UUID']['output'];
+    status: PayoutStatus;
+    withdrawalByPayoutId?: Maybe<Withdrawal>;
+};
+export type PayoutCondition = {
+    chillId?: InputMaybe<Scalars['UUID']['input']>;
+    id?: InputMaybe<Scalars['UUID']['input']>;
+    referenceId?: InputMaybe<Scalars['UUID']['input']>;
+};
+export type PayoutConnection = {
+    __typename?: 'PayoutConnection';
+    edges: Array<Maybe<PayoutEdge>>;
+    nodes: Array<Maybe<Payout>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type PayoutEdge = {
+    __typename?: 'PayoutEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<Payout>;
+};
+export declare enum PayoutOrderBy {
+    ChillIdAsc = "CHILL_ID_ASC",
+    ChillIdDesc = "CHILL_ID_DESC",
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
+    ReferenceIdAsc = "REFERENCE_ID_ASC",
+    ReferenceIdDesc = "REFERENCE_ID_DESC"
+}
+export declare enum PayoutStatus {
+    AwaitingFunds = "awaiting_funds",
+    Complete = "complete",
+    Confirmed = "confirmed",
+    Draft = "draft",
+    New = "new",
+    Pending = "pending",
+    Rejected = "rejected",
+    Unconfirmed = "unconfirmed"
+}
+export type PendingPayout = {
+    __typename?: 'PendingPayout';
+    address: Scalars['String']['output'];
+    amount: Scalars['Int']['output'];
+    attemptCount: Scalars['Int']['output'];
+    currencyByCurrencyKey?: Maybe<Currency>;
+    currencyKey: Scalars['String']['output'];
+    id: Scalars['UUID']['output'];
+    lastAttemptAt?: Maybe<Scalars['Datetime']['output']>;
+    payoutByReferenceId?: Maybe<Payout>;
+    pendingPayoutAttemptsByPendingPayoutId: PendingPayoutAttemptConnection;
+    status: PendingPayoutStatus;
+    userByUserId?: Maybe<User>;
+    userId: Scalars['UUID']['output'];
+    withdrawalFee: Scalars['Int']['output'];
+};
+export type PendingPayoutPendingPayoutAttemptsByPendingPayoutIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<PendingPayoutAttemptCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<PendingPayoutAttemptOrderBy>>;
+};
+export type PendingPayoutAttempt = {
+    __typename?: 'PendingPayoutAttempt';
+    errorMessage?: Maybe<Scalars['String']['output']>;
+    errorReason?: Maybe<Scalars['String']['output']>;
+    httpStatus: Scalars['Int']['output'];
+    id: Scalars['UUID']['output'];
+    json: Scalars['JSON']['output'];
+    pendingPayoutByPendingPayoutId?: Maybe<PendingPayout>;
+    pendingPayoutId: Scalars['UUID']['output'];
+};
+export type PendingPayoutAttemptCondition = {
+    id?: InputMaybe<Scalars['UUID']['input']>;
+    pendingPayoutId?: InputMaybe<Scalars['UUID']['input']>;
+};
+export type PendingPayoutAttemptConnection = {
+    __typename?: 'PendingPayoutAttemptConnection';
+    edges: Array<Maybe<PendingPayoutAttemptEdge>>;
+    nodes: Array<Maybe<PendingPayoutAttempt>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type PendingPayoutAttemptEdge = {
+    __typename?: 'PendingPayoutAttemptEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<PendingPayoutAttempt>;
+};
+export declare enum PendingPayoutAttemptOrderBy {
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PendingPayoutIdAsc = "PENDING_PAYOUT_ID_ASC",
+    PendingPayoutIdDesc = "PENDING_PAYOUT_ID_DESC",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC"
+}
+export type PendingPayoutCondition = {
+    id?: InputMaybe<Scalars['UUID']['input']>;
+    status?: InputMaybe<PendingPayoutStatus>;
+    userId?: InputMaybe<Scalars['UUID']['input']>;
+};
+export type PendingPayoutConnection = {
+    __typename?: 'PendingPayoutConnection';
+    edges: Array<Maybe<PendingPayoutEdge>>;
+    nodes: Array<Maybe<PendingPayout>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type PendingPayoutEdge = {
+    __typename?: 'PendingPayoutEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<PendingPayout>;
+};
+export declare enum PendingPayoutOrderBy {
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
+    StatusAsc = "STATUS_ASC",
+    StatusDesc = "STATUS_DESC",
+    UserIdAsc = "USER_ID_ASC",
+    UserIdDesc = "USER_ID_DESC"
+}
+export declare enum PendingPayoutStatus {
+    Error = "error",
+    PayoutCreated = "payout_created",
+    Pending = "pending"
+}
+export type Query = {
+    __typename?: 'Query';
+    accountByHolderIdAndCurrency?: Maybe<Account>;
+    accountById?: Maybe<Account>;
+    activeSessionById?: Maybe<ActiveSession>;
+    allAccounts?: Maybe<AccountConnection>;
+    allActiveSessions?: Maybe<ActiveSessionConnection>;
+    allApiKeys?: Maybe<ApiKeyConnection>;
+    allAuthnLoginRequests?: Maybe<AuthnLoginRequestConnection>;
+    allAuthnRegisterRequests?: Maybe<AuthnRegisterRequestConnection>;
+    allAuthnRequests?: Maybe<AuthnRequestConnection>;
+    allControllerTransfers?: Maybe<ControllerTransferConnection>;
+    allControllers?: Maybe<ControllerConnection>;
+    allCurrencies?: Maybe<CurrencyConnection>;
+    allDeposits?: Maybe<DepositConnection>;
+    allExperienceTransfers?: Maybe<ExperienceTransferConnection>;
+    allExperiences?: Maybe<ExperienceConnection>;
+    allFaucetClaims?: Maybe<FaucetClaimConnection>;
+    allGeneralTransfers?: Maybe<GeneralTransferConnection>;
+    allHolders?: Maybe<HolderConnection>;
+    allInvoices?: Maybe<InvoiceConnection>;
+    allKeyPairs?: Maybe<KeyPairConnection>;
+    allPayouts?: Maybe<PayoutConnection>;
+    allPendingPayoutAttempts?: Maybe<PendingPayoutAttemptConnection>;
+    allPendingPayouts?: Maybe<PendingPayoutConnection>;
+    allSessions?: Maybe<SessionConnection>;
+    allTransactions?: Maybe<TransactionConnection>;
+    allTransferStatuses?: Maybe<TransferStatusConnection>;
+    allTransfers?: Maybe<TransferConnection>;
+    allUserEmails?: Maybe<UserEmailConnection>;
+    allUserTransfers?: Maybe<UserTransferConnection>;
+    allUsers?: Maybe<UserConnection>;
+    allWithdrawals?: Maybe<WithdrawalConnection>;
+    apiKeyById?: Maybe<ApiKey>;
+    apiKeyByKey?: Maybe<ApiKey>;
+    authnLoginRequestById?: Maybe<AuthnLoginRequest>;
+    authnRegisterRequestById?: Maybe<AuthnRegisterRequest>;
+    authnRequestById?: Maybe<AuthnRequest>;
+    controllerById?: Maybe<Controller>;
+    controllerTransferById?: Maybe<ControllerTransfer>;
+    currencyById?: Maybe<Currency>;
+    currentController?: Maybe<Controller>;
+    currentUser?: Maybe<User>;
+    depositById?: Maybe<Deposit>;
+    experienceById?: Maybe<Experience>;
+    experienceTransferById?: Maybe<ExperienceTransfer>;
+    faucetClaimById?: Maybe<FaucetClaim>;
+    generalTransferById?: Maybe<GeneralTransfer>;
+    getDepositInvoice: GetDepositInvoicePayload;
+    invoiceByChillId?: Maybe<Invoice>;
+    invoiceById?: Maybe<Invoice>;
+    jwks: Scalars['JSON']['output'];
+    keyPairById?: Maybe<KeyPair>;
+    keyPairByPrivateKey?: Maybe<KeyPair>;
+    payoutByChillId?: Maybe<Payout>;
+    payoutById?: Maybe<Payout>;
+    payoutByReferenceId?: Maybe<Payout>;
+    pendingEmailChangeRequest?: Maybe<EmailChangeRequest>;
+    pendingPayoutAttemptById?: Maybe<PendingPayoutAttempt>;
+    pendingPayoutById?: Maybe<PendingPayout>;
+    query: Query;
+    sessionById?: Maybe<Session>;
+    sessionByKey?: Maybe<Session>;
+    transactionByChillId?: Maybe<Transaction>;
+    transactionById?: Maybe<Transaction>;
+    transferStatusById?: Maybe<TransferStatus>;
+    transfersByExperience?: Maybe<TransfersByExperienceConnection>;
+    transfersByHolder?: Maybe<TransfersByHolderConnection>;
+    userById?: Maybe<User>;
+    userByUname?: Maybe<User>;
+    userEmailById?: Maybe<UserEmail>;
+    userTransferById?: Maybe<UserTransfer>;
+    withdrawalById?: Maybe<Withdrawal>;
+    withdrawalByPayoutId?: Maybe<Withdrawal>;
+};
+export type QueryAccountByHolderIdAndCurrencyArgs = {
+    currency: Scalars['String']['input'];
+    holderId: Scalars['UUID']['input'];
+};
+export type QueryAccountByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryActiveSessionByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryAllAccountsArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<AccountCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<AccountOrderBy>>;
+};
+export type QueryAllActiveSessionsArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    includeRevoked?: InputMaybe<IncludeRevokedOption>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<ActiveSessionOrderBy>>;
+};
+export type QueryAllApiKeysArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<ApiKeyCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    includeRevoked?: InputMaybe<IncludeRevokedOption>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<ApiKeyOrderBy>>;
+};
+export type QueryAllAuthnLoginRequestsArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<AuthnLoginRequestCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<AuthnLoginRequestOrderBy>>;
+};
+export type QueryAllAuthnRegisterRequestsArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<AuthnRegisterRequestCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<AuthnRegisterRequestOrderBy>>;
+};
+export type QueryAllAuthnRequestsArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<AuthnRequestCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<AuthnRequestOrderBy>>;
+};
+export type QueryAllControllerTransfersArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<ControllerTransferCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<ControllerTransferOrderBy>>;
+};
+export type QueryAllControllersArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<ControllerCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    includeDeleted?: InputMaybe<IncludeDeletedOption>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<ControllerOrderBy>>;
+};
+export type QueryAllCurrenciesArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<CurrencyCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<CurrencyOrderBy>>;
+};
+export type QueryAllDepositsArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<DepositCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<DepositOrderBy>>;
+};
+export type QueryAllExperienceTransfersArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<ExperienceTransferCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<ExperienceTransferOrderBy>>;
+};
+export type QueryAllExperiencesArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<ExperienceCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    includeDeleted?: InputMaybe<IncludeDeletedOption>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<ExperienceOrderBy>>;
+};
+export type QueryAllFaucetClaimsArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<FaucetClaimCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<FaucetClaimOrderBy>>;
+};
+export type QueryAllGeneralTransfersArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<GeneralTransferCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<GeneralTransferOrderBy>>;
+};
+export type QueryAllHoldersArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<HolderCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    includeDeleted?: InputMaybe<IncludeDeletedOption>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<HolderOrderBy>>;
+};
+export type QueryAllInvoicesArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<InvoiceCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<InvoiceOrderBy>>;
+};
+export type QueryAllKeyPairsArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<KeyPairCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    includeRevoked?: InputMaybe<IncludeRevokedOption>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<KeyPairOrderBy>>;
+};
+export type QueryAllPayoutsArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<PayoutCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<PayoutOrderBy>>;
+};
+export type QueryAllPendingPayoutAttemptsArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<PendingPayoutAttemptCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<PendingPayoutAttemptOrderBy>>;
+};
+export type QueryAllPendingPayoutsArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<PendingPayoutCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<PendingPayoutOrderBy>>;
+};
+export type QueryAllSessionsArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<SessionCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    includeExpired?: InputMaybe<IncludeExpiredOption>;
+    includeRevoked?: InputMaybe<IncludeRevokedOption>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<SessionOrderBy>>;
+};
+export type QueryAllTransactionsArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<TransactionCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<TransactionOrderBy>>;
+};
+export type QueryAllTransferStatusesArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<TransferStatusCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<TransferStatusOrderBy>>;
+};
+export type QueryAllTransfersArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<TransferCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<TransferOrderBy>>;
+};
+export type QueryAllUserEmailsArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<UserEmailCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<UserEmailOrderBy>>;
+};
+export type QueryAllUserTransfersArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<UserTransferCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<UserTransferOrderBy>>;
+};
+export type QueryAllUsersArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<UserCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    includeDeleted?: InputMaybe<IncludeDeletedOption>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<UserOrderBy>>;
+};
+export type QueryAllWithdrawalsArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<WithdrawalCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<WithdrawalOrderBy>>;
+};
+export type QueryApiKeyByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryApiKeyByKeyArgs = {
+    key: Scalars['UUID']['input'];
+};
+export type QueryAuthnLoginRequestByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryAuthnRegisterRequestByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryAuthnRequestByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryControllerByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryControllerTransferByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryCurrencyByIdArgs = {
+    id: Scalars['String']['input'];
+};
+export type QueryDepositByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryExperienceByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryExperienceTransferByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryFaucetClaimByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryGeneralTransferByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryGetDepositInvoiceArgs = {
+    input: GetDepositInvoiceInput;
+};
+export type QueryInvoiceByChillIdArgs = {
+    chillId: Scalars['UUID']['input'];
+};
+export type QueryInvoiceByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryKeyPairByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryKeyPairByPrivateKeyArgs = {
+    privateKey: Scalars['Base64EncodedBinary']['input'];
+};
+export type QueryPayoutByChillIdArgs = {
+    chillId: Scalars['UUID']['input'];
+};
+export type QueryPayoutByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryPayoutByReferenceIdArgs = {
+    referenceId: Scalars['UUID']['input'];
+};
+export type QueryPendingPayoutAttemptByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryPendingPayoutByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QuerySessionByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QuerySessionByKeyArgs = {
+    key: Scalars['UUID']['input'];
+};
+export type QueryTransactionByChillIdArgs = {
+    chillId: Scalars['UUID']['input'];
+};
+export type QueryTransactionByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryTransferStatusByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryTransfersByExperienceArgs = {
+    input: TransfersByExperienceInput;
+};
+export type QueryTransfersByHolderArgs = {
+    input: TransfersByHolderInput;
+};
+export type QueryUserByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryUserByUnameArgs = {
+    uname: Scalars['String']['input'];
+};
+export type QueryUserEmailByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryUserTransferByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryWithdrawalByIdArgs = {
+    id: Scalars['UUID']['input'];
+};
+export type QueryWithdrawalByPayoutIdArgs = {
+    payoutId: Scalars['UUID']['input'];
+};
+export type RegisterUserInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    email: Scalars['String']['input'];
+    uname: Scalars['String']['input'];
+};
+export type RegisterUserPayload = {
+    __typename?: 'RegisterUserPayload';
+    authnRequestId: Scalars['UUID']['output'];
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    devLoginUrl?: Maybe<Scalars['String']['output']>;
+    query?: Maybe<Query>;
+};
+export type ResendEmailConfirmationInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+};
+export type ResendEmailConfirmationPayload = {
+    __typename?: 'ResendEmailConfirmationPayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    result?: Maybe<ResendEmailResult>;
+};
+export declare enum ResendEmailResult {
+    AlreadyDone = "ALREADY_DONE",
+    Enqueued = "ENQUEUED",
+    NoPendingRequest = "NO_PENDING_REQUEST"
+}
+export type ResendEmailVerificationInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+};
+export type ResendEmailVerificationPayload = {
+    __typename?: 'ResendEmailVerificationPayload';
+    result?: Maybe<ResendEmailResult>;
+};
+export type RevokeKeyPairError = {
+    __typename?: 'RevokeKeyPairError';
+    message: Scalars['String']['output'];
+};
+export type RevokeKeyPairInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    id: Scalars['UUID']['input'];
+};
+export type RevokeKeyPairPayload = {
+    __typename?: 'RevokeKeyPairPayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    result: RevokeKeyPairResult;
+};
+export type RevokeKeyPairResult = RevokeKeyPairError | RevokeKeyPairSuccess;
+export type RevokeKeyPairSuccess = {
+    __typename?: 'RevokeKeyPairSuccess';
+    keyPair: KeyPair;
+};
+export type RevokeSessionInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    sessionId: Scalars['UUID']['input'];
+};
+export type RevokeSessionPayload = {
+    __typename?: 'RevokeSessionPayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    session?: Maybe<Session>;
+};
+export type SendOneTimeLoginCodeInput = {
+    authnRequestId: Scalars['UUID']['input'];
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+};
+export type SendOneTimeLoginCodePayload = {
+    __typename?: 'SendOneTimeLoginCodePayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+};
+export type Session = {
+    __typename?: 'Session';
+    expiredAt: Scalars['Datetime']['output'];
+    id: Scalars['UUID']['output'];
+    key: Scalars['UUID']['output'];
+    lastUsedAt?: Maybe<Scalars['Datetime']['output']>;
+    revokedAt?: Maybe<Scalars['Datetime']['output']>;
+    trackingId: Scalars['UUID']['output'];
+    userAgent?: Maybe<Scalars['String']['output']>;
+    userByUserId?: Maybe<User>;
+    userId: Scalars['UUID']['output'];
+};
+export type SessionCondition = {
+    id?: InputMaybe<Scalars['UUID']['input']>;
+    key?: InputMaybe<Scalars['UUID']['input']>;
+    userId?: InputMaybe<Scalars['UUID']['input']>;
+};
+export type SessionConnection = {
+    __typename?: 'SessionConnection';
+    edges: Array<Maybe<SessionEdge>>;
+    nodes: Array<Maybe<Session>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type SessionEdge = {
+    __typename?: 'SessionEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<Session>;
+};
+export declare enum SessionOrderBy {
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    KeyAsc = "KEY_ASC",
+    KeyDesc = "KEY_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
+    UserIdAsc = "USER_ID_ASC",
+    UserIdDesc = "USER_ID_DESC"
+}
+export type StartEmailChangeInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    newEmail: Scalars['String']['input'];
+};
+export type StartEmailChangePayload = {
+    __typename?: 'StartEmailChangePayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    query?: Maybe<Query>;
+    result?: Maybe<Scalars['Boolean']['output']>;
+};
+export type StartLoginInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    email: Scalars['String']['input'];
+};
+export type StartLoginPayload = {
+    __typename?: 'StartLoginPayload';
+    authnRequestId: Scalars['UUID']['output'];
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    query?: Maybe<Query>;
+};
+export type StartPayoutInput = {
+    address: Scalars['String']['input'];
+    amount: Scalars['Int']['input'];
+    currency: Scalars['String']['input'];
+    unpaidDepositFee: Scalars['Int']['input'];
+    withdrawalFee: Scalars['Int']['input'];
+};
+export type StartPayoutPayload = {
+    __typename?: 'StartPayoutPayload';
+    pendingPayout: PendingPayout;
+};
+export type Subscription = {
+    __typename?: 'Subscription';
+    balanceAlert: BalanceAlertPayload;
+    transferAlert?: Maybe<TransferAlertPayload>;
+};
+export type ToyLoginInput = {
+    uname: Scalars['String']['input'];
+};
+export type ToyLoginPayload = {
+    __typename?: 'ToyLoginPayload';
+    sessionKey?: Maybe<Scalars['UUID']['output']>;
+};
+export type Transaction = {
+    __typename?: 'Transaction';
+    amount: Scalars['Int']['output'];
+    chillId: Scalars['UUID']['output'];
+    createdAt: Scalars['Datetime']['output'];
+    depositById?: Maybe<Deposit>;
+    id: Scalars['UUID']['output'];
+    invoiceByInvoiceId?: Maybe<Invoice>;
+    invoiceId: Scalars['UUID']['output'];
+    json: Scalars['JSON']['output'];
+    lastFetchAt: Scalars['Datetime']['output'];
+    network: Network;
+    status: TransactionStatus;
+};
+export type TransactionCondition = {
+    chillId?: InputMaybe<Scalars['UUID']['input']>;
+    id?: InputMaybe<Scalars['UUID']['input']>;
+    invoiceId?: InputMaybe<Scalars['UUID']['input']>;
+};
+export type TransactionConnection = {
+    __typename?: 'TransactionConnection';
+    edges: Array<Maybe<TransactionEdge>>;
+    nodes: Array<Maybe<Transaction>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type TransactionEdge = {
+    __typename?: 'TransactionEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<Transaction>;
+};
+export declare enum TransactionOrderBy {
+    ChillIdAsc = "CHILL_ID_ASC",
+    ChillIdDesc = "CHILL_ID_DESC",
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    InvoiceIdAsc = "INVOICE_ID_ASC",
+    InvoiceIdDesc = "INVOICE_ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC"
+}
+export declare enum TransactionStatus {
+    Complete = "complete",
+    Confirmed = "confirmed",
+    Failed = "failed",
+    Pending = "pending",
+    Replaced = "replaced",
+    Unconfirmed = "unconfirmed"
+}
+export type Transfer = {
+    accountByFromAccountId?: Maybe<Account>;
+    accountByToAccountId?: Maybe<Account>;
+    amount: Scalars['Float']['output'];
+    currency: Scalars['String']['output'];
+    currencyByCurrency?: Maybe<Currency>;
+    expiredAt?: Maybe<Scalars['Datetime']['output']>;
+    fromAccountId: Scalars['UUID']['output'];
+    fromHolderId: Scalars['UUID']['output'];
+    holderByFromHolderId?: Maybe<Holder>;
+    holderByToHolderId?: Maybe<Holder>;
+    id: Scalars['UUID']['output'];
+    metadata: Scalars['JSON']['output'];
+    metadataId?: Maybe<Scalars['String']['output']>;
+    status: TransferStatusKind;
+    statusAt: Scalars['Datetime']['output'];
+    toAccountId: Scalars['UUID']['output'];
+    toHolderId: Scalars['UUID']['output'];
+    transferStatusesByTransferId: TransferStatusConnection;
+    type: TransferType;
+};
+export type TransferTransferStatusesByTransferIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+};
+export type TransferAlertPayload = {
+    __typename?: 'TransferAlertPayload';
+    dummy?: Maybe<Scalars['Boolean']['output']>;
+};
+export type TransferCondition = {
+    currency?: InputMaybe<Scalars['String']['input']>;
+    fromAccountId?: InputMaybe<Scalars['UUID']['input']>;
+    fromHolderId?: InputMaybe<Scalars['UUID']['input']>;
+    id?: InputMaybe<Scalars['UUID']['input']>;
+    toAccountId?: InputMaybe<Scalars['UUID']['input']>;
+    toHolderId?: InputMaybe<Scalars['UUID']['input']>;
+    type?: InputMaybe<TransferType>;
+};
+export type TransferConnection = {
+    __typename?: 'TransferConnection';
+    edges: Array<Maybe<TransferEdge>>;
+    nodes: Array<Maybe<Transfer>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type TransferCurrencyExperienceToUserInput = {
+    amount: Scalars['Int']['input'];
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    currency: Scalars['String']['input'];
+    experienceId: Scalars['UUID']['input'];
+    metadata?: InputMaybe<Scalars['JSON']['input']>;
+    userId: Scalars['UUID']['input'];
+};
+export type TransferCurrencyExperienceToUserPayload = {
+    __typename?: 'TransferCurrencyExperienceToUserPayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    query?: Maybe<Query>;
+    result?: Maybe<TransferCurrencyExperienceToUserResult>;
+};
+export type TransferCurrencyExperienceToUserResult = TransferCurrencyExperienceToUserSuccess | TransferMetadataIdExists;
+export type TransferCurrencyExperienceToUserSuccess = {
+    __typename?: 'TransferCurrencyExperienceToUserSuccess';
+    transfer: Transfer;
+};
+export type TransferCurrencyFromControllerInput = {
+    amount: Scalars['Int']['input'];
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    controllerId: Scalars['UUID']['input'];
+    currency: Scalars['String']['input'];
+};
+export type TransferCurrencyFromControllerPayload = {
+    __typename?: 'TransferCurrencyFromControllerPayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    query?: Maybe<Query>;
+    transferId?: Maybe<Scalars['UUID']['output']>;
+};
+export type TransferCurrencyToControllerInput = {
+    amount: Scalars['Int']['input'];
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    controllerId: Scalars['UUID']['input'];
+    currency: Scalars['String']['input'];
+};
+export type TransferCurrencyToControllerPayload = {
+    __typename?: 'TransferCurrencyToControllerPayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    query?: Maybe<Query>;
+    transferId?: Maybe<Scalars['UUID']['output']>;
+};
+export type TransferCurrencyToExperienceInput = {
+    amount: Scalars['Int']['input'];
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    currency: Scalars['String']['input'];
+    experienceId: Scalars['UUID']['input'];
+};
+export type TransferCurrencyToExperiencePayload = {
+    __typename?: 'TransferCurrencyToExperiencePayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    query?: Maybe<Query>;
+    transferId?: Maybe<Scalars['String']['output']>;
+};
+export type TransferCurrencyUserToUnameInput = {
+    amount: Scalars['Int']['input'];
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    currency: Scalars['String']['input'];
+    uname: Scalars['String']['input'];
+};
+export type TransferCurrencyUserToUnamePayload = {
+    __typename?: 'TransferCurrencyUserToUnamePayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    query?: Maybe<Query>;
+    transferId?: Maybe<Scalars['String']['output']>;
+};
+export declare enum TransferDirection {
+    Incoming = "INCOMING",
+    Outgoing = "OUTGOING"
+}
+export type TransferEdge = {
+    __typename?: 'TransferEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<Transfer>;
+};
+export type TransferMetadataIdExists = {
+    __typename?: 'TransferMetadataIdExists';
+    transfer: Transfer;
+};
+export declare enum TransferOrderBy {
+    CurrencyAsc = "CURRENCY_ASC",
+    CurrencyDesc = "CURRENCY_DESC",
+    FromAccountIdAsc = "FROM_ACCOUNT_ID_ASC",
+    FromAccountIdDesc = "FROM_ACCOUNT_ID_DESC",
+    FromHolderIdAsc = "FROM_HOLDER_ID_ASC",
+    FromHolderIdDesc = "FROM_HOLDER_ID_DESC",
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
+    ToAccountIdAsc = "TO_ACCOUNT_ID_ASC",
+    ToAccountIdDesc = "TO_ACCOUNT_ID_DESC",
+    ToHolderIdAsc = "TO_HOLDER_ID_ASC",
+    ToHolderIdDesc = "TO_HOLDER_ID_DESC",
+    TypeAsc = "TYPE_ASC",
+    TypeDesc = "TYPE_DESC"
+}
+export type TransferStatus = {
+    __typename?: 'TransferStatus';
+    id: Scalars['UUID']['output'];
+    newStatus: TransferStatusKind;
+    oldStatus?: Maybe<TransferStatusKind>;
+    transferByTransferId?: Maybe<Transfer>;
+    transferId: Scalars['UUID']['output'];
+};
+export type TransferStatusCondition = {
+    id?: InputMaybe<Scalars['UUID']['input']>;
+    transferId?: InputMaybe<Scalars['UUID']['input']>;
+};
+export type TransferStatusConnection = {
+    __typename?: 'TransferStatusConnection';
+    edges: Array<Maybe<TransferStatusEdge>>;
+    nodes: Array<Maybe<TransferStatus>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type TransferStatusEdge = {
+    __typename?: 'TransferStatusEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<TransferStatus>;
+};
+export declare enum TransferStatusKind {
+    Canceled = "CANCELED",
+    Completed = "COMPLETED",
+    Expired = "EXPIRED",
+    Pending = "PENDING",
+    Unclaimed = "UNCLAIMED"
+}
+export declare enum TransferStatusOrderBy {
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
+    TransferIdAsc = "TRANSFER_ID_ASC",
+    TransferIdDesc = "TRANSFER_ID_DESC"
+}
+export declare enum TransferType {
+    Controller = "CONTROLLER",
+    Experience = "EXPERIENCE",
+    General = "GENERAL",
+    User = "USER"
+}
+export type TransfersByExperienceConnection = {
+    __typename?: 'TransfersByExperienceConnection';
+    edges: Array<TransfersByExperienceEdge>;
+    pageInfo: TransfersByExperiencePageInfo;
+};
+export type TransfersByExperienceEdge = {
+    __typename?: 'TransfersByExperienceEdge';
+    cursor: Scalars['Cursor']['output'];
+    node: ExperienceTransfer;
+};
+export type TransfersByExperienceInput = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    direction?: InputMaybe<TransferDirection>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    id: Scalars['UUID']['input'];
+    orderBy?: InputMaybe<TransfersByExperienceOrderBy>;
+    userId?: InputMaybe<Scalars['UUID']['input']>;
+};
+export declare enum TransfersByExperienceOrderBy {
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC"
+}
+export type TransfersByExperiencePageInfo = {
+    __typename?: 'TransfersByExperiencePageInfo';
+    endCursor?: Maybe<Scalars['Cursor']['output']>;
+    hasNextPage: Scalars['Boolean']['output'];
+};
+export type TransfersByHolderConnection = {
+    __typename?: 'TransfersByHolderConnection';
+    edges: Array<TransfersByHolderEdge>;
+    pageInfo: TransfersByHolderPageInfo;
+};
+export type TransfersByHolderEdge = {
+    __typename?: 'TransfersByHolderEdge';
+    cursor: Scalars['Cursor']['output'];
+    node: Transfer;
+};
+export type TransfersByHolderInput = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    direction?: InputMaybe<TransferDirection>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    holderId: Scalars['UUID']['input'];
+    orderBy?: InputMaybe<TransfersByHolderOrderBy>;
+    otherHolderId?: InputMaybe<Scalars['UUID']['input']>;
+    status?: InputMaybe<TransferStatusKind>;
+    type?: InputMaybe<TransferType>;
+};
+export declare enum TransfersByHolderOrderBy {
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC"
+}
+export type TransfersByHolderPageInfo = {
+    __typename?: 'TransfersByHolderPageInfo';
+    endCursor?: Maybe<Scalars['Cursor']['output']>;
+    hasNextPage: Scalars['Boolean']['output'];
+};
+export type UnpaidDepositFeeInput = {
+    currency: Scalars['String']['input'];
+};
+export type UnpaidDepositFeePayload = {
+    __typename?: 'UnpaidDepositFeePayload';
+    amount: Scalars['Int']['output'];
+};
+export type UpdateControllerByIdInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    controllerPatch: ControllerPatch;
+    id: Scalars['UUID']['input'];
+};
+export type UpdateControllerPayload = {
+    __typename?: 'UpdateControllerPayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    controller?: Maybe<Controller>;
+    controllerEdge?: Maybe<ControllerEdge>;
+    query?: Maybe<Query>;
+};
+export type UpdateControllerPayloadControllerEdgeArgs = {
+    orderBy?: Array<ControllerOrderBy>;
+};
+export type UpdateExperienceByIdInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    experiencePatch: ExperiencePatch;
+    id: Scalars['UUID']['input'];
+};
+export type UpdateExperiencePayload = {
+    __typename?: 'UpdateExperiencePayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    experience?: Maybe<Experience>;
+    experienceEdge?: Maybe<ExperienceEdge>;
+    query?: Maybe<Query>;
+};
+export type UpdateExperiencePayloadExperienceEdgeArgs = {
+    orderBy?: Array<ExperienceOrderBy>;
+};
+export type User = Holder & {
+    __typename?: 'User';
+    acceptedTosVersion: Scalars['Int']['output'];
+    accountByCurrency?: Maybe<Account>;
+    accountsByHolderId: AccountConnection;
+    activeSessionsByUserId: ActiveSessionConnection;
+    balanceByCurrency?: Maybe<Scalars['Float']['output']>;
+    controllersByUserId: ControllerConnection;
+    deletedAt?: Maybe<Scalars['Datetime']['output']>;
+    email?: Maybe<Scalars['String']['output']>;
+    experiencesByUserId: ExperienceConnection;
+    faucetClaimsByHolderId: FaucetClaimConnection;
+    id: Scalars['UUID']['output'];
+    invoicesByUserId: InvoiceConnection;
+    kind: HolderKind;
+    payouts: PayoutConnection;
+    pendingPayouts: PendingPayoutConnection;
+    pendingPayoutsByUserId: PendingPayoutConnection;
+    role: UserRole;
+    sessionsByUserId: SessionConnection;
+    transactions: TransactionConnection;
+    transfers: TransferConnection;
+    transfersByFromHolderId: TransferConnection;
+    transfersByToHolderId: TransferConnection;
+    uname: Scalars['String']['output'];
+    unpaidDepositFee: UnpaidDepositFeePayload;
+    userEmailsByUserId: UserEmailConnection;
+    userTransfersByToUserId: UserTransferConnection;
+};
+export type UserAccountByCurrencyArgs = {
+    currency: Scalars['String']['input'];
+};
+export type UserAccountsByHolderIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<AccountCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<AccountOrderBy>>;
+};
+export type UserActiveSessionsByUserIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    includeRevoked?: InputMaybe<IncludeRevokedOption>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<ActiveSessionOrderBy>>;
+};
+export type UserBalanceByCurrencyArgs = {
+    currency: Scalars['String']['input'];
+};
+export type UserControllersByUserIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<ControllerCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    includeDeleted?: InputMaybe<IncludeDeletedOption>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<ControllerOrderBy>>;
+};
+export type UserExperiencesByUserIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<ExperienceCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    includeDeleted?: InputMaybe<IncludeDeletedOption>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<ExperienceOrderBy>>;
+};
+export type UserFaucetClaimsByHolderIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<FaucetClaimCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<FaucetClaimOrderBy>>;
+};
+export type UserInvoicesByUserIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<InvoiceCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<InvoiceOrderBy>>;
+};
+export type UserPayoutsArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    hasWithdrawal?: InputMaybe<Scalars['Boolean']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+};
+export type UserPendingPayoutsArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    hasPayout?: InputMaybe<Scalars['Boolean']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+};
+export type UserPendingPayoutsByUserIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<PendingPayoutCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<PendingPayoutOrderBy>>;
+};
+export type UserSessionsByUserIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<SessionCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    includeExpired?: InputMaybe<IncludeExpiredOption>;
+    includeRevoked?: InputMaybe<IncludeRevokedOption>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<SessionOrderBy>>;
+};
+export type UserTransactionsArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    status?: InputMaybe<TransactionStatus>;
+};
+export type UserTransfersArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    direction?: InputMaybe<TransferDirection>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    status?: InputMaybe<TransferStatusKind>;
+};
+export type UserTransfersByFromHolderIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<TransferCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<TransferOrderBy>>;
+};
+export type UserTransfersByToHolderIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<TransferCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<TransferOrderBy>>;
+};
+export type UserUnpaidDepositFeeArgs = {
+    input: UnpaidDepositFeeInput;
+};
+export type UserUserEmailsByUserIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<UserEmailCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<UserEmailOrderBy>>;
+};
+export type UserUserTransfersByToUserIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<UserTransferCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<UserTransferOrderBy>>;
+};
+export type UserCondition = {
+    id?: InputMaybe<Scalars['UUID']['input']>;
+};
+export type UserConnection = {
+    __typename?: 'UserConnection';
+    edges: Array<Maybe<UserEdge>>;
+    nodes: Array<Maybe<User>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type UserEdge = {
+    __typename?: 'UserEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<User>;
+};
+export type UserEmail = {
+    __typename?: 'UserEmail';
+    email: Scalars['String']['output'];
+    id: Scalars['UUID']['output'];
+    isCurrent: Scalars['Boolean']['output'];
+    userByUserId?: Maybe<User>;
+    userId: Scalars['UUID']['output'];
+};
+export type UserEmailCondition = {
+    id?: InputMaybe<Scalars['UUID']['input']>;
+    userId?: InputMaybe<Scalars['UUID']['input']>;
+};
+export type UserEmailConnection = {
+    __typename?: 'UserEmailConnection';
+    edges: Array<Maybe<UserEmailEdge>>;
+    nodes: Array<Maybe<UserEmail>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type UserEmailEdge = {
+    __typename?: 'UserEmailEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<UserEmail>;
+};
+export declare enum UserEmailOrderBy {
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
+    UserIdAsc = "USER_ID_ASC",
+    UserIdDesc = "USER_ID_DESC"
+}
+export type UserFromUserTokenInput = {
+    token: Scalars['UUID']['input'];
+};
+export type UserFromUserTokenPayload = {
+    __typename?: 'UserFromUserTokenPayload';
+    experience?: Maybe<Experience>;
+    query?: Maybe<Query>;
+    user?: Maybe<User>;
+};
+export declare enum UserOrderBy {
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
+    UnameAsc = "UNAME_ASC",
+    UnameDesc = "UNAME_DESC"
+}
+export declare enum UserRole {
+    Admin = "ADMIN",
+    Member = "MEMBER"
+}
+export type UserTransfer = Transfer & {
+    __typename?: 'UserTransfer';
+    accountByFromAccountId?: Maybe<Account>;
+    accountByToAccountId?: Maybe<Account>;
+    amount: Scalars['Float']['output'];
+    currency: Scalars['String']['output'];
+    currencyByCurrency?: Maybe<Currency>;
+    expiredAt?: Maybe<Scalars['Datetime']['output']>;
+    fromAccountId: Scalars['UUID']['output'];
+    fromHolderId: Scalars['UUID']['output'];
+    holderByFromHolderId?: Maybe<Holder>;
+    holderByToHolderId?: Maybe<Holder>;
+    id: Scalars['UUID']['output'];
+    metadata: Scalars['JSON']['output'];
+    metadataId?: Maybe<Scalars['String']['output']>;
+    status: TransferStatusKind;
+    statusAt: Scalars['Datetime']['output'];
+    toAccountId: Scalars['UUID']['output'];
+    toHolderId: Scalars['UUID']['output'];
+    toUserId: Scalars['UUID']['output'];
+    transferStatusesByTransferId: TransferStatusConnection;
+    type: TransferType;
+    userByToUserId?: Maybe<User>;
+};
+export type UserTransferTransferStatusesByTransferIdArgs = {
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    before?: InputMaybe<Scalars['Cursor']['input']>;
+    condition?: InputMaybe<TransferStatusCondition>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    last?: InputMaybe<Scalars['Int']['input']>;
+    offset?: InputMaybe<Scalars['Int']['input']>;
+    orderBy?: InputMaybe<Array<TransferStatusOrderBy>>;
+};
+export type UserTransferCondition = {
+    currency?: InputMaybe<Scalars['String']['input']>;
+    fromAccountId?: InputMaybe<Scalars['UUID']['input']>;
+    fromHolderId?: InputMaybe<Scalars['UUID']['input']>;
+    id?: InputMaybe<Scalars['UUID']['input']>;
+    toAccountId?: InputMaybe<Scalars['UUID']['input']>;
+    toHolderId?: InputMaybe<Scalars['UUID']['input']>;
+    toUserId?: InputMaybe<Scalars['UUID']['input']>;
+    type?: InputMaybe<TransferType>;
+};
+export type UserTransferConnection = {
+    __typename?: 'UserTransferConnection';
+    edges: Array<Maybe<UserTransferEdge>>;
+    nodes: Array<Maybe<UserTransfer>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type UserTransferEdge = {
+    __typename?: 'UserTransferEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<UserTransfer>;
+};
+export declare enum UserTransferOrderBy {
+    CurrencyAsc = "CURRENCY_ASC",
+    CurrencyDesc = "CURRENCY_DESC",
+    FromAccountIdAsc = "FROM_ACCOUNT_ID_ASC",
+    FromAccountIdDesc = "FROM_ACCOUNT_ID_DESC",
+    FromHolderIdAsc = "FROM_HOLDER_ID_ASC",
+    FromHolderIdDesc = "FROM_HOLDER_ID_DESC",
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
+    ToAccountIdAsc = "TO_ACCOUNT_ID_ASC",
+    ToAccountIdDesc = "TO_ACCOUNT_ID_DESC",
+    ToHolderIdAsc = "TO_HOLDER_ID_ASC",
+    ToHolderIdDesc = "TO_HOLDER_ID_DESC",
+    ToUserIdAsc = "TO_USER_ID_ASC",
+    ToUserIdDesc = "TO_USER_ID_DESC",
+    TypeAsc = "TYPE_ASC",
+    TypeDesc = "TYPE_DESC"
+}
+export type VerifyEmailTokenInput = {
+    clientMutationId?: InputMaybe<Scalars['String']['input']>;
+    token: Scalars['UUID']['input'];
+};
+export type VerifyEmailTokenPayload = {
+    __typename?: 'VerifyEmailTokenPayload';
+    clientMutationId?: Maybe<Scalars['String']['output']>;
+    query?: Maybe<Query>;
+    result?: Maybe<EmailStepResult>;
+};
+export type Withdrawal = {
+    __typename?: 'Withdrawal';
+    id: Scalars['UUID']['output'];
+    payoutByPayoutId?: Maybe<Payout>;
+    payoutId: Scalars['UUID']['output'];
+};
+export type WithdrawalCondition = {
+    id?: InputMaybe<Scalars['UUID']['input']>;
+    payoutId?: InputMaybe<Scalars['UUID']['input']>;
+};
+export type WithdrawalConnection = {
+    __typename?: 'WithdrawalConnection';
+    edges: Array<Maybe<WithdrawalEdge>>;
+    nodes: Array<Maybe<Withdrawal>>;
+    pageInfo: PageInfo;
+    totalCount: Scalars['Int']['output'];
+};
+export type WithdrawalEdge = {
+    __typename?: 'WithdrawalEdge';
+    cursor?: Maybe<Scalars['Cursor']['output']>;
+    node?: Maybe<Withdrawal>;
+};
+export declare enum WithdrawalOrderBy {
+    IdAsc = "ID_ASC",
+    IdDesc = "ID_DESC",
+    Natural = "NATURAL",
+    PayoutIdAsc = "PAYOUT_ID_ASC",
+    PayoutIdDesc = "PAYOUT_ID_DESC",
+    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
+    PrimaryKeyDesc = "PRIMARY_KEY_DESC"
+}
+export type AddCasino_GetCurrentControllerQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type AddCasino_GetCurrentControllerQuery = {
+    __typename?: 'Query';
+    currentController?: {
+        __typename?: 'Controller';
+        id: string;
+    } | null;
+};
+export type GetUserFromUserTokenMutationVariables = Exact<{
+    token: Scalars['UUID']['input'];
+}>;
+export type GetUserFromUserTokenMutation = {
+    __typename?: 'Mutation';
+    userFromUserToken?: {
+        __typename?: 'UserFromUserTokenPayload';
+        user?: {
+            __typename?: 'User';
+            id: string;
+            uname: string;
+        } | null;
+        experience?: {
+            __typename?: 'Experience';
+            id: string;
+            name: string;
+        } | null;
+    } | null;
+};
+export type StartPendingExperienceTransferMutationVariables = Exact<{
+    mpUserId: Scalars['UUID']['input'];
+    mpExperienceId: Scalars['UUID']['input'];
+    amount: Scalars['Int']['input'];
+    currency: Scalars['String']['input'];
+    metadata: Scalars['JSON']['input'];
+}>;
+export type StartPendingExperienceTransferMutation = {
+    __typename?: 'Mutation';
+    transferCurrencyExperienceToUser?: {
+        __typename?: 'TransferCurrencyExperienceToUserPayload';
+        result?: {
+            __typename: 'TransferCurrencyExperienceToUserSuccess';
+            transfer: {
+                __typename?: 'ControllerTransfer';
+                id: string;
+                status: TransferStatusKind;
+            } | {
+                __typename?: 'ExperienceTransfer';
+                id: string;
+                status: TransferStatusKind;
+            } | {
+                __typename?: 'GeneralTransfer';
+                id: string;
+                status: TransferStatusKind;
+            } | {
+                __typename?: 'UserTransfer';
+                id: string;
+                status: TransferStatusKind;
+            };
+        } | {
+            __typename: 'TransferMetadataIdExists';
+            transfer: {
+                __typename?: 'ControllerTransfer';
+                id: string;
+                status: TransferStatusKind;
+            } | {
+                __typename?: 'ExperienceTransfer';
+                id: string;
+                status: TransferStatusKind;
+            } | {
+                __typename?: 'GeneralTransfer';
+                id: string;
+                status: TransferStatusKind;
+            } | {
+                __typename?: 'UserTransfer';
+                id: string;
+                status: TransferStatusKind;
+            };
+        } | null;
+    } | null;
+};
+export type PaginateTransfersQueryVariables = Exact<{
+    controllerId: Scalars['UUID']['input'];
+    after?: InputMaybe<Scalars['Cursor']['input']>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+}>;
+export type PaginateTransfersQuery = {
+    __typename?: 'Query';
+    transfersByHolder?: {
+        __typename?: 'TransfersByHolderConnection';
+        pageInfo: {
+            __typename?: 'TransfersByHolderPageInfo';
+            endCursor?: string | null;
+            hasNextPage: boolean;
+        };
+        edges: Array<{
+            __typename?: 'TransfersByHolderEdge';
+            cursor: string;
+            node: {
+                __typename: 'ControllerTransfer';
+                id: string;
+                amount: number;
+                status: TransferStatusKind;
+                statusAt: string;
+                fromHolderId: string;
+                toHolderId: string;
+                currencyByCurrency?: {
+                    __typename?: 'Currency';
+                    id: string;
+                    displayUnitName: string;
+                    displayUnitScale: number;
+                } | null;
+                holderByFromHolderId?: {
+                    __typename: 'Controller';
+                    id: string;
+                } | {
+                    __typename: 'User';
+                    uname: string;
+                    id: string;
+                } | null;
+                holderByToHolderId?: {
+                    __typename: 'Controller';
+                    id: string;
+                } | {
+                    __typename: 'User';
+                    uname: string;
+                    id: string;
+                } | null;
+            } | {
+                __typename: 'ExperienceTransfer';
+                id: string;
+                experienceId: string;
+                amount: number;
+                status: TransferStatusKind;
+                statusAt: string;
+                fromHolderId: string;
+                toHolderId: string;
+                experienceByExperienceId?: {
+                    __typename?: 'Experience';
+                    id: string;
+                    name: string;
+                } | null;
+                currencyByCurrency?: {
+                    __typename?: 'Currency';
+                    id: string;
+                    displayUnitName: string;
+                    displayUnitScale: number;
+                } | null;
+                holderByFromHolderId?: {
+                    __typename: 'Controller';
+                    id: string;
+                } | {
+                    __typename: 'User';
+                    uname: string;
+                    id: string;
+                } | null;
+                holderByToHolderId?: {
+                    __typename: 'Controller';
+                    id: string;
+                } | {
+                    __typename: 'User';
+                    uname: string;
+                    id: string;
+                } | null;
+            } | {
+                __typename: 'GeneralTransfer';
+                id: string;
+                amount: number;
+                status: TransferStatusKind;
+                statusAt: string;
+                fromHolderId: string;
+                toHolderId: string;
+                currencyByCurrency?: {
+                    __typename?: 'Currency';
+                    id: string;
+                    displayUnitName: string;
+                    displayUnitScale: number;
+                } | null;
+                holderByFromHolderId?: {
+                    __typename: 'Controller';
+                    id: string;
+                } | {
+                    __typename: 'User';
+                    uname: string;
+                    id: string;
+                } | null;
+                holderByToHolderId?: {
+                    __typename: 'Controller';
+                    id: string;
+                } | {
+                    __typename: 'User';
+                    uname: string;
+                    id: string;
+                } | null;
+            } | {
+                __typename: 'UserTransfer';
+                id: string;
+                amount: number;
+                status: TransferStatusKind;
+                statusAt: string;
+                fromHolderId: string;
+                toHolderId: string;
+                currencyByCurrency?: {
+                    __typename?: 'Currency';
+                    id: string;
+                    displayUnitName: string;
+                    displayUnitScale: number;
+                } | null;
+                holderByFromHolderId?: {
+                    __typename: 'Controller';
+                    id: string;
+                } | {
+                    __typename: 'User';
+                    uname: string;
+                    id: string;
+                } | null;
+                holderByToHolderId?: {
+                    __typename: 'Controller';
+                    id: string;
+                } | {
+                    __typename: 'User';
+                    uname: string;
+                    id: string;
+                } | null;
+            };
+        }>;
+    } | null;
+};
+export type GetCurrenciesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetCurrenciesQuery = {
+    __typename?: 'Query';
+    allCurrencies?: {
+        __typename?: 'CurrencyConnection';
+        nodes: Array<{
+            __typename?: 'Currency';
+            id: string;
+            displayUnitName: string;
+            displayUnitScale: number;
+        } | null>;
+    } | null;
+};
+export type GetCurrentControllerQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetCurrentControllerQuery = {
+    __typename?: 'Query';
+    currentController?: {
+        __typename?: 'Controller';
+        id: string;
+    } | null;
+    allCurrencies?: {
+        __typename?: 'CurrencyConnection';
+        nodes: Array<{
+            __typename?: 'Currency';
+            id: string;
+            displayUnitName: string;
+            displayUnitScale: number;
+        } | null>;
+    } | null;
+};
+export type CompleteTransferMutationVariables = Exact<{
+    mpTransferId: Scalars['UUID']['input'];
+}>;
+export type CompleteTransferMutation = {
+    __typename?: 'Mutation';
+    completeTransfer?: {
+        __typename?: 'CompleteTransferPayload';
+        result: {
+            __typename: 'CompleteTransferSuccess';
+            transfer: {
+                __typename?: 'ControllerTransfer';
+                id: string;
+            } | {
+                __typename?: 'ExperienceTransfer';
+                id: string;
+                status: TransferStatusKind;
+            } | {
+                __typename?: 'GeneralTransfer';
+                id: string;
+            } | {
+                __typename?: 'UserTransfer';
+                id: string;
+            };
+        } | {
+            __typename: 'InvalidTransferStatus';
+            currentStatus: TransferStatusKind;
+            message: string;
+        };
+    } | null;
+};
+export type ClaimTransferMutationVariables = Exact<{
+    mpTransferId: Scalars['UUID']['input'];
+}>;
+export type ClaimTransferMutation = {
+    __typename?: 'Mutation';
+    claimTransfer?: {
+        __typename?: 'ClaimTransferPayload';
+        result: {
+            __typename: 'ClaimTransferSuccess';
+            transfer: {
+                __typename?: 'ControllerTransfer';
+                id: string;
+            } | {
+                __typename?: 'ExperienceTransfer';
+                id: string;
+                status: TransferStatusKind;
+            } | {
+                __typename?: 'GeneralTransfer';
+                id: string;
+            } | {
+                __typename?: 'UserTransfer';
+                id: string;
+            };
+        } | {
+            __typename: 'InvalidTransferStatus';
+            currentStatus: TransferStatusKind;
+            message: string;
+        };
+    } | null;
+};
+export type GetCasinoJwksQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetCasinoJwksQuery = {
+    __typename?: 'Query';
+    jwks: any;
+};
+export declare const AddCasino_GetCurrentControllerDocument: DocumentNode<AddCasino_GetCurrentControllerQuery, AddCasino_GetCurrentControllerQueryVariables>;
+export declare const GetUserFromUserTokenDocument: DocumentNode<GetUserFromUserTokenMutation, GetUserFromUserTokenMutationVariables>;
+export declare const StartPendingExperienceTransferDocument: DocumentNode<StartPendingExperienceTransferMutation, StartPendingExperienceTransferMutationVariables>;
+export declare const PaginateTransfersDocument: DocumentNode<PaginateTransfersQuery, PaginateTransfersQueryVariables>;
+export declare const GetCurrenciesDocument: DocumentNode<GetCurrenciesQuery, GetCurrenciesQueryVariables>;
+export declare const GetCurrentControllerDocument: DocumentNode<GetCurrentControllerQuery, GetCurrentControllerQueryVariables>;
+export declare const CompleteTransferDocument: DocumentNode<CompleteTransferMutation, CompleteTransferMutationVariables>;
+export declare const ClaimTransferDocument: DocumentNode<ClaimTransferMutation, ClaimTransferMutationVariables>;
+export declare const GetCasinoJwksDocument: DocumentNode<GetCasinoJwksQuery, GetCasinoJwksQueryVariables>;