aleph-indexer-sdk/dist/index.d.ts

TypeScript SDK for Aleph Indexer GraphQL API

import * as graphql from 'graphql';
import { GraphQLClient, RequestOptions } from 'graphql-request';

type Maybe<T> = T | null;
type InputMaybe<T> = Maybe<T>;
type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]: Maybe<T[SubKey]>;
};
type MakeEmpty<T extends {
    [key: string]: unknown;
}, K extends keyof T> = {
    [_ in K]?: never;
};
type Incremental<T> = T | {
    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
};
type GraphQLClientRequestHeaders = RequestOptions['requestHeaders'];
/** All built-in and custom scalars, mapped to their actual values */
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;
    };
    contract_type: {
        input: any;
        output: any;
    };
    jsonb: {
        input: any;
        output: any;
    };
    numeric: {
        input: any;
        output: any;
    };
    timestamp: {
        input: any;
        output: any;
    };
    timestamptz: {
        input: any;
        output: any;
    };
};
/** columns and relationships of "AlephVaultFactory_Initialized" */
type AlephVaultFactory_Initialized = {
    __typename?: 'AlephVaultFactory_Initialized';
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    id: Scalars['String']['output'];
    version: Scalars['numeric']['output'];
};
/** Boolean expression to filter rows from the table "AlephVaultFactory_Initialized". All fields are combined with a logical 'AND'. */
type AlephVaultFactory_Initialized_Bool_Exp = {
    _and?: InputMaybe<Array<AlephVaultFactory_Initialized_Bool_Exp>>;
    _not?: InputMaybe<AlephVaultFactory_Initialized_Bool_Exp>;
    _or?: InputMaybe<Array<AlephVaultFactory_Initialized_Bool_Exp>>;
    db_write_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
    id?: InputMaybe<String_Comparison_Exp>;
    version?: InputMaybe<Numeric_Comparison_Exp>;
};
/** Ordering options when selecting data from "AlephVaultFactory_Initialized". */
type AlephVaultFactory_Initialized_Order_By = {
    db_write_timestamp?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    version?: InputMaybe<Order_By>;
};
/** select columns of table "AlephVaultFactory_Initialized" */
declare enum AlephVaultFactory_Initialized_Select_Column {
    /** column name */
    DbWriteTimestamp = "db_write_timestamp",
    /** column name */
    Id = "id",
    /** column name */
    Version = "version"
}
/** Streaming cursor of the table "AlephVaultFactory_Initialized" */
type AlephVaultFactory_Initialized_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: AlephVaultFactory_Initialized_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
type AlephVaultFactory_Initialized_Stream_Cursor_Value_Input = {
    db_write_timestamp?: InputMaybe<Scalars['timestamp']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    version?: InputMaybe<Scalars['numeric']['input']>;
};
/** columns and relationships of "AlephVaultFactory_RoleAdminChanged" */
type AlephVaultFactory_RoleAdminChanged = {
    __typename?: 'AlephVaultFactory_RoleAdminChanged';
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    id: Scalars['String']['output'];
    newAdminRole: Scalars['String']['output'];
    previousAdminRole: Scalars['String']['output'];
    role: Scalars['String']['output'];
};
/** Boolean expression to filter rows from the table "AlephVaultFactory_RoleAdminChanged". All fields are combined with a logical 'AND'. */
type AlephVaultFactory_RoleAdminChanged_Bool_Exp = {
    _and?: InputMaybe<Array<AlephVaultFactory_RoleAdminChanged_Bool_Exp>>;
    _not?: InputMaybe<AlephVaultFactory_RoleAdminChanged_Bool_Exp>;
    _or?: InputMaybe<Array<AlephVaultFactory_RoleAdminChanged_Bool_Exp>>;
    db_write_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
    id?: InputMaybe<String_Comparison_Exp>;
    newAdminRole?: InputMaybe<String_Comparison_Exp>;
    previousAdminRole?: InputMaybe<String_Comparison_Exp>;
    role?: InputMaybe<String_Comparison_Exp>;
};
/** Ordering options when selecting data from "AlephVaultFactory_RoleAdminChanged". */
type AlephVaultFactory_RoleAdminChanged_Order_By = {
    db_write_timestamp?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    newAdminRole?: InputMaybe<Order_By>;
    previousAdminRole?: InputMaybe<Order_By>;
    role?: InputMaybe<Order_By>;
};
/** select columns of table "AlephVaultFactory_RoleAdminChanged" */
declare enum AlephVaultFactory_RoleAdminChanged_Select_Column {
    /** column name */
    DbWriteTimestamp = "db_write_timestamp",
    /** column name */
    Id = "id",
    /** column name */
    NewAdminRole = "newAdminRole",
    /** column name */
    PreviousAdminRole = "previousAdminRole",
    /** column name */
    Role = "role"
}
/** Streaming cursor of the table "AlephVaultFactory_RoleAdminChanged" */
type AlephVaultFactory_RoleAdminChanged_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: AlephVaultFactory_RoleAdminChanged_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
type AlephVaultFactory_RoleAdminChanged_Stream_Cursor_Value_Input = {
    db_write_timestamp?: InputMaybe<Scalars['timestamp']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    newAdminRole?: InputMaybe<Scalars['String']['input']>;
    previousAdminRole?: InputMaybe<Scalars['String']['input']>;
    role?: InputMaybe<Scalars['String']['input']>;
};
/** columns and relationships of "AlephVaultFactory_RoleGranted" */
type AlephVaultFactory_RoleGranted = {
    __typename?: 'AlephVaultFactory_RoleGranted';
    account: Scalars['String']['output'];
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    id: Scalars['String']['output'];
    role: Scalars['String']['output'];
    sender: Scalars['String']['output'];
};
/** Boolean expression to filter rows from the table "AlephVaultFactory_RoleGranted". All fields are combined with a logical 'AND'. */
type AlephVaultFactory_RoleGranted_Bool_Exp = {
    _and?: InputMaybe<Array<AlephVaultFactory_RoleGranted_Bool_Exp>>;
    _not?: InputMaybe<AlephVaultFactory_RoleGranted_Bool_Exp>;
    _or?: InputMaybe<Array<AlephVaultFactory_RoleGranted_Bool_Exp>>;
    account?: InputMaybe<String_Comparison_Exp>;
    db_write_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
    id?: InputMaybe<String_Comparison_Exp>;
    role?: InputMaybe<String_Comparison_Exp>;
    sender?: InputMaybe<String_Comparison_Exp>;
};
/** Ordering options when selecting data from "AlephVaultFactory_RoleGranted". */
type AlephVaultFactory_RoleGranted_Order_By = {
    account?: InputMaybe<Order_By>;
    db_write_timestamp?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    role?: InputMaybe<Order_By>;
    sender?: InputMaybe<Order_By>;
};
/** select columns of table "AlephVaultFactory_RoleGranted" */
declare enum AlephVaultFactory_RoleGranted_Select_Column {
    /** column name */
    Account = "account",
    /** column name */
    DbWriteTimestamp = "db_write_timestamp",
    /** column name */
    Id = "id",
    /** column name */
    Role = "role",
    /** column name */
    Sender = "sender"
}
/** Streaming cursor of the table "AlephVaultFactory_RoleGranted" */
type AlephVaultFactory_RoleGranted_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: AlephVaultFactory_RoleGranted_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
type AlephVaultFactory_RoleGranted_Stream_Cursor_Value_Input = {
    account?: InputMaybe<Scalars['String']['input']>;
    db_write_timestamp?: InputMaybe<Scalars['timestamp']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    role?: InputMaybe<Scalars['String']['input']>;
    sender?: InputMaybe<Scalars['String']['input']>;
};
/** columns and relationships of "AlephVaultFactory_RoleRevoked" */
type AlephVaultFactory_RoleRevoked = {
    __typename?: 'AlephVaultFactory_RoleRevoked';
    account: Scalars['String']['output'];
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    id: Scalars['String']['output'];
    role: Scalars['String']['output'];
    sender: Scalars['String']['output'];
};
/** Boolean expression to filter rows from the table "AlephVaultFactory_RoleRevoked". All fields are combined with a logical 'AND'. */
type AlephVaultFactory_RoleRevoked_Bool_Exp = {
    _and?: InputMaybe<Array<AlephVaultFactory_RoleRevoked_Bool_Exp>>;
    _not?: InputMaybe<AlephVaultFactory_RoleRevoked_Bool_Exp>;
    _or?: InputMaybe<Array<AlephVaultFactory_RoleRevoked_Bool_Exp>>;
    account?: InputMaybe<String_Comparison_Exp>;
    db_write_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
    id?: InputMaybe<String_Comparison_Exp>;
    role?: InputMaybe<String_Comparison_Exp>;
    sender?: InputMaybe<String_Comparison_Exp>;
};
/** Ordering options when selecting data from "AlephVaultFactory_RoleRevoked". */
type AlephVaultFactory_RoleRevoked_Order_By = {
    account?: InputMaybe<Order_By>;
    db_write_timestamp?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    role?: InputMaybe<Order_By>;
    sender?: InputMaybe<Order_By>;
};
/** select columns of table "AlephVaultFactory_RoleRevoked" */
declare enum AlephVaultFactory_RoleRevoked_Select_Column {
    /** column name */
    Account = "account",
    /** column name */
    DbWriteTimestamp = "db_write_timestamp",
    /** column name */
    Id = "id",
    /** column name */
    Role = "role",
    /** column name */
    Sender = "sender"
}
/** Streaming cursor of the table "AlephVaultFactory_RoleRevoked" */
type AlephVaultFactory_RoleRevoked_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: AlephVaultFactory_RoleRevoked_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
type AlephVaultFactory_RoleRevoked_Stream_Cursor_Value_Input = {
    account?: InputMaybe<Scalars['String']['input']>;
    db_write_timestamp?: InputMaybe<Scalars['timestamp']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    role?: InputMaybe<Scalars['String']['input']>;
    sender?: InputMaybe<Scalars['String']['input']>;
};
/** columns and relationships of "AlephVaultFactory_VaultDeployed" */
type AlephVaultFactory_VaultDeployed = {
    __typename?: 'AlephVaultFactory_VaultDeployed';
    configId: Scalars['String']['output'];
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    id: Scalars['String']['output'];
    manager: Scalars['String']['output'];
    name: Scalars['String']['output'];
    vault: Scalars['String']['output'];
};
/** Boolean expression to filter rows from the table "AlephVaultFactory_VaultDeployed". All fields are combined with a logical 'AND'. */
type AlephVaultFactory_VaultDeployed_Bool_Exp = {
    _and?: InputMaybe<Array<AlephVaultFactory_VaultDeployed_Bool_Exp>>;
    _not?: InputMaybe<AlephVaultFactory_VaultDeployed_Bool_Exp>;
    _or?: InputMaybe<Array<AlephVaultFactory_VaultDeployed_Bool_Exp>>;
    configId?: InputMaybe<String_Comparison_Exp>;
    db_write_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
    id?: InputMaybe<String_Comparison_Exp>;
    manager?: InputMaybe<String_Comparison_Exp>;
    name?: InputMaybe<String_Comparison_Exp>;
    vault?: InputMaybe<String_Comparison_Exp>;
};
/** Ordering options when selecting data from "AlephVaultFactory_VaultDeployed". */
type AlephVaultFactory_VaultDeployed_Order_By = {
    configId?: InputMaybe<Order_By>;
    db_write_timestamp?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    manager?: InputMaybe<Order_By>;
    name?: InputMaybe<Order_By>;
    vault?: InputMaybe<Order_By>;
};
/** select columns of table "AlephVaultFactory_VaultDeployed" */
declare enum AlephVaultFactory_VaultDeployed_Select_Column {
    /** column name */
    ConfigId = "configId",
    /** column name */
    DbWriteTimestamp = "db_write_timestamp",
    /** column name */
    Id = "id",
    /** column name */
    Manager = "manager",
    /** column name */
    Name = "name",
    /** column name */
    Vault = "vault"
}
/** Streaming cursor of the table "AlephVaultFactory_VaultDeployed" */
type AlephVaultFactory_VaultDeployed_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: AlephVaultFactory_VaultDeployed_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
type AlephVaultFactory_VaultDeployed_Stream_Cursor_Value_Input = {
    configId?: InputMaybe<Scalars['String']['input']>;
    db_write_timestamp?: InputMaybe<Scalars['timestamp']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    manager?: InputMaybe<Scalars['String']['input']>;
    name?: InputMaybe<Scalars['String']['input']>;
    vault?: InputMaybe<Scalars['String']['input']>;
};
/** columns and relationships of "AlephVault_DepositRequest" */
type AlephVault_DepositRequest = {
    __typename?: 'AlephVault_DepositRequest';
    amount: Scalars['String']['output'];
    batchId: Scalars['numeric']['output'];
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    id: Scalars['String']['output'];
    txHash: Scalars['String']['output'];
    userWalletAddress: Scalars['String']['output'];
    vaultId: Scalars['String']['output'];
};
/** columns and relationships of "AlephVault_DepositRequestSettled" */
type AlephVault_DepositRequestSettled = {
    __typename?: 'AlephVault_DepositRequestSettled';
    amount: Scalars['String']['output'];
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    id: Scalars['String']['output'];
    sharesToMint: Scalars['String']['output'];
    user: Scalars['String']['output'];
    vaultId: Scalars['String']['output'];
};
/** Boolean expression to filter rows from the table "AlephVault_DepositRequestSettled". All fields are combined with a logical 'AND'. */
type AlephVault_DepositRequestSettled_Bool_Exp = {
    _and?: InputMaybe<Array<AlephVault_DepositRequestSettled_Bool_Exp>>;
    _not?: InputMaybe<AlephVault_DepositRequestSettled_Bool_Exp>;
    _or?: InputMaybe<Array<AlephVault_DepositRequestSettled_Bool_Exp>>;
    amount?: InputMaybe<String_Comparison_Exp>;
    db_write_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
    id?: InputMaybe<String_Comparison_Exp>;
    sharesToMint?: InputMaybe<String_Comparison_Exp>;
    user?: InputMaybe<String_Comparison_Exp>;
    vaultId?: InputMaybe<String_Comparison_Exp>;
};
/** Ordering options when selecting data from "AlephVault_DepositRequestSettled". */
type AlephVault_DepositRequestSettled_Order_By = {
    amount?: InputMaybe<Order_By>;
    db_write_timestamp?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    sharesToMint?: InputMaybe<Order_By>;
    user?: InputMaybe<Order_By>;
    vaultId?: InputMaybe<Order_By>;
};
/** select columns of table "AlephVault_DepositRequestSettled" */
declare enum AlephVault_DepositRequestSettled_Select_Column {
    /** column name */
    Amount = "amount",
    /** column name */
    DbWriteTimestamp = "db_write_timestamp",
    /** column name */
    Id = "id",
    /** column name */
    SharesToMint = "sharesToMint",
    /** column name */
    User = "user",
    /** column name */
    VaultId = "vaultId"
}
/** Streaming cursor of the table "AlephVault_DepositRequestSettled" */
type AlephVault_DepositRequestSettled_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: AlephVault_DepositRequestSettled_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
type AlephVault_DepositRequestSettled_Stream_Cursor_Value_Input = {
    amount?: InputMaybe<Scalars['String']['input']>;
    db_write_timestamp?: InputMaybe<Scalars['timestamp']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    sharesToMint?: InputMaybe<Scalars['String']['input']>;
    user?: InputMaybe<Scalars['String']['input']>;
    vaultId?: InputMaybe<Scalars['String']['input']>;
};
/** Boolean expression to filter rows from the table "AlephVault_DepositRequest". All fields are combined with a logical 'AND'. */
type AlephVault_DepositRequest_Bool_Exp = {
    _and?: InputMaybe<Array<AlephVault_DepositRequest_Bool_Exp>>;
    _not?: InputMaybe<AlephVault_DepositRequest_Bool_Exp>;
    _or?: InputMaybe<Array<AlephVault_DepositRequest_Bool_Exp>>;
    amount?: InputMaybe<String_Comparison_Exp>;
    batchId?: InputMaybe<Numeric_Comparison_Exp>;
    db_write_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
    id?: InputMaybe<String_Comparison_Exp>;
    txHash?: InputMaybe<String_Comparison_Exp>;
    userWalletAddress?: InputMaybe<String_Comparison_Exp>;
    vaultId?: InputMaybe<String_Comparison_Exp>;
};
/** Ordering options when selecting data from "AlephVault_DepositRequest". */
type AlephVault_DepositRequest_Order_By = {
    amount?: InputMaybe<Order_By>;
    batchId?: InputMaybe<Order_By>;
    db_write_timestamp?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    txHash?: InputMaybe<Order_By>;
    userWalletAddress?: InputMaybe<Order_By>;
    vaultId?: InputMaybe<Order_By>;
};
/** select columns of table "AlephVault_DepositRequest" */
declare enum AlephVault_DepositRequest_Select_Column {
    /** column name */
    Amount = "amount",
    /** column name */
    BatchId = "batchId",
    /** column name */
    DbWriteTimestamp = "db_write_timestamp",
    /** column name */
    Id = "id",
    /** column name */
    TxHash = "txHash",
    /** column name */
    UserWalletAddress = "userWalletAddress",
    /** column name */
    VaultId = "vaultId"
}
/** Streaming cursor of the table "AlephVault_DepositRequest" */
type AlephVault_DepositRequest_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: AlephVault_DepositRequest_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
type AlephVault_DepositRequest_Stream_Cursor_Value_Input = {
    amount?: InputMaybe<Scalars['String']['input']>;
    batchId?: InputMaybe<Scalars['numeric']['input']>;
    db_write_timestamp?: InputMaybe<Scalars['timestamp']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    txHash?: InputMaybe<Scalars['String']['input']>;
    userWalletAddress?: InputMaybe<Scalars['String']['input']>;
    vaultId?: InputMaybe<Scalars['String']['input']>;
};
/** columns and relationships of "AlephVault_FeesAccumulated" */
type AlephVault_FeesAccumulated = {
    __typename?: 'AlephVault_FeesAccumulated';
    currentBatchId: Scalars['numeric']['output'];
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    id: Scalars['String']['output'];
    lastFeePaidId: Scalars['numeric']['output'];
    managementFee: Scalars['String']['output'];
    performanceFee: Scalars['String']['output'];
};
/** Boolean expression to filter rows from the table "AlephVault_FeesAccumulated". All fields are combined with a logical 'AND'. */
type AlephVault_FeesAccumulated_Bool_Exp = {
    _and?: InputMaybe<Array<AlephVault_FeesAccumulated_Bool_Exp>>;
    _not?: InputMaybe<AlephVault_FeesAccumulated_Bool_Exp>;
    _or?: InputMaybe<Array<AlephVault_FeesAccumulated_Bool_Exp>>;
    currentBatchId?: InputMaybe<Numeric_Comparison_Exp>;
    db_write_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
    id?: InputMaybe<String_Comparison_Exp>;
    lastFeePaidId?: InputMaybe<Numeric_Comparison_Exp>;
    managementFee?: InputMaybe<String_Comparison_Exp>;
    performanceFee?: InputMaybe<String_Comparison_Exp>;
};
/** Ordering options when selecting data from "AlephVault_FeesAccumulated". */
type AlephVault_FeesAccumulated_Order_By = {
    currentBatchId?: InputMaybe<Order_By>;
    db_write_timestamp?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    lastFeePaidId?: InputMaybe<Order_By>;
    managementFee?: InputMaybe<Order_By>;
    performanceFee?: InputMaybe<Order_By>;
};
/** select columns of table "AlephVault_FeesAccumulated" */
declare enum AlephVault_FeesAccumulated_Select_Column {
    /** column name */
    CurrentBatchId = "currentBatchId",
    /** column name */
    DbWriteTimestamp = "db_write_timestamp",
    /** column name */
    Id = "id",
    /** column name */
    LastFeePaidId = "lastFeePaidId",
    /** column name */
    ManagementFee = "managementFee",
    /** column name */
    PerformanceFee = "performanceFee"
}
/** Streaming cursor of the table "AlephVault_FeesAccumulated" */
type AlephVault_FeesAccumulated_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: AlephVault_FeesAccumulated_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
type AlephVault_FeesAccumulated_Stream_Cursor_Value_Input = {
    currentBatchId?: InputMaybe<Scalars['numeric']['input']>;
    db_write_timestamp?: InputMaybe<Scalars['timestamp']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    lastFeePaidId?: InputMaybe<Scalars['numeric']['input']>;
    managementFee?: InputMaybe<Scalars['String']['input']>;
    performanceFee?: InputMaybe<Scalars['String']['input']>;
};
/** columns and relationships of "AlephVault_FeesCollected" */
type AlephVault_FeesCollected = {
    __typename?: 'AlephVault_FeesCollected';
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    id: Scalars['String']['output'];
    managementFeesCollected: Scalars['String']['output'];
    performanceFeesCollected: Scalars['String']['output'];
};
/** Boolean expression to filter rows from the table "AlephVault_FeesCollected". All fields are combined with a logical 'AND'. */
type AlephVault_FeesCollected_Bool_Exp = {
    _and?: InputMaybe<Array<AlephVault_FeesCollected_Bool_Exp>>;
    _not?: InputMaybe<AlephVault_FeesCollected_Bool_Exp>;
    _or?: InputMaybe<Array<AlephVault_FeesCollected_Bool_Exp>>;
    db_write_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
    id?: InputMaybe<String_Comparison_Exp>;
    managementFeesCollected?: InputMaybe<String_Comparison_Exp>;
    performanceFeesCollected?: InputMaybe<String_Comparison_Exp>;
};
/** Ordering options when selecting data from "AlephVault_FeesCollected". */
type AlephVault_FeesCollected_Order_By = {
    db_write_timestamp?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    managementFeesCollected?: InputMaybe<Order_By>;
    performanceFeesCollected?: InputMaybe<Order_By>;
};
/** select columns of table "AlephVault_FeesCollected" */
declare enum AlephVault_FeesCollected_Select_Column {
    /** column name */
    DbWriteTimestamp = "db_write_timestamp",
    /** column name */
    Id = "id",
    /** column name */
    ManagementFeesCollected = "managementFeesCollected",
    /** column name */
    PerformanceFeesCollected = "performanceFeesCollected"
}
/** Streaming cursor of the table "AlephVault_FeesCollected" */
type AlephVault_FeesCollected_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: AlephVault_FeesCollected_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
type AlephVault_FeesCollected_Stream_Cursor_Value_Input = {
    db_write_timestamp?: InputMaybe<Scalars['timestamp']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    managementFeesCollected?: InputMaybe<Scalars['String']['input']>;
    performanceFeesCollected?: InputMaybe<Scalars['String']['input']>;
};
/** columns and relationships of "AlephVault_FlowPaused" */
type AlephVault_FlowPaused = {
    __typename?: 'AlephVault_FlowPaused';
    _pausableFlow: Scalars['String']['output'];
    _pauser: Scalars['String']['output'];
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    id: Scalars['String']['output'];
};
/** Boolean expression to filter rows from the table "AlephVault_FlowPaused". All fields are combined with a logical 'AND'. */
type AlephVault_FlowPaused_Bool_Exp = {
    _and?: InputMaybe<Array<AlephVault_FlowPaused_Bool_Exp>>;
    _not?: InputMaybe<AlephVault_FlowPaused_Bool_Exp>;
    _or?: InputMaybe<Array<AlephVault_FlowPaused_Bool_Exp>>;
    _pausableFlow?: InputMaybe<String_Comparison_Exp>;
    _pauser?: InputMaybe<String_Comparison_Exp>;
    db_write_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
    id?: InputMaybe<String_Comparison_Exp>;
};
/** Ordering options when selecting data from "AlephVault_FlowPaused". */
type AlephVault_FlowPaused_Order_By = {
    _pausableFlow?: InputMaybe<Order_By>;
    _pauser?: InputMaybe<Order_By>;
    db_write_timestamp?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
};
/** select columns of table "AlephVault_FlowPaused" */
declare enum AlephVault_FlowPaused_Select_Column {
    /** column name */
    PausableFlow = "_pausableFlow",
    /** column name */
    Pauser = "_pauser",
    /** column name */
    DbWriteTimestamp = "db_write_timestamp",
    /** column name */
    Id = "id"
}
/** Streaming cursor of the table "AlephVault_FlowPaused" */
type AlephVault_FlowPaused_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: AlephVault_FlowPaused_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
type AlephVault_FlowPaused_Stream_Cursor_Value_Input = {
    _pausableFlow?: InputMaybe<Scalars['String']['input']>;
    _pauser?: InputMaybe<Scalars['String']['input']>;
    db_write_timestamp?: InputMaybe<Scalars['timestamp']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
};
/** columns and relationships of "AlephVault_FlowUnpaused" */
type AlephVault_FlowUnpaused = {
    __typename?: 'AlephVault_FlowUnpaused';
    _pausableFlowFlag: Scalars['String']['output'];
    _unpauser: Scalars['String']['output'];
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    id: Scalars['String']['output'];
};
/** Boolean expression to filter rows from the table "AlephVault_FlowUnpaused". All fields are combined with a logical 'AND'. */
type AlephVault_FlowUnpaused_Bool_Exp = {
    _and?: InputMaybe<Array<AlephVault_FlowUnpaused_Bool_Exp>>;
    _not?: InputMaybe<AlephVault_FlowUnpaused_Bool_Exp>;
    _or?: InputMaybe<Array<AlephVault_FlowUnpaused_Bool_Exp>>;
    _pausableFlowFlag?: InputMaybe<String_Comparison_Exp>;
    _unpauser?: InputMaybe<String_Comparison_Exp>;
    db_write_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
    id?: InputMaybe<String_Comparison_Exp>;
};
/** Ordering options when selecting data from "AlephVault_FlowUnpaused". */
type AlephVault_FlowUnpaused_Order_By = {
    _pausableFlowFlag?: InputMaybe<Order_By>;
    _unpauser?: InputMaybe<Order_By>;
    db_write_timestamp?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
};
/** select columns of table "AlephVault_FlowUnpaused" */
declare enum AlephVault_FlowUnpaused_Select_Column {
    /** column name */
    PausableFlowFlag = "_pausableFlowFlag",
    /** column name */
    Unpauser = "_unpauser",
    /** column name */
    DbWriteTimestamp = "db_write_timestamp",
    /** column name */
    Id = "id"
}
/** Streaming cursor of the table "AlephVault_FlowUnpaused" */
type AlephVault_FlowUnpaused_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: AlephVault_FlowUnpaused_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
type AlephVault_FlowUnpaused_Stream_Cursor_Value_Input = {
    _pausableFlowFlag?: InputMaybe<Scalars['String']['input']>;
    _unpauser?: InputMaybe<Scalars['String']['input']>;
    db_write_timestamp?: InputMaybe<Scalars['timestamp']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
};
/** columns and relationships of "AlephVault_Initialized" */
type AlephVault_Initialized = {
    __typename?: 'AlephVault_Initialized';
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    id: Scalars['String']['output'];
    version: Scalars['numeric']['output'];
};
/** Boolean expression to filter rows from the table "AlephVault_Initialized". All fields are combined with a logical 'AND'. */
type AlephVault_Initialized_Bool_Exp = {
    _and?: InputMaybe<Array<AlephVault_Initialized_Bool_Exp>>;
    _not?: InputMaybe<AlephVault_Initialized_Bool_Exp>;
    _or?: InputMaybe<Array<AlephVault_Initialized_Bool_Exp>>;
    db_write_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
    id?: InputMaybe<String_Comparison_Exp>;
    version?: InputMaybe<Numeric_Comparison_Exp>;
};
/** Ordering options when selecting data from "AlephVault_Initialized". */
type AlephVault_Initialized_Order_By = {
    db_write_timestamp?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    version?: InputMaybe<Order_By>;
};
/** select columns of table "AlephVault_Initialized" */
declare enum AlephVault_Initialized_Select_Column {
    /** column name */
    DbWriteTimestamp = "db_write_timestamp",
    /** column name */
    Id = "id",
    /** column name */
    Version = "version"
}
/** Streaming cursor of the table "AlephVault_Initialized" */
type AlephVault_Initialized_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: AlephVault_Initialized_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
type AlephVault_Initialized_Stream_Cursor_Value_Input = {
    db_write_timestamp?: InputMaybe<Scalars['timestamp']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    version?: InputMaybe<Scalars['numeric']['input']>;
};
/** columns and relationships of "AlephVault_MetadataUriSet" */
type AlephVault_MetadataUriSet = {
    __typename?: 'AlephVault_MetadataUriSet';
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    id: Scalars['String']['output'];
    metadataUri: Scalars['String']['output'];
};
/** Boolean expression to filter rows from the table "AlephVault_MetadataUriSet". All fields are combined with a logical 'AND'. */
type AlephVault_MetadataUriSet_Bool_Exp = {
    _and?: InputMaybe<Array<AlephVault_MetadataUriSet_Bool_Exp>>;
    _not?: InputMaybe<AlephVault_MetadataUriSet_Bool_Exp>;
    _or?: InputMaybe<Array<AlephVault_MetadataUriSet_Bool_Exp>>;
    db_write_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
    id?: InputMaybe<String_Comparison_Exp>;
    metadataUri?: InputMaybe<String_Comparison_Exp>;
};
/** Ordering options when selecting data from "AlephVault_MetadataUriSet". */
type AlephVault_MetadataUriSet_Order_By = {
    db_write_timestamp?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    metadataUri?: InputMaybe<Order_By>;
};
/** select columns of table "AlephVault_MetadataUriSet" */
declare enum AlephVault_MetadataUriSet_Select_Column {
    /** column name */
    DbWriteTimestamp = "db_write_timestamp",
    /** column name */
    Id = "id",
    /** column name */
    MetadataUri = "metadataUri"
}
/** Streaming cursor of the table "AlephVault_MetadataUriSet" */
type AlephVault_MetadataUriSet_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: AlephVault_MetadataUriSet_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
type AlephVault_MetadataUriSet_Stream_Cursor_Value_Input = {
    db_write_timestamp?: InputMaybe<Scalars['timestamp']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    metadataUri?: InputMaybe<Scalars['String']['input']>;
};
/** columns and relationships of "AlephVault_NewFeeRecipientQueued" */
type AlephVault_NewFeeRecipientQueued = {
    __typename?: 'AlephVault_NewFeeRecipientQueued';
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    feeRecipient: Scalars['String']['output'];
    id: Scalars['String']['output'];
};
/** Boolean expression to filter rows from the table "AlephVault_NewFeeRecipientQueued". All fields are combined with a logical 'AND'. */
type AlephVault_NewFeeRecipientQueued_Bool_Exp = {
    _and?: InputMaybe<Array<AlephVault_NewFeeRecipientQueued_Bool_Exp>>;
    _not?: InputMaybe<AlephVault_NewFeeRecipientQueued_Bool_Exp>;
    _or?: InputMaybe<Array<AlephVault_NewFeeRecipientQueued_Bool_Exp>>;
    db_write_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
    feeRecipient?: InputMaybe<String_Comparison_Exp>;
    id?: InputMaybe<String_Comparison_Exp>;
};
/** Ordering options when selecting data from "AlephVault_NewFeeRecipientQueued". */
type AlephVault_NewFeeRecipientQueued_Order_By = {
    db_write_timestamp?: InputMaybe<Order_By>;
    feeRecipient?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
};
/** select columns of table "AlephVault_NewFeeRecipientQueued" */
declare enum AlephVault_NewFeeRecipientQueued_Select_Column {
    /** column name */
    DbWriteTimestamp = "db_write_timestamp",
    /** column name */
    FeeRecipient = "feeRecipient",
    /** column name */
    Id = "id"
}
/** Streaming cursor of the table "AlephVault_NewFeeRecipientQueued" */
type AlephVault_NewFeeRecipientQueued_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: AlephVault_NewFeeRecipientQueued_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
type AlephVault_NewFeeRecipientQueued_Stream_Cursor_Value_Input = {
    db_write_timestamp?: InputMaybe<Scalars['timestamp']['input']>;
    feeRecipient?: InputMaybe<Scalars['String']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
};
/** columns and relationships of "AlephVault_NewFeeRecipientSet" */
type AlephVault_NewFeeRecipientSet = {
    __typename?: 'AlephVault_NewFeeRecipientSet';
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    feeRecipient: Scalars['String']['output'];
    id: Scalars['String']['output'];
};
/** Boolean expression to filter rows from the table "AlephVault_NewFeeRecipientSet". All fields are combined with a logical 'AND'. */
type AlephVault_NewFeeRecipientSet_Bool_Exp = {
    _and?: InputMaybe<Array<AlephVault_NewFeeRecipientSet_Bool_Exp>>;
    _not?: InputMaybe<AlephVault_NewFeeRecipientSet_Bool_Exp>;
    _or?: InputMaybe<Array<AlephVault_NewFeeRecipientSet_Bool_Exp>>;
    db_write_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
    feeRecipient?: InputMaybe<String_Comparison_Exp>;
    id?: InputMaybe<String_Comparison_Exp>;
};
/** Ordering options when selecting data from "AlephVault_NewFeeRecipientSet". */
type AlephVault_NewFeeRecipientSet_Order_By = {
    db_write_timestamp?: InputMaybe<Order_By>;
    feeRecipient?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
};
/** select columns of table "AlephVault_NewFeeRecipientSet" */
declare enum AlephVault_NewFeeRecipientSet_Select_Column {
    /** column name */
    DbWriteTimestamp = "db_write_timestamp",
    /** column name */
    FeeRecipient = "feeRecipient",
    /** column name */
    Id = "id"
}
/** Streaming cursor of the table "AlephVault_NewFeeRecipientSet" */
type AlephVault_NewFeeRecipientSet_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: AlephVault_NewFeeRecipientSet_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
type AlephVault_NewFeeRecipientSet_Stream_Cursor_Value_Input = {
    db_write_timestamp?: InputMaybe<Scalars['timestamp']['input']>;
    feeRecipient?: InputMaybe<Scalars['String']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
};
/** columns and relationships of "AlephVault_NewHighWaterMarkSet" */
type AlephVault_NewHighWaterMarkSet = {
    __typename?: 'AlephVault_NewHighWaterMarkSet';
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    highWaterMark: Scalars['numeric']['output'];
    id: Scalars['String']['output'];
};
/** Boolean expression to filter rows from the table "AlephVault_NewHighWaterMarkSet". All fields are combined with a logical 'AND'. */
type AlephVault_NewHighWaterMarkSet_Bool_Exp = {
    _and?: InputMaybe<Array<AlephVault_NewHighWaterMarkSet_Bool_Exp>>;
    _not?: InputMaybe<AlephVault_NewHighWaterMarkSet_Bool_Exp>;
    _or?: InputMaybe<Array<AlephVault_NewHighWaterMarkSet_Bool_Exp>>;
    db_write_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
    highWaterMark?: InputMaybe<Numeric_Comparison_Exp>;
    id?: InputMaybe<String_Comparison_Exp>;
};
/** Ordering options when selecting data from "AlephVault_NewHighWaterMarkSet". */
type AlephVault_NewHighWaterMarkSet_Order_By = {
    db_write_timestamp?: InputMaybe<Order_By>;
    highWaterMark?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
};
/** select columns of table "AlephVault_NewHighWaterMarkSet" */
declare enum AlephVault_NewHighWaterMarkSet_Select_Column {
    /** column name */
    DbWriteTimestamp = "db_write_timestamp",
    /** column name */
    HighWaterMark = "highWaterMark",
    /** column name */
    Id = "id"
}
/** Streaming cursor of the table "AlephVault_NewHighWaterMarkSet" */
type AlephVault_NewHighWaterMarkSet_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: AlephVault_NewHighWaterMarkSet_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
type AlephVault_NewHighWaterMarkSet_Stream_Cursor_Value_Input = {
    db_write_timestamp?: InputMaybe<Scalars['timestamp']['input']>;
    highWaterMark?: InputMaybe<Scalars['numeric']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
};
/** columns and relationships of "AlephVault_NewManagementFeeQueued" */
type AlephVault_NewManagementFeeQueued = {
    __typename?: 'AlephVault_NewManagementFeeQueued';
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    id: Scalars['String']['output'];
    managementFee: Scalars['numeric']['output'];
};
/** Boolean expression to filter rows from the table "AlephVault_NewManagementFeeQueued". All fields are combined with a logical 'AND'. */
type AlephVault_NewManagementFeeQueued_Bool_Exp = {
    _and?: InputMaybe<Array<AlephVault_NewManagementFeeQueued_Bool_Exp>>;
    _not?: InputMaybe<AlephVault_NewManagementFeeQueued_Bool_Exp>;
    _or?: InputMaybe<Array<AlephVault_NewManagementFeeQueued_Bool_Exp>>;
    db_write_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
    id?: InputMaybe<String_Comparison_Exp>;
    managementFee?: InputMaybe<Numeric_Comparison_Exp>;
};
/** Ordering options when selecting data from "AlephVault_NewManagementFeeQueued". */
type AlephVault_NewManagementFeeQueued_Order_By = {
    db_write_timestamp?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    managementFee?: InputMaybe<Order_By>;
};
/** select columns of table "AlephVault_NewManagementFeeQueued" */
declare enum AlephVault_NewManagementFeeQueued_Select_Column {
    /** column name */
    DbWriteTimestamp = "db_write_timestamp",
    /** column name */
    Id = "id",
    /** column name */
    ManagementFee = "managementFee"
}
/** Streaming cursor of the table "AlephVault_NewManagementFeeQueued" */
type AlephVault_NewManagementFeeQueued_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: AlephVault_NewManagementFeeQueued_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
type AlephVault_NewManagementFeeQueued_Stream_Cursor_Value_Input = {
    db_write_timestamp?: InputMaybe<Scalars['timestamp']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    managementFee?: InputMaybe<Scalars['numeric']['input']>;
};
/** columns and relationships of "AlephVault_NewManagementFeeSet" */
type AlephVault_NewManagementFeeSet = {
    __typename?: 'AlephVault_NewManagementFeeSet';
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    id: Scalars['String']['output'];
    managementFee: Scalars['numeric']['output'];
};
/** Boolean expression to filter rows from the table "AlephVault_NewManagementFeeSet". All fields are combined with a logical 'AND'. */
type AlephVault_NewManagementFeeSet_Bool_Exp = {
    _and?: InputMaybe<Array<AlephVault_NewManagementFeeSet_Bool_Exp>>;
    _not?: InputMaybe<AlephVault_NewManagementFeeSet_Bool_Exp>;
    _or?: InputMaybe<Array<AlephVault_NewManagementFeeSet_Bool_Exp>>;
    db_write_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
    id?: InputMaybe<String_Comparison_Exp>;
    managementFee?: InputMaybe<Numeric_Comparison_Exp>;
};
/** Ordering options when selecting data from "AlephVault_NewManagementFeeSet". */
type AlephVault_NewManagementFeeSet_Order_By = {
    db_write_timestamp?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    managementFee?: InputMaybe<Order_By>;
};
/** select columns of table "AlephVault_NewManagementFeeSet" */
declare enum AlephVault_NewManagementFeeSet_Select_Column {
    /** column name */
    DbWriteTimestamp = "db_write_timestamp",
    /** column name */
    Id = "id",
    /** column name */
    ManagementFee = "managementFee"
}
/** Streaming cursor of the table "AlephVault_NewManagementFeeSet" */
type AlephVault_NewManagementFeeSet_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: AlephVault_NewManagementFeeSet_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
type AlephVault_NewManagementFeeSet_Stream_Cursor_Value_Input = {
    db_write_timestamp?: InputMaybe<Scalars['timestamp']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    managementFee?: InputMaybe<Scalars['numeric']['input']>;
};
/** columns and relationships of "AlephVault_NewMaxDepositCapQueued" */
type AlephVault_NewMaxDepositCapQueued = {
    __typename?: 'AlephVault_NewMaxDepositCapQueued';
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    id: Scalars['String']['output'];
    maxDepositCap: Scalars['String']['output'];
};
/** Boolean expression to filter rows from the table "AlephVault_NewMaxDepositCapQueued". All fields are combined with a logical 'AND'. */
type AlephVault_NewMaxDepositCapQueued_Bool_Exp = {
    _and?: InputMaybe<Array<AlephVault_NewMaxDepositCapQueued_Bool_Exp>>;
    _not?: InputMaybe<AlephVault_NewMaxDepositCapQueued_Bool_Exp>;
    _or?: InputMaybe<Array<AlephVault_NewMaxDepositCapQueued_Bool_Exp>>;
    db_write_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
    id?: InputMaybe<String_Comparison_Exp>;
    maxDepositCap?: InputMaybe<String_Comparison_Exp>;
};
/** Ordering options when selecting data from "AlephVault_NewMaxDepositCapQueued". */
type AlephVault_NewMaxDepositCapQueued_Order_By = {
    db_write_timestamp?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    maxDepositCap?: InputMaybe<Order_By>;
};
/** select columns of table "AlephVault_NewMaxDepositCapQueued" */
declare enum AlephVault_NewMaxDepositCapQueued_Select_Column {
    /** column name */
    DbWriteTimestamp = "db_write_timestamp",
    /** column name */
    Id = "id",
    /** column name */
    MaxDepositCap = "maxDepositCap"
}
/** Streaming cursor of the table "AlephVault_NewMaxDepositCapQueued" */
type AlephVault_NewMaxDepositCapQueued_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: AlephVault_NewMaxDepositCapQueued_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
type AlephVault_NewMaxDepositCapQueued_Stream_Cursor_Value_Input = {
    db_write_timestamp?: InputMaybe<Scalars['timestamp']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    maxDepositCap?: InputMaybe<Scalars['String']['input']>;
};
/** columns and relationships of "AlephVault_NewMaxDepositCapSet" */
type AlephVault_NewMaxDepositCapSet = {
    __typename?: 'AlephVault_NewMaxDepositCapSet';
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    id: Scalars['String']['output'];
    maxDepositCap: Scalars['String']['output'];
};
/** Boolean expression to filter rows from the table "AlephVault_NewMaxDepositCapSet". All fields are combined with a logical 'AND'. */
type AlephVault_NewMaxDepositCapSet_Bool_Exp = {
    _and?: InputMaybe<Array<AlephVault_NewMaxDepositCapSet_Bool_Exp>>;
    _not?: InputMaybe<AlephVault_NewMaxDepositCapSet_Bool_Exp>;
    _or?: InputMaybe<Array<AlephVault_NewMaxDepositCapSet_Bool_Exp>>;
    db_write_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
    id?: InputMaybe<String_Comparison_Exp>;
    maxDepositCap?: InputMaybe<String_Comparison_Exp>;
};
/** Ordering options when selecting data from "AlephVault_NewMaxDepositCapSet". */
type AlephVault_NewMaxDepositCapSet_Order_By = {
    db_write_timestamp?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    maxDepositCap?: InputMaybe<Order_By>;
};
/** select columns of table "AlephVault_NewMaxDepositCapSet" */
declare enum AlephVault_NewMaxDepositCapSet_Select_Column {
    /** column name */
    DbWriteTimestamp = "db_write_timestamp",
    /** column name */
    Id = "id",
    /** column name */
    MaxDepositCap = "maxDepositCap"
}
/** Streaming cursor of the table "AlephVault_NewMaxDepositCapSet" */
type AlephVault_NewMaxDepositCapSet_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: AlephVault_NewMaxDepositCapSet_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
type AlephVault_NewMaxDepositCapSet_Stream_Cursor_Value_Input = {
    db_write_timestamp?: InputMaybe<Scalars['timestamp']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    maxDepositCap?: InputMaybe<Scalars['String']['input']>;
};
/** columns and relationships of "AlephVault_NewMinDepositAmountQueued" */
type AlephVault_NewMinDepositAmountQueued = {
    __typename?: 'AlephVault_NewMinDepositAmountQueued';
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    id: Scalars['String']['output'];
    minDepositAmount: Scalars['String']['output'];
};
/** Boolean expression to filter rows from the table "AlephVault_NewMinDepositAmountQueued". All fields are combined with a logical 'AND'. */
type AlephVault_NewMinDepositAmountQueued_Bool_Exp = {
    _and?: InputMaybe<Array<AlephVault_NewMinDepositAmountQueued_Bool_Exp>>;
    _not?: InputMaybe<AlephVault_NewMinDepositAmountQueued_Bool_Exp>;
    _or?: InputMaybe<Array<AlephVault_NewMinDepositAmountQueued_Bool_Exp>>;
    db_write_timestamp?: InputMaybe<Timestamp_Comparison_Exp>;
    id?: InputMaybe<String_Comparison_Exp>;
    minDepositAmount?: InputMaybe<String_Comparison_Exp>;
};
/** Ordering options when selecting data from "AlephVault_NewMinDepositAmountQueued". */
type AlephVault_NewMinDepositAmountQueued_Order_By = {
    db_write_timestamp?: InputMaybe<Order_By>;
    id?: InputMaybe<Order_By>;
    minDepositAmount?: InputMaybe<Order_By>;
};
/** select columns of table "AlephVault_NewMinDepositAmountQueued" */
declare enum AlephVault_NewMinDepositAmountQueued_Select_Column {
    /** column name */
    DbWriteTimestamp = "db_write_timestamp",
    /** column name */
    Id = "id",
    /** column name */
    MinDepositAmount = "minDepositAmount"
}
/** Streaming cursor of the table "AlephVault_NewMinDepositAmountQueued" */
type AlephVault_NewMinDepositAmountQueued_Stream_Cursor_Input = {
    /** Stream column input with initial value */
    initial_value: AlephVault_NewMinDepositAmountQueued_Stream_Cursor_Value_Input;
    /** cursor ordering */
    ordering?: InputMaybe<Cursor_Ordering>;
};
/** Initial value of the column from where the streaming should start */
type AlephVault_NewMinDepositAmountQueued_Stream_Cursor_Value_Input = {
    db_write_timestamp?: InputMaybe<Scalars['timestamp']['input']>;
    id?: InputMaybe<Scalars['String']['input']>;
    minDepositAmount?: InputMaybe<Scalars['String']['input']>;
};
/** columns and relationships of "AlephVault_NewMinDepositAmountSet" */
type AlephVault_NewMinDepositAmountSet = {
    __typename?: 'AlephVault_NewMinDepositAmountSet';
    db_write_timestamp?: Maybe<Scalars['timestamp']['output']>;
    id: Scalars['String']['output'];
    minDepositAmount: Scalars['String']['output'];
};
/** Boolean expression to filter rows from the table "AlephVault_NewMinDepositAmountSet". All fields are combined with a logical 'AND'. */
type AlephVault_NewMinDepositAmountSe