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;
    };
    BigFloat: {
        input: any;
        output: any;
    };
    BigInt: {
        input: any;
        output: any;
    };
    Cursor: {
        input: any;
        output: any;
    };
    Datetime: {
        input: any;
        output: any;
    };
    JSON: {
        input: any;
        output: any;
    };
};
export type BigFloatFilter = {
    distinctFrom?: InputMaybe<Scalars['BigFloat']['input']>;
    equalTo?: InputMaybe<Scalars['BigFloat']['input']>;
    greaterThan?: InputMaybe<Scalars['BigFloat']['input']>;
    greaterThanOrEqualTo?: InputMaybe<Scalars['BigFloat']['input']>;
    in?: InputMaybe<Array<Scalars['BigFloat']['input']>>;
    isNull?: InputMaybe<Scalars['Boolean']['input']>;
    lessThan?: InputMaybe<Scalars['BigFloat']['input']>;
    lessThanOrEqualTo?: InputMaybe<Scalars['BigFloat']['input']>;
    notDistinctFrom?: InputMaybe<Scalars['BigFloat']['input']>;
    notEqualTo?: InputMaybe<Scalars['BigFloat']['input']>;
    notIn?: InputMaybe<Array<Scalars['BigFloat']['input']>>;
};
export type BigIntFilter = {
    distinctFrom?: InputMaybe<Scalars['BigInt']['input']>;
    equalTo?: InputMaybe<Scalars['BigInt']['input']>;
    greaterThan?: InputMaybe<Scalars['BigInt']['input']>;
    greaterThanOrEqualTo?: InputMaybe<Scalars['BigInt']['input']>;
    in?: InputMaybe<Array<Scalars['BigInt']['input']>>;
    isNull?: InputMaybe<Scalars['Boolean']['input']>;
    lessThan?: InputMaybe<Scalars['BigInt']['input']>;
    lessThanOrEqualTo?: InputMaybe<Scalars['BigInt']['input']>;
    notDistinctFrom?: InputMaybe<Scalars['BigInt']['input']>;
    notEqualTo?: InputMaybe<Scalars['BigInt']['input']>;
    notIn?: InputMaybe<Array<Scalars['BigInt']['input']>>;
};
export type Bond = Node & {
    __typename?: 'Bond';
    allowReserveWithdrawals: Scalars['Boolean']['output'];
    allowSells: Scalars['Boolean']['output'];
    alphaBond: Scalars['Boolean']['output'];
    availableReserve: Scalars['JSON']['output'];
    batchBlocks: Scalars['String']['output'];
    bondAlphasByBondDid: BondAlphasConnection;
    bondBuysByBondDid: BondBuysConnection;
    bondDid: Scalars['String']['output'];
    bondSellsByBondDid: BondSellsConnection;
    bondSwapsByBondDid: BondSwapsConnection;
    controllerDid: Scalars['String']['output'];
    creatorDid: Scalars['String']['output'];
    currentOutcomePaymentReserve: Scalars['JSON']['output'];
    currentReserve: Scalars['JSON']['output'];
    currentSupply?: Maybe<Scalars['JSON']['output']>;
    description: Scalars['String']['output'];
    exitFeePercentage: Scalars['String']['output'];
    feeAddress: Scalars['String']['output'];
    functionParameters: Scalars['JSON']['output'];
    functionType: Scalars['String']['output'];
    maxSupply?: Maybe<Scalars['JSON']['output']>;
    name: Scalars['String']['output'];
    nodeId: Scalars['ID']['output'];
    oracleDid: Scalars['String']['output'];
    orderQuantityLimits: Scalars['JSON']['output'];
    outcomePayment: Scalars['String']['output'];
    outcomePaymentsByBondDid: OutcomePaymentsConnection;
    reserveTokens?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
    reserveWithdrawalAddress: Scalars['String']['output'];
    reserveWithdrawalsByBondDid: ReserveWithdrawalsConnection;
    sanityMarginPercentage: Scalars['String']['output'];
    sanityRate: Scalars['String']['output'];
    shareWithdrawalsByBondDid: ShareWithdrawalsConnection;
    state: Scalars['String']['output'];
    token: Scalars['String']['output'];
    txFeePercentage: Scalars['String']['output'];
};
export type BondBondAlphasByBondDidArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<BondAlphaCondition>;
    filter?: InputMaybe<BondAlphaFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<BondAlphasOrderBy>>;
};
export type BondBondBuysByBondDidArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<BondBuyCondition>;
    filter?: InputMaybe<BondBuyFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<BondBuysOrderBy>>;
};
export type BondBondSellsByBondDidArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<BondSellCondition>;
    filter?: InputMaybe<BondSellFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<BondSellsOrderBy>>;
};
export type BondBondSwapsByBondDidArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<BondSwapCondition>;
    filter?: InputMaybe<BondSwapFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<BondSwapsOrderBy>>;
};
export type BondOutcomePaymentsByBondDidArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<OutcomePaymentCondition>;
    filter?: InputMaybe<OutcomePaymentFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<OutcomePaymentsOrderBy>>;
};
export type BondReserveWithdrawalsByBondDidArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<ReserveWithdrawalCondition>;
    filter?: InputMaybe<ReserveWithdrawalFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<ReserveWithdrawalsOrderBy>>;
};
export type BondShareWithdrawalsByBondDidArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<ShareWithdrawalCondition>;
    filter?: InputMaybe<ShareWithdrawalFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<ShareWithdrawalsOrderBy>>;
};
export type BondAlpha = Node & {
    __typename?: 'BondAlpha';
    alpha: Scalars['String']['output'];
    bondByBondDid?: Maybe<Bond>;
    bondDid: Scalars['String']['output'];
    height: Scalars['Int']['output'];
    id: Scalars['Int']['output'];
    nodeId: Scalars['ID']['output'];
    oracleDid: Scalars['String']['output'];
    timestamp: Scalars['Datetime']['output'];
};
export type BondAlphaCondition = {
    alpha?: InputMaybe<Scalars['String']['input']>;
    bondDid?: InputMaybe<Scalars['String']['input']>;
    height?: InputMaybe<Scalars['Int']['input']>;
    id?: InputMaybe<Scalars['Int']['input']>;
    oracleDid?: InputMaybe<Scalars['String']['input']>;
    timestamp?: InputMaybe<Scalars['Datetime']['input']>;
};
export type BondAlphaFilter = {
    alpha?: InputMaybe<StringFilter>;
    and?: InputMaybe<Array<BondAlphaFilter>>;
    bondByBondDid?: InputMaybe<BondFilter>;
    bondDid?: InputMaybe<StringFilter>;
    height?: InputMaybe<IntFilter>;
    id?: InputMaybe<IntFilter>;
    not?: InputMaybe<BondAlphaFilter>;
    or?: InputMaybe<Array<BondAlphaFilter>>;
    oracleDid?: InputMaybe<StringFilter>;
    timestamp?: InputMaybe<DatetimeFilter>;
};
export type BondAlphasConnection = {
    __typename?: 'BondAlphasConnection';
    edges: Array<BondAlphasEdge>;
    nodes: Array<BondAlpha>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type BondAlphasEdge = {
    __typename?: 'BondAlphasEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: BondAlpha;
};
export declare enum BondAlphasOrderBy {
    AlphaAsc = "ALPHA_ASC",
    AlphaDesc = "ALPHA_DESC",
    BondDidAsc = "BOND_DID_ASC",
    BondDidDesc = "BOND_DID_DESC",
    HeightAsc = "HEIGHT_ASC",
    HeightDesc = "HEIGHT_DESC",
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    Natural = "NATURAL",
    OracleDidAsc = "ORACLE_DID_ASC",
    OracleDidDesc = "ORACLE_DID_DESC",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    TimestampAsc = "TIMESTAMP_ASC",
    TimestampDesc = "TIMESTAMP_DESC"
}
export type BondBuy = Node & {
    __typename?: 'BondBuy';
    accountDid: Scalars['String']['output'];
    amount: Scalars['JSON']['output'];
    bondByBondDid?: Maybe<Bond>;
    bondDid: Scalars['String']['output'];
    height: Scalars['Int']['output'];
    id: Scalars['Int']['output'];
    maxPrices: Scalars['JSON']['output'];
    nodeId: Scalars['ID']['output'];
    timestamp: Scalars['Datetime']['output'];
};
export type BondBuyCondition = {
    accountDid?: InputMaybe<Scalars['String']['input']>;
    amount?: InputMaybe<Scalars['JSON']['input']>;
    bondDid?: InputMaybe<Scalars['String']['input']>;
    height?: InputMaybe<Scalars['Int']['input']>;
    id?: InputMaybe<Scalars['Int']['input']>;
    maxPrices?: InputMaybe<Scalars['JSON']['input']>;
    timestamp?: InputMaybe<Scalars['Datetime']['input']>;
};
export type BondBuyFilter = {
    accountDid?: InputMaybe<StringFilter>;
    amount?: InputMaybe<JsonFilter>;
    and?: InputMaybe<Array<BondBuyFilter>>;
    bondByBondDid?: InputMaybe<BondFilter>;
    bondDid?: InputMaybe<StringFilter>;
    height?: InputMaybe<IntFilter>;
    id?: InputMaybe<IntFilter>;
    maxPrices?: InputMaybe<JsonFilter>;
    not?: InputMaybe<BondBuyFilter>;
    or?: InputMaybe<Array<BondBuyFilter>>;
    timestamp?: InputMaybe<DatetimeFilter>;
};
export type BondBuysConnection = {
    __typename?: 'BondBuysConnection';
    edges: Array<BondBuysEdge>;
    nodes: Array<BondBuy>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type BondBuysEdge = {
    __typename?: 'BondBuysEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: BondBuy;
};
export declare enum BondBuysOrderBy {
    AccountDidAsc = "ACCOUNT_DID_ASC",
    AccountDidDesc = "ACCOUNT_DID_DESC",
    AmountAsc = "AMOUNT_ASC",
    AmountDesc = "AMOUNT_DESC",
    BondDidAsc = "BOND_DID_ASC",
    BondDidDesc = "BOND_DID_DESC",
    HeightAsc = "HEIGHT_ASC",
    HeightDesc = "HEIGHT_DESC",
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    MaxPricesAsc = "MAX_PRICES_ASC",
    MaxPricesDesc = "MAX_PRICES_DESC",
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    TimestampAsc = "TIMESTAMP_ASC",
    TimestampDesc = "TIMESTAMP_DESC"
}
export type BondCondition = {
    allowReserveWithdrawals?: InputMaybe<Scalars['Boolean']['input']>;
    allowSells?: InputMaybe<Scalars['Boolean']['input']>;
    alphaBond?: InputMaybe<Scalars['Boolean']['input']>;
    availableReserve?: InputMaybe<Scalars['JSON']['input']>;
    batchBlocks?: InputMaybe<Scalars['String']['input']>;
    bondDid?: InputMaybe<Scalars['String']['input']>;
    controllerDid?: InputMaybe<Scalars['String']['input']>;
    creatorDid?: InputMaybe<Scalars['String']['input']>;
    currentOutcomePaymentReserve?: InputMaybe<Scalars['JSON']['input']>;
    currentReserve?: InputMaybe<Scalars['JSON']['input']>;
    currentSupply?: InputMaybe<Scalars['JSON']['input']>;
    description?: InputMaybe<Scalars['String']['input']>;
    exitFeePercentage?: InputMaybe<Scalars['String']['input']>;
    feeAddress?: InputMaybe<Scalars['String']['input']>;
    functionParameters?: InputMaybe<Scalars['JSON']['input']>;
    functionType?: InputMaybe<Scalars['String']['input']>;
    maxSupply?: InputMaybe<Scalars['JSON']['input']>;
    name?: InputMaybe<Scalars['String']['input']>;
    oracleDid?: InputMaybe<Scalars['String']['input']>;
    orderQuantityLimits?: InputMaybe<Scalars['JSON']['input']>;
    outcomePayment?: InputMaybe<Scalars['String']['input']>;
    reserveTokens?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
    reserveWithdrawalAddress?: InputMaybe<Scalars['String']['input']>;
    sanityMarginPercentage?: InputMaybe<Scalars['String']['input']>;
    sanityRate?: InputMaybe<Scalars['String']['input']>;
    state?: InputMaybe<Scalars['String']['input']>;
    token?: InputMaybe<Scalars['String']['input']>;
    txFeePercentage?: InputMaybe<Scalars['String']['input']>;
};
export type BondFilter = {
    allowReserveWithdrawals?: InputMaybe<BooleanFilter>;
    allowSells?: InputMaybe<BooleanFilter>;
    alphaBond?: InputMaybe<BooleanFilter>;
    and?: InputMaybe<Array<BondFilter>>;
    availableReserve?: InputMaybe<JsonFilter>;
    batchBlocks?: InputMaybe<StringFilter>;
    bondAlphasByBondDid?: InputMaybe<BondToManyBondAlphaFilter>;
    bondAlphasByBondDidExist?: InputMaybe<Scalars['Boolean']['input']>;
    bondBuysByBondDid?: InputMaybe<BondToManyBondBuyFilter>;
    bondBuysByBondDidExist?: InputMaybe<Scalars['Boolean']['input']>;
    bondDid?: InputMaybe<StringFilter>;
    bondSellsByBondDid?: InputMaybe<BondToManyBondSellFilter>;
    bondSellsByBondDidExist?: InputMaybe<Scalars['Boolean']['input']>;
    bondSwapsByBondDid?: InputMaybe<BondToManyBondSwapFilter>;
    bondSwapsByBondDidExist?: InputMaybe<Scalars['Boolean']['input']>;
    controllerDid?: InputMaybe<StringFilter>;
    creatorDid?: InputMaybe<StringFilter>;
    currentOutcomePaymentReserve?: InputMaybe<JsonFilter>;
    currentReserve?: InputMaybe<JsonFilter>;
    currentSupply?: InputMaybe<JsonFilter>;
    description?: InputMaybe<StringFilter>;
    exitFeePercentage?: InputMaybe<StringFilter>;
    feeAddress?: InputMaybe<StringFilter>;
    functionParameters?: InputMaybe<JsonFilter>;
    functionType?: InputMaybe<StringFilter>;
    maxSupply?: InputMaybe<JsonFilter>;
    name?: InputMaybe<StringFilter>;
    not?: InputMaybe<BondFilter>;
    or?: InputMaybe<Array<BondFilter>>;
    oracleDid?: InputMaybe<StringFilter>;
    orderQuantityLimits?: InputMaybe<JsonFilter>;
    outcomePayment?: InputMaybe<StringFilter>;
    outcomePaymentsByBondDid?: InputMaybe<BondToManyOutcomePaymentFilter>;
    outcomePaymentsByBondDidExist?: InputMaybe<Scalars['Boolean']['input']>;
    reserveTokens?: InputMaybe<StringListFilter>;
    reserveWithdrawalAddress?: InputMaybe<StringFilter>;
    reserveWithdrawalsByBondDid?: InputMaybe<BondToManyReserveWithdrawalFilter>;
    reserveWithdrawalsByBondDidExist?: InputMaybe<Scalars['Boolean']['input']>;
    sanityMarginPercentage?: InputMaybe<StringFilter>;
    sanityRate?: InputMaybe<StringFilter>;
    shareWithdrawalsByBondDid?: InputMaybe<BondToManyShareWithdrawalFilter>;
    shareWithdrawalsByBondDidExist?: InputMaybe<Scalars['Boolean']['input']>;
    state?: InputMaybe<StringFilter>;
    token?: InputMaybe<StringFilter>;
    txFeePercentage?: InputMaybe<StringFilter>;
};
export type BondSell = Node & {
    __typename?: 'BondSell';
    accountDid: Scalars['String']['output'];
    amount: Scalars['JSON']['output'];
    bondByBondDid?: Maybe<Bond>;
    bondDid: Scalars['String']['output'];
    height: Scalars['Int']['output'];
    id: Scalars['Int']['output'];
    nodeId: Scalars['ID']['output'];
    timestamp: Scalars['Datetime']['output'];
};
export type BondSellCondition = {
    accountDid?: InputMaybe<Scalars['String']['input']>;
    amount?: InputMaybe<Scalars['JSON']['input']>;
    bondDid?: InputMaybe<Scalars['String']['input']>;
    height?: InputMaybe<Scalars['Int']['input']>;
    id?: InputMaybe<Scalars['Int']['input']>;
    timestamp?: InputMaybe<Scalars['Datetime']['input']>;
};
export type BondSellFilter = {
    accountDid?: InputMaybe<StringFilter>;
    amount?: InputMaybe<JsonFilter>;
    and?: InputMaybe<Array<BondSellFilter>>;
    bondByBondDid?: InputMaybe<BondFilter>;
    bondDid?: InputMaybe<StringFilter>;
    height?: InputMaybe<IntFilter>;
    id?: InputMaybe<IntFilter>;
    not?: InputMaybe<BondSellFilter>;
    or?: InputMaybe<Array<BondSellFilter>>;
    timestamp?: InputMaybe<DatetimeFilter>;
};
export type BondSellsConnection = {
    __typename?: 'BondSellsConnection';
    edges: Array<BondSellsEdge>;
    nodes: Array<BondSell>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type BondSellsEdge = {
    __typename?: 'BondSellsEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: BondSell;
};
export declare enum BondSellsOrderBy {
    AccountDidAsc = "ACCOUNT_DID_ASC",
    AccountDidDesc = "ACCOUNT_DID_DESC",
    AmountAsc = "AMOUNT_ASC",
    AmountDesc = "AMOUNT_DESC",
    BondDidAsc = "BOND_DID_ASC",
    BondDidDesc = "BOND_DID_DESC",
    HeightAsc = "HEIGHT_ASC",
    HeightDesc = "HEIGHT_DESC",
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    TimestampAsc = "TIMESTAMP_ASC",
    TimestampDesc = "TIMESTAMP_DESC"
}
export type BondSwap = Node & {
    __typename?: 'BondSwap';
    accountDid: Scalars['String']['output'];
    amount: Scalars['JSON']['output'];
    bondByBondDid?: Maybe<Bond>;
    bondDid: Scalars['String']['output'];
    height: Scalars['Int']['output'];
    id: Scalars['Int']['output'];
    nodeId: Scalars['ID']['output'];
    timestamp: Scalars['Datetime']['output'];
    toToken: Scalars['String']['output'];
};
export type BondSwapCondition = {
    accountDid?: InputMaybe<Scalars['String']['input']>;
    amount?: InputMaybe<Scalars['JSON']['input']>;
    bondDid?: InputMaybe<Scalars['String']['input']>;
    height?: InputMaybe<Scalars['Int']['input']>;
    id?: InputMaybe<Scalars['Int']['input']>;
    timestamp?: InputMaybe<Scalars['Datetime']['input']>;
    toToken?: InputMaybe<Scalars['String']['input']>;
};
export type BondSwapFilter = {
    accountDid?: InputMaybe<StringFilter>;
    amount?: InputMaybe<JsonFilter>;
    and?: InputMaybe<Array<BondSwapFilter>>;
    bondByBondDid?: InputMaybe<BondFilter>;
    bondDid?: InputMaybe<StringFilter>;
    height?: InputMaybe<IntFilter>;
    id?: InputMaybe<IntFilter>;
    not?: InputMaybe<BondSwapFilter>;
    or?: InputMaybe<Array<BondSwapFilter>>;
    timestamp?: InputMaybe<DatetimeFilter>;
    toToken?: InputMaybe<StringFilter>;
};
export type BondSwapsConnection = {
    __typename?: 'BondSwapsConnection';
    edges: Array<BondSwapsEdge>;
    nodes: Array<BondSwap>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type BondSwapsEdge = {
    __typename?: 'BondSwapsEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: BondSwap;
};
export declare enum BondSwapsOrderBy {
    AccountDidAsc = "ACCOUNT_DID_ASC",
    AccountDidDesc = "ACCOUNT_DID_DESC",
    AmountAsc = "AMOUNT_ASC",
    AmountDesc = "AMOUNT_DESC",
    BondDidAsc = "BOND_DID_ASC",
    BondDidDesc = "BOND_DID_DESC",
    HeightAsc = "HEIGHT_ASC",
    HeightDesc = "HEIGHT_DESC",
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    TimestampAsc = "TIMESTAMP_ASC",
    TimestampDesc = "TIMESTAMP_DESC",
    ToTokenAsc = "TO_TOKEN_ASC",
    ToTokenDesc = "TO_TOKEN_DESC"
}
export type BondToManyBondAlphaFilter = {
    every?: InputMaybe<BondAlphaFilter>;
    none?: InputMaybe<BondAlphaFilter>;
    some?: InputMaybe<BondAlphaFilter>;
};
export type BondToManyBondBuyFilter = {
    every?: InputMaybe<BondBuyFilter>;
    none?: InputMaybe<BondBuyFilter>;
    some?: InputMaybe<BondBuyFilter>;
};
export type BondToManyBondSellFilter = {
    every?: InputMaybe<BondSellFilter>;
    none?: InputMaybe<BondSellFilter>;
    some?: InputMaybe<BondSellFilter>;
};
export type BondToManyBondSwapFilter = {
    every?: InputMaybe<BondSwapFilter>;
    none?: InputMaybe<BondSwapFilter>;
    some?: InputMaybe<BondSwapFilter>;
};
export type BondToManyOutcomePaymentFilter = {
    every?: InputMaybe<OutcomePaymentFilter>;
    none?: InputMaybe<OutcomePaymentFilter>;
    some?: InputMaybe<OutcomePaymentFilter>;
};
export type BondToManyReserveWithdrawalFilter = {
    every?: InputMaybe<ReserveWithdrawalFilter>;
    none?: InputMaybe<ReserveWithdrawalFilter>;
    some?: InputMaybe<ReserveWithdrawalFilter>;
};
export type BondToManyShareWithdrawalFilter = {
    every?: InputMaybe<ShareWithdrawalFilter>;
    none?: InputMaybe<ShareWithdrawalFilter>;
    some?: InputMaybe<ShareWithdrawalFilter>;
};
export type BondsConnection = {
    __typename?: 'BondsConnection';
    edges: Array<BondsEdge>;
    nodes: Array<Bond>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type BondsEdge = {
    __typename?: 'BondsEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: Bond;
};
export declare enum BondsOrderBy {
    AllowReserveWithdrawalsAsc = "ALLOW_RESERVE_WITHDRAWALS_ASC",
    AllowReserveWithdrawalsDesc = "ALLOW_RESERVE_WITHDRAWALS_DESC",
    AllowSellsAsc = "ALLOW_SELLS_ASC",
    AllowSellsDesc = "ALLOW_SELLS_DESC",
    AlphaBondAsc = "ALPHA_BOND_ASC",
    AlphaBondDesc = "ALPHA_BOND_DESC",
    AvailableReserveAsc = "AVAILABLE_RESERVE_ASC",
    AvailableReserveDesc = "AVAILABLE_RESERVE_DESC",
    BatchBlocksAsc = "BATCH_BLOCKS_ASC",
    BatchBlocksDesc = "BATCH_BLOCKS_DESC",
    BondDidAsc = "BOND_DID_ASC",
    BondDidDesc = "BOND_DID_DESC",
    ControllerDidAsc = "CONTROLLER_DID_ASC",
    ControllerDidDesc = "CONTROLLER_DID_DESC",
    CreatorDidAsc = "CREATOR_DID_ASC",
    CreatorDidDesc = "CREATOR_DID_DESC",
    CurrentOutcomePaymentReserveAsc = "CURRENT_OUTCOME_PAYMENT_RESERVE_ASC",
    CurrentOutcomePaymentReserveDesc = "CURRENT_OUTCOME_PAYMENT_RESERVE_DESC",
    CurrentReserveAsc = "CURRENT_RESERVE_ASC",
    CurrentReserveDesc = "CURRENT_RESERVE_DESC",
    CurrentSupplyAsc = "CURRENT_SUPPLY_ASC",
    CurrentSupplyDesc = "CURRENT_SUPPLY_DESC",
    DescriptionAsc = "DESCRIPTION_ASC",
    DescriptionDesc = "DESCRIPTION_DESC",
    ExitFeePercentageAsc = "EXIT_FEE_PERCENTAGE_ASC",
    ExitFeePercentageDesc = "EXIT_FEE_PERCENTAGE_DESC",
    FeeAddressAsc = "FEE_ADDRESS_ASC",
    FeeAddressDesc = "FEE_ADDRESS_DESC",
    FunctionParametersAsc = "FUNCTION_PARAMETERS_ASC",
    FunctionParametersDesc = "FUNCTION_PARAMETERS_DESC",
    FunctionTypeAsc = "FUNCTION_TYPE_ASC",
    FunctionTypeDesc = "FUNCTION_TYPE_DESC",
    MaxSupplyAsc = "MAX_SUPPLY_ASC",
    MaxSupplyDesc = "MAX_SUPPLY_DESC",
    NameAsc = "NAME_ASC",
    NameDesc = "NAME_DESC",
    Natural = "NATURAL",
    OracleDidAsc = "ORACLE_DID_ASC",
    OracleDidDesc = "ORACLE_DID_DESC",
    OrderQuantityLimitsAsc = "ORDER_QUANTITY_LIMITS_ASC",
    OrderQuantityLimitsDesc = "ORDER_QUANTITY_LIMITS_DESC",
    OutcomePaymentAsc = "OUTCOME_PAYMENT_ASC",
    OutcomePaymentDesc = "OUTCOME_PAYMENT_DESC",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    ReserveTokensAsc = "RESERVE_TOKENS_ASC",
    ReserveTokensDesc = "RESERVE_TOKENS_DESC",
    ReserveWithdrawalAddressAsc = "RESERVE_WITHDRAWAL_ADDRESS_ASC",
    ReserveWithdrawalAddressDesc = "RESERVE_WITHDRAWAL_ADDRESS_DESC",
    SanityMarginPercentageAsc = "SANITY_MARGIN_PERCENTAGE_ASC",
    SanityMarginPercentageDesc = "SANITY_MARGIN_PERCENTAGE_DESC",
    SanityRateAsc = "SANITY_RATE_ASC",
    SanityRateDesc = "SANITY_RATE_DESC",
    StateAsc = "STATE_ASC",
    StateDesc = "STATE_DESC",
    TokenAsc = "TOKEN_ASC",
    TokenDesc = "TOKEN_DESC",
    TxFeePercentageAsc = "TX_FEE_PERCENTAGE_ASC",
    TxFeePercentageDesc = "TX_FEE_PERCENTAGE_DESC"
}
export type BooleanFilter = {
    distinctFrom?: InputMaybe<Scalars['Boolean']['input']>;
    equalTo?: InputMaybe<Scalars['Boolean']['input']>;
    greaterThan?: InputMaybe<Scalars['Boolean']['input']>;
    greaterThanOrEqualTo?: InputMaybe<Scalars['Boolean']['input']>;
    in?: InputMaybe<Array<Scalars['Boolean']['input']>>;
    isNull?: InputMaybe<Scalars['Boolean']['input']>;
    lessThan?: InputMaybe<Scalars['Boolean']['input']>;
    lessThanOrEqualTo?: InputMaybe<Scalars['Boolean']['input']>;
    notDistinctFrom?: InputMaybe<Scalars['Boolean']['input']>;
    notEqualTo?: InputMaybe<Scalars['Boolean']['input']>;
    notIn?: InputMaybe<Array<Scalars['Boolean']['input']>>;
};
export type Chain = Node & {
    __typename?: 'Chain';
    blockHeight: Scalars['Int']['output'];
    chainId: Scalars['String']['output'];
    nodeId: Scalars['ID']['output'];
};
export type ChainCondition = {
    blockHeight?: InputMaybe<Scalars['Int']['input']>;
    chainId?: InputMaybe<Scalars['String']['input']>;
};
export type ChainFilter = {
    and?: InputMaybe<Array<ChainFilter>>;
    blockHeight?: InputMaybe<IntFilter>;
    chainId?: InputMaybe<StringFilter>;
    not?: InputMaybe<ChainFilter>;
    or?: InputMaybe<Array<ChainFilter>>;
};
export type ChainsConnection = {
    __typename?: 'ChainsConnection';
    edges: Array<ChainsEdge>;
    nodes: Array<Chain>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type ChainsEdge = {
    __typename?: 'ChainsEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: Chain;
};
export declare enum ChainsOrderBy {
    BlockHeightAsc = "BLOCK_HEIGHT_ASC",
    BlockHeightDesc = "BLOCK_HEIGHT_DESC",
    ChainIdAsc = "CHAIN_ID_ASC",
    ChainIdDesc = "CHAIN_ID_DESC",
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC"
}
export type Claim = Node & {
    __typename?: 'Claim';
    agentAddress: Scalars['String']['output'];
    agentDid: Scalars['String']['output'];
    claimId: Scalars['String']['output'];
    collection?: Maybe<ClaimCollection>;
    collectionId: Scalars['String']['output'];
    evaluationByClaimId?: Maybe<Evaluation>;
    nodeId: Scalars['ID']['output'];
    paymentsStatus: Scalars['JSON']['output'];
    schemaType?: Maybe<Scalars['String']['output']>;
    submissionDate: Scalars['Datetime']['output'];
};
export type ClaimCollection = Node & {
    __typename?: 'ClaimCollection';
    admin: Scalars['String']['output'];
    approved: Scalars['BigFloat']['output'];
    claimSchemaTypesLoaded: Scalars['Boolean']['output'];
    claimsByCollectionId: ClaimsConnection;
    count: Scalars['BigFloat']['output'];
    disputed: Scalars['BigFloat']['output'];
    endDate?: Maybe<Scalars['Datetime']['output']>;
    entity: Scalars['String']['output'];
    evaluated: Scalars['BigFloat']['output'];
    id: Scalars['String']['output'];
    invalidated: Scalars['BigFloat']['output'];
    nodeId: Scalars['ID']['output'];
    payments: Scalars['JSON']['output'];
    protocol: Scalars['String']['output'];
    quota: Scalars['BigFloat']['output'];
    rejected: Scalars['BigFloat']['output'];
    startDate?: Maybe<Scalars['Datetime']['output']>;
    state: Scalars['Int']['output'];
};
export type ClaimCollectionClaimsByCollectionIdArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<ClaimCondition>;
    filter?: InputMaybe<ClaimFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<ClaimsOrderBy>>;
};
export type ClaimCollectionCondition = {
    admin?: InputMaybe<Scalars['String']['input']>;
    approved?: InputMaybe<Scalars['BigFloat']['input']>;
    count?: InputMaybe<Scalars['BigFloat']['input']>;
    disputed?: InputMaybe<Scalars['BigFloat']['input']>;
    endDate?: InputMaybe<Scalars['Datetime']['input']>;
    entity?: InputMaybe<Scalars['String']['input']>;
    evaluated?: InputMaybe<Scalars['BigFloat']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    invalidated?: InputMaybe<Scalars['BigFloat']['input']>;
    payments?: InputMaybe<Scalars['JSON']['input']>;
    protocol?: InputMaybe<Scalars['String']['input']>;
    quota?: InputMaybe<Scalars['BigFloat']['input']>;
    rejected?: InputMaybe<Scalars['BigFloat']['input']>;
    startDate?: InputMaybe<Scalars['Datetime']['input']>;
    state?: InputMaybe<Scalars['Int']['input']>;
};
export type ClaimCollectionFilter = {
    admin?: InputMaybe<StringFilter>;
    and?: InputMaybe<Array<ClaimCollectionFilter>>;
    approved?: InputMaybe<BigFloatFilter>;
    claimsByCollectionId?: InputMaybe<ClaimCollectionToManyClaimFilter>;
    claimsByCollectionIdExist?: InputMaybe<Scalars['Boolean']['input']>;
    count?: InputMaybe<BigFloatFilter>;
    disputed?: InputMaybe<BigFloatFilter>;
    endDate?: InputMaybe<DatetimeFilter>;
    entity?: InputMaybe<StringFilter>;
    evaluated?: InputMaybe<BigFloatFilter>;
    id?: InputMaybe<StringFilter>;
    invalidated?: InputMaybe<BigFloatFilter>;
    not?: InputMaybe<ClaimCollectionFilter>;
    or?: InputMaybe<Array<ClaimCollectionFilter>>;
    payments?: InputMaybe<JsonFilter>;
    protocol?: InputMaybe<StringFilter>;
    quota?: InputMaybe<BigFloatFilter>;
    rejected?: InputMaybe<BigFloatFilter>;
    startDate?: InputMaybe<DatetimeFilter>;
    state?: InputMaybe<IntFilter>;
};
export type ClaimCollectionToManyClaimFilter = {
    every?: InputMaybe<ClaimFilter>;
    none?: InputMaybe<ClaimFilter>;
    some?: InputMaybe<ClaimFilter>;
};
export type ClaimCollectionsConnection = {
    __typename?: 'ClaimCollectionsConnection';
    edges: Array<ClaimCollectionsEdge>;
    nodes: Array<ClaimCollection>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type ClaimCollectionsEdge = {
    __typename?: 'ClaimCollectionsEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: ClaimCollection;
};
export declare enum ClaimCollectionsOrderBy {
    AdminAsc = "ADMIN_ASC",
    AdminDesc = "ADMIN_DESC",
    ApprovedAsc = "APPROVED_ASC",
    ApprovedDesc = "APPROVED_DESC",
    CountAsc = "COUNT_ASC",
    CountDesc = "COUNT_DESC",
    DisputedAsc = "DISPUTED_ASC",
    DisputedDesc = "DISPUTED_DESC",
    EndDateAsc = "END_DATE_ASC",
    EndDateDesc = "END_DATE_DESC",
    EntityAsc = "ENTITY_ASC",
    EntityDesc = "ENTITY_DESC",
    EvaluatedAsc = "EVALUATED_ASC",
    EvaluatedDesc = "EVALUATED_DESC",
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    InvalidatedAsc = "INVALIDATED_ASC",
    InvalidatedDesc = "INVALIDATED_DESC",
    Natural = "NATURAL",
    PaymentsAsc = "PAYMENTS_ASC",
    PaymentsDesc = "PAYMENTS_DESC",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    ProtocolAsc = "PROTOCOL_ASC",
    ProtocolDesc = "PROTOCOL_DESC",
    QuotaAsc = "QUOTA_ASC",
    QuotaDesc = "QUOTA_DESC",
    RejectedAsc = "REJECTED_ASC",
    RejectedDesc = "REJECTED_DESC",
    StartDateAsc = "START_DATE_ASC",
    StartDateDesc = "START_DATE_DESC",
    StateAsc = "STATE_ASC",
    StateDesc = "STATE_DESC"
}
export type ClaimCondition = {
    agentAddress?: InputMaybe<Scalars['String']['input']>;
    agentDid?: InputMaybe<Scalars['String']['input']>;
    claimId?: InputMaybe<Scalars['String']['input']>;
    collectionId?: InputMaybe<Scalars['String']['input']>;
    paymentsStatus?: InputMaybe<Scalars['JSON']['input']>;
    schemaType?: InputMaybe<Scalars['String']['input']>;
    submissionDate?: InputMaybe<Scalars['Datetime']['input']>;
};
export type ClaimFilter = {
    agentAddress?: InputMaybe<StringFilter>;
    agentDid?: InputMaybe<StringFilter>;
    and?: InputMaybe<Array<ClaimFilter>>;
    claimId?: InputMaybe<StringFilter>;
    collection?: InputMaybe<ClaimCollectionFilter>;
    collectionId?: InputMaybe<StringFilter>;
    evaluationByClaimId?: InputMaybe<EvaluationFilter>;
    evaluationByClaimIdExists?: InputMaybe<Scalars['Boolean']['input']>;
    not?: InputMaybe<ClaimFilter>;
    or?: InputMaybe<Array<ClaimFilter>>;
    paymentsStatus?: InputMaybe<JsonFilter>;
    schemaType?: InputMaybe<StringFilter>;
    submissionDate?: InputMaybe<DatetimeFilter>;
};
export type ClaimsConnection = {
    __typename?: 'ClaimsConnection';
    edges: Array<ClaimsEdge>;
    nodes: Array<Claim>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type ClaimsEdge = {
    __typename?: 'ClaimsEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: Claim;
};
export declare enum ClaimsOrderBy {
    AgentAddressAsc = "AGENT_ADDRESS_ASC",
    AgentAddressDesc = "AGENT_ADDRESS_DESC",
    AgentDidAsc = "AGENT_DID_ASC",
    AgentDidDesc = "AGENT_DID_DESC",
    ClaimIdAsc = "CLAIM_ID_ASC",
    ClaimIdDesc = "CLAIM_ID_DESC",
    CollectionIdAsc = "COLLECTION_ID_ASC",
    CollectionIdDesc = "COLLECTION_ID_DESC",
    Natural = "NATURAL",
    PaymentsStatusAsc = "PAYMENTS_STATUS_ASC",
    PaymentsStatusDesc = "PAYMENTS_STATUS_DESC",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    SchemaTypeAsc = "SCHEMA_TYPE_ASC",
    SchemaTypeDesc = "SCHEMA_TYPE_DESC",
    SubmissionDateAsc = "SUBMISSION_DATE_ASC",
    SubmissionDateDesc = "SUBMISSION_DATE_DESC"
}
export type DatetimeFilter = {
    distinctFrom?: InputMaybe<Scalars['Datetime']['input']>;
    equalTo?: InputMaybe<Scalars['Datetime']['input']>;
    greaterThan?: InputMaybe<Scalars['Datetime']['input']>;
    greaterThanOrEqualTo?: InputMaybe<Scalars['Datetime']['input']>;
    in?: InputMaybe<Array<Scalars['Datetime']['input']>>;
    isNull?: InputMaybe<Scalars['Boolean']['input']>;
    lessThan?: InputMaybe<Scalars['Datetime']['input']>;
    lessThanOrEqualTo?: InputMaybe<Scalars['Datetime']['input']>;
    notDistinctFrom?: InputMaybe<Scalars['Datetime']['input']>;
    notEqualTo?: InputMaybe<Scalars['Datetime']['input']>;
    notIn?: InputMaybe<Array<Scalars['Datetime']['input']>>;
};
export type Dispute = Node & {
    __typename?: 'Dispute';
    data: Scalars['JSON']['output'];
    nodeId: Scalars['ID']['output'];
    proof: Scalars['String']['output'];
    subjectId: Scalars['String']['output'];
    type: Scalars['Int']['output'];
};
export type DisputeCondition = {
    data?: InputMaybe<Scalars['JSON']['input']>;
    proof?: InputMaybe<Scalars['String']['input']>;
    subjectId?: InputMaybe<Scalars['String']['input']>;
    type?: InputMaybe<Scalars['Int']['input']>;
};
export type DisputeFilter = {
    and?: InputMaybe<Array<DisputeFilter>>;
    data?: InputMaybe<JsonFilter>;
    not?: InputMaybe<DisputeFilter>;
    or?: InputMaybe<Array<DisputeFilter>>;
    proof?: InputMaybe<StringFilter>;
    subjectId?: InputMaybe<StringFilter>;
    type?: InputMaybe<IntFilter>;
};
export type DisputesConnection = {
    __typename?: 'DisputesConnection';
    edges: Array<DisputesEdge>;
    nodes: Array<Dispute>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type DisputesEdge = {
    __typename?: 'DisputesEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: Dispute;
};
export declare enum DisputesOrderBy {
    DataAsc = "DATA_ASC",
    DataDesc = "DATA_DESC",
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    ProofAsc = "PROOF_ASC",
    ProofDesc = "PROOF_DESC",
    SubjectIdAsc = "SUBJECT_ID_ASC",
    SubjectIdDesc = "SUBJECT_ID_DESC",
    TypeAsc = "TYPE_ASC",
    TypeDesc = "TYPE_DESC"
}
export type EntitiesConnection = {
    __typename?: 'EntitiesConnection';
    edges: Array<EntitiesEdge>;
    nodes: Array<Entity>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type EntitiesEdge = {
    __typename?: 'EntitiesEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: Entity;
};
export declare enum EntitiesOrderBy {
    AccountsAsc = "ACCOUNTS_ASC",
    AccountsDesc = "ACCOUNTS_DESC",
    CredentialsAsc = "CREDENTIALS_ASC",
    CredentialsDesc = "CREDENTIALS_DESC",
    EndDateAsc = "END_DATE_ASC",
    EndDateDesc = "END_DATE_DESC",
    EntityVerifiedAsc = "ENTITY_VERIFIED_ASC",
    EntityVerifiedDesc = "ENTITY_VERIFIED_DESC",
    ExternalIdAsc = "EXTERNAL_ID_ASC",
    ExternalIdDesc = "EXTERNAL_ID_DESC",
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    MetadataAsc = "METADATA_ASC",
    MetadataDesc = "METADATA_DESC",
    Natural = "NATURAL",
    OwnerAsc = "OWNER_ASC",
    OwnerDesc = "OWNER_DESC",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    RelayerNodeAsc = "RELAYER_NODE_ASC",
    RelayerNodeDesc = "RELAYER_NODE_DESC",
    StartDateAsc = "START_DATE_ASC",
    StartDateDesc = "START_DATE_DESC",
    StatusAsc = "STATUS_ASC",
    StatusDesc = "STATUS_DESC",
    TypeAsc = "TYPE_ASC",
    TypeDesc = "TYPE_DESC"
}
export type Entity = Node & {
    __typename?: 'Entity';
    accordedRight: Scalars['JSON']['output'];
    accounts: Scalars['JSON']['output'];
    alsoKnownAs: Scalars['String']['output'];
    assertionMethod: Array<Scalars['String']['output']>;
    authentication: Array<Scalars['String']['output']>;
    capabilityDelegation: Array<Scalars['String']['output']>;
    capabilityInvocation: Array<Scalars['String']['output']>;
    context: Scalars['JSON']['output'];
    controller: Array<Scalars['String']['output']>;
    credentials?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
    endDate?: Maybe<Scalars['Datetime']['output']>;
    entityVerified: Scalars['Boolean']['output'];
    externalId?: Maybe<Scalars['String']['output']>;
    id: Scalars['String']['output'];
    iidById?: Maybe<Iid>;
    keyAgreement: Array<Scalars['String']['output']>;
    linkedClaim: Scalars['JSON']['output'];
    linkedEntity: Scalars['JSON']['output'];
    linkedResource: Scalars['JSON']['output'];
    metadata: Scalars['JSON']['output'];
    nodeId: Scalars['ID']['output'];
    owner?: Maybe<Scalars['String']['output']>;
    relayerNode: Scalars['String']['output'];
    service: Scalars['JSON']['output'];
    settings: Scalars['JSON']['output'];
    startDate?: Maybe<Scalars['Datetime']['output']>;
    status: Scalars['Int']['output'];
    tokenClassesByClass: TokenClassesConnection;
    tokensByCollection: TokensConnection;
    type: Scalars['String']['output'];
    verificationMethod: Scalars['JSON']['output'];
};
export type EntityTokenClassesByClassArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<TokenClassCondition>;
    filter?: InputMaybe<TokenClassFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<TokenClassesOrderBy>>;
};
export type EntityTokensByCollectionArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<TokenCondition>;
    filter?: InputMaybe<TokenFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<TokensOrderBy>>;
};
export type EntityCondition = {
    accounts?: InputMaybe<Scalars['JSON']['input']>;
    credentials?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
    endDate?: InputMaybe<Scalars['Datetime']['input']>;
    entityVerified?: InputMaybe<Scalars['Boolean']['input']>;
    externalId?: InputMaybe<Scalars['String']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    metadata?: InputMaybe<Scalars['JSON']['input']>;
    owner?: InputMaybe<Scalars['String']['input']>;
    relayerNode?: InputMaybe<Scalars['String']['input']>;
    startDate?: InputMaybe<Scalars['Datetime']['input']>;
    status?: InputMaybe<Scalars['Int']['input']>;
    type?: InputMaybe<Scalars['String']['input']>;
};
export type EntityFilter = {
    accounts?: InputMaybe<JsonFilter>;
    and?: InputMaybe<Array<EntityFilter>>;
    credentials?: InputMaybe<StringListFilter>;
    endDate?: InputMaybe<DatetimeFilter>;
    entityVerified?: InputMaybe<BooleanFilter>;
    externalId?: InputMaybe<StringFilter>;
    id?: InputMaybe<StringFilter>;
    iidById?: InputMaybe<IidFilter>;
    metadata?: InputMaybe<JsonFilter>;
    not?: InputMaybe<EntityFilter>;
    or?: InputMaybe<Array<EntityFilter>>;
    owner?: InputMaybe<StringFilter>;
    relayerNode?: InputMaybe<StringFilter>;
    startDate?: InputMaybe<DatetimeFilter>;
    status?: InputMaybe<IntFilter>;
    tokenClassesByClass?: InputMaybe<EntityToManyTokenClassFilter>;
    tokenClassesByClassExist?: InputMaybe<Scalars['Boolean']['input']>;
    tokensByCollection?: InputMaybe<EntityToManyTokenFilter>;
    tokensByCollectionExist?: InputMaybe<Scalars['Boolean']['input']>;
    type?: InputMaybe<StringFilter>;
};
export type EntityToManyTokenClassFilter = {
    every?: InputMaybe<TokenClassFilter>;
    none?: InputMaybe<TokenClassFilter>;
    some?: InputMaybe<TokenClassFilter>;
};
export type EntityToManyTokenFilter = {
    every?: InputMaybe<TokenFilter>;
    none?: InputMaybe<TokenFilter>;
    some?: InputMaybe<TokenFilter>;
};
export type Evaluation = Node & {
    __typename?: 'Evaluation';
    agentAddress: Scalars['String']['output'];
    agentDid: Scalars['String']['output'];
    amount: Scalars['JSON']['output'];
    claim?: Maybe<Claim>;
    claimId: Scalars['String']['output'];
    collectionId: Scalars['String']['output'];
    evaluationDate: Scalars['Datetime']['output'];
    nodeId: Scalars['ID']['output'];
    oracle: Scalars['String']['output'];
    reason: Scalars['BigFloat']['output'];
    status: Scalars['Int']['output'];
    verificationProof?: Maybe<Scalars['String']['output']>;
};
export type EvaluationCondition = {
    agentAddress?: InputMaybe<Scalars['String']['input']>;
    agentDid?: InputMaybe<Scalars['String']['input']>;
    amount?: InputMaybe<Scalars['JSON']['input']>;
    claimId?: InputMaybe<Scalars['String']['input']>;
    collectionId?: InputMaybe<Scalars['String']['input']>;
    evaluationDate?: InputMaybe<Scalars['Datetime']['input']>;
    oracle?: InputMaybe<Scalars['String']['input']>;
    reason?: InputMaybe<Scalars['BigFloat']['input']>;
    status?: InputMaybe<Scalars['Int']['input']>;
    verificationProof?: InputMaybe<Scalars['String']['input']>;
};
export type EvaluationFilter = {
    agentAddress?: InputMaybe<StringFilter>;
    agentDid?: InputMaybe<StringFilter>;
    amount?: InputMaybe<JsonFilter>;
    and?: InputMaybe<Array<EvaluationFilter>>;
    claim?: InputMaybe<ClaimFilter>;
    claimId?: InputMaybe<StringFilter>;
    collectionId?: InputMaybe<StringFilter>;
    evaluationDate?: InputMaybe<DatetimeFilter>;
    not?: InputMaybe<EvaluationFilter>;
    or?: InputMaybe<Array<EvaluationFilter>>;
    oracle?: InputMaybe<StringFilter>;
    reason?: InputMaybe<BigFloatFilter>;
    status?: InputMaybe<IntFilter>;
    verificationProof?: InputMaybe<StringFilter>;
};
export type EvaluationsConnection = {
    __typename?: 'EvaluationsConnection';
    edges: Array<EvaluationsEdge>;
    nodes: Array<Evaluation>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type EvaluationsEdge = {
    __typename?: 'EvaluationsEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: Evaluation;
};
export declare enum EvaluationsOrderBy {
    AgentAddressAsc = "AGENT_ADDRESS_ASC",
    AgentAddressDesc = "AGENT_ADDRESS_DESC",
    AgentDidAsc = "AGENT_DID_ASC",
    AgentDidDesc = "AGENT_DID_DESC",
    AmountAsc = "AMOUNT_ASC",
    AmountDesc = "AMOUNT_DESC",
    ClaimIdAsc = "CLAIM_ID_ASC",
    ClaimIdDesc = "CLAIM_ID_DESC",
    CollectionIdAsc = "COLLECTION_ID_ASC",
    CollectionIdDesc = "COLLECTION_ID_DESC",
    EvaluationDateAsc = "EVALUATION_DATE_ASC",
    EvaluationDateDesc = "EVALUATION_DATE_DESC",
    Natural = "NATURAL",
    OracleAsc = "ORACLE_ASC",
    OracleDesc = "ORACLE_DESC",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    ReasonAsc = "REASON_ASC",
    ReasonDesc = "REASON_DESC",
    StatusAsc = "STATUS_ASC",
    StatusDesc = "STATUS_DESC",
    VerificationProofAsc = "VERIFICATION_PROOF_ASC",
    VerificationProofDesc = "VERIFICATION_PROOF_DESC"
}
export type HavingBigintFilter = {
    equalTo?: InputMaybe<Scalars['BigInt']['input']>;
    greaterThan?: InputMaybe<Scalars['BigInt']['input']>;
    greaterThanOrEqualTo?: InputMaybe<Scalars['BigInt']['input']>;
    lessThan?: InputMaybe<Scalars['BigInt']['input']>;
    lessThanOrEqualTo?: InputMaybe<Scalars['BigInt']['input']>;
    notEqualTo?: InputMaybe<Scalars['BigInt']['input']>;
};
export type HavingIntFilter = {
    equalTo?: InputMaybe<Scalars['Int']['input']>;
    greaterThan?: InputMaybe<Scalars['Int']['input']>;
    greaterThanOrEqualTo?: InputMaybe<Scalars['Int']['input']>;
    lessThan?: InputMaybe<Scalars['Int']['input']>;
    lessThanOrEqualTo?: InputMaybe<Scalars['Int']['input']>;
    notEqualTo?: InputMaybe<Scalars['Int']['input']>;
};
export type Iid = Node & {
    __typename?: 'Iid';
    accordedRight: Scalars['JSON']['output'];
    alsoKnownAs: Scalars['String']['output'];
    assertionMethod?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
    authentication?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
    capabilityDelegation?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
    capabilityInvocation?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
    context: Scalars['JSON']['output'];
    controller?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
    entityById?: Maybe<Entity>;
    id: Scalars['String']['output'];
    keyAgreement?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
    linkedClaim: Scalars['JSON']['output'];
    linkedEntity: Scalars['JSON']['output'];
    linkedResource: Scalars['JSON']['output'];
    metadata: Scalars['JSON']['output'];
    nodeId: Scalars['ID']['output'];
    service: Scalars['JSON']['output'];
    verificationMethod: Scalars['JSON']['output'];
};
export type IidCondition = {
    accordedRight?: InputMaybe<Scalars['JSON']['input']>;
    alsoKnownAs?: InputMaybe<Scalars['String']['input']>;
    assertionMethod?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
    authentication?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
    capabilityDelegation?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
    capabilityInvocation?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
    context?: InputMaybe<Scalars['JSON']['input']>;
    controller?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
    id?: InputMaybe<Scalars['String']['input']>;
    keyAgreement?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
    linkedClaim?: InputMaybe<Scalars['JSON']['input']>;
    linkedEntity?: InputMaybe<Scalars['JSON']['input']>;
    linkedResource?: InputMaybe<Scalars['JSON']['input']>;
    metadata?: InputMaybe<Scalars['JSON']['input']>;
    service?: InputMaybe<Scalars['JSON']['input']>;
    verificationMethod?: InputMaybe<Scalars['JSON']['input']>;
};
export type IidFilter = {
    accordedRight?: InputMaybe<JsonFilter>;
    alsoKnownAs?: InputMaybe<StringFilter>;
    and?: InputMaybe<Array<IidFilter>>;
    assertionMethod?: InputMaybe<StringListFilter>;
    authentication?: InputMaybe<StringListFilter>;
    capabilityDelegation?: InputMaybe<StringListFilter>;
    capabilityInvocation?: InputMaybe<StringListFilter>;
    context?: InputMaybe<JsonFilter>;
    controller?: InputMaybe<StringListFilter>;
    entityById?: InputMaybe<EntityFilter>;
    entityByIdExists?: InputMaybe<Scalars['Boolean']['input']>;
    id?: InputMaybe<StringFilter>;
    keyAgreement?: InputMaybe<StringListFilter>;
    linkedClaim?: InputMaybe<JsonFilter>;
    linkedEntity?: InputMaybe<JsonFilter>;
    linkedResource?: InputMaybe<JsonFilter>;
    metadata?: InputMaybe<JsonFilter>;
    not?: InputMaybe<IidFilter>;
    or?: InputMaybe<Array<IidFilter>>;
    service?: InputMaybe<JsonFilter>;
    verificationMethod?: InputMaybe<JsonFilter>;
};
export type IidsConnection = {
    __typename?: 'IidsConnection';
    edges: Array<IidsEdge>;
    nodes: Array<Iid>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type IidsEdge = {
    __typename?: 'IidsEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: Iid;
};
export declare enum IidsOrderBy {
    AccordedRightAsc = "ACCORDED_RIGHT_ASC",
    AccordedRightDesc = "ACCORDED_RIGHT_DESC",
    AlsoKnownAsAsc = "ALSO_KNOWN_AS_ASC",
    AlsoKnownAsDesc = "ALSO_KNOWN_AS_DESC",
    AssertionMethodAsc = "ASSERTION_METHOD_ASC",
    AssertionMethodDesc = "ASSERTION_METHOD_DESC",
    AuthenticationAsc = "AUTHENTICATION_ASC",
    AuthenticationDesc = "AUTHENTICATION_DESC",
    CapabilityDelegationAsc = "CAPABILITY_DELEGATION_ASC",
    CapabilityDelegationDesc = "CAPABILITY_DELEGATION_DESC",
    CapabilityInvocationAsc = "CAPABILITY_INVOCATION_ASC",
    CapabilityInvocationDesc = "CAPABILITY_INVOCATION_DESC",
    ContextAsc = "CONTEXT_ASC",
    ContextDesc = "CONTEXT_DESC",
    ControllerAsc = "CONTROLLER_ASC",
    ControllerDesc = "CONTROLLER_DESC",
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    KeyAgreementAsc = "KEY_AGREEMENT_ASC",
    KeyAgreementDesc = "KEY_AGREEMENT_DESC",
    LinkedClaimAsc = "LINKED_CLAIM_ASC",
    LinkedClaimDesc = "LINKED_CLAIM_DESC",
    LinkedEntityAsc = "LINKED_ENTITY_ASC",
    LinkedEntityDesc = "LINKED_ENTITY_DESC",
    LinkedResourceAsc = "LINKED_RESOURCE_ASC",
    LinkedResourceDesc = "LINKED_RESOURCE_DESC",
    MetadataAsc = "METADATA_ASC",
    MetadataDesc = "METADATA_DESC",
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    ServiceAsc = "SERVICE_ASC",
    ServiceDesc = "SERVICE_DESC",
    VerificationMethodAsc = "VERIFICATION_METHOD_ASC",
    VerificationMethodDesc = "VERIFICATION_METHOD_DESC"
}
export type IntFilter = {
    distinctFrom?: InputMaybe<Scalars['Int']['input']>;
    equalTo?: InputMaybe<Scalars['Int']['input']>;
    greaterThan?: InputMaybe<Scalars['Int']['input']>;
    greaterThanOrEqualTo?: InputMaybe<Scalars['Int']['input']>;
    in?: InputMaybe<Array<Scalars['Int']['input']>>;
    isNull?: InputMaybe<Scalars['Boolean']['input']>;
    lessThan?: InputMaybe<Scalars['Int']['input']>;
    lessThanOrEqualTo?: InputMaybe<Scalars['Int']['input']>;
    notDistinctFrom?: InputMaybe<Scalars['Int']['input']>;
    notEqualTo?: InputMaybe<Scalars['Int']['input']>;
    notIn?: InputMaybe<Array<Scalars['Int']['input']>>;
};
export type Ipf = Node & {
    __typename?: 'Ipf';
    cid: Scalars['String']['output'];
    contentType: Scalars['String']['output'];
    data: Scalars['String']['output'];
    nodeId: Scalars['ID']['output'];
};
export type IpfCondition = {
    cid?: InputMaybe<Scalars['String']['input']>;
    contentType?: InputMaybe<Scalars['String']['input']>;
    data?: InputMaybe<Scalars['String']['input']>;
};
export type IpfFilter = {
    and?: InputMaybe<Array<IpfFilter>>;
    cid?: InputMaybe<StringFilter>;
    contentType?: InputMaybe<StringFilter>;
    data?: InputMaybe<StringFilter>;
    not?: InputMaybe<IpfFilter>;
    or?: InputMaybe<Array<IpfFilter>>;
};
export type IpfsConnection = {
    __typename?: 'IpfsConnection';
    edges: Array<IpfsEdge>;
    nodes: Array<Ipf>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type IpfsEdge = {
    __typename?: 'IpfsEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: Ipf;
};
export declare enum IpfsOrderBy {
    CidAsc = "CID_ASC",
    CidDesc = "CID_DESC",
    ContentTypeAsc = "CONTENT_TYPE_ASC",
    ContentTypeDesc = "CONTENT_TYPE_DESC",
    DataAsc = "DATA_ASC",
    DataDesc = "DATA_DESC",
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC"
}
export type IxoSwap = Node & {
    __typename?: 'IxoSwap';
    address: Scalars['String']['output'];
    frozen: Scalars['Boolean']['output'];
    ixoSwapPriceHistoriesByAddress: IxoSwapPriceHistoriesConnection;
    lpAddress: Scalars['String']['output'];
    lpFeePercent: Scalars['String']['output'];
    maxSlippagePercent: Scalars['String']['output'];
    nodeId: Scalars['ID']['output'];
    owner: Scalars['String']['output'];
    pendingOwner?: Maybe<Scalars['String']['output']>;
    protocolFeePercent: Scalars['String']['output'];
    protocolFeeRecipient: Scalars['String']['output'];
    token2Denom: Scalars['String']['output'];
    token2Reserve: Scalars['BigInt']['output'];
    token1155Denom: Scalars['String']['output'];
    token1155Reserve: Scalars['BigInt']['output'];
};
export type IxoSwapIxoSwapPriceHistoriesByAddressArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<IxoSwapPriceHistoryCondition>;
    filter?: InputMaybe<IxoSwapPriceHistoryFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<IxoSwapPriceHistoriesOrderBy>>;
};
export type IxoSwapCondition = {
    address?: InputMaybe<Scalars['String']['input']>;
    frozen?: InputMaybe<Scalars['Boolean']['input']>;
    lpAddress?: InputMaybe<Scalars['String']['input']>;
    lpFeePercent?: InputMaybe<Scalars['String']['input']>;
    maxSlippagePercent?: InputMaybe<Scalars['String']['input']>;
    owner?: InputMaybe<Scalars['String']['input']>;
    pendingOwner?: InputMaybe<Scalars['String']['input']>;
    protocolFeePercent?: InputMaybe<Scalars['String']['input']>;
    protocolFeeRecipient?: InputMaybe<Scalars['String']['input']>;
    token2Denom?: InputMaybe<Scalars['String']['input']>;
    token2Reserve?: InputMaybe<Scalars['BigInt']['input']>;
    token1155Denom?: InputMaybe<Scalars['String']['input']>;
    token1155Reserve?: InputMaybe<Scalars['BigInt']['input']>;
};
export type IxoSwapFilter = {
    address?: InputMaybe<StringFilter>;
    and?: InputMaybe<Array<IxoSwapFilter>>;
    frozen?: InputMaybe<BooleanFilter>;
    ixoSwapPriceHistoriesByAddress?: InputMaybe<IxoSwapToManyIxoSwapPriceHistoryFilter>;
    ixoSwapPriceHistoriesByAddressExist?: InputMaybe<Scalars['Boolean']['input']>;
    lpAddress?: InputMaybe<StringFilter>;
    lpFeePercent?: InputMaybe<StringFilter>;
    maxSlippagePercent?: InputMaybe<StringFilter>;
    not?: InputMaybe<IxoSwapFilter>;
    or?: InputMaybe<Array<IxoSwapFilter>>;
    owner?: InputMaybe<StringFilter>;
    pendingOwner?: InputMaybe<StringFilter>;
    protocolFeePercent?: InputMaybe<StringFilter>;
    protocolFeeRecipient?: InputMaybe<StringFilter>;
    token2Denom?: InputMaybe<StringFilter>;
    token2Reserve?: InputMaybe<BigIntFilter>;
    token1155Denom?: InputMaybe<StringFilter>;
    token1155Reserve?: InputMaybe<BigIntFilter>;
};
export type IxoSwapPriceHistoriesConnection = {
    __typename?: 'IxoSwapPriceHistoriesConnection';
    edges: Array<IxoSwapPriceHistoriesEdge>;
    nodes: Array<IxoSwapPriceHistory>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type IxoSwapPriceHistoriesEdge = {
    __typename?: 'IxoSwapPriceHistoriesEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: IxoSwapPriceHistory;
};
export declare enum IxoSwapPriceHistoriesOrderBy {
    AddressAsc = "ADDRESS_ASC",
    AddressDesc = "ADDRESS_DESC",
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    TimestampAsc = "TIMESTAMP_ASC",
    TimestampDesc = "TIMESTAMP_DESC",
    Token_2PriceAsc = "TOKEN_2_PRICE_ASC",
    Token_2PriceDesc = "TOKEN_2_PRICE_DESC",
    Token_2VolumeAsc = "TOKEN_2_VOLUME_ASC",
    Token_2VolumeDesc = "TOKEN_2_VOLUME_DESC",
    Token_1155PriceAsc = "TOKEN_1155_PRICE_ASC",
    Token_1155PriceDesc = "TOKEN_1155_PRICE_DESC",
    Token_1155VolumeAsc = "TOKEN_1155_VOLUME_ASC",
    Token_1155VolumeDesc = "TOKEN_1155_VOLUME_DESC"
}
export type IxoSwapPriceHistory = Node & {
    __typename?: 'IxoSwapPriceHistory';
    address: Scalars['String']['output'];
    id: Scalars['Int']['output'];
    ixoSwapByAddress?: Maybe<IxoSwap>;
    nodeId: Scalars['ID']['output'];
    timestamp: Scalars['Datetime']['output'];
    token2Price: Scalars['BigFloat']['output'];
    token2Volume: Scalars['BigFloat']['output'];
    token1155Price: Scalars['BigFloat']['output'];
    token1155Volume: Scalars['BigFloat']['output'];
};
export type IxoSwapPriceHistoryCondition = {
    address?: InputMaybe<Scalars['String']['input']>;
    id?: InputMaybe<Scalars['Int']['input']>;
    timestamp?: InputMaybe<Scalars['Datetime']['input']>;
    token2Price?: InputMaybe<Scalars['BigFloat']['input']>;
    token2Volume?: InputMaybe<Scalars['BigFloat']['input']>;
    token1155Price?: InputMaybe<Scalars['BigFloat']['input']>;
    token1155Volume?: InputMaybe<Scalars['BigFloat']['input']>;
};
export type IxoSwapPriceHistoryFilter = {
    address?: InputMaybe<StringFilter>;
    and?: InputMaybe<Array<IxoSwapPriceHistoryFilter>>;
    id?: InputMaybe<IntFilter>;
    ixoSwapByAddress?: InputMaybe<IxoSwapFilter>;
    not?: InputMaybe<IxoSwapPriceHistoryFilter>;
    or?: InputMaybe<Array<IxoSwapPriceHistoryFilter>>;
    timestamp?: InputMaybe<DatetimeFilter>;
    token2Price?: InputMaybe<BigFloatFilter>;
    token2Volume?: InputMaybe<BigFloatFilter>;
    token1155Price?: InputMaybe<BigFloatFilter>;
    token1155Volume?: InputMaybe<BigFloatFilter>;
};
export type IxoSwapToManyIxoSwapPriceHistoryFilter = {
    every?: InputMaybe<IxoSwapPriceHistoryFilter>;
    none?: InputMaybe<IxoSwapPriceHistoryFilter>;
    some?: InputMaybe<IxoSwapPriceHistoryFilter>;
};
export type IxoSwapsConnection = {
    __typename?: 'IxoSwapsConnection';
    edges: Array<IxoSwapsEdge>;
    nodes: Array<IxoSwap>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type IxoSwapsEdge = {
    __typename?: 'IxoSwapsEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: IxoSwap;
};
export declare enum IxoSwapsOrderBy {
    AddressAsc = "ADDRESS_ASC",
    AddressDesc = "ADDRESS_DESC",
    FrozenAsc = "FROZEN_ASC",
    FrozenDesc = "FROZEN_DESC",
    LpAddressAsc = "LP_ADDRESS_ASC",
    LpAddressDesc = "LP_ADDRESS_DESC",
    LpFeePercentAsc = "LP_FEE_PERCENT_ASC",
    LpFeePercentDesc = "LP_FEE_PERCENT_DESC",
    MaxSlippagePercentAsc = "MAX_SLIPPAGE_PERCENT_ASC",
    MaxSlippagePercentDesc = "MAX_SLIPPAGE_PERCENT_DESC",
    Natural = "NATURAL",
    OwnerAsc = "OWNER_ASC",
    OwnerDesc = "OWNER_DESC",
    PendingOwnerAsc = "PENDING_OWNER_ASC",
    PendingOwnerDesc = "PENDING_OWNER_DESC",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    ProtocolFeePercentAsc = "PROTOCOL_FEE_PERCENT_ASC",
    ProtocolFeePercentDesc = "PROTOCOL_FEE_PERCENT_DESC",
    ProtocolFeeRecipientAsc = "PROTOCOL_FEE_RECIPIENT_ASC",
    ProtocolFeeRecipientDesc = "PROTOCOL_FEE_RECIPIENT_DESC",
    Token_2DenomAsc = "TOKEN_2_DENOM_ASC",
    Token_2DenomDesc = "TOKEN_2_DENOM_DESC",
    Token_2ReserveAsc = "TOKEN_2_RESERVE_ASC",
    Token_2ReserveDesc = "TOKEN_2_RESERVE_DESC",
    Token_1155DenomAsc = "TOKEN_1155_DENOM_ASC",
    Token_1155DenomDesc = "TOKEN_1155_DENOM_DESC",
    Token_1155ReserveAsc = "TOKEN_1155_RESERVE_ASC",
    Token_1155ReserveDesc = "TOKEN_1155_RESERVE_DESC"
}
export type JsonFilter = {
    containedBy?: InputMaybe<Scalars['JSON']['input']>;
    contains?: InputMaybe<Scalars['JSON']['input']>;
    containsAllKeys?: InputMaybe<Array<Scalars['String']['input']>>;
    containsAnyKeys?: InputMaybe<Array<Scalars['String']['input']>>;
    containsKey?: InputMaybe<Scalars['String']['input']>;
    distinctFrom?: InputMaybe<Scalars['JSON']['input']>;
    equalTo?: InputMaybe<Scalars['JSON']['input']>;
    greaterThan?: InputMaybe<Scalars['JSON']['input']>;
    greaterThanOrEqualTo?: InputMaybe<Scalars['JSON']['input']>;
    in?: InputMaybe<Array<Scalars['JSON']['input']>>;
    isNull?: InputMaybe<Scalars['Boolean']['input']>;
    lessThan?: InputMaybe<Scalars['JSON']['input']>;
    lessThanOrEqualTo?: InputMaybe<Scalars['JSON']['input']>;
    notDistinctFrom?: InputMaybe<Scalars['JSON']['input']>;
    notEqualTo?: InputMaybe<Scalars['JSON']['input']>;
    notIn?: InputMaybe<Array<Scalars['JSON']['input']>>;
};
export type Message = Node & {
    __typename?: 'Message';
    denoms?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
    from?: Maybe<Scalars['String']['output']>;
    id: Scalars['Int']['output'];
    nodeId: Scalars['ID']['output'];
    to?: Maybe<Scalars['String']['output']>;
    tokenNames?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
    transactionByTransactionHash?: Maybe<Transaction>;
    transactionHash: Scalars['String']['output'];
    typeUrl: Scalars['String']['output'];
    value: Scalars['JSON']['output'];
};
export type MessageCondition = {
    denoms?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
    from?: InputMaybe<Scalars['String']['input']>;
    id?: InputMaybe<Scalars['Int']['input']>;
    to?: InputMaybe<Scalars['String']['input']>;
    tokenNames?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
    transactionHash?: InputMaybe<Scalars['String']['input']>;
    typeUrl?: InputMaybe<Scalars['String']['input']>;
    value?: InputMaybe<Scalars['JSON']['input']>;
};
export type MessageFilter = {
    and?: InputMaybe<Array<MessageFilter>>;
    denoms?: InputMaybe<StringListFilter>;
    from?: InputMaybe<StringFilter>;
    id?: InputMaybe<IntFilter>;
    not?: InputMaybe<MessageFilter>;
    or?: InputMaybe<Array<MessageFilter>>;
    to?: InputMaybe<StringFilter>;
    tokenNames?: InputMaybe<StringListFilter>;
    transactionByTransactionHash?: InputMaybe<TransactionFilter>;
    transactionHash?: InputMaybe<StringFilter>;
    typeUrl?: InputMaybe<StringFilter>;
    value?: InputMaybe<JsonFilter>;
};
export type MessagesConnection = {
    __typename?: 'MessagesConnection';
    edges: Array<MessagesEdge>;
    nodes: Array<Message>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type MessagesEdge = {
    __typename?: 'MessagesEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: Message;
};
export declare enum MessagesOrderBy {
    DenomsAsc = "DENOMS_ASC",
    DenomsDesc = "DENOMS_DESC",
    FromAsc = "FROM_ASC",
    FromDesc = "FROM_DESC",
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    TokenNamesAsc = "TOKEN_NAMES_ASC",
    TokenNamesDesc = "TOKEN_NAMES_DESC",
    ToAsc = "TO_ASC",
    ToDesc = "TO_DESC",
    TransactionHashAsc = "TRANSACTION_HASH_ASC",
    TransactionHashDesc = "TRANSACTION_HASH_DESC",
    TypeUrlAsc = "TYPE_URL_ASC",
    TypeUrlDesc = "TYPE_URL_DESC",
    ValueAsc = "VALUE_ASC",
    ValueDesc = "VALUE_DESC"
}
export type Node = {
    nodeId: Scalars['ID']['output'];
};
export type OutcomePayment = Node & {
    __typename?: 'OutcomePayment';
    amount: Scalars['JSON']['output'];
    bondByBondDid?: Maybe<Bond>;
    bondDid: Scalars['String']['output'];
    height: Scalars['Int']['output'];
    id: Scalars['Int']['output'];
    nodeId: Scalars['ID']['output'];
    senderAddress: Scalars['String']['output'];
    senderDid: Scalars['String']['output'];
    timestamp: Scalars['Datetime']['output'];
};
export type OutcomePaymentCondition = {
    amount?: InputMaybe<Scalars['JSON']['input']>;
    bondDid?: InputMaybe<Scalars['String']['input']>;
    height?: InputMaybe<Scalars['Int']['input']>;
    id?: InputMaybe<Scalars['Int']['input']>;
    senderAddress?: InputMaybe<Scalars['String']['input']>;
    senderDid?: InputMaybe<Scalars['String']['input']>;
    timestamp?: InputMaybe<Scalars['Datetime']['input']>;
};
export type OutcomePaymentFilter = {
    amount?: InputMaybe<JsonFilter>;
    and?: InputMaybe<Array<OutcomePaymentFilter>>;
    bondByBondDid?: InputMaybe<BondFilter>;
    bondDid?: InputMaybe<StringFilter>;
    height?: InputMaybe<IntFilter>;
    id?: InputMaybe<IntFilter>;
    not?: InputMaybe<OutcomePaymentFilter>;
    or?: InputMaybe<Array<OutcomePaymentFilter>>;
    senderAddress?: InputMaybe<StringFilter>;
    senderDid?: InputMaybe<StringFilter>;
    timestamp?: InputMaybe<DatetimeFilter>;
};
export type OutcomePaymentsConnection = {
    __typename?: 'OutcomePaymentsConnection';
    edges: Array<OutcomePaymentsEdge>;
    nodes: Array<OutcomePayment>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type OutcomePaymentsEdge = {
    __typename?: 'OutcomePaymentsEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: OutcomePayment;
};
export declare enum OutcomePaymentsOrderBy {
    AmountAsc = "AMOUNT_ASC",
    AmountDesc = "AMOUNT_DESC",
    BondDidAsc = "BOND_DID_ASC",
    BondDidDesc = "BOND_DID_DESC",
    HeightAsc = "HEIGHT_ASC",
    HeightDesc = "HEIGHT_DESC",
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    SenderAddressAsc = "SENDER_ADDRESS_ASC",
    SenderAddressDesc = "SENDER_ADDRESS_DESC",
    SenderDidAsc = "SENDER_DID_ASC",
    SenderDidDesc = "SENDER_DID_DESC",
    TimestampAsc = "TIMESTAMP_ASC",
    TimestampDesc = "TIMESTAMP_DESC"
}
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 Pgmigration = Node & {
    __typename?: 'Pgmigration';
    id: Scalars['Int']['output'];
    name: Scalars['String']['output'];
    nodeId: Scalars['ID']['output'];
    runOn: Scalars['Datetime']['output'];
};
export type PgmigrationCondition = {
    id?: InputMaybe<Scalars['Int']['input']>;
    name?: InputMaybe<Scalars['String']['input']>;
    runOn?: InputMaybe<Scalars['Datetime']['input']>;
};
export type PgmigrationFilter = {
    and?: InputMaybe<Array<PgmigrationFilter>>;
    id?: InputMaybe<IntFilter>;
    name?: InputMaybe<StringFilter>;
    not?: InputMaybe<PgmigrationFilter>;
    or?: InputMaybe<Array<PgmigrationFilter>>;
    runOn?: InputMaybe<DatetimeFilter>;
};
export type PgmigrationsConnection = {
    __typename?: 'PgmigrationsConnection';
    edges: Array<PgmigrationsEdge>;
    nodes: Array<Pgmigration>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type PgmigrationsEdge = {
    __typename?: 'PgmigrationsEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: Pgmigration;
};
export declare enum PgmigrationsOrderBy {
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    NameAsc = "NAME_ASC",
    NameDesc = "NAME_DESC",
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    RunOnAsc = "RUN_ON_ASC",
    RunOnDesc = "RUN_ON_DESC"
}
export type Query = Node & {
    __typename?: 'Query';
    bond?: Maybe<Bond>;
    bondAlpha?: Maybe<BondAlpha>;
    bondAlphaByNodeId?: Maybe<BondAlpha>;
    bondAlphas?: Maybe<BondAlphasConnection>;
    bondBuy?: Maybe<BondBuy>;
    bondBuyByNodeId?: Maybe<BondBuy>;
    bondBuys?: Maybe<BondBuysConnection>;
    bondByNodeId?: Maybe<Bond>;
    bondSell?: Maybe<BondSell>;
    bondSellByNodeId?: Maybe<BondSell>;
    bondSells?: Maybe<BondSellsConnection>;
    bondSwap?: Maybe<BondSwap>;
    bondSwapByNodeId?: Maybe<BondSwap>;
    bondSwaps?: Maybe<BondSwapsConnection>;
    bonds?: Maybe<BondsConnection>;
    chain?: Maybe<Chain>;
    chainByNodeId?: Maybe<Chain>;
    chains?: Maybe<ChainsConnection>;
    claim?: Maybe<Claim>;
    claimByNodeId?: Maybe<Claim>;
    claimCollection?: Maybe<ClaimCollection>;
    claimCollectionByNodeId?: Maybe<ClaimCollection>;
    claimCollections?: Maybe<ClaimCollectionsConnection>;
    claims?: Maybe<ClaimsConnection>;
    deviceExternalIdsLoaded: Scalars['Boolean']['output'];
    dispute?: Maybe<Dispute>;
    disputeByNodeId?: Maybe<Dispute>;
    disputes?: Maybe<DisputesConnection>;
    entities?: Maybe<EntitiesConnection>;
    entity?: Maybe<Entity>;
    entityByNodeId?: Maybe<Entity>;
    evaluation?: Maybe<Evaluation>;
    evaluationByNodeId?: Maybe<Evaluation>;
    evaluations?: Maybe<EvaluationsConnection>;
    getAccountTokens: Scalars['JSON']['output'];
    getTokensTotalByAddress: Scalars['JSON']['output'];
    getTokensTotalForCollection: Scalars['JSON']['output'];
    getTokensTotalForCollectionAmounts: Scalars['JSON']['output'];
    getTokensTotalForEntities: Scalars['JSON']['output'];
    iid?: Maybe<Iid>;
    iidByNodeId?: Maybe<Iid>;
    iids?: Maybe<IidsConnection>;
    ipf?: Maybe<Ipf>;
    ipfByNodeId?: Maybe<Ipf>;
    ipfs?: Maybe<IpfsConnection>;
    ixoSwap?: Maybe<IxoSwap>;
    ixoSwapByNodeId?: Maybe<IxoSwap>;
    ixoSwapPriceHistories?: Maybe<IxoSwapPriceHistoriesConnection>;
    ixoSwapPriceHistory?: Maybe<IxoSwapPriceHistory>;
    ixoSwapPriceHistoryByNodeId?: Maybe<IxoSwapPriceHistory>;
    ixoSwapPriceHistoryByTimestampAndAddress?: Maybe<IxoSwapPriceHistory>;
    ixoSwaps?: Maybe<IxoSwapsConnection>;
    message?: Maybe<Message>;
    messageByNodeId?: Maybe<Message>;
    messages?: Maybe<MessagesConnection>;
    node?: Maybe<Node>;
    nodeId: Scalars['ID']['output'];
    outcomePayment?: Maybe<OutcomePayment>;
    outcomePaymentByNodeId?: Maybe<OutcomePayment>;
    outcomePayments?: Maybe<OutcomePaymentsConnection>;
    pgmigration?: Maybe<Pgmigration>;
    pgmigrationByNodeId?: Maybe<Pgmigration>;
    pgmigrations?: Maybe<PgmigrationsConnection>;
    query: Query;
    reserveWithdrawal?: Maybe<ReserveWithdrawal>;
    reserveWithdrawalByNodeId?: Maybe<ReserveWithdrawal>;
    reserveWithdrawals?: Maybe<ReserveWithdrawalsConnection>;
    shareWithdrawal?: Maybe<ShareWithdrawal>;
    shareWithdrawalByNodeId?: Maybe<ShareWithdrawal>;
    shareWithdrawals?: Maybe<ShareWithdrawalsConnection>;
    smartAccountAuthenticator?: Maybe<SmartAccountAuthenticator>;
    smartAccountAuthenticatorByNodeId?: Maybe<SmartAccountAuthenticator>;
    smartAccountAuthenticators?: Maybe<SmartAccountAuthenticatorsConnection>;
    token?: Maybe<Token>;
    tokenByNodeId?: Maybe<Token>;
    tokenCancelled?: Maybe<TokenCancelled>;
    tokenCancelledByNodeId?: Maybe<TokenCancelled>;
    tokenCancelleds?: Maybe<TokenCancelledsConnection>;
    tokenClass?: Maybe<TokenClass>;
    tokenClassByNodeId?: Maybe<TokenClass>;
    tokenClasses?: Maybe<TokenClassesConnection>;
    tokenData?: Maybe<TokenDataConnection>;
    tokenDatum?: Maybe<TokenDatum>;
    tokenDatumByNodeId?: Maybe<TokenDatum>;
    tokenRetired?: Maybe<TokenRetired>;
    tokenRetiredByNodeId?: Maybe<TokenRetired>;
    tokenRetireds?: Maybe<TokenRetiredsConnection>;
    tokenTransaction?: Maybe<TokenTransaction>;
    tokenTransactionByNodeId?: Maybe<TokenTransaction>;
    tokenTransactions?: Maybe<TokenTransactionsConnection>;
    tokenomicsAccount?: Maybe<TokenomicsAccount>;
    tokenomicsAccountByNodeId?: Maybe<TokenomicsAccount>;
    tokenomicsAccounts?: Maybe<TokenomicsAccountsConnection>;
    tokenomicsInflation: Scalars['JSON']['output'];
    tokenomicsSupplyCommunityPool: Scalars['JSON']['output'];
    tokenomicsSupplyIBC: Scalars['JSON']['output'];
    tokenomicsSupplyStaked: Scalars['JSON']['output'];
    tokenomicsSupplyTotal: Scalars['JSON']['output'];
    tokens?: Maybe<TokensConnection>;
    transaction?: Maybe<Transaction>;
    transactionByNodeId?: Maybe<Transaction>;
    transactions?: Maybe<TransactionsConnection>;
};
export type QueryBondArgs = {
    bondDid: Scalars['String']['input'];
};
export type QueryBondAlphaArgs = {
    id: Scalars['Int']['input'];
};
export type QueryBondAlphaByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryBondAlphasArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<BondAlphaCondition>;
    filter?: InputMaybe<BondAlphaFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<BondAlphasOrderBy>>;
};
export type QueryBondBuyArgs = {
    id: Scalars['Int']['input'];
};
export type QueryBondBuyByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryBondBuysArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<BondBuyCondition>;
    filter?: InputMaybe<BondBuyFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<BondBuysOrderBy>>;
};
export type QueryBondByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryBondSellArgs = {
    id: Scalars['Int']['input'];
};
export type QueryBondSellByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryBondSellsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<BondSellCondition>;
    filter?: InputMaybe<BondSellFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<BondSellsOrderBy>>;
};
export type QueryBondSwapArgs = {
    id: Scalars['Int']['input'];
};
export type QueryBondSwapByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryBondSwapsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<BondSwapCondition>;
    filter?: InputMaybe<BondSwapFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<BondSwapsOrderBy>>;
};
export type QueryBondsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<BondCondition>;
    filter?: InputMaybe<BondFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<BondsOrderBy>>;
};
export type QueryChainArgs = {
    chainId: Scalars['String']['input'];
};
export type QueryChainByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryChainsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<ChainCondition>;
    filter?: InputMaybe<ChainFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<ChainsOrderBy>>;
};
export type QueryClaimArgs = {
    claimId: Scalars['String']['input'];
};
export type QueryClaimByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryClaimCollectionArgs = {
    id: Scalars['String']['input'];
};
export type QueryClaimCollectionByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryClaimCollectionsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<ClaimCollectionCondition>;
    filter?: InputMaybe<ClaimCollectionFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<ClaimCollectionsOrderBy>>;
};
export type QueryClaimsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<ClaimCondition>;
    filter?: InputMaybe<ClaimFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<ClaimsOrderBy>>;
};
export type QueryDisputeArgs = {
    proof: Scalars['String']['input'];
};
export type QueryDisputeByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryDisputesArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<DisputeCondition>;
    filter?: InputMaybe<DisputeFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<DisputesOrderBy>>;
};
export type QueryEntitiesArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<EntityCondition>;
    filter?: InputMaybe<EntityFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<EntitiesOrderBy>>;
};
export type QueryEntityArgs = {
    id: Scalars['String']['input'];
};
export type QueryEntityByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryEvaluationArgs = {
    claimId: Scalars['String']['input'];
};
export type QueryEvaluationByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryEvaluationsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<EvaluationCondition>;
    filter?: InputMaybe<EvaluationFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<EvaluationsOrderBy>>;
};
export type QueryGetAccountTokensArgs = {
    address: Scalars['String']['input'];
    allEntityRetired?: InputMaybe<Scalars['Boolean']['input']>;
    name?: InputMaybe<Scalars['String']['input']>;
};
export type QueryGetTokensTotalByAddressArgs = {
    address: Scalars['String']['input'];
    allEntityRetired?: InputMaybe<Scalars['Boolean']['input']>;
    name?: InputMaybe<Scalars['String']['input']>;
};
export type QueryGetTokensTotalForCollectionArgs = {
    allEntityRetired?: InputMaybe<Scalars['Boolean']['input']>;
    did: Scalars['String']['input'];
    name?: InputMaybe<Scalars['String']['input']>;
};
export type QueryGetTokensTotalForCollectionAmountsArgs = {
    allEntityRetired?: InputMaybe<Scalars['Boolean']['input']>;
    did: Scalars['String']['input'];
    name?: InputMaybe<Scalars['String']['input']>;
};
export type QueryGetTokensTotalForEntitiesArgs = {
    address: Scalars['String']['input'];
    allEntityRetired?: InputMaybe<Scalars['Boolean']['input']>;
    name?: InputMaybe<Scalars['String']['input']>;
};
export type QueryIidArgs = {
    id: Scalars['String']['input'];
};
export type QueryIidByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryIidsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<IidCondition>;
    filter?: InputMaybe<IidFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<IidsOrderBy>>;
};
export type QueryIpfArgs = {
    cid: Scalars['String']['input'];
};
export type QueryIpfByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryIpfsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<IpfCondition>;
    filter?: InputMaybe<IpfFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<IpfsOrderBy>>;
};
export type QueryIxoSwapArgs = {
    address: Scalars['String']['input'];
};
export type QueryIxoSwapByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryIxoSwapPriceHistoriesArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<IxoSwapPriceHistoryCondition>;
    filter?: InputMaybe<IxoSwapPriceHistoryFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<IxoSwapPriceHistoriesOrderBy>>;
};
export type QueryIxoSwapPriceHistoryArgs = {
    id: Scalars['Int']['input'];
};
export type QueryIxoSwapPriceHistoryByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryIxoSwapPriceHistoryByTimestampAndAddressArgs = {
    address: Scalars['String']['input'];
    timestamp: Scalars['Datetime']['input'];
};
export type QueryIxoSwapsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<IxoSwapCondition>;
    filter?: InputMaybe<IxoSwapFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<IxoSwapsOrderBy>>;
};
export type QueryMessageArgs = {
    id: Scalars['Int']['input'];
};
export type QueryMessageByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryMessagesArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<MessageCondition>;
    filter?: InputMaybe<MessageFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<MessagesOrderBy>>;
};
export type QueryNodeArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryOutcomePaymentArgs = {
    id: Scalars['Int']['input'];
};
export type QueryOutcomePaymentByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryOutcomePaymentsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<OutcomePaymentCondition>;
    filter?: InputMaybe<OutcomePaymentFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<OutcomePaymentsOrderBy>>;
};
export type QueryPgmigrationArgs = {
    id: Scalars['Int']['input'];
};
export type QueryPgmigrationByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryPgmigrationsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<PgmigrationCondition>;
    filter?: InputMaybe<PgmigrationFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<PgmigrationsOrderBy>>;
};
export type QueryReserveWithdrawalArgs = {
    id: Scalars['Int']['input'];
};
export type QueryReserveWithdrawalByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryReserveWithdrawalsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<ReserveWithdrawalCondition>;
    filter?: InputMaybe<ReserveWithdrawalFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<ReserveWithdrawalsOrderBy>>;
};
export type QueryShareWithdrawalArgs = {
    id: Scalars['Int']['input'];
};
export type QueryShareWithdrawalByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryShareWithdrawalsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<ShareWithdrawalCondition>;
    filter?: InputMaybe<ShareWithdrawalFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<ShareWithdrawalsOrderBy>>;
};
export type QuerySmartAccountAuthenticatorArgs = {
    id: Scalars['String']['input'];
};
export type QuerySmartAccountAuthenticatorByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QuerySmartAccountAuthenticatorsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<SmartAccountAuthenticatorCondition>;
    filter?: InputMaybe<SmartAccountAuthenticatorFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<SmartAccountAuthenticatorsOrderBy>>;
};
export type QueryTokenArgs = {
    id: Scalars['String']['input'];
};
export type QueryTokenByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryTokenCancelledArgs = {
    aid: Scalars['Int']['input'];
};
export type QueryTokenCancelledByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryTokenCancelledsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<TokenCancelledCondition>;
    filter?: InputMaybe<TokenCancelledFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<TokenCancelledsOrderBy>>;
};
export type QueryTokenClassArgs = {
    contractAddress: Scalars['String']['input'];
};
export type QueryTokenClassByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryTokenClassesArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<TokenClassCondition>;
    filter?: InputMaybe<TokenClassFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<TokenClassesOrderBy>>;
};
export type QueryTokenDataArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<TokenDatumCondition>;
    filter?: InputMaybe<TokenDatumFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<TokenDataOrderBy>>;
};
export type QueryTokenDatumArgs = {
    aid: Scalars['Int']['input'];
};
export type QueryTokenDatumByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryTokenRetiredArgs = {
    aid: Scalars['Int']['input'];
};
export type QueryTokenRetiredByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryTokenRetiredsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<TokenRetiredCondition>;
    filter?: InputMaybe<TokenRetiredFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<TokenRetiredsOrderBy>>;
};
export type QueryTokenTransactionArgs = {
    aid: Scalars['Int']['input'];
};
export type QueryTokenTransactionByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryTokenTransactionsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<TokenTransactionCondition>;
    filter?: InputMaybe<TokenTransactionFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<TokenTransactionsOrderBy>>;
};
export type QueryTokenomicsAccountArgs = {
    address: Scalars['String']['input'];
};
export type QueryTokenomicsAccountByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryTokenomicsAccountsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<TokenomicsAccountCondition>;
    filter?: InputMaybe<TokenomicsAccountFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<TokenomicsAccountsOrderBy>>;
};
export type QueryTokensArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<TokenCondition>;
    filter?: InputMaybe<TokenFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<TokensOrderBy>>;
};
export type QueryTransactionArgs = {
    hash: Scalars['String']['input'];
};
export type QueryTransactionByNodeIdArgs = {
    nodeId: Scalars['ID']['input'];
};
export type QueryTransactionsArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<TransactionCondition>;
    filter?: InputMaybe<TransactionFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<TransactionsOrderBy>>;
};
export type ReserveWithdrawal = Node & {
    __typename?: 'ReserveWithdrawal';
    amount: Scalars['JSON']['output'];
    bondByBondDid?: Maybe<Bond>;
    bondDid: Scalars['String']['output'];
    height: Scalars['Int']['output'];
    id: Scalars['Int']['output'];
    nodeId: Scalars['ID']['output'];
    reserveWithdrawalAddress: Scalars['String']['output'];
    timestamp: Scalars['Datetime']['output'];
    withdrawerAddress: Scalars['String']['output'];
    withdrawerDid: Scalars['String']['output'];
};
export type ReserveWithdrawalCondition = {
    amount?: InputMaybe<Scalars['JSON']['input']>;
    bondDid?: InputMaybe<Scalars['String']['input']>;
    height?: InputMaybe<Scalars['Int']['input']>;
    id?: InputMaybe<Scalars['Int']['input']>;
    reserveWithdrawalAddress?: InputMaybe<Scalars['String']['input']>;
    timestamp?: InputMaybe<Scalars['Datetime']['input']>;
    withdrawerAddress?: InputMaybe<Scalars['String']['input']>;
    withdrawerDid?: InputMaybe<Scalars['String']['input']>;
};
export type ReserveWithdrawalFilter = {
    amount?: InputMaybe<JsonFilter>;
    and?: InputMaybe<Array<ReserveWithdrawalFilter>>;
    bondByBondDid?: InputMaybe<BondFilter>;
    bondDid?: InputMaybe<StringFilter>;
    height?: InputMaybe<IntFilter>;
    id?: InputMaybe<IntFilter>;
    not?: InputMaybe<ReserveWithdrawalFilter>;
    or?: InputMaybe<Array<ReserveWithdrawalFilter>>;
    reserveWithdrawalAddress?: InputMaybe<StringFilter>;
    timestamp?: InputMaybe<DatetimeFilter>;
    withdrawerAddress?: InputMaybe<StringFilter>;
    withdrawerDid?: InputMaybe<StringFilter>;
};
export type ReserveWithdrawalsConnection = {
    __typename?: 'ReserveWithdrawalsConnection';
    edges: Array<ReserveWithdrawalsEdge>;
    nodes: Array<ReserveWithdrawal>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type ReserveWithdrawalsEdge = {
    __typename?: 'ReserveWithdrawalsEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: ReserveWithdrawal;
};
export declare enum ReserveWithdrawalsOrderBy {
    AmountAsc = "AMOUNT_ASC",
    AmountDesc = "AMOUNT_DESC",
    BondDidAsc = "BOND_DID_ASC",
    BondDidDesc = "BOND_DID_DESC",
    HeightAsc = "HEIGHT_ASC",
    HeightDesc = "HEIGHT_DESC",
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    ReserveWithdrawalAddressAsc = "RESERVE_WITHDRAWAL_ADDRESS_ASC",
    ReserveWithdrawalAddressDesc = "RESERVE_WITHDRAWAL_ADDRESS_DESC",
    TimestampAsc = "TIMESTAMP_ASC",
    TimestampDesc = "TIMESTAMP_DESC",
    WithdrawerAddressAsc = "WITHDRAWER_ADDRESS_ASC",
    WithdrawerAddressDesc = "WITHDRAWER_ADDRESS_DESC",
    WithdrawerDidAsc = "WITHDRAWER_DID_ASC",
    WithdrawerDidDesc = "WITHDRAWER_DID_DESC"
}
export type ShareWithdrawal = Node & {
    __typename?: 'ShareWithdrawal';
    amount: Scalars['JSON']['output'];
    bondByBondDid?: Maybe<Bond>;
    bondDid: Scalars['String']['output'];
    height: Scalars['Int']['output'];
    id: Scalars['Int']['output'];
    nodeId: Scalars['ID']['output'];
    recipientAddress: Scalars['String']['output'];
    recipientDid: Scalars['String']['output'];
    timestamp: Scalars['Datetime']['output'];
};
export type ShareWithdrawalCondition = {
    amount?: InputMaybe<Scalars['JSON']['input']>;
    bondDid?: InputMaybe<Scalars['String']['input']>;
    height?: InputMaybe<Scalars['Int']['input']>;
    id?: InputMaybe<Scalars['Int']['input']>;
    recipientAddress?: InputMaybe<Scalars['String']['input']>;
    recipientDid?: InputMaybe<Scalars['String']['input']>;
    timestamp?: InputMaybe<Scalars['Datetime']['input']>;
};
export type ShareWithdrawalFilter = {
    amount?: InputMaybe<JsonFilter>;
    and?: InputMaybe<Array<ShareWithdrawalFilter>>;
    bondByBondDid?: InputMaybe<BondFilter>;
    bondDid?: InputMaybe<StringFilter>;
    height?: InputMaybe<IntFilter>;
    id?: InputMaybe<IntFilter>;
    not?: InputMaybe<ShareWithdrawalFilter>;
    or?: InputMaybe<Array<ShareWithdrawalFilter>>;
    recipientAddress?: InputMaybe<StringFilter>;
    recipientDid?: InputMaybe<StringFilter>;
    timestamp?: InputMaybe<DatetimeFilter>;
};
export type ShareWithdrawalsConnection = {
    __typename?: 'ShareWithdrawalsConnection';
    edges: Array<ShareWithdrawalsEdge>;
    nodes: Array<ShareWithdrawal>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type ShareWithdrawalsEdge = {
    __typename?: 'ShareWithdrawalsEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: ShareWithdrawal;
};
export declare enum ShareWithdrawalsOrderBy {
    AmountAsc = "AMOUNT_ASC",
    AmountDesc = "AMOUNT_DESC",
    BondDidAsc = "BOND_DID_ASC",
    BondDidDesc = "BOND_DID_DESC",
    HeightAsc = "HEIGHT_ASC",
    HeightDesc = "HEIGHT_DESC",
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    RecipientAddressAsc = "RECIPIENT_ADDRESS_ASC",
    RecipientAddressDesc = "RECIPIENT_ADDRESS_DESC",
    RecipientDidAsc = "RECIPIENT_DID_ASC",
    RecipientDidDesc = "RECIPIENT_DID_DESC",
    TimestampAsc = "TIMESTAMP_ASC",
    TimestampDesc = "TIMESTAMP_DESC"
}
export type SmartAccountAuthenticator = Node & {
    __typename?: 'SmartAccountAuthenticator';
    address: Scalars['String']['output'];
    config?: Maybe<Scalars['JSON']['output']>;
    createdAt: Scalars['Datetime']['output'];
    id: Scalars['String']['output'];
    keyId?: Maybe<Scalars['String']['output']>;
    nodeId: Scalars['ID']['output'];
    type: Scalars['String']['output'];
};
export type SmartAccountAuthenticatorCondition = {
    address?: InputMaybe<Scalars['String']['input']>;
    config?: InputMaybe<Scalars['JSON']['input']>;
    createdAt?: InputMaybe<Scalars['Datetime']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    keyId?: InputMaybe<Scalars['String']['input']>;
    type?: InputMaybe<Scalars['String']['input']>;
};
export type SmartAccountAuthenticatorFilter = {
    address?: InputMaybe<StringFilter>;
    and?: InputMaybe<Array<SmartAccountAuthenticatorFilter>>;
    config?: InputMaybe<JsonFilter>;
    createdAt?: InputMaybe<DatetimeFilter>;
    id?: InputMaybe<StringFilter>;
    keyId?: InputMaybe<StringFilter>;
    not?: InputMaybe<SmartAccountAuthenticatorFilter>;
    or?: InputMaybe<Array<SmartAccountAuthenticatorFilter>>;
    type?: InputMaybe<StringFilter>;
};
export type SmartAccountAuthenticatorsConnection = {
    __typename?: 'SmartAccountAuthenticatorsConnection';
    edges: Array<SmartAccountAuthenticatorsEdge>;
    nodes: Array<SmartAccountAuthenticator>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type SmartAccountAuthenticatorsEdge = {
    __typename?: 'SmartAccountAuthenticatorsEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: SmartAccountAuthenticator;
};
export declare enum SmartAccountAuthenticatorsOrderBy {
    AddressAsc = "ADDRESS_ASC",
    AddressDesc = "ADDRESS_DESC",
    ConfigAsc = "CONFIG_ASC",
    ConfigDesc = "CONFIG_DESC",
    CreatedAtAsc = "CREATED_AT_ASC",
    CreatedAtDesc = "CREATED_AT_DESC",
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    KeyIdAsc = "KEY_ID_ASC",
    KeyIdDesc = "KEY_ID_DESC",
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    TypeAsc = "TYPE_ASC",
    TypeDesc = "TYPE_DESC"
}
export type StringFilter = {
    distinctFrom?: InputMaybe<Scalars['String']['input']>;
    distinctFromInsensitive?: InputMaybe<Scalars['String']['input']>;
    endsWith?: InputMaybe<Scalars['String']['input']>;
    endsWithInsensitive?: InputMaybe<Scalars['String']['input']>;
    equalTo?: InputMaybe<Scalars['String']['input']>;
    equalToInsensitive?: InputMaybe<Scalars['String']['input']>;
    greaterThan?: InputMaybe<Scalars['String']['input']>;
    greaterThanInsensitive?: InputMaybe<Scalars['String']['input']>;
    greaterThanOrEqualTo?: InputMaybe<Scalars['String']['input']>;
    greaterThanOrEqualToInsensitive?: InputMaybe<Scalars['String']['input']>;
    in?: InputMaybe<Array<Scalars['String']['input']>>;
    inInsensitive?: InputMaybe<Array<Scalars['String']['input']>>;
    includes?: InputMaybe<Scalars['String']['input']>;
    includesInsensitive?: InputMaybe<Scalars['String']['input']>;
    isNull?: InputMaybe<Scalars['Boolean']['input']>;
    lessThan?: InputMaybe<Scalars['String']['input']>;
    lessThanInsensitive?: InputMaybe<Scalars['String']['input']>;
    lessThanOrEqualTo?: InputMaybe<Scalars['String']['input']>;
    lessThanOrEqualToInsensitive?: InputMaybe<Scalars['String']['input']>;
    like?: InputMaybe<Scalars['String']['input']>;
    likeInsensitive?: InputMaybe<Scalars['String']['input']>;
    notDistinctFrom?: InputMaybe<Scalars['String']['input']>;
    notDistinctFromInsensitive?: InputMaybe<Scalars['String']['input']>;
    notEndsWith?: InputMaybe<Scalars['String']['input']>;
    notEndsWithInsensitive?: InputMaybe<Scalars['String']['input']>;
    notEqualTo?: InputMaybe<Scalars['String']['input']>;
    notEqualToInsensitive?: InputMaybe<Scalars['String']['input']>;
    notIn?: InputMaybe<Array<Scalars['String']['input']>>;
    notInInsensitive?: InputMaybe<Array<Scalars['String']['input']>>;
    notIncludes?: InputMaybe<Scalars['String']['input']>;
    notIncludesInsensitive?: InputMaybe<Scalars['String']['input']>;
    notLike?: InputMaybe<Scalars['String']['input']>;
    notLikeInsensitive?: InputMaybe<Scalars['String']['input']>;
    notStartsWith?: InputMaybe<Scalars['String']['input']>;
    notStartsWithInsensitive?: InputMaybe<Scalars['String']['input']>;
    startsWith?: InputMaybe<Scalars['String']['input']>;
    startsWithInsensitive?: InputMaybe<Scalars['String']['input']>;
};
export type StringListFilter = {
    anyEqualTo?: InputMaybe<Scalars['String']['input']>;
    anyGreaterThan?: InputMaybe<Scalars['String']['input']>;
    anyGreaterThanOrEqualTo?: InputMaybe<Scalars['String']['input']>;
    anyLessThan?: InputMaybe<Scalars['String']['input']>;
    anyLessThanOrEqualTo?: InputMaybe<Scalars['String']['input']>;
    anyNotEqualTo?: InputMaybe<Scalars['String']['input']>;
    containedBy?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
    contains?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
    distinctFrom?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
    equalTo?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
    greaterThan?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
    greaterThanOrEqualTo?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
    isNull?: InputMaybe<Scalars['Boolean']['input']>;
    lessThan?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
    lessThanOrEqualTo?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
    notDistinctFrom?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
    notEqualTo?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
    overlaps?: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
};
export type Token = Node & {
    __typename?: 'Token';
    collection: Scalars['String']['output'];
    entityByCollection?: Maybe<Entity>;
    id: Scalars['String']['output'];
    index: Scalars['String']['output'];
    name: Scalars['String']['output'];
    nodeId: Scalars['ID']['output'];
    tokenClassByName?: Maybe<TokenClass>;
    tokenDataByTokenId: TokenDataConnection;
    tokenRetiredsById: TokenRetiredsConnection;
    tokenTransactionsByTokenId: TokenTransactionsConnection;
};
export type TokenTokenDataByTokenIdArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<TokenDatumCondition>;
    filter?: InputMaybe<TokenDatumFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<TokenDataOrderBy>>;
};
export type TokenTokenRetiredsByIdArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<TokenRetiredCondition>;
    filter?: InputMaybe<TokenRetiredFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<TokenRetiredsOrderBy>>;
};
export type TokenTokenTransactionsByTokenIdArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<TokenTransactionCondition>;
    filter?: InputMaybe<TokenTransactionFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<TokenTransactionsOrderBy>>;
};
export type TokenCancelled = Node & {
    __typename?: 'TokenCancelled';
    aid: Scalars['Int']['output'];
    amount: Scalars['BigInt']['output'];
    id: Scalars['String']['output'];
    name: Scalars['String']['output'];
    nodeId: Scalars['ID']['output'];
    owner: Scalars['String']['output'];
    reason: Scalars['String']['output'];
    tokenClassByName?: Maybe<TokenClass>;
};
export type TokenCancelledAggregates = {
    __typename?: 'TokenCancelledAggregates';
    average?: Maybe<TokenCancelledAverageAggregates>;
    distinctCount?: Maybe<TokenCancelledDistinctCountAggregates>;
    keys?: Maybe<Array<Scalars['String']['output']>>;
    max?: Maybe<TokenCancelledMaxAggregates>;
    min?: Maybe<TokenCancelledMinAggregates>;
    stddevPopulation?: Maybe<TokenCancelledStddevPopulationAggregates>;
    stddevSample?: Maybe<TokenCancelledStddevSampleAggregates>;
    sum?: Maybe<TokenCancelledSumAggregates>;
    variancePopulation?: Maybe<TokenCancelledVariancePopulationAggregates>;
    varianceSample?: Maybe<TokenCancelledVarianceSampleAggregates>;
};
export type TokenCancelledAggregatesFilter = {
    average?: InputMaybe<TokenCancelledAverageAggregateFilter>;
    distinctCount?: InputMaybe<TokenCancelledDistinctCountAggregateFilter>;
    filter?: InputMaybe<TokenCancelledFilter>;
    max?: InputMaybe<TokenCancelledMaxAggregateFilter>;
    min?: InputMaybe<TokenCancelledMinAggregateFilter>;
    stddevPopulation?: InputMaybe<TokenCancelledStddevPopulationAggregateFilter>;
    stddevSample?: InputMaybe<TokenCancelledStddevSampleAggregateFilter>;
    sum?: InputMaybe<TokenCancelledSumAggregateFilter>;
    variancePopulation?: InputMaybe<TokenCancelledVariancePopulationAggregateFilter>;
    varianceSample?: InputMaybe<TokenCancelledVarianceSampleAggregateFilter>;
};
export type TokenCancelledAverageAggregateFilter = {
    aid?: InputMaybe<BigFloatFilter>;
    amount?: InputMaybe<BigFloatFilter>;
};
export type TokenCancelledAverageAggregates = {
    __typename?: 'TokenCancelledAverageAggregates';
    aid?: Maybe<Scalars['BigFloat']['output']>;
    amount?: Maybe<Scalars['BigFloat']['output']>;
};
export type TokenCancelledCondition = {
    aid?: InputMaybe<Scalars['Int']['input']>;
    amount?: InputMaybe<Scalars['BigInt']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    name?: InputMaybe<Scalars['String']['input']>;
    owner?: InputMaybe<Scalars['String']['input']>;
    reason?: InputMaybe<Scalars['String']['input']>;
};
export type TokenCancelledDistinctCountAggregateFilter = {
    aid?: InputMaybe<BigIntFilter>;
    amount?: InputMaybe<BigIntFilter>;
    id?: InputMaybe<BigIntFilter>;
    name?: InputMaybe<BigIntFilter>;
    owner?: InputMaybe<BigIntFilter>;
    reason?: InputMaybe<BigIntFilter>;
};
export type TokenCancelledDistinctCountAggregates = {
    __typename?: 'TokenCancelledDistinctCountAggregates';
    aid?: Maybe<Scalars['BigInt']['output']>;
    amount?: Maybe<Scalars['BigInt']['output']>;
    id?: Maybe<Scalars['BigInt']['output']>;
    name?: Maybe<Scalars['BigInt']['output']>;
    owner?: Maybe<Scalars['BigInt']['output']>;
    reason?: Maybe<Scalars['BigInt']['output']>;
};
export type TokenCancelledFilter = {
    aid?: InputMaybe<IntFilter>;
    amount?: InputMaybe<BigIntFilter>;
    and?: InputMaybe<Array<TokenCancelledFilter>>;
    id?: InputMaybe<StringFilter>;
    name?: InputMaybe<StringFilter>;
    not?: InputMaybe<TokenCancelledFilter>;
    or?: InputMaybe<Array<TokenCancelledFilter>>;
    owner?: InputMaybe<StringFilter>;
    reason?: InputMaybe<StringFilter>;
    tokenClassByName?: InputMaybe<TokenClassFilter>;
};
export declare enum TokenCancelledGroupBy {
    Amount = "AMOUNT",
    Id = "ID",
    Name = "NAME",
    Owner = "OWNER",
    Reason = "REASON"
}
export type TokenCancelledHavingAverageInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenCancelledHavingDistinctCountInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenCancelledHavingInput = {
    AND?: InputMaybe<Array<TokenCancelledHavingInput>>;
    OR?: InputMaybe<Array<TokenCancelledHavingInput>>;
    average?: InputMaybe<TokenCancelledHavingAverageInput>;
    distinctCount?: InputMaybe<TokenCancelledHavingDistinctCountInput>;
    max?: InputMaybe<TokenCancelledHavingMaxInput>;
    min?: InputMaybe<TokenCancelledHavingMinInput>;
    stddevPopulation?: InputMaybe<TokenCancelledHavingStddevPopulationInput>;
    stddevSample?: InputMaybe<TokenCancelledHavingStddevSampleInput>;
    sum?: InputMaybe<TokenCancelledHavingSumInput>;
    variancePopulation?: InputMaybe<TokenCancelledHavingVariancePopulationInput>;
    varianceSample?: InputMaybe<TokenCancelledHavingVarianceSampleInput>;
};
export type TokenCancelledHavingMaxInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenCancelledHavingMinInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenCancelledHavingStddevPopulationInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenCancelledHavingStddevSampleInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenCancelledHavingSumInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenCancelledHavingVariancePopulationInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenCancelledHavingVarianceSampleInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenCancelledMaxAggregateFilter = {
    aid?: InputMaybe<IntFilter>;
    amount?: InputMaybe<BigIntFilter>;
};
export type TokenCancelledMaxAggregates = {
    __typename?: 'TokenCancelledMaxAggregates';
    aid?: Maybe<Scalars['Int']['output']>;
    amount?: Maybe<Scalars['BigInt']['output']>;
};
export type TokenCancelledMinAggregateFilter = {
    aid?: InputMaybe<IntFilter>;
    amount?: InputMaybe<BigIntFilter>;
};
export type TokenCancelledMinAggregates = {
    __typename?: 'TokenCancelledMinAggregates';
    aid?: Maybe<Scalars['Int']['output']>;
    amount?: Maybe<Scalars['BigInt']['output']>;
};
export type TokenCancelledStddevPopulationAggregateFilter = {
    aid?: InputMaybe<BigFloatFilter>;
    amount?: InputMaybe<BigFloatFilter>;
};
export type TokenCancelledStddevPopulationAggregates = {
    __typename?: 'TokenCancelledStddevPopulationAggregates';
    aid?: Maybe<Scalars['BigFloat']['output']>;
    amount?: Maybe<Scalars['BigFloat']['output']>;
};
export type TokenCancelledStddevSampleAggregateFilter = {
    aid?: InputMaybe<BigFloatFilter>;
    amount?: InputMaybe<BigFloatFilter>;
};
export type TokenCancelledStddevSampleAggregates = {
    __typename?: 'TokenCancelledStddevSampleAggregates';
    aid?: Maybe<Scalars['BigFloat']['output']>;
    amount?: Maybe<Scalars['BigFloat']['output']>;
};
export type TokenCancelledSumAggregateFilter = {
    aid?: InputMaybe<BigIntFilter>;
    amount?: InputMaybe<BigFloatFilter>;
};
export type TokenCancelledSumAggregates = {
    __typename?: 'TokenCancelledSumAggregates';
    aid: Scalars['BigInt']['output'];
    amount: Scalars['BigFloat']['output'];
};
export type TokenCancelledVariancePopulationAggregateFilter = {
    aid?: InputMaybe<BigFloatFilter>;
    amount?: InputMaybe<BigFloatFilter>;
};
export type TokenCancelledVariancePopulationAggregates = {
    __typename?: 'TokenCancelledVariancePopulationAggregates';
    aid?: Maybe<Scalars['BigFloat']['output']>;
    amount?: Maybe<Scalars['BigFloat']['output']>;
};
export type TokenCancelledVarianceSampleAggregateFilter = {
    aid?: InputMaybe<BigFloatFilter>;
    amount?: InputMaybe<BigFloatFilter>;
};
export type TokenCancelledVarianceSampleAggregates = {
    __typename?: 'TokenCancelledVarianceSampleAggregates';
    aid?: Maybe<Scalars['BigFloat']['output']>;
    amount?: Maybe<Scalars['BigFloat']['output']>;
};
export type TokenCancelledsConnection = {
    __typename?: 'TokenCancelledsConnection';
    aggregates?: Maybe<TokenCancelledAggregates>;
    edges: Array<TokenCancelledsEdge>;
    groupedAggregates?: Maybe<Array<TokenCancelledAggregates>>;
    nodes: Array<TokenCancelled>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type TokenCancelledsConnectionGroupedAggregatesArgs = {
    groupBy: Array<TokenCancelledGroupBy>;
    having?: InputMaybe<TokenCancelledHavingInput>;
};
export type TokenCancelledsEdge = {
    __typename?: 'TokenCancelledsEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: TokenCancelled;
};
export declare enum TokenCancelledsOrderBy {
    AidAsc = "AID_ASC",
    AidDesc = "AID_DESC",
    AmountAsc = "AMOUNT_ASC",
    AmountDesc = "AMOUNT_DESC",
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    NameAsc = "NAME_ASC",
    NameDesc = "NAME_DESC",
    Natural = "NATURAL",
    OwnerAsc = "OWNER_ASC",
    OwnerDesc = "OWNER_DESC",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    ReasonAsc = "REASON_ASC",
    ReasonDesc = "REASON_DESC"
}
export type TokenClass = Node & {
    __typename?: 'TokenClass';
    cap: Scalars['BigInt']['output'];
    class: Scalars['String']['output'];
    contractAddress: Scalars['String']['output'];
    description: Scalars['String']['output'];
    entityByClass?: Maybe<Entity>;
    image: Scalars['String']['output'];
    minter: Scalars['String']['output'];
    name: Scalars['String']['output'];
    nodeId: Scalars['ID']['output'];
    paused: Scalars['Boolean']['output'];
    stopped: Scalars['Boolean']['output'];
    supply: Scalars['BigInt']['output'];
    tokenCancelledsByName: TokenCancelledsConnection;
    tokenRetiredsByName: TokenRetiredsConnection;
    tokensByName: TokensConnection;
    type: Scalars['String']['output'];
};
export type TokenClassTokenCancelledsByNameArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<TokenCancelledCondition>;
    filter?: InputMaybe<TokenCancelledFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<TokenCancelledsOrderBy>>;
};
export type TokenClassTokenRetiredsByNameArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<TokenRetiredCondition>;
    filter?: InputMaybe<TokenRetiredFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<TokenRetiredsOrderBy>>;
};
export type TokenClassTokensByNameArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<TokenCondition>;
    filter?: InputMaybe<TokenFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<TokensOrderBy>>;
};
export type TokenClassCondition = {
    cap?: InputMaybe<Scalars['BigInt']['input']>;
    class?: InputMaybe<Scalars['String']['input']>;
    contractAddress?: InputMaybe<Scalars['String']['input']>;
    description?: InputMaybe<Scalars['String']['input']>;
    image?: InputMaybe<Scalars['String']['input']>;
    minter?: InputMaybe<Scalars['String']['input']>;
    name?: InputMaybe<Scalars['String']['input']>;
    paused?: InputMaybe<Scalars['Boolean']['input']>;
    stopped?: InputMaybe<Scalars['Boolean']['input']>;
    supply?: InputMaybe<Scalars['BigInt']['input']>;
    type?: InputMaybe<Scalars['String']['input']>;
};
export type TokenClassFilter = {
    and?: InputMaybe<Array<TokenClassFilter>>;
    cap?: InputMaybe<BigIntFilter>;
    class?: InputMaybe<StringFilter>;
    contractAddress?: InputMaybe<StringFilter>;
    description?: InputMaybe<StringFilter>;
    entityByClass?: InputMaybe<EntityFilter>;
    image?: InputMaybe<StringFilter>;
    minter?: InputMaybe<StringFilter>;
    name?: InputMaybe<StringFilter>;
    not?: InputMaybe<TokenClassFilter>;
    or?: InputMaybe<Array<TokenClassFilter>>;
    paused?: InputMaybe<BooleanFilter>;
    stopped?: InputMaybe<BooleanFilter>;
    supply?: InputMaybe<BigIntFilter>;
    tokenCancelledsByName?: InputMaybe<TokenClassToManyTokenCancelledFilter>;
    tokenCancelledsByNameExist?: InputMaybe<Scalars['Boolean']['input']>;
    tokenRetiredsByName?: InputMaybe<TokenClassToManyTokenRetiredFilter>;
    tokenRetiredsByNameExist?: InputMaybe<Scalars['Boolean']['input']>;
    tokensByName?: InputMaybe<TokenClassToManyTokenFilter>;
    tokensByNameExist?: InputMaybe<Scalars['Boolean']['input']>;
    type?: InputMaybe<StringFilter>;
};
export type TokenClassToManyTokenCancelledFilter = {
    aggregates?: InputMaybe<TokenCancelledAggregatesFilter>;
    every?: InputMaybe<TokenCancelledFilter>;
    none?: InputMaybe<TokenCancelledFilter>;
    some?: InputMaybe<TokenCancelledFilter>;
};
export type TokenClassToManyTokenFilter = {
    every?: InputMaybe<TokenFilter>;
    none?: InputMaybe<TokenFilter>;
    some?: InputMaybe<TokenFilter>;
};
export type TokenClassToManyTokenRetiredFilter = {
    aggregates?: InputMaybe<TokenRetiredAggregatesFilter>;
    every?: InputMaybe<TokenRetiredFilter>;
    none?: InputMaybe<TokenRetiredFilter>;
    some?: InputMaybe<TokenRetiredFilter>;
};
export type TokenClassesConnection = {
    __typename?: 'TokenClassesConnection';
    edges: Array<TokenClassesEdge>;
    nodes: Array<TokenClass>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type TokenClassesEdge = {
    __typename?: 'TokenClassesEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: TokenClass;
};
export declare enum TokenClassesOrderBy {
    CapAsc = "CAP_ASC",
    CapDesc = "CAP_DESC",
    ClassAsc = "CLASS_ASC",
    ClassDesc = "CLASS_DESC",
    ContractAddressAsc = "CONTRACT_ADDRESS_ASC",
    ContractAddressDesc = "CONTRACT_ADDRESS_DESC",
    DescriptionAsc = "DESCRIPTION_ASC",
    DescriptionDesc = "DESCRIPTION_DESC",
    ImageAsc = "IMAGE_ASC",
    ImageDesc = "IMAGE_DESC",
    MinterAsc = "MINTER_ASC",
    MinterDesc = "MINTER_DESC",
    NameAsc = "NAME_ASC",
    NameDesc = "NAME_DESC",
    Natural = "NATURAL",
    PausedAsc = "PAUSED_ASC",
    PausedDesc = "PAUSED_DESC",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    StoppedAsc = "STOPPED_ASC",
    StoppedDesc = "STOPPED_DESC",
    SupplyAsc = "SUPPLY_ASC",
    SupplyDesc = "SUPPLY_DESC",
    TokenCancelledsByNameAverageAidAsc = "TOKEN_CANCELLEDS_BY_NAME_AVERAGE_AID_ASC",
    TokenCancelledsByNameAverageAidDesc = "TOKEN_CANCELLEDS_BY_NAME_AVERAGE_AID_DESC",
    TokenCancelledsByNameAverageAmountAsc = "TOKEN_CANCELLEDS_BY_NAME_AVERAGE_AMOUNT_ASC",
    TokenCancelledsByNameAverageAmountDesc = "TOKEN_CANCELLEDS_BY_NAME_AVERAGE_AMOUNT_DESC",
    TokenCancelledsByNameAverageIdAsc = "TOKEN_CANCELLEDS_BY_NAME_AVERAGE_ID_ASC",
    TokenCancelledsByNameAverageIdDesc = "TOKEN_CANCELLEDS_BY_NAME_AVERAGE_ID_DESC",
    TokenCancelledsByNameAverageNameAsc = "TOKEN_CANCELLEDS_BY_NAME_AVERAGE_NAME_ASC",
    TokenCancelledsByNameAverageNameDesc = "TOKEN_CANCELLEDS_BY_NAME_AVERAGE_NAME_DESC",
    TokenCancelledsByNameAverageOwnerAsc = "TOKEN_CANCELLEDS_BY_NAME_AVERAGE_OWNER_ASC",
    TokenCancelledsByNameAverageOwnerDesc = "TOKEN_CANCELLEDS_BY_NAME_AVERAGE_OWNER_DESC",
    TokenCancelledsByNameAverageReasonAsc = "TOKEN_CANCELLEDS_BY_NAME_AVERAGE_REASON_ASC",
    TokenCancelledsByNameAverageReasonDesc = "TOKEN_CANCELLEDS_BY_NAME_AVERAGE_REASON_DESC",
    TokenCancelledsByNameCountAsc = "TOKEN_CANCELLEDS_BY_NAME_COUNT_ASC",
    TokenCancelledsByNameCountDesc = "TOKEN_CANCELLEDS_BY_NAME_COUNT_DESC",
    TokenCancelledsByNameDistinctCountAidAsc = "TOKEN_CANCELLEDS_BY_NAME_DISTINCT_COUNT_AID_ASC",
    TokenCancelledsByNameDistinctCountAidDesc = "TOKEN_CANCELLEDS_BY_NAME_DISTINCT_COUNT_AID_DESC",
    TokenCancelledsByNameDistinctCountAmountAsc = "TOKEN_CANCELLEDS_BY_NAME_DISTINCT_COUNT_AMOUNT_ASC",
    TokenCancelledsByNameDistinctCountAmountDesc = "TOKEN_CANCELLEDS_BY_NAME_DISTINCT_COUNT_AMOUNT_DESC",
    TokenCancelledsByNameDistinctCountIdAsc = "TOKEN_CANCELLEDS_BY_NAME_DISTINCT_COUNT_ID_ASC",
    TokenCancelledsByNameDistinctCountIdDesc = "TOKEN_CANCELLEDS_BY_NAME_DISTINCT_COUNT_ID_DESC",
    TokenCancelledsByNameDistinctCountNameAsc = "TOKEN_CANCELLEDS_BY_NAME_DISTINCT_COUNT_NAME_ASC",
    TokenCancelledsByNameDistinctCountNameDesc = "TOKEN_CANCELLEDS_BY_NAME_DISTINCT_COUNT_NAME_DESC",
    TokenCancelledsByNameDistinctCountOwnerAsc = "TOKEN_CANCELLEDS_BY_NAME_DISTINCT_COUNT_OWNER_ASC",
    TokenCancelledsByNameDistinctCountOwnerDesc = "TOKEN_CANCELLEDS_BY_NAME_DISTINCT_COUNT_OWNER_DESC",
    TokenCancelledsByNameDistinctCountReasonAsc = "TOKEN_CANCELLEDS_BY_NAME_DISTINCT_COUNT_REASON_ASC",
    TokenCancelledsByNameDistinctCountReasonDesc = "TOKEN_CANCELLEDS_BY_NAME_DISTINCT_COUNT_REASON_DESC",
    TokenCancelledsByNameMaxAidAsc = "TOKEN_CANCELLEDS_BY_NAME_MAX_AID_ASC",
    TokenCancelledsByNameMaxAidDesc = "TOKEN_CANCELLEDS_BY_NAME_MAX_AID_DESC",
    TokenCancelledsByNameMaxAmountAsc = "TOKEN_CANCELLEDS_BY_NAME_MAX_AMOUNT_ASC",
    TokenCancelledsByNameMaxAmountDesc = "TOKEN_CANCELLEDS_BY_NAME_MAX_AMOUNT_DESC",
    TokenCancelledsByNameMaxIdAsc = "TOKEN_CANCELLEDS_BY_NAME_MAX_ID_ASC",
    TokenCancelledsByNameMaxIdDesc = "TOKEN_CANCELLEDS_BY_NAME_MAX_ID_DESC",
    TokenCancelledsByNameMaxNameAsc = "TOKEN_CANCELLEDS_BY_NAME_MAX_NAME_ASC",
    TokenCancelledsByNameMaxNameDesc = "TOKEN_CANCELLEDS_BY_NAME_MAX_NAME_DESC",
    TokenCancelledsByNameMaxOwnerAsc = "TOKEN_CANCELLEDS_BY_NAME_MAX_OWNER_ASC",
    TokenCancelledsByNameMaxOwnerDesc = "TOKEN_CANCELLEDS_BY_NAME_MAX_OWNER_DESC",
    TokenCancelledsByNameMaxReasonAsc = "TOKEN_CANCELLEDS_BY_NAME_MAX_REASON_ASC",
    TokenCancelledsByNameMaxReasonDesc = "TOKEN_CANCELLEDS_BY_NAME_MAX_REASON_DESC",
    TokenCancelledsByNameMinAidAsc = "TOKEN_CANCELLEDS_BY_NAME_MIN_AID_ASC",
    TokenCancelledsByNameMinAidDesc = "TOKEN_CANCELLEDS_BY_NAME_MIN_AID_DESC",
    TokenCancelledsByNameMinAmountAsc = "TOKEN_CANCELLEDS_BY_NAME_MIN_AMOUNT_ASC",
    TokenCancelledsByNameMinAmountDesc = "TOKEN_CANCELLEDS_BY_NAME_MIN_AMOUNT_DESC",
    TokenCancelledsByNameMinIdAsc = "TOKEN_CANCELLEDS_BY_NAME_MIN_ID_ASC",
    TokenCancelledsByNameMinIdDesc = "TOKEN_CANCELLEDS_BY_NAME_MIN_ID_DESC",
    TokenCancelledsByNameMinNameAsc = "TOKEN_CANCELLEDS_BY_NAME_MIN_NAME_ASC",
    TokenCancelledsByNameMinNameDesc = "TOKEN_CANCELLEDS_BY_NAME_MIN_NAME_DESC",
    TokenCancelledsByNameMinOwnerAsc = "TOKEN_CANCELLEDS_BY_NAME_MIN_OWNER_ASC",
    TokenCancelledsByNameMinOwnerDesc = "TOKEN_CANCELLEDS_BY_NAME_MIN_OWNER_DESC",
    TokenCancelledsByNameMinReasonAsc = "TOKEN_CANCELLEDS_BY_NAME_MIN_REASON_ASC",
    TokenCancelledsByNameMinReasonDesc = "TOKEN_CANCELLEDS_BY_NAME_MIN_REASON_DESC",
    TokenCancelledsByNameStddevPopulationAidAsc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_POPULATION_AID_ASC",
    TokenCancelledsByNameStddevPopulationAidDesc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_POPULATION_AID_DESC",
    TokenCancelledsByNameStddevPopulationAmountAsc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_POPULATION_AMOUNT_ASC",
    TokenCancelledsByNameStddevPopulationAmountDesc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_POPULATION_AMOUNT_DESC",
    TokenCancelledsByNameStddevPopulationIdAsc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_POPULATION_ID_ASC",
    TokenCancelledsByNameStddevPopulationIdDesc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_POPULATION_ID_DESC",
    TokenCancelledsByNameStddevPopulationNameAsc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_POPULATION_NAME_ASC",
    TokenCancelledsByNameStddevPopulationNameDesc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_POPULATION_NAME_DESC",
    TokenCancelledsByNameStddevPopulationOwnerAsc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_POPULATION_OWNER_ASC",
    TokenCancelledsByNameStddevPopulationOwnerDesc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_POPULATION_OWNER_DESC",
    TokenCancelledsByNameStddevPopulationReasonAsc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_POPULATION_REASON_ASC",
    TokenCancelledsByNameStddevPopulationReasonDesc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_POPULATION_REASON_DESC",
    TokenCancelledsByNameStddevSampleAidAsc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_SAMPLE_AID_ASC",
    TokenCancelledsByNameStddevSampleAidDesc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_SAMPLE_AID_DESC",
    TokenCancelledsByNameStddevSampleAmountAsc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_SAMPLE_AMOUNT_ASC",
    TokenCancelledsByNameStddevSampleAmountDesc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_SAMPLE_AMOUNT_DESC",
    TokenCancelledsByNameStddevSampleIdAsc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_SAMPLE_ID_ASC",
    TokenCancelledsByNameStddevSampleIdDesc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_SAMPLE_ID_DESC",
    TokenCancelledsByNameStddevSampleNameAsc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_SAMPLE_NAME_ASC",
    TokenCancelledsByNameStddevSampleNameDesc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_SAMPLE_NAME_DESC",
    TokenCancelledsByNameStddevSampleOwnerAsc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_SAMPLE_OWNER_ASC",
    TokenCancelledsByNameStddevSampleOwnerDesc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_SAMPLE_OWNER_DESC",
    TokenCancelledsByNameStddevSampleReasonAsc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_SAMPLE_REASON_ASC",
    TokenCancelledsByNameStddevSampleReasonDesc = "TOKEN_CANCELLEDS_BY_NAME_STDDEV_SAMPLE_REASON_DESC",
    TokenCancelledsByNameSumAidAsc = "TOKEN_CANCELLEDS_BY_NAME_SUM_AID_ASC",
    TokenCancelledsByNameSumAidDesc = "TOKEN_CANCELLEDS_BY_NAME_SUM_AID_DESC",
    TokenCancelledsByNameSumAmountAsc = "TOKEN_CANCELLEDS_BY_NAME_SUM_AMOUNT_ASC",
    TokenCancelledsByNameSumAmountDesc = "TOKEN_CANCELLEDS_BY_NAME_SUM_AMOUNT_DESC",
    TokenCancelledsByNameSumIdAsc = "TOKEN_CANCELLEDS_BY_NAME_SUM_ID_ASC",
    TokenCancelledsByNameSumIdDesc = "TOKEN_CANCELLEDS_BY_NAME_SUM_ID_DESC",
    TokenCancelledsByNameSumNameAsc = "TOKEN_CANCELLEDS_BY_NAME_SUM_NAME_ASC",
    TokenCancelledsByNameSumNameDesc = "TOKEN_CANCELLEDS_BY_NAME_SUM_NAME_DESC",
    TokenCancelledsByNameSumOwnerAsc = "TOKEN_CANCELLEDS_BY_NAME_SUM_OWNER_ASC",
    TokenCancelledsByNameSumOwnerDesc = "TOKEN_CANCELLEDS_BY_NAME_SUM_OWNER_DESC",
    TokenCancelledsByNameSumReasonAsc = "TOKEN_CANCELLEDS_BY_NAME_SUM_REASON_ASC",
    TokenCancelledsByNameSumReasonDesc = "TOKEN_CANCELLEDS_BY_NAME_SUM_REASON_DESC",
    TokenCancelledsByNameVariancePopulationAidAsc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_POPULATION_AID_ASC",
    TokenCancelledsByNameVariancePopulationAidDesc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_POPULATION_AID_DESC",
    TokenCancelledsByNameVariancePopulationAmountAsc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_POPULATION_AMOUNT_ASC",
    TokenCancelledsByNameVariancePopulationAmountDesc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_POPULATION_AMOUNT_DESC",
    TokenCancelledsByNameVariancePopulationIdAsc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_POPULATION_ID_ASC",
    TokenCancelledsByNameVariancePopulationIdDesc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_POPULATION_ID_DESC",
    TokenCancelledsByNameVariancePopulationNameAsc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_POPULATION_NAME_ASC",
    TokenCancelledsByNameVariancePopulationNameDesc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_POPULATION_NAME_DESC",
    TokenCancelledsByNameVariancePopulationOwnerAsc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_POPULATION_OWNER_ASC",
    TokenCancelledsByNameVariancePopulationOwnerDesc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_POPULATION_OWNER_DESC",
    TokenCancelledsByNameVariancePopulationReasonAsc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_POPULATION_REASON_ASC",
    TokenCancelledsByNameVariancePopulationReasonDesc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_POPULATION_REASON_DESC",
    TokenCancelledsByNameVarianceSampleAidAsc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_SAMPLE_AID_ASC",
    TokenCancelledsByNameVarianceSampleAidDesc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_SAMPLE_AID_DESC",
    TokenCancelledsByNameVarianceSampleAmountAsc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_SAMPLE_AMOUNT_ASC",
    TokenCancelledsByNameVarianceSampleAmountDesc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_SAMPLE_AMOUNT_DESC",
    TokenCancelledsByNameVarianceSampleIdAsc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_SAMPLE_ID_ASC",
    TokenCancelledsByNameVarianceSampleIdDesc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_SAMPLE_ID_DESC",
    TokenCancelledsByNameVarianceSampleNameAsc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_SAMPLE_NAME_ASC",
    TokenCancelledsByNameVarianceSampleNameDesc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_SAMPLE_NAME_DESC",
    TokenCancelledsByNameVarianceSampleOwnerAsc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_SAMPLE_OWNER_ASC",
    TokenCancelledsByNameVarianceSampleOwnerDesc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_SAMPLE_OWNER_DESC",
    TokenCancelledsByNameVarianceSampleReasonAsc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_SAMPLE_REASON_ASC",
    TokenCancelledsByNameVarianceSampleReasonDesc = "TOKEN_CANCELLEDS_BY_NAME_VARIANCE_SAMPLE_REASON_DESC",
    TokenRetiredsByNameAverageAidAsc = "TOKEN_RETIREDS_BY_NAME_AVERAGE_AID_ASC",
    TokenRetiredsByNameAverageAidDesc = "TOKEN_RETIREDS_BY_NAME_AVERAGE_AID_DESC",
    TokenRetiredsByNameAverageAmountAsc = "TOKEN_RETIREDS_BY_NAME_AVERAGE_AMOUNT_ASC",
    TokenRetiredsByNameAverageAmountDesc = "TOKEN_RETIREDS_BY_NAME_AVERAGE_AMOUNT_DESC",
    TokenRetiredsByNameAverageIdAsc = "TOKEN_RETIREDS_BY_NAME_AVERAGE_ID_ASC",
    TokenRetiredsByNameAverageIdDesc = "TOKEN_RETIREDS_BY_NAME_AVERAGE_ID_DESC",
    TokenRetiredsByNameAverageJurisdictionAsc = "TOKEN_RETIREDS_BY_NAME_AVERAGE_JURISDICTION_ASC",
    TokenRetiredsByNameAverageJurisdictionDesc = "TOKEN_RETIREDS_BY_NAME_AVERAGE_JURISDICTION_DESC",
    TokenRetiredsByNameAverageNameAsc = "TOKEN_RETIREDS_BY_NAME_AVERAGE_NAME_ASC",
    TokenRetiredsByNameAverageNameDesc = "TOKEN_RETIREDS_BY_NAME_AVERAGE_NAME_DESC",
    TokenRetiredsByNameAverageOwnerAsc = "TOKEN_RETIREDS_BY_NAME_AVERAGE_OWNER_ASC",
    TokenRetiredsByNameAverageOwnerDesc = "TOKEN_RETIREDS_BY_NAME_AVERAGE_OWNER_DESC",
    TokenRetiredsByNameAverageReasonAsc = "TOKEN_RETIREDS_BY_NAME_AVERAGE_REASON_ASC",
    TokenRetiredsByNameAverageReasonDesc = "TOKEN_RETIREDS_BY_NAME_AVERAGE_REASON_DESC",
    TokenRetiredsByNameCountAsc = "TOKEN_RETIREDS_BY_NAME_COUNT_ASC",
    TokenRetiredsByNameCountDesc = "TOKEN_RETIREDS_BY_NAME_COUNT_DESC",
    TokenRetiredsByNameDistinctCountAidAsc = "TOKEN_RETIREDS_BY_NAME_DISTINCT_COUNT_AID_ASC",
    TokenRetiredsByNameDistinctCountAidDesc = "TOKEN_RETIREDS_BY_NAME_DISTINCT_COUNT_AID_DESC",
    TokenRetiredsByNameDistinctCountAmountAsc = "TOKEN_RETIREDS_BY_NAME_DISTINCT_COUNT_AMOUNT_ASC",
    TokenRetiredsByNameDistinctCountAmountDesc = "TOKEN_RETIREDS_BY_NAME_DISTINCT_COUNT_AMOUNT_DESC",
    TokenRetiredsByNameDistinctCountIdAsc = "TOKEN_RETIREDS_BY_NAME_DISTINCT_COUNT_ID_ASC",
    TokenRetiredsByNameDistinctCountIdDesc = "TOKEN_RETIREDS_BY_NAME_DISTINCT_COUNT_ID_DESC",
    TokenRetiredsByNameDistinctCountJurisdictionAsc = "TOKEN_RETIREDS_BY_NAME_DISTINCT_COUNT_JURISDICTION_ASC",
    TokenRetiredsByNameDistinctCountJurisdictionDesc = "TOKEN_RETIREDS_BY_NAME_DISTINCT_COUNT_JURISDICTION_DESC",
    TokenRetiredsByNameDistinctCountNameAsc = "TOKEN_RETIREDS_BY_NAME_DISTINCT_COUNT_NAME_ASC",
    TokenRetiredsByNameDistinctCountNameDesc = "TOKEN_RETIREDS_BY_NAME_DISTINCT_COUNT_NAME_DESC",
    TokenRetiredsByNameDistinctCountOwnerAsc = "TOKEN_RETIREDS_BY_NAME_DISTINCT_COUNT_OWNER_ASC",
    TokenRetiredsByNameDistinctCountOwnerDesc = "TOKEN_RETIREDS_BY_NAME_DISTINCT_COUNT_OWNER_DESC",
    TokenRetiredsByNameDistinctCountReasonAsc = "TOKEN_RETIREDS_BY_NAME_DISTINCT_COUNT_REASON_ASC",
    TokenRetiredsByNameDistinctCountReasonDesc = "TOKEN_RETIREDS_BY_NAME_DISTINCT_COUNT_REASON_DESC",
    TokenRetiredsByNameMaxAidAsc = "TOKEN_RETIREDS_BY_NAME_MAX_AID_ASC",
    TokenRetiredsByNameMaxAidDesc = "TOKEN_RETIREDS_BY_NAME_MAX_AID_DESC",
    TokenRetiredsByNameMaxAmountAsc = "TOKEN_RETIREDS_BY_NAME_MAX_AMOUNT_ASC",
    TokenRetiredsByNameMaxAmountDesc = "TOKEN_RETIREDS_BY_NAME_MAX_AMOUNT_DESC",
    TokenRetiredsByNameMaxIdAsc = "TOKEN_RETIREDS_BY_NAME_MAX_ID_ASC",
    TokenRetiredsByNameMaxIdDesc = "TOKEN_RETIREDS_BY_NAME_MAX_ID_DESC",
    TokenRetiredsByNameMaxJurisdictionAsc = "TOKEN_RETIREDS_BY_NAME_MAX_JURISDICTION_ASC",
    TokenRetiredsByNameMaxJurisdictionDesc = "TOKEN_RETIREDS_BY_NAME_MAX_JURISDICTION_DESC",
    TokenRetiredsByNameMaxNameAsc = "TOKEN_RETIREDS_BY_NAME_MAX_NAME_ASC",
    TokenRetiredsByNameMaxNameDesc = "TOKEN_RETIREDS_BY_NAME_MAX_NAME_DESC",
    TokenRetiredsByNameMaxOwnerAsc = "TOKEN_RETIREDS_BY_NAME_MAX_OWNER_ASC",
    TokenRetiredsByNameMaxOwnerDesc = "TOKEN_RETIREDS_BY_NAME_MAX_OWNER_DESC",
    TokenRetiredsByNameMaxReasonAsc = "TOKEN_RETIREDS_BY_NAME_MAX_REASON_ASC",
    TokenRetiredsByNameMaxReasonDesc = "TOKEN_RETIREDS_BY_NAME_MAX_REASON_DESC",
    TokenRetiredsByNameMinAidAsc = "TOKEN_RETIREDS_BY_NAME_MIN_AID_ASC",
    TokenRetiredsByNameMinAidDesc = "TOKEN_RETIREDS_BY_NAME_MIN_AID_DESC",
    TokenRetiredsByNameMinAmountAsc = "TOKEN_RETIREDS_BY_NAME_MIN_AMOUNT_ASC",
    TokenRetiredsByNameMinAmountDesc = "TOKEN_RETIREDS_BY_NAME_MIN_AMOUNT_DESC",
    TokenRetiredsByNameMinIdAsc = "TOKEN_RETIREDS_BY_NAME_MIN_ID_ASC",
    TokenRetiredsByNameMinIdDesc = "TOKEN_RETIREDS_BY_NAME_MIN_ID_DESC",
    TokenRetiredsByNameMinJurisdictionAsc = "TOKEN_RETIREDS_BY_NAME_MIN_JURISDICTION_ASC",
    TokenRetiredsByNameMinJurisdictionDesc = "TOKEN_RETIREDS_BY_NAME_MIN_JURISDICTION_DESC",
    TokenRetiredsByNameMinNameAsc = "TOKEN_RETIREDS_BY_NAME_MIN_NAME_ASC",
    TokenRetiredsByNameMinNameDesc = "TOKEN_RETIREDS_BY_NAME_MIN_NAME_DESC",
    TokenRetiredsByNameMinOwnerAsc = "TOKEN_RETIREDS_BY_NAME_MIN_OWNER_ASC",
    TokenRetiredsByNameMinOwnerDesc = "TOKEN_RETIREDS_BY_NAME_MIN_OWNER_DESC",
    TokenRetiredsByNameMinReasonAsc = "TOKEN_RETIREDS_BY_NAME_MIN_REASON_ASC",
    TokenRetiredsByNameMinReasonDesc = "TOKEN_RETIREDS_BY_NAME_MIN_REASON_DESC",
    TokenRetiredsByNameStddevPopulationAidAsc = "TOKEN_RETIREDS_BY_NAME_STDDEV_POPULATION_AID_ASC",
    TokenRetiredsByNameStddevPopulationAidDesc = "TOKEN_RETIREDS_BY_NAME_STDDEV_POPULATION_AID_DESC",
    TokenRetiredsByNameStddevPopulationAmountAsc = "TOKEN_RETIREDS_BY_NAME_STDDEV_POPULATION_AMOUNT_ASC",
    TokenRetiredsByNameStddevPopulationAmountDesc = "TOKEN_RETIREDS_BY_NAME_STDDEV_POPULATION_AMOUNT_DESC",
    TokenRetiredsByNameStddevPopulationIdAsc = "TOKEN_RETIREDS_BY_NAME_STDDEV_POPULATION_ID_ASC",
    TokenRetiredsByNameStddevPopulationIdDesc = "TOKEN_RETIREDS_BY_NAME_STDDEV_POPULATION_ID_DESC",
    TokenRetiredsByNameStddevPopulationJurisdictionAsc = "TOKEN_RETIREDS_BY_NAME_STDDEV_POPULATION_JURISDICTION_ASC",
    TokenRetiredsByNameStddevPopulationJurisdictionDesc = "TOKEN_RETIREDS_BY_NAME_STDDEV_POPULATION_JURISDICTION_DESC",
    TokenRetiredsByNameStddevPopulationNameAsc = "TOKEN_RETIREDS_BY_NAME_STDDEV_POPULATION_NAME_ASC",
    TokenRetiredsByNameStddevPopulationNameDesc = "TOKEN_RETIREDS_BY_NAME_STDDEV_POPULATION_NAME_DESC",
    TokenRetiredsByNameStddevPopulationOwnerAsc = "TOKEN_RETIREDS_BY_NAME_STDDEV_POPULATION_OWNER_ASC",
    TokenRetiredsByNameStddevPopulationOwnerDesc = "TOKEN_RETIREDS_BY_NAME_STDDEV_POPULATION_OWNER_DESC",
    TokenRetiredsByNameStddevPopulationReasonAsc = "TOKEN_RETIREDS_BY_NAME_STDDEV_POPULATION_REASON_ASC",
    TokenRetiredsByNameStddevPopulationReasonDesc = "TOKEN_RETIREDS_BY_NAME_STDDEV_POPULATION_REASON_DESC",
    TokenRetiredsByNameStddevSampleAidAsc = "TOKEN_RETIREDS_BY_NAME_STDDEV_SAMPLE_AID_ASC",
    TokenRetiredsByNameStddevSampleAidDesc = "TOKEN_RETIREDS_BY_NAME_STDDEV_SAMPLE_AID_DESC",
    TokenRetiredsByNameStddevSampleAmountAsc = "TOKEN_RETIREDS_BY_NAME_STDDEV_SAMPLE_AMOUNT_ASC",
    TokenRetiredsByNameStddevSampleAmountDesc = "TOKEN_RETIREDS_BY_NAME_STDDEV_SAMPLE_AMOUNT_DESC",
    TokenRetiredsByNameStddevSampleIdAsc = "TOKEN_RETIREDS_BY_NAME_STDDEV_SAMPLE_ID_ASC",
    TokenRetiredsByNameStddevSampleIdDesc = "TOKEN_RETIREDS_BY_NAME_STDDEV_SAMPLE_ID_DESC",
    TokenRetiredsByNameStddevSampleJurisdictionAsc = "TOKEN_RETIREDS_BY_NAME_STDDEV_SAMPLE_JURISDICTION_ASC",
    TokenRetiredsByNameStddevSampleJurisdictionDesc = "TOKEN_RETIREDS_BY_NAME_STDDEV_SAMPLE_JURISDICTION_DESC",
    TokenRetiredsByNameStddevSampleNameAsc = "TOKEN_RETIREDS_BY_NAME_STDDEV_SAMPLE_NAME_ASC",
    TokenRetiredsByNameStddevSampleNameDesc = "TOKEN_RETIREDS_BY_NAME_STDDEV_SAMPLE_NAME_DESC",
    TokenRetiredsByNameStddevSampleOwnerAsc = "TOKEN_RETIREDS_BY_NAME_STDDEV_SAMPLE_OWNER_ASC",
    TokenRetiredsByNameStddevSampleOwnerDesc = "TOKEN_RETIREDS_BY_NAME_STDDEV_SAMPLE_OWNER_DESC",
    TokenRetiredsByNameStddevSampleReasonAsc = "TOKEN_RETIREDS_BY_NAME_STDDEV_SAMPLE_REASON_ASC",
    TokenRetiredsByNameStddevSampleReasonDesc = "TOKEN_RETIREDS_BY_NAME_STDDEV_SAMPLE_REASON_DESC",
    TokenRetiredsByNameSumAidAsc = "TOKEN_RETIREDS_BY_NAME_SUM_AID_ASC",
    TokenRetiredsByNameSumAidDesc = "TOKEN_RETIREDS_BY_NAME_SUM_AID_DESC",
    TokenRetiredsByNameSumAmountAsc = "TOKEN_RETIREDS_BY_NAME_SUM_AMOUNT_ASC",
    TokenRetiredsByNameSumAmountDesc = "TOKEN_RETIREDS_BY_NAME_SUM_AMOUNT_DESC",
    TokenRetiredsByNameSumIdAsc = "TOKEN_RETIREDS_BY_NAME_SUM_ID_ASC",
    TokenRetiredsByNameSumIdDesc = "TOKEN_RETIREDS_BY_NAME_SUM_ID_DESC",
    TokenRetiredsByNameSumJurisdictionAsc = "TOKEN_RETIREDS_BY_NAME_SUM_JURISDICTION_ASC",
    TokenRetiredsByNameSumJurisdictionDesc = "TOKEN_RETIREDS_BY_NAME_SUM_JURISDICTION_DESC",
    TokenRetiredsByNameSumNameAsc = "TOKEN_RETIREDS_BY_NAME_SUM_NAME_ASC",
    TokenRetiredsByNameSumNameDesc = "TOKEN_RETIREDS_BY_NAME_SUM_NAME_DESC",
    TokenRetiredsByNameSumOwnerAsc = "TOKEN_RETIREDS_BY_NAME_SUM_OWNER_ASC",
    TokenRetiredsByNameSumOwnerDesc = "TOKEN_RETIREDS_BY_NAME_SUM_OWNER_DESC",
    TokenRetiredsByNameSumReasonAsc = "TOKEN_RETIREDS_BY_NAME_SUM_REASON_ASC",
    TokenRetiredsByNameSumReasonDesc = "TOKEN_RETIREDS_BY_NAME_SUM_REASON_DESC",
    TokenRetiredsByNameVariancePopulationAidAsc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_POPULATION_AID_ASC",
    TokenRetiredsByNameVariancePopulationAidDesc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_POPULATION_AID_DESC",
    TokenRetiredsByNameVariancePopulationAmountAsc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_POPULATION_AMOUNT_ASC",
    TokenRetiredsByNameVariancePopulationAmountDesc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_POPULATION_AMOUNT_DESC",
    TokenRetiredsByNameVariancePopulationIdAsc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_POPULATION_ID_ASC",
    TokenRetiredsByNameVariancePopulationIdDesc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_POPULATION_ID_DESC",
    TokenRetiredsByNameVariancePopulationJurisdictionAsc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_POPULATION_JURISDICTION_ASC",
    TokenRetiredsByNameVariancePopulationJurisdictionDesc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_POPULATION_JURISDICTION_DESC",
    TokenRetiredsByNameVariancePopulationNameAsc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_POPULATION_NAME_ASC",
    TokenRetiredsByNameVariancePopulationNameDesc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_POPULATION_NAME_DESC",
    TokenRetiredsByNameVariancePopulationOwnerAsc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_POPULATION_OWNER_ASC",
    TokenRetiredsByNameVariancePopulationOwnerDesc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_POPULATION_OWNER_DESC",
    TokenRetiredsByNameVariancePopulationReasonAsc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_POPULATION_REASON_ASC",
    TokenRetiredsByNameVariancePopulationReasonDesc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_POPULATION_REASON_DESC",
    TokenRetiredsByNameVarianceSampleAidAsc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_SAMPLE_AID_ASC",
    TokenRetiredsByNameVarianceSampleAidDesc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_SAMPLE_AID_DESC",
    TokenRetiredsByNameVarianceSampleAmountAsc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_SAMPLE_AMOUNT_ASC",
    TokenRetiredsByNameVarianceSampleAmountDesc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_SAMPLE_AMOUNT_DESC",
    TokenRetiredsByNameVarianceSampleIdAsc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_SAMPLE_ID_ASC",
    TokenRetiredsByNameVarianceSampleIdDesc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_SAMPLE_ID_DESC",
    TokenRetiredsByNameVarianceSampleJurisdictionAsc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_SAMPLE_JURISDICTION_ASC",
    TokenRetiredsByNameVarianceSampleJurisdictionDesc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_SAMPLE_JURISDICTION_DESC",
    TokenRetiredsByNameVarianceSampleNameAsc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_SAMPLE_NAME_ASC",
    TokenRetiredsByNameVarianceSampleNameDesc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_SAMPLE_NAME_DESC",
    TokenRetiredsByNameVarianceSampleOwnerAsc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_SAMPLE_OWNER_ASC",
    TokenRetiredsByNameVarianceSampleOwnerDesc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_SAMPLE_OWNER_DESC",
    TokenRetiredsByNameVarianceSampleReasonAsc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_SAMPLE_REASON_ASC",
    TokenRetiredsByNameVarianceSampleReasonDesc = "TOKEN_RETIREDS_BY_NAME_VARIANCE_SAMPLE_REASON_DESC",
    TypeAsc = "TYPE_ASC",
    TypeDesc = "TYPE_DESC"
}
export type TokenCondition = {
    collection?: InputMaybe<Scalars['String']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    index?: InputMaybe<Scalars['String']['input']>;
    name?: InputMaybe<Scalars['String']['input']>;
};
export type TokenDataConnection = {
    __typename?: 'TokenDataConnection';
    edges: Array<TokenDataEdge>;
    nodes: Array<TokenDatum>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type TokenDataEdge = {
    __typename?: 'TokenDataEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: TokenDatum;
};
export declare enum TokenDataOrderBy {
    AidAsc = "AID_ASC",
    AidDesc = "AID_DESC",
    EncryptedAsc = "ENCRYPTED_ASC",
    EncryptedDesc = "ENCRYPTED_DESC",
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    ProofAsc = "PROOF_ASC",
    ProofDesc = "PROOF_DESC",
    TokenIdAsc = "TOKEN_ID_ASC",
    TokenIdDesc = "TOKEN_ID_DESC",
    TypeAsc = "TYPE_ASC",
    TypeDesc = "TYPE_DESC",
    UriAsc = "URI_ASC",
    UriDesc = "URI_DESC"
}
export type TokenDatum = Node & {
    __typename?: 'TokenDatum';
    aid: Scalars['Int']['output'];
    encrypted: Scalars['Boolean']['output'];
    id: Scalars['String']['output'];
    nodeId: Scalars['ID']['output'];
    proof: Scalars['String']['output'];
    token?: Maybe<Token>;
    tokenId: Scalars['String']['output'];
    type: Scalars['String']['output'];
    uri: Scalars['String']['output'];
};
export type TokenDatumCondition = {
    aid?: InputMaybe<Scalars['Int']['input']>;
    encrypted?: InputMaybe<Scalars['Boolean']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    proof?: InputMaybe<Scalars['String']['input']>;
    tokenId?: InputMaybe<Scalars['String']['input']>;
    type?: InputMaybe<Scalars['String']['input']>;
    uri?: InputMaybe<Scalars['String']['input']>;
};
export type TokenDatumFilter = {
    aid?: InputMaybe<IntFilter>;
    and?: InputMaybe<Array<TokenDatumFilter>>;
    encrypted?: InputMaybe<BooleanFilter>;
    id?: InputMaybe<StringFilter>;
    not?: InputMaybe<TokenDatumFilter>;
    or?: InputMaybe<Array<TokenDatumFilter>>;
    proof?: InputMaybe<StringFilter>;
    token?: InputMaybe<TokenFilter>;
    tokenId?: InputMaybe<StringFilter>;
    type?: InputMaybe<StringFilter>;
    uri?: InputMaybe<StringFilter>;
};
export type TokenFilter = {
    and?: InputMaybe<Array<TokenFilter>>;
    collection?: InputMaybe<StringFilter>;
    entityByCollection?: InputMaybe<EntityFilter>;
    id?: InputMaybe<StringFilter>;
    index?: InputMaybe<StringFilter>;
    name?: InputMaybe<StringFilter>;
    not?: InputMaybe<TokenFilter>;
    or?: InputMaybe<Array<TokenFilter>>;
    tokenClassByName?: InputMaybe<TokenClassFilter>;
    tokenDataByTokenId?: InputMaybe<TokenToManyTokenDatumFilter>;
    tokenDataByTokenIdExist?: InputMaybe<Scalars['Boolean']['input']>;
    tokenRetiredsById?: InputMaybe<TokenToManyTokenRetiredFilter>;
    tokenRetiredsByIdExist?: InputMaybe<Scalars['Boolean']['input']>;
    tokenTransactionsByTokenId?: InputMaybe<TokenToManyTokenTransactionFilter>;
    tokenTransactionsByTokenIdExist?: InputMaybe<Scalars['Boolean']['input']>;
};
export type TokenRetired = Node & {
    __typename?: 'TokenRetired';
    aid: Scalars['Int']['output'];
    amount: Scalars['BigInt']['output'];
    id: Scalars['String']['output'];
    jurisdiction: Scalars['String']['output'];
    name: Scalars['String']['output'];
    nodeId: Scalars['ID']['output'];
    owner: Scalars['String']['output'];
    reason: Scalars['String']['output'];
    tokenById?: Maybe<Token>;
    tokenClassByName?: Maybe<TokenClass>;
};
export type TokenRetiredAggregates = {
    __typename?: 'TokenRetiredAggregates';
    average?: Maybe<TokenRetiredAverageAggregates>;
    distinctCount?: Maybe<TokenRetiredDistinctCountAggregates>;
    keys?: Maybe<Array<Scalars['String']['output']>>;
    max?: Maybe<TokenRetiredMaxAggregates>;
    min?: Maybe<TokenRetiredMinAggregates>;
    stddevPopulation?: Maybe<TokenRetiredStddevPopulationAggregates>;
    stddevSample?: Maybe<TokenRetiredStddevSampleAggregates>;
    sum?: Maybe<TokenRetiredSumAggregates>;
    variancePopulation?: Maybe<TokenRetiredVariancePopulationAggregates>;
    varianceSample?: Maybe<TokenRetiredVarianceSampleAggregates>;
};
export type TokenRetiredAggregatesFilter = {
    average?: InputMaybe<TokenRetiredAverageAggregateFilter>;
    distinctCount?: InputMaybe<TokenRetiredDistinctCountAggregateFilter>;
    filter?: InputMaybe<TokenRetiredFilter>;
    max?: InputMaybe<TokenRetiredMaxAggregateFilter>;
    min?: InputMaybe<TokenRetiredMinAggregateFilter>;
    stddevPopulation?: InputMaybe<TokenRetiredStddevPopulationAggregateFilter>;
    stddevSample?: InputMaybe<TokenRetiredStddevSampleAggregateFilter>;
    sum?: InputMaybe<TokenRetiredSumAggregateFilter>;
    variancePopulation?: InputMaybe<TokenRetiredVariancePopulationAggregateFilter>;
    varianceSample?: InputMaybe<TokenRetiredVarianceSampleAggregateFilter>;
};
export type TokenRetiredAverageAggregateFilter = {
    aid?: InputMaybe<BigFloatFilter>;
    amount?: InputMaybe<BigFloatFilter>;
};
export type TokenRetiredAverageAggregates = {
    __typename?: 'TokenRetiredAverageAggregates';
    aid?: Maybe<Scalars['BigFloat']['output']>;
    amount?: Maybe<Scalars['BigFloat']['output']>;
};
export type TokenRetiredCondition = {
    aid?: InputMaybe<Scalars['Int']['input']>;
    amount?: InputMaybe<Scalars['BigInt']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    jurisdiction?: InputMaybe<Scalars['String']['input']>;
    name?: InputMaybe<Scalars['String']['input']>;
    owner?: InputMaybe<Scalars['String']['input']>;
    reason?: InputMaybe<Scalars['String']['input']>;
};
export type TokenRetiredDistinctCountAggregateFilter = {
    aid?: InputMaybe<BigIntFilter>;
    amount?: InputMaybe<BigIntFilter>;
    id?: InputMaybe<BigIntFilter>;
    jurisdiction?: InputMaybe<BigIntFilter>;
    name?: InputMaybe<BigIntFilter>;
    owner?: InputMaybe<BigIntFilter>;
    reason?: InputMaybe<BigIntFilter>;
};
export type TokenRetiredDistinctCountAggregates = {
    __typename?: 'TokenRetiredDistinctCountAggregates';
    aid?: Maybe<Scalars['BigInt']['output']>;
    amount?: Maybe<Scalars['BigInt']['output']>;
    id?: Maybe<Scalars['BigInt']['output']>;
    jurisdiction?: Maybe<Scalars['BigInt']['output']>;
    name?: Maybe<Scalars['BigInt']['output']>;
    owner?: Maybe<Scalars['BigInt']['output']>;
    reason?: Maybe<Scalars['BigInt']['output']>;
};
export type TokenRetiredFilter = {
    aid?: InputMaybe<IntFilter>;
    amount?: InputMaybe<BigIntFilter>;
    and?: InputMaybe<Array<TokenRetiredFilter>>;
    id?: InputMaybe<StringFilter>;
    jurisdiction?: InputMaybe<StringFilter>;
    name?: InputMaybe<StringFilter>;
    not?: InputMaybe<TokenRetiredFilter>;
    or?: InputMaybe<Array<TokenRetiredFilter>>;
    owner?: InputMaybe<StringFilter>;
    reason?: InputMaybe<StringFilter>;
    tokenById?: InputMaybe<TokenFilter>;
    tokenClassByName?: InputMaybe<TokenClassFilter>;
};
export declare enum TokenRetiredGroupBy {
    Amount = "AMOUNT",
    Id = "ID",
    Jurisdiction = "JURISDICTION",
    Name = "NAME",
    Owner = "OWNER",
    Reason = "REASON"
}
export type TokenRetiredHavingAverageInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenRetiredHavingDistinctCountInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenRetiredHavingInput = {
    AND?: InputMaybe<Array<TokenRetiredHavingInput>>;
    OR?: InputMaybe<Array<TokenRetiredHavingInput>>;
    average?: InputMaybe<TokenRetiredHavingAverageInput>;
    distinctCount?: InputMaybe<TokenRetiredHavingDistinctCountInput>;
    max?: InputMaybe<TokenRetiredHavingMaxInput>;
    min?: InputMaybe<TokenRetiredHavingMinInput>;
    stddevPopulation?: InputMaybe<TokenRetiredHavingStddevPopulationInput>;
    stddevSample?: InputMaybe<TokenRetiredHavingStddevSampleInput>;
    sum?: InputMaybe<TokenRetiredHavingSumInput>;
    variancePopulation?: InputMaybe<TokenRetiredHavingVariancePopulationInput>;
    varianceSample?: InputMaybe<TokenRetiredHavingVarianceSampleInput>;
};
export type TokenRetiredHavingMaxInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenRetiredHavingMinInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenRetiredHavingStddevPopulationInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenRetiredHavingStddevSampleInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenRetiredHavingSumInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenRetiredHavingVariancePopulationInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenRetiredHavingVarianceSampleInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenRetiredMaxAggregateFilter = {
    aid?: InputMaybe<IntFilter>;
    amount?: InputMaybe<BigIntFilter>;
};
export type TokenRetiredMaxAggregates = {
    __typename?: 'TokenRetiredMaxAggregates';
    aid?: Maybe<Scalars['Int']['output']>;
    amount?: Maybe<Scalars['BigInt']['output']>;
};
export type TokenRetiredMinAggregateFilter = {
    aid?: InputMaybe<IntFilter>;
    amount?: InputMaybe<BigIntFilter>;
};
export type TokenRetiredMinAggregates = {
    __typename?: 'TokenRetiredMinAggregates';
    aid?: Maybe<Scalars['Int']['output']>;
    amount?: Maybe<Scalars['BigInt']['output']>;
};
export type TokenRetiredStddevPopulationAggregateFilter = {
    aid?: InputMaybe<BigFloatFilter>;
    amount?: InputMaybe<BigFloatFilter>;
};
export type TokenRetiredStddevPopulationAggregates = {
    __typename?: 'TokenRetiredStddevPopulationAggregates';
    aid?: Maybe<Scalars['BigFloat']['output']>;
    amount?: Maybe<Scalars['BigFloat']['output']>;
};
export type TokenRetiredStddevSampleAggregateFilter = {
    aid?: InputMaybe<BigFloatFilter>;
    amount?: InputMaybe<BigFloatFilter>;
};
export type TokenRetiredStddevSampleAggregates = {
    __typename?: 'TokenRetiredStddevSampleAggregates';
    aid?: Maybe<Scalars['BigFloat']['output']>;
    amount?: Maybe<Scalars['BigFloat']['output']>;
};
export type TokenRetiredSumAggregateFilter = {
    aid?: InputMaybe<BigIntFilter>;
    amount?: InputMaybe<BigFloatFilter>;
};
export type TokenRetiredSumAggregates = {
    __typename?: 'TokenRetiredSumAggregates';
    aid: Scalars['BigInt']['output'];
    amount: Scalars['BigFloat']['output'];
};
export type TokenRetiredVariancePopulationAggregateFilter = {
    aid?: InputMaybe<BigFloatFilter>;
    amount?: InputMaybe<BigFloatFilter>;
};
export type TokenRetiredVariancePopulationAggregates = {
    __typename?: 'TokenRetiredVariancePopulationAggregates';
    aid?: Maybe<Scalars['BigFloat']['output']>;
    amount?: Maybe<Scalars['BigFloat']['output']>;
};
export type TokenRetiredVarianceSampleAggregateFilter = {
    aid?: InputMaybe<BigFloatFilter>;
    amount?: InputMaybe<BigFloatFilter>;
};
export type TokenRetiredVarianceSampleAggregates = {
    __typename?: 'TokenRetiredVarianceSampleAggregates';
    aid?: Maybe<Scalars['BigFloat']['output']>;
    amount?: Maybe<Scalars['BigFloat']['output']>;
};
export type TokenRetiredsConnection = {
    __typename?: 'TokenRetiredsConnection';
    aggregates?: Maybe<TokenRetiredAggregates>;
    edges: Array<TokenRetiredsEdge>;
    groupedAggregates?: Maybe<Array<TokenRetiredAggregates>>;
    nodes: Array<TokenRetired>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type TokenRetiredsConnectionGroupedAggregatesArgs = {
    groupBy: Array<TokenRetiredGroupBy>;
    having?: InputMaybe<TokenRetiredHavingInput>;
};
export type TokenRetiredsEdge = {
    __typename?: 'TokenRetiredsEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: TokenRetired;
};
export declare enum TokenRetiredsOrderBy {
    AidAsc = "AID_ASC",
    AidDesc = "AID_DESC",
    AmountAsc = "AMOUNT_ASC",
    AmountDesc = "AMOUNT_DESC",
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    JurisdictionAsc = "JURISDICTION_ASC",
    JurisdictionDesc = "JURISDICTION_DESC",
    NameAsc = "NAME_ASC",
    NameDesc = "NAME_DESC",
    Natural = "NATURAL",
    OwnerAsc = "OWNER_ASC",
    OwnerDesc = "OWNER_DESC",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    ReasonAsc = "REASON_ASC",
    ReasonDesc = "REASON_DESC"
}
export type TokenToManyTokenDatumFilter = {
    every?: InputMaybe<TokenDatumFilter>;
    none?: InputMaybe<TokenDatumFilter>;
    some?: InputMaybe<TokenDatumFilter>;
};
export type TokenToManyTokenRetiredFilter = {
    aggregates?: InputMaybe<TokenRetiredAggregatesFilter>;
    every?: InputMaybe<TokenRetiredFilter>;
    none?: InputMaybe<TokenRetiredFilter>;
    some?: InputMaybe<TokenRetiredFilter>;
};
export type TokenToManyTokenTransactionFilter = {
    aggregates?: InputMaybe<TokenTransactionAggregatesFilter>;
    every?: InputMaybe<TokenTransactionFilter>;
    none?: InputMaybe<TokenTransactionFilter>;
    some?: InputMaybe<TokenTransactionFilter>;
};
export type TokenTransaction = Node & {
    __typename?: 'TokenTransaction';
    aid: Scalars['Int']['output'];
    amount: Scalars['BigInt']['output'];
    from: Scalars['String']['output'];
    nodeId: Scalars['ID']['output'];
    to: Scalars['String']['output'];
    token?: Maybe<Token>;
    tokenId: Scalars['String']['output'];
};
export type TokenTransactionAggregates = {
    __typename?: 'TokenTransactionAggregates';
    average?: Maybe<TokenTransactionAverageAggregates>;
    distinctCount?: Maybe<TokenTransactionDistinctCountAggregates>;
    keys?: Maybe<Array<Scalars['String']['output']>>;
    max?: Maybe<TokenTransactionMaxAggregates>;
    min?: Maybe<TokenTransactionMinAggregates>;
    stddevPopulation?: Maybe<TokenTransactionStddevPopulationAggregates>;
    stddevSample?: Maybe<TokenTransactionStddevSampleAggregates>;
    sum?: Maybe<TokenTransactionSumAggregates>;
    variancePopulation?: Maybe<TokenTransactionVariancePopulationAggregates>;
    varianceSample?: Maybe<TokenTransactionVarianceSampleAggregates>;
};
export type TokenTransactionAggregatesFilter = {
    average?: InputMaybe<TokenTransactionAverageAggregateFilter>;
    distinctCount?: InputMaybe<TokenTransactionDistinctCountAggregateFilter>;
    filter?: InputMaybe<TokenTransactionFilter>;
    max?: InputMaybe<TokenTransactionMaxAggregateFilter>;
    min?: InputMaybe<TokenTransactionMinAggregateFilter>;
    stddevPopulation?: InputMaybe<TokenTransactionStddevPopulationAggregateFilter>;
    stddevSample?: InputMaybe<TokenTransactionStddevSampleAggregateFilter>;
    sum?: InputMaybe<TokenTransactionSumAggregateFilter>;
    variancePopulation?: InputMaybe<TokenTransactionVariancePopulationAggregateFilter>;
    varianceSample?: InputMaybe<TokenTransactionVarianceSampleAggregateFilter>;
};
export type TokenTransactionAverageAggregateFilter = {
    aid?: InputMaybe<BigFloatFilter>;
    amount?: InputMaybe<BigFloatFilter>;
};
export type TokenTransactionAverageAggregates = {
    __typename?: 'TokenTransactionAverageAggregates';
    aid?: Maybe<Scalars['BigFloat']['output']>;
    amount?: Maybe<Scalars['BigFloat']['output']>;
};
export type TokenTransactionCondition = {
    aid?: InputMaybe<Scalars['Int']['input']>;
    amount?: InputMaybe<Scalars['BigInt']['input']>;
    from?: InputMaybe<Scalars['String']['input']>;
    to?: InputMaybe<Scalars['String']['input']>;
    tokenId?: InputMaybe<Scalars['String']['input']>;
};
export type TokenTransactionDistinctCountAggregateFilter = {
    aid?: InputMaybe<BigIntFilter>;
    amount?: InputMaybe<BigIntFilter>;
    from?: InputMaybe<BigIntFilter>;
    to?: InputMaybe<BigIntFilter>;
    tokenId?: InputMaybe<BigIntFilter>;
};
export type TokenTransactionDistinctCountAggregates = {
    __typename?: 'TokenTransactionDistinctCountAggregates';
    aid?: Maybe<Scalars['BigInt']['output']>;
    amount?: Maybe<Scalars['BigInt']['output']>;
    from?: Maybe<Scalars['BigInt']['output']>;
    to?: Maybe<Scalars['BigInt']['output']>;
    tokenId?: Maybe<Scalars['BigInt']['output']>;
};
export type TokenTransactionFilter = {
    aid?: InputMaybe<IntFilter>;
    amount?: InputMaybe<BigIntFilter>;
    and?: InputMaybe<Array<TokenTransactionFilter>>;
    from?: InputMaybe<StringFilter>;
    not?: InputMaybe<TokenTransactionFilter>;
    or?: InputMaybe<Array<TokenTransactionFilter>>;
    to?: InputMaybe<StringFilter>;
    token?: InputMaybe<TokenFilter>;
    tokenId?: InputMaybe<StringFilter>;
};
export declare enum TokenTransactionGroupBy {
    Amount = "AMOUNT",
    From = "FROM",
    To = "TO",
    TokenId = "TOKEN_ID"
}
export type TokenTransactionHavingAverageInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenTransactionHavingDistinctCountInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenTransactionHavingInput = {
    AND?: InputMaybe<Array<TokenTransactionHavingInput>>;
    OR?: InputMaybe<Array<TokenTransactionHavingInput>>;
    average?: InputMaybe<TokenTransactionHavingAverageInput>;
    distinctCount?: InputMaybe<TokenTransactionHavingDistinctCountInput>;
    max?: InputMaybe<TokenTransactionHavingMaxInput>;
    min?: InputMaybe<TokenTransactionHavingMinInput>;
    stddevPopulation?: InputMaybe<TokenTransactionHavingStddevPopulationInput>;
    stddevSample?: InputMaybe<TokenTransactionHavingStddevSampleInput>;
    sum?: InputMaybe<TokenTransactionHavingSumInput>;
    variancePopulation?: InputMaybe<TokenTransactionHavingVariancePopulationInput>;
    varianceSample?: InputMaybe<TokenTransactionHavingVarianceSampleInput>;
};
export type TokenTransactionHavingMaxInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenTransactionHavingMinInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenTransactionHavingStddevPopulationInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenTransactionHavingStddevSampleInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenTransactionHavingSumInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenTransactionHavingVariancePopulationInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenTransactionHavingVarianceSampleInput = {
    aid?: InputMaybe<HavingIntFilter>;
    amount?: InputMaybe<HavingBigintFilter>;
};
export type TokenTransactionMaxAggregateFilter = {
    aid?: InputMaybe<IntFilter>;
    amount?: InputMaybe<BigIntFilter>;
};
export type TokenTransactionMaxAggregates = {
    __typename?: 'TokenTransactionMaxAggregates';
    aid?: Maybe<Scalars['Int']['output']>;
    amount?: Maybe<Scalars['BigInt']['output']>;
};
export type TokenTransactionMinAggregateFilter = {
    aid?: InputMaybe<IntFilter>;
    amount?: InputMaybe<BigIntFilter>;
};
export type TokenTransactionMinAggregates = {
    __typename?: 'TokenTransactionMinAggregates';
    aid?: Maybe<Scalars['Int']['output']>;
    amount?: Maybe<Scalars['BigInt']['output']>;
};
export type TokenTransactionStddevPopulationAggregateFilter = {
    aid?: InputMaybe<BigFloatFilter>;
    amount?: InputMaybe<BigFloatFilter>;
};
export type TokenTransactionStddevPopulationAggregates = {
    __typename?: 'TokenTransactionStddevPopulationAggregates';
    aid?: Maybe<Scalars['BigFloat']['output']>;
    amount?: Maybe<Scalars['BigFloat']['output']>;
};
export type TokenTransactionStddevSampleAggregateFilter = {
    aid?: InputMaybe<BigFloatFilter>;
    amount?: InputMaybe<BigFloatFilter>;
};
export type TokenTransactionStddevSampleAggregates = {
    __typename?: 'TokenTransactionStddevSampleAggregates';
    aid?: Maybe<Scalars['BigFloat']['output']>;
    amount?: Maybe<Scalars['BigFloat']['output']>;
};
export type TokenTransactionSumAggregateFilter = {
    aid?: InputMaybe<BigIntFilter>;
    amount?: InputMaybe<BigFloatFilter>;
};
export type TokenTransactionSumAggregates = {
    __typename?: 'TokenTransactionSumAggregates';
    aid: Scalars['BigInt']['output'];
    amount: Scalars['BigFloat']['output'];
};
export type TokenTransactionVariancePopulationAggregateFilter = {
    aid?: InputMaybe<BigFloatFilter>;
    amount?: InputMaybe<BigFloatFilter>;
};
export type TokenTransactionVariancePopulationAggregates = {
    __typename?: 'TokenTransactionVariancePopulationAggregates';
    aid?: Maybe<Scalars['BigFloat']['output']>;
    amount?: Maybe<Scalars['BigFloat']['output']>;
};
export type TokenTransactionVarianceSampleAggregateFilter = {
    aid?: InputMaybe<BigFloatFilter>;
    amount?: InputMaybe<BigFloatFilter>;
};
export type TokenTransactionVarianceSampleAggregates = {
    __typename?: 'TokenTransactionVarianceSampleAggregates';
    aid?: Maybe<Scalars['BigFloat']['output']>;
    amount?: Maybe<Scalars['BigFloat']['output']>;
};
export type TokenTransactionsConnection = {
    __typename?: 'TokenTransactionsConnection';
    aggregates?: Maybe<TokenTransactionAggregates>;
    edges: Array<TokenTransactionsEdge>;
    groupedAggregates?: Maybe<Array<TokenTransactionAggregates>>;
    nodes: Array<TokenTransaction>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type TokenTransactionsConnectionGroupedAggregatesArgs = {
    groupBy: Array<TokenTransactionGroupBy>;
    having?: InputMaybe<TokenTransactionHavingInput>;
};
export type TokenTransactionsEdge = {
    __typename?: 'TokenTransactionsEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: TokenTransaction;
};
export declare enum TokenTransactionsOrderBy {
    AidAsc = "AID_ASC",
    AidDesc = "AID_DESC",
    AmountAsc = "AMOUNT_ASC",
    AmountDesc = "AMOUNT_DESC",
    FromAsc = "FROM_ASC",
    FromDesc = "FROM_DESC",
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    TokenIdAsc = "TOKEN_ID_ASC",
    TokenIdDesc = "TOKEN_ID_DESC",
    ToAsc = "TO_ASC",
    ToDesc = "TO_DESC"
}
export type TokenomicsAccount = Node & {
    __typename?: 'TokenomicsAccount';
    accountNumber: Scalars['Int']['output'];
    address: Scalars['String']['output'];
    availBalance: Scalars['BigInt']['output'];
    delegationsBalance: Scalars['BigInt']['output'];
    nodeId: Scalars['ID']['output'];
    rewardsBalance: Scalars['BigInt']['output'];
    totalBalance: Scalars['BigInt']['output'];
    type?: Maybe<Scalars['String']['output']>;
};
export type TokenomicsAccountCondition = {
    accountNumber?: InputMaybe<Scalars['Int']['input']>;
    address?: InputMaybe<Scalars['String']['input']>;
    availBalance?: InputMaybe<Scalars['BigInt']['input']>;
    delegationsBalance?: InputMaybe<Scalars['BigInt']['input']>;
    rewardsBalance?: InputMaybe<Scalars['BigInt']['input']>;
    totalBalance?: InputMaybe<Scalars['BigInt']['input']>;
    type?: InputMaybe<Scalars['String']['input']>;
};
export type TokenomicsAccountFilter = {
    accountNumber?: InputMaybe<IntFilter>;
    address?: InputMaybe<StringFilter>;
    and?: InputMaybe<Array<TokenomicsAccountFilter>>;
    availBalance?: InputMaybe<BigIntFilter>;
    delegationsBalance?: InputMaybe<BigIntFilter>;
    not?: InputMaybe<TokenomicsAccountFilter>;
    or?: InputMaybe<Array<TokenomicsAccountFilter>>;
    rewardsBalance?: InputMaybe<BigIntFilter>;
    totalBalance?: InputMaybe<BigIntFilter>;
    type?: InputMaybe<StringFilter>;
};
export type TokenomicsAccountsConnection = {
    __typename?: 'TokenomicsAccountsConnection';
    edges: Array<TokenomicsAccountsEdge>;
    nodes: Array<TokenomicsAccount>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type TokenomicsAccountsEdge = {
    __typename?: 'TokenomicsAccountsEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: TokenomicsAccount;
};
export declare enum TokenomicsAccountsOrderBy {
    AccountNumberAsc = "ACCOUNT_NUMBER_ASC",
    AccountNumberDesc = "ACCOUNT_NUMBER_DESC",
    AddressAsc = "ADDRESS_ASC",
    AddressDesc = "ADDRESS_DESC",
    AvailBalanceAsc = "AVAIL_BALANCE_ASC",
    AvailBalanceDesc = "AVAIL_BALANCE_DESC",
    DelegationsBalanceAsc = "DELEGATIONS_BALANCE_ASC",
    DelegationsBalanceDesc = "DELEGATIONS_BALANCE_DESC",
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    RewardsBalanceAsc = "REWARDS_BALANCE_ASC",
    RewardsBalanceDesc = "REWARDS_BALANCE_DESC",
    TotalBalanceAsc = "TOTAL_BALANCE_ASC",
    TotalBalanceDesc = "TOTAL_BALANCE_DESC",
    TypeAsc = "TYPE_ASC",
    TypeDesc = "TYPE_DESC"
}
export type TokensConnection = {
    __typename?: 'TokensConnection';
    edges: Array<TokensEdge>;
    nodes: Array<Token>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type TokensEdge = {
    __typename?: 'TokensEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: Token;
};
export declare enum TokensOrderBy {
    CollectionAsc = "COLLECTION_ASC",
    CollectionDesc = "COLLECTION_DESC",
    IdAsc = "ID_ASC",
    IdDesc = "ID_DESC",
    IndexAsc = "INDEX_ASC",
    IndexDesc = "INDEX_DESC",
    NameAsc = "NAME_ASC",
    NameDesc = "NAME_DESC",
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    TokenRetiredsByIdAverageAidAsc = "TOKEN_RETIREDS_BY_ID_AVERAGE_AID_ASC",
    TokenRetiredsByIdAverageAidDesc = "TOKEN_RETIREDS_BY_ID_AVERAGE_AID_DESC",
    TokenRetiredsByIdAverageAmountAsc = "TOKEN_RETIREDS_BY_ID_AVERAGE_AMOUNT_ASC",
    TokenRetiredsByIdAverageAmountDesc = "TOKEN_RETIREDS_BY_ID_AVERAGE_AMOUNT_DESC",
    TokenRetiredsByIdAverageIdAsc = "TOKEN_RETIREDS_BY_ID_AVERAGE_ID_ASC",
    TokenRetiredsByIdAverageIdDesc = "TOKEN_RETIREDS_BY_ID_AVERAGE_ID_DESC",
    TokenRetiredsByIdAverageJurisdictionAsc = "TOKEN_RETIREDS_BY_ID_AVERAGE_JURISDICTION_ASC",
    TokenRetiredsByIdAverageJurisdictionDesc = "TOKEN_RETIREDS_BY_ID_AVERAGE_JURISDICTION_DESC",
    TokenRetiredsByIdAverageNameAsc = "TOKEN_RETIREDS_BY_ID_AVERAGE_NAME_ASC",
    TokenRetiredsByIdAverageNameDesc = "TOKEN_RETIREDS_BY_ID_AVERAGE_NAME_DESC",
    TokenRetiredsByIdAverageOwnerAsc = "TOKEN_RETIREDS_BY_ID_AVERAGE_OWNER_ASC",
    TokenRetiredsByIdAverageOwnerDesc = "TOKEN_RETIREDS_BY_ID_AVERAGE_OWNER_DESC",
    TokenRetiredsByIdAverageReasonAsc = "TOKEN_RETIREDS_BY_ID_AVERAGE_REASON_ASC",
    TokenRetiredsByIdAverageReasonDesc = "TOKEN_RETIREDS_BY_ID_AVERAGE_REASON_DESC",
    TokenRetiredsByIdCountAsc = "TOKEN_RETIREDS_BY_ID_COUNT_ASC",
    TokenRetiredsByIdCountDesc = "TOKEN_RETIREDS_BY_ID_COUNT_DESC",
    TokenRetiredsByIdDistinctCountAidAsc = "TOKEN_RETIREDS_BY_ID_DISTINCT_COUNT_AID_ASC",
    TokenRetiredsByIdDistinctCountAidDesc = "TOKEN_RETIREDS_BY_ID_DISTINCT_COUNT_AID_DESC",
    TokenRetiredsByIdDistinctCountAmountAsc = "TOKEN_RETIREDS_BY_ID_DISTINCT_COUNT_AMOUNT_ASC",
    TokenRetiredsByIdDistinctCountAmountDesc = "TOKEN_RETIREDS_BY_ID_DISTINCT_COUNT_AMOUNT_DESC",
    TokenRetiredsByIdDistinctCountIdAsc = "TOKEN_RETIREDS_BY_ID_DISTINCT_COUNT_ID_ASC",
    TokenRetiredsByIdDistinctCountIdDesc = "TOKEN_RETIREDS_BY_ID_DISTINCT_COUNT_ID_DESC",
    TokenRetiredsByIdDistinctCountJurisdictionAsc = "TOKEN_RETIREDS_BY_ID_DISTINCT_COUNT_JURISDICTION_ASC",
    TokenRetiredsByIdDistinctCountJurisdictionDesc = "TOKEN_RETIREDS_BY_ID_DISTINCT_COUNT_JURISDICTION_DESC",
    TokenRetiredsByIdDistinctCountNameAsc = "TOKEN_RETIREDS_BY_ID_DISTINCT_COUNT_NAME_ASC",
    TokenRetiredsByIdDistinctCountNameDesc = "TOKEN_RETIREDS_BY_ID_DISTINCT_COUNT_NAME_DESC",
    TokenRetiredsByIdDistinctCountOwnerAsc = "TOKEN_RETIREDS_BY_ID_DISTINCT_COUNT_OWNER_ASC",
    TokenRetiredsByIdDistinctCountOwnerDesc = "TOKEN_RETIREDS_BY_ID_DISTINCT_COUNT_OWNER_DESC",
    TokenRetiredsByIdDistinctCountReasonAsc = "TOKEN_RETIREDS_BY_ID_DISTINCT_COUNT_REASON_ASC",
    TokenRetiredsByIdDistinctCountReasonDesc = "TOKEN_RETIREDS_BY_ID_DISTINCT_COUNT_REASON_DESC",
    TokenRetiredsByIdMaxAidAsc = "TOKEN_RETIREDS_BY_ID_MAX_AID_ASC",
    TokenRetiredsByIdMaxAidDesc = "TOKEN_RETIREDS_BY_ID_MAX_AID_DESC",
    TokenRetiredsByIdMaxAmountAsc = "TOKEN_RETIREDS_BY_ID_MAX_AMOUNT_ASC",
    TokenRetiredsByIdMaxAmountDesc = "TOKEN_RETIREDS_BY_ID_MAX_AMOUNT_DESC",
    TokenRetiredsByIdMaxIdAsc = "TOKEN_RETIREDS_BY_ID_MAX_ID_ASC",
    TokenRetiredsByIdMaxIdDesc = "TOKEN_RETIREDS_BY_ID_MAX_ID_DESC",
    TokenRetiredsByIdMaxJurisdictionAsc = "TOKEN_RETIREDS_BY_ID_MAX_JURISDICTION_ASC",
    TokenRetiredsByIdMaxJurisdictionDesc = "TOKEN_RETIREDS_BY_ID_MAX_JURISDICTION_DESC",
    TokenRetiredsByIdMaxNameAsc = "TOKEN_RETIREDS_BY_ID_MAX_NAME_ASC",
    TokenRetiredsByIdMaxNameDesc = "TOKEN_RETIREDS_BY_ID_MAX_NAME_DESC",
    TokenRetiredsByIdMaxOwnerAsc = "TOKEN_RETIREDS_BY_ID_MAX_OWNER_ASC",
    TokenRetiredsByIdMaxOwnerDesc = "TOKEN_RETIREDS_BY_ID_MAX_OWNER_DESC",
    TokenRetiredsByIdMaxReasonAsc = "TOKEN_RETIREDS_BY_ID_MAX_REASON_ASC",
    TokenRetiredsByIdMaxReasonDesc = "TOKEN_RETIREDS_BY_ID_MAX_REASON_DESC",
    TokenRetiredsByIdMinAidAsc = "TOKEN_RETIREDS_BY_ID_MIN_AID_ASC",
    TokenRetiredsByIdMinAidDesc = "TOKEN_RETIREDS_BY_ID_MIN_AID_DESC",
    TokenRetiredsByIdMinAmountAsc = "TOKEN_RETIREDS_BY_ID_MIN_AMOUNT_ASC",
    TokenRetiredsByIdMinAmountDesc = "TOKEN_RETIREDS_BY_ID_MIN_AMOUNT_DESC",
    TokenRetiredsByIdMinIdAsc = "TOKEN_RETIREDS_BY_ID_MIN_ID_ASC",
    TokenRetiredsByIdMinIdDesc = "TOKEN_RETIREDS_BY_ID_MIN_ID_DESC",
    TokenRetiredsByIdMinJurisdictionAsc = "TOKEN_RETIREDS_BY_ID_MIN_JURISDICTION_ASC",
    TokenRetiredsByIdMinJurisdictionDesc = "TOKEN_RETIREDS_BY_ID_MIN_JURISDICTION_DESC",
    TokenRetiredsByIdMinNameAsc = "TOKEN_RETIREDS_BY_ID_MIN_NAME_ASC",
    TokenRetiredsByIdMinNameDesc = "TOKEN_RETIREDS_BY_ID_MIN_NAME_DESC",
    TokenRetiredsByIdMinOwnerAsc = "TOKEN_RETIREDS_BY_ID_MIN_OWNER_ASC",
    TokenRetiredsByIdMinOwnerDesc = "TOKEN_RETIREDS_BY_ID_MIN_OWNER_DESC",
    TokenRetiredsByIdMinReasonAsc = "TOKEN_RETIREDS_BY_ID_MIN_REASON_ASC",
    TokenRetiredsByIdMinReasonDesc = "TOKEN_RETIREDS_BY_ID_MIN_REASON_DESC",
    TokenRetiredsByIdStddevPopulationAidAsc = "TOKEN_RETIREDS_BY_ID_STDDEV_POPULATION_AID_ASC",
    TokenRetiredsByIdStddevPopulationAidDesc = "TOKEN_RETIREDS_BY_ID_STDDEV_POPULATION_AID_DESC",
    TokenRetiredsByIdStddevPopulationAmountAsc = "TOKEN_RETIREDS_BY_ID_STDDEV_POPULATION_AMOUNT_ASC",
    TokenRetiredsByIdStddevPopulationAmountDesc = "TOKEN_RETIREDS_BY_ID_STDDEV_POPULATION_AMOUNT_DESC",
    TokenRetiredsByIdStddevPopulationIdAsc = "TOKEN_RETIREDS_BY_ID_STDDEV_POPULATION_ID_ASC",
    TokenRetiredsByIdStddevPopulationIdDesc = "TOKEN_RETIREDS_BY_ID_STDDEV_POPULATION_ID_DESC",
    TokenRetiredsByIdStddevPopulationJurisdictionAsc = "TOKEN_RETIREDS_BY_ID_STDDEV_POPULATION_JURISDICTION_ASC",
    TokenRetiredsByIdStddevPopulationJurisdictionDesc = "TOKEN_RETIREDS_BY_ID_STDDEV_POPULATION_JURISDICTION_DESC",
    TokenRetiredsByIdStddevPopulationNameAsc = "TOKEN_RETIREDS_BY_ID_STDDEV_POPULATION_NAME_ASC",
    TokenRetiredsByIdStddevPopulationNameDesc = "TOKEN_RETIREDS_BY_ID_STDDEV_POPULATION_NAME_DESC",
    TokenRetiredsByIdStddevPopulationOwnerAsc = "TOKEN_RETIREDS_BY_ID_STDDEV_POPULATION_OWNER_ASC",
    TokenRetiredsByIdStddevPopulationOwnerDesc = "TOKEN_RETIREDS_BY_ID_STDDEV_POPULATION_OWNER_DESC",
    TokenRetiredsByIdStddevPopulationReasonAsc = "TOKEN_RETIREDS_BY_ID_STDDEV_POPULATION_REASON_ASC",
    TokenRetiredsByIdStddevPopulationReasonDesc = "TOKEN_RETIREDS_BY_ID_STDDEV_POPULATION_REASON_DESC",
    TokenRetiredsByIdStddevSampleAidAsc = "TOKEN_RETIREDS_BY_ID_STDDEV_SAMPLE_AID_ASC",
    TokenRetiredsByIdStddevSampleAidDesc = "TOKEN_RETIREDS_BY_ID_STDDEV_SAMPLE_AID_DESC",
    TokenRetiredsByIdStddevSampleAmountAsc = "TOKEN_RETIREDS_BY_ID_STDDEV_SAMPLE_AMOUNT_ASC",
    TokenRetiredsByIdStddevSampleAmountDesc = "TOKEN_RETIREDS_BY_ID_STDDEV_SAMPLE_AMOUNT_DESC",
    TokenRetiredsByIdStddevSampleIdAsc = "TOKEN_RETIREDS_BY_ID_STDDEV_SAMPLE_ID_ASC",
    TokenRetiredsByIdStddevSampleIdDesc = "TOKEN_RETIREDS_BY_ID_STDDEV_SAMPLE_ID_DESC",
    TokenRetiredsByIdStddevSampleJurisdictionAsc = "TOKEN_RETIREDS_BY_ID_STDDEV_SAMPLE_JURISDICTION_ASC",
    TokenRetiredsByIdStddevSampleJurisdictionDesc = "TOKEN_RETIREDS_BY_ID_STDDEV_SAMPLE_JURISDICTION_DESC",
    TokenRetiredsByIdStddevSampleNameAsc = "TOKEN_RETIREDS_BY_ID_STDDEV_SAMPLE_NAME_ASC",
    TokenRetiredsByIdStddevSampleNameDesc = "TOKEN_RETIREDS_BY_ID_STDDEV_SAMPLE_NAME_DESC",
    TokenRetiredsByIdStddevSampleOwnerAsc = "TOKEN_RETIREDS_BY_ID_STDDEV_SAMPLE_OWNER_ASC",
    TokenRetiredsByIdStddevSampleOwnerDesc = "TOKEN_RETIREDS_BY_ID_STDDEV_SAMPLE_OWNER_DESC",
    TokenRetiredsByIdStddevSampleReasonAsc = "TOKEN_RETIREDS_BY_ID_STDDEV_SAMPLE_REASON_ASC",
    TokenRetiredsByIdStddevSampleReasonDesc = "TOKEN_RETIREDS_BY_ID_STDDEV_SAMPLE_REASON_DESC",
    TokenRetiredsByIdSumAidAsc = "TOKEN_RETIREDS_BY_ID_SUM_AID_ASC",
    TokenRetiredsByIdSumAidDesc = "TOKEN_RETIREDS_BY_ID_SUM_AID_DESC",
    TokenRetiredsByIdSumAmountAsc = "TOKEN_RETIREDS_BY_ID_SUM_AMOUNT_ASC",
    TokenRetiredsByIdSumAmountDesc = "TOKEN_RETIREDS_BY_ID_SUM_AMOUNT_DESC",
    TokenRetiredsByIdSumIdAsc = "TOKEN_RETIREDS_BY_ID_SUM_ID_ASC",
    TokenRetiredsByIdSumIdDesc = "TOKEN_RETIREDS_BY_ID_SUM_ID_DESC",
    TokenRetiredsByIdSumJurisdictionAsc = "TOKEN_RETIREDS_BY_ID_SUM_JURISDICTION_ASC",
    TokenRetiredsByIdSumJurisdictionDesc = "TOKEN_RETIREDS_BY_ID_SUM_JURISDICTION_DESC",
    TokenRetiredsByIdSumNameAsc = "TOKEN_RETIREDS_BY_ID_SUM_NAME_ASC",
    TokenRetiredsByIdSumNameDesc = "TOKEN_RETIREDS_BY_ID_SUM_NAME_DESC",
    TokenRetiredsByIdSumOwnerAsc = "TOKEN_RETIREDS_BY_ID_SUM_OWNER_ASC",
    TokenRetiredsByIdSumOwnerDesc = "TOKEN_RETIREDS_BY_ID_SUM_OWNER_DESC",
    TokenRetiredsByIdSumReasonAsc = "TOKEN_RETIREDS_BY_ID_SUM_REASON_ASC",
    TokenRetiredsByIdSumReasonDesc = "TOKEN_RETIREDS_BY_ID_SUM_REASON_DESC",
    TokenRetiredsByIdVariancePopulationAidAsc = "TOKEN_RETIREDS_BY_ID_VARIANCE_POPULATION_AID_ASC",
    TokenRetiredsByIdVariancePopulationAidDesc = "TOKEN_RETIREDS_BY_ID_VARIANCE_POPULATION_AID_DESC",
    TokenRetiredsByIdVariancePopulationAmountAsc = "TOKEN_RETIREDS_BY_ID_VARIANCE_POPULATION_AMOUNT_ASC",
    TokenRetiredsByIdVariancePopulationAmountDesc = "TOKEN_RETIREDS_BY_ID_VARIANCE_POPULATION_AMOUNT_DESC",
    TokenRetiredsByIdVariancePopulationIdAsc = "TOKEN_RETIREDS_BY_ID_VARIANCE_POPULATION_ID_ASC",
    TokenRetiredsByIdVariancePopulationIdDesc = "TOKEN_RETIREDS_BY_ID_VARIANCE_POPULATION_ID_DESC",
    TokenRetiredsByIdVariancePopulationJurisdictionAsc = "TOKEN_RETIREDS_BY_ID_VARIANCE_POPULATION_JURISDICTION_ASC",
    TokenRetiredsByIdVariancePopulationJurisdictionDesc = "TOKEN_RETIREDS_BY_ID_VARIANCE_POPULATION_JURISDICTION_DESC",
    TokenRetiredsByIdVariancePopulationNameAsc = "TOKEN_RETIREDS_BY_ID_VARIANCE_POPULATION_NAME_ASC",
    TokenRetiredsByIdVariancePopulationNameDesc = "TOKEN_RETIREDS_BY_ID_VARIANCE_POPULATION_NAME_DESC",
    TokenRetiredsByIdVariancePopulationOwnerAsc = "TOKEN_RETIREDS_BY_ID_VARIANCE_POPULATION_OWNER_ASC",
    TokenRetiredsByIdVariancePopulationOwnerDesc = "TOKEN_RETIREDS_BY_ID_VARIANCE_POPULATION_OWNER_DESC",
    TokenRetiredsByIdVariancePopulationReasonAsc = "TOKEN_RETIREDS_BY_ID_VARIANCE_POPULATION_REASON_ASC",
    TokenRetiredsByIdVariancePopulationReasonDesc = "TOKEN_RETIREDS_BY_ID_VARIANCE_POPULATION_REASON_DESC",
    TokenRetiredsByIdVarianceSampleAidAsc = "TOKEN_RETIREDS_BY_ID_VARIANCE_SAMPLE_AID_ASC",
    TokenRetiredsByIdVarianceSampleAidDesc = "TOKEN_RETIREDS_BY_ID_VARIANCE_SAMPLE_AID_DESC",
    TokenRetiredsByIdVarianceSampleAmountAsc = "TOKEN_RETIREDS_BY_ID_VARIANCE_SAMPLE_AMOUNT_ASC",
    TokenRetiredsByIdVarianceSampleAmountDesc = "TOKEN_RETIREDS_BY_ID_VARIANCE_SAMPLE_AMOUNT_DESC",
    TokenRetiredsByIdVarianceSampleIdAsc = "TOKEN_RETIREDS_BY_ID_VARIANCE_SAMPLE_ID_ASC",
    TokenRetiredsByIdVarianceSampleIdDesc = "TOKEN_RETIREDS_BY_ID_VARIANCE_SAMPLE_ID_DESC",
    TokenRetiredsByIdVarianceSampleJurisdictionAsc = "TOKEN_RETIREDS_BY_ID_VARIANCE_SAMPLE_JURISDICTION_ASC",
    TokenRetiredsByIdVarianceSampleJurisdictionDesc = "TOKEN_RETIREDS_BY_ID_VARIANCE_SAMPLE_JURISDICTION_DESC",
    TokenRetiredsByIdVarianceSampleNameAsc = "TOKEN_RETIREDS_BY_ID_VARIANCE_SAMPLE_NAME_ASC",
    TokenRetiredsByIdVarianceSampleNameDesc = "TOKEN_RETIREDS_BY_ID_VARIANCE_SAMPLE_NAME_DESC",
    TokenRetiredsByIdVarianceSampleOwnerAsc = "TOKEN_RETIREDS_BY_ID_VARIANCE_SAMPLE_OWNER_ASC",
    TokenRetiredsByIdVarianceSampleOwnerDesc = "TOKEN_RETIREDS_BY_ID_VARIANCE_SAMPLE_OWNER_DESC",
    TokenRetiredsByIdVarianceSampleReasonAsc = "TOKEN_RETIREDS_BY_ID_VARIANCE_SAMPLE_REASON_ASC",
    TokenRetiredsByIdVarianceSampleReasonDesc = "TOKEN_RETIREDS_BY_ID_VARIANCE_SAMPLE_REASON_DESC",
    TokenTransactionsByTokenIdAverageAidAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_AVERAGE_AID_ASC",
    TokenTransactionsByTokenIdAverageAidDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_AVERAGE_AID_DESC",
    TokenTransactionsByTokenIdAverageAmountAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_AVERAGE_AMOUNT_ASC",
    TokenTransactionsByTokenIdAverageAmountDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_AVERAGE_AMOUNT_DESC",
    TokenTransactionsByTokenIdAverageFromAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_AVERAGE_FROM_ASC",
    TokenTransactionsByTokenIdAverageFromDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_AVERAGE_FROM_DESC",
    TokenTransactionsByTokenIdAverageTokenIdAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_AVERAGE_TOKEN_ID_ASC",
    TokenTransactionsByTokenIdAverageTokenIdDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_AVERAGE_TOKEN_ID_DESC",
    TokenTransactionsByTokenIdAverageToAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_AVERAGE_TO_ASC",
    TokenTransactionsByTokenIdAverageToDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_AVERAGE_TO_DESC",
    TokenTransactionsByTokenIdCountAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_COUNT_ASC",
    TokenTransactionsByTokenIdCountDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_COUNT_DESC",
    TokenTransactionsByTokenIdDistinctCountAidAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_DISTINCT_COUNT_AID_ASC",
    TokenTransactionsByTokenIdDistinctCountAidDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_DISTINCT_COUNT_AID_DESC",
    TokenTransactionsByTokenIdDistinctCountAmountAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_DISTINCT_COUNT_AMOUNT_ASC",
    TokenTransactionsByTokenIdDistinctCountAmountDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_DISTINCT_COUNT_AMOUNT_DESC",
    TokenTransactionsByTokenIdDistinctCountFromAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_DISTINCT_COUNT_FROM_ASC",
    TokenTransactionsByTokenIdDistinctCountFromDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_DISTINCT_COUNT_FROM_DESC",
    TokenTransactionsByTokenIdDistinctCountTokenIdAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_DISTINCT_COUNT_TOKEN_ID_ASC",
    TokenTransactionsByTokenIdDistinctCountTokenIdDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_DISTINCT_COUNT_TOKEN_ID_DESC",
    TokenTransactionsByTokenIdDistinctCountToAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_DISTINCT_COUNT_TO_ASC",
    TokenTransactionsByTokenIdDistinctCountToDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_DISTINCT_COUNT_TO_DESC",
    TokenTransactionsByTokenIdMaxAidAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_MAX_AID_ASC",
    TokenTransactionsByTokenIdMaxAidDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_MAX_AID_DESC",
    TokenTransactionsByTokenIdMaxAmountAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_MAX_AMOUNT_ASC",
    TokenTransactionsByTokenIdMaxAmountDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_MAX_AMOUNT_DESC",
    TokenTransactionsByTokenIdMaxFromAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_MAX_FROM_ASC",
    TokenTransactionsByTokenIdMaxFromDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_MAX_FROM_DESC",
    TokenTransactionsByTokenIdMaxTokenIdAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_MAX_TOKEN_ID_ASC",
    TokenTransactionsByTokenIdMaxTokenIdDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_MAX_TOKEN_ID_DESC",
    TokenTransactionsByTokenIdMaxToAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_MAX_TO_ASC",
    TokenTransactionsByTokenIdMaxToDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_MAX_TO_DESC",
    TokenTransactionsByTokenIdMinAidAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_MIN_AID_ASC",
    TokenTransactionsByTokenIdMinAidDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_MIN_AID_DESC",
    TokenTransactionsByTokenIdMinAmountAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_MIN_AMOUNT_ASC",
    TokenTransactionsByTokenIdMinAmountDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_MIN_AMOUNT_DESC",
    TokenTransactionsByTokenIdMinFromAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_MIN_FROM_ASC",
    TokenTransactionsByTokenIdMinFromDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_MIN_FROM_DESC",
    TokenTransactionsByTokenIdMinTokenIdAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_MIN_TOKEN_ID_ASC",
    TokenTransactionsByTokenIdMinTokenIdDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_MIN_TOKEN_ID_DESC",
    TokenTransactionsByTokenIdMinToAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_MIN_TO_ASC",
    TokenTransactionsByTokenIdMinToDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_MIN_TO_DESC",
    TokenTransactionsByTokenIdStddevPopulationAidAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_STDDEV_POPULATION_AID_ASC",
    TokenTransactionsByTokenIdStddevPopulationAidDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_STDDEV_POPULATION_AID_DESC",
    TokenTransactionsByTokenIdStddevPopulationAmountAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_STDDEV_POPULATION_AMOUNT_ASC",
    TokenTransactionsByTokenIdStddevPopulationAmountDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_STDDEV_POPULATION_AMOUNT_DESC",
    TokenTransactionsByTokenIdStddevPopulationFromAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_STDDEV_POPULATION_FROM_ASC",
    TokenTransactionsByTokenIdStddevPopulationFromDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_STDDEV_POPULATION_FROM_DESC",
    TokenTransactionsByTokenIdStddevPopulationTokenIdAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_STDDEV_POPULATION_TOKEN_ID_ASC",
    TokenTransactionsByTokenIdStddevPopulationTokenIdDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_STDDEV_POPULATION_TOKEN_ID_DESC",
    TokenTransactionsByTokenIdStddevPopulationToAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_STDDEV_POPULATION_TO_ASC",
    TokenTransactionsByTokenIdStddevPopulationToDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_STDDEV_POPULATION_TO_DESC",
    TokenTransactionsByTokenIdStddevSampleAidAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_STDDEV_SAMPLE_AID_ASC",
    TokenTransactionsByTokenIdStddevSampleAidDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_STDDEV_SAMPLE_AID_DESC",
    TokenTransactionsByTokenIdStddevSampleAmountAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_STDDEV_SAMPLE_AMOUNT_ASC",
    TokenTransactionsByTokenIdStddevSampleAmountDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_STDDEV_SAMPLE_AMOUNT_DESC",
    TokenTransactionsByTokenIdStddevSampleFromAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_STDDEV_SAMPLE_FROM_ASC",
    TokenTransactionsByTokenIdStddevSampleFromDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_STDDEV_SAMPLE_FROM_DESC",
    TokenTransactionsByTokenIdStddevSampleTokenIdAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_STDDEV_SAMPLE_TOKEN_ID_ASC",
    TokenTransactionsByTokenIdStddevSampleTokenIdDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_STDDEV_SAMPLE_TOKEN_ID_DESC",
    TokenTransactionsByTokenIdStddevSampleToAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_STDDEV_SAMPLE_TO_ASC",
    TokenTransactionsByTokenIdStddevSampleToDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_STDDEV_SAMPLE_TO_DESC",
    TokenTransactionsByTokenIdSumAidAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_SUM_AID_ASC",
    TokenTransactionsByTokenIdSumAidDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_SUM_AID_DESC",
    TokenTransactionsByTokenIdSumAmountAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_SUM_AMOUNT_ASC",
    TokenTransactionsByTokenIdSumAmountDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_SUM_AMOUNT_DESC",
    TokenTransactionsByTokenIdSumFromAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_SUM_FROM_ASC",
    TokenTransactionsByTokenIdSumFromDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_SUM_FROM_DESC",
    TokenTransactionsByTokenIdSumTokenIdAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_SUM_TOKEN_ID_ASC",
    TokenTransactionsByTokenIdSumTokenIdDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_SUM_TOKEN_ID_DESC",
    TokenTransactionsByTokenIdSumToAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_SUM_TO_ASC",
    TokenTransactionsByTokenIdSumToDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_SUM_TO_DESC",
    TokenTransactionsByTokenIdVariancePopulationAidAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_VARIANCE_POPULATION_AID_ASC",
    TokenTransactionsByTokenIdVariancePopulationAidDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_VARIANCE_POPULATION_AID_DESC",
    TokenTransactionsByTokenIdVariancePopulationAmountAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_VARIANCE_POPULATION_AMOUNT_ASC",
    TokenTransactionsByTokenIdVariancePopulationAmountDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_VARIANCE_POPULATION_AMOUNT_DESC",
    TokenTransactionsByTokenIdVariancePopulationFromAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_VARIANCE_POPULATION_FROM_ASC",
    TokenTransactionsByTokenIdVariancePopulationFromDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_VARIANCE_POPULATION_FROM_DESC",
    TokenTransactionsByTokenIdVariancePopulationTokenIdAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_VARIANCE_POPULATION_TOKEN_ID_ASC",
    TokenTransactionsByTokenIdVariancePopulationTokenIdDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_VARIANCE_POPULATION_TOKEN_ID_DESC",
    TokenTransactionsByTokenIdVariancePopulationToAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_VARIANCE_POPULATION_TO_ASC",
    TokenTransactionsByTokenIdVariancePopulationToDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_VARIANCE_POPULATION_TO_DESC",
    TokenTransactionsByTokenIdVarianceSampleAidAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_VARIANCE_SAMPLE_AID_ASC",
    TokenTransactionsByTokenIdVarianceSampleAidDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_VARIANCE_SAMPLE_AID_DESC",
    TokenTransactionsByTokenIdVarianceSampleAmountAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_VARIANCE_SAMPLE_AMOUNT_ASC",
    TokenTransactionsByTokenIdVarianceSampleAmountDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_VARIANCE_SAMPLE_AMOUNT_DESC",
    TokenTransactionsByTokenIdVarianceSampleFromAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_VARIANCE_SAMPLE_FROM_ASC",
    TokenTransactionsByTokenIdVarianceSampleFromDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_VARIANCE_SAMPLE_FROM_DESC",
    TokenTransactionsByTokenIdVarianceSampleTokenIdAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_VARIANCE_SAMPLE_TOKEN_ID_ASC",
    TokenTransactionsByTokenIdVarianceSampleTokenIdDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_VARIANCE_SAMPLE_TOKEN_ID_DESC",
    TokenTransactionsByTokenIdVarianceSampleToAsc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_VARIANCE_SAMPLE_TO_ASC",
    TokenTransactionsByTokenIdVarianceSampleToDesc = "TOKEN_TRANSACTIONS_BY_TOKEN_ID_VARIANCE_SAMPLE_TO_DESC"
}
export type Transaction = Node & {
    __typename?: 'Transaction';
    code: Scalars['Int']['output'];
    fee: Scalars['JSON']['output'];
    gasUsed: Scalars['String']['output'];
    gasWanted: Scalars['String']['output'];
    hash: Scalars['String']['output'];
    height: Scalars['Int']['output'];
    memo: Scalars['String']['output'];
    messagesByTransactionHash: MessagesConnection;
    nodeId: Scalars['ID']['output'];
    time: Scalars['Datetime']['output'];
};
export type TransactionMessagesByTransactionHashArgs = {
    after?: InputMaybe<Scalars['Cursor']['input']>;
    before?: InputMaybe<Scalars['Cursor']['input']>;
    condition?: InputMaybe<MessageCondition>;
    filter?: InputMaybe<MessageFilter>;
    first?: InputMaybe<Scalars['Int']['input']>;
    last?: InputMaybe<Scalars['Int']['input']>;
    offset?: InputMaybe<Scalars['Int']['input']>;
    orderBy?: InputMaybe<Array<MessagesOrderBy>>;
};
export type TransactionCondition = {
    code?: InputMaybe<Scalars['Int']['input']>;
    fee?: InputMaybe<Scalars['JSON']['input']>;
    gasUsed?: InputMaybe<Scalars['String']['input']>;
    gasWanted?: InputMaybe<Scalars['String']['input']>;
    hash?: InputMaybe<Scalars['String']['input']>;
    height?: InputMaybe<Scalars['Int']['input']>;
    memo?: InputMaybe<Scalars['String']['input']>;
    time?: InputMaybe<Scalars['Datetime']['input']>;
};
export type TransactionFilter = {
    and?: InputMaybe<Array<TransactionFilter>>;
    code?: InputMaybe<IntFilter>;
    fee?: InputMaybe<JsonFilter>;
    gasUsed?: InputMaybe<StringFilter>;
    gasWanted?: InputMaybe<StringFilter>;
    hash?: InputMaybe<StringFilter>;
    height?: InputMaybe<IntFilter>;
    memo?: InputMaybe<StringFilter>;
    messagesByTransactionHash?: InputMaybe<TransactionToManyMessageFilter>;
    messagesByTransactionHashExist?: InputMaybe<Scalars['Boolean']['input']>;
    not?: InputMaybe<TransactionFilter>;
    or?: InputMaybe<Array<TransactionFilter>>;
    time?: InputMaybe<DatetimeFilter>;
};
export type TransactionToManyMessageFilter = {
    every?: InputMaybe<MessageFilter>;
    none?: InputMaybe<MessageFilter>;
    some?: InputMaybe<MessageFilter>;
};
export type TransactionsConnection = {
    __typename?: 'TransactionsConnection';
    edges: Array<TransactionsEdge>;
    nodes: Array<Transaction>;
    pageInfo: PageInfo;
    totalCount: Scalars['Int']['output'];
};
export type TransactionsEdge = {
    __typename?: 'TransactionsEdge';
    cursor?: Maybe<Scalars['Cursor']['output']>;
    node: Transaction;
};
export declare enum TransactionsOrderBy {
    CodeAsc = "CODE_ASC",
    CodeDesc = "CODE_DESC",
    FeeAsc = "FEE_ASC",
    FeeDesc = "FEE_DESC",
    GasUsedAsc = "GAS_USED_ASC",
    GasUsedDesc = "GAS_USED_DESC",
    GasWantedAsc = "GAS_WANTED_ASC",
    GasWantedDesc = "GAS_WANTED_DESC",
    HashAsc = "HASH_ASC",
    HashDesc = "HASH_DESC",
    HeightAsc = "HEIGHT_ASC",
    HeightDesc = "HEIGHT_DESC",
    MemoAsc = "MEMO_ASC",
    MemoDesc = "MEMO_DESC",
    Natural = "NATURAL",
    PrimaryKeyAsc = "PRIMARY_KEY_ASC",
    PrimaryKeyDesc = "PRIMARY_KEY_DESC",
    TimeAsc = "TIME_ASC",
    TimeDesc = "TIME_DESC"
}
export type ClaimsQueryVariables = Exact<{
    agentAddress?: InputMaybe<Scalars['String']['input']>;
    collectionId?: InputMaybe<Scalars['String']['input']>;
}>;
export type ClaimsQuery = {
    __typename?: 'Query';
    claims?: {
        __typename?: 'ClaimsConnection';
        totalCount: number;
        nodes: Array<{
            __typename?: 'Claim';
            nodeId: string;
            claimId: string;
            agentDid: string;
            agentAddress: string;
            submissionDate: any;
            paymentsStatus: any;
            schemaType?: string | null;
            collectionId: string;
            evaluationByClaimId?: {
                __typename?: 'Evaluation';
                nodeId: string;
                collectionId: string;
                oracle: string;
                agentDid: string;
                agentAddress: string;
                status: number;
                reason: any;
                verificationProof?: string | null;
                amount: any;
                evaluationDate: any;
                claimId: string;
            } | null;
        }>;
    } | null;
};
export type ClaimByIdQueryVariables = Exact<{
    claimId: Scalars['String']['input'];
}>;
export type ClaimByIdQuery = {
    __typename?: 'Query';
    claim?: {
        __typename?: 'Claim';
        claimId: string;
        agentDid: string;
        agentAddress: string;
        submissionDate: any;
        paymentsStatus: any;
        schemaType?: string | null;
        collectionId: string;
        evaluationByClaimId?: {
            __typename?: 'Evaluation';
            status: number;
        } | null;
    } | null;
};
export type GetEntitiesQueryVariables = Exact<{
    [key: string]: never;
}>;
export type GetEntitiesQuery = {
    __typename?: 'Query';
    entities?: {
        __typename?: 'EntitiesConnection';
        totalCount: number;
        nodes: Array<{
            __typename?: 'Entity';
            id: string;
            type: string;
            status: number;
            metadata: any;
            owner?: string | null;
            startDate?: any | null;
            endDate?: any | null;
            entityVerified: boolean;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: any | null;
            endCursor?: any | null;
        };
    } | null;
};
export type GetEntityByIdQueryVariables = Exact<{
    id: Scalars['String']['input'];
}>;
export type GetEntityByIdQuery = {
    __typename?: 'Query';
    entity?: {
        __typename?: 'Entity';
        id: string;
        type: string;
        status: number;
        metadata: any;
        owner?: string | null;
        startDate?: any | null;
        endDate?: any | null;
        entityVerified: boolean;
        accounts: any;
        service: any;
        linkedResource: any;
        settings: any;
    } | null;
};
export type GetEntityByTypeQueryVariables = Exact<{
    type: Scalars['String']['input'];
}>;
export type GetEntityByTypeQuery = {
    __typename?: 'Query';
    entities?: {
        __typename?: 'EntitiesConnection';
        nodes: Array<{
            __typename?: 'Entity';
            alsoKnownAs: string;
            accounts: any;
            context: any;
            id: string;
            linkedEntity: any;
            linkedResource: any;
            metadata: any;
            owner?: string | null;
            service: any;
            settings: any;
            type: string;
            status: number;
        }>;
    } | null;
};
export type GetEntitiesByOwnerAddressQueryVariables = Exact<{
    ownerAddress: Scalars['String']['input'];
}>;
export type GetEntitiesByOwnerAddressQuery = {
    __typename?: 'Query';
    entities?: {
        __typename?: 'EntitiesConnection';
        nodes: Array<{
            __typename?: 'Entity';
            alsoKnownAs: string;
            accounts: any;
            context: any;
            id: string;
            linkedEntity: any;
            linkedResource: any;
            metadata: any;
            owner?: string | null;
            service: any;
            settings: any;
            type: string;
            status: number;
        }>;
    } | null;
};
export type GetEntityIdByClaimCollectionIdQueryVariables = Exact<{
    claimCollectionId: Scalars['String']['input'];
}>;
export type GetEntityIdByClaimCollectionIdQuery = {
    __typename?: 'Query';
    claimCollection?: {
        __typename?: 'ClaimCollection';
        entityId: string;
    } | null;
};
export type GetClaimCollectionQueryVariables = Exact<{
    claimCollectionId: Scalars['String']['input'];
}>;
export type GetClaimCollectionQuery = {
    __typename?: 'Query';
    claimCollection?: {
        __typename?: 'ClaimCollection';
        id: string;
        admin: string;
        protocol: string;
        startDate?: any | null;
        endDate?: any | null;
        quota: any;
        count: any;
        evaluated: any;
        approved: any;
        rejected: any;
        disputed: any;
        invalidated: any;
        state: number;
        payments: any;
        entityId: string;
    } | null;
};
export type GetIidVerificationMethodQueryVariables = Exact<{
    did: Scalars['String']['input'];
}>;
export type GetIidVerificationMethodQuery = {
    __typename?: 'Query';
    iids?: {
        __typename?: 'IidsConnection';
        nodes: Array<{
            __typename?: 'Iid';
            id: string;
            verificationMethod: any;
        }>;
    } | null;
};
//# sourceMappingURL=graphql.d.ts.map