import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
export declare type Maybe<T> = T | null;
export declare type RequireFields<T, K extends keyof T> = {
    [X in Exclude<keyof T, K>]?: T[X];
} & {
    [P in K]-?: NonNullable<T[P]>;
};
export declare type Scalars = {
    ID: string;
    String: string;
    Boolean: boolean;
    Int: number;
    Float: number;
    DateTime: any;
    BigInt: any;
    Hash32HexString: any;
    Lovelaces: any;
    Percentage: any;
};
export declare type BigInt_Comparison_Exp = {
    _eq?: Maybe<Scalars['BigInt']>;
    _gt?: Maybe<Scalars['BigInt']>;
    _gte?: Maybe<Scalars['BigInt']>;
    _in?: Maybe<Array<Scalars['BigInt']>>;
    _is_null?: Maybe<Scalars['Boolean']>;
    _lt?: Maybe<Scalars['BigInt']>;
    _lte?: Maybe<Scalars['BigInt']>;
    _neq?: Maybe<Scalars['BigInt']>;
    _nin?: Maybe<Array<Scalars['BigInt']>>;
};
export declare type Block = {
    __typename?: 'Block';
    createdAt: Scalars['DateTime'];
    createdBy: Scalars['String'];
    epoch?: Maybe<Epoch>;
    epochNo?: Maybe<Scalars['Int']>;
    fees: Scalars['BigInt'];
    hash: Scalars['Hash32HexString'];
    merkelRoot?: Maybe<Scalars['Hash32HexString']>;
    number?: Maybe<Scalars['Int']>;
    slotNo?: Maybe<Scalars['Int']>;
    slotWithinEpoch?: Maybe<Scalars['Int']>;
    previousBlock?: Maybe<Block>;
    nextBlock?: Maybe<Block>;
    size: Scalars['BigInt'];
    transactions: Array<Maybe<Transaction>>;
    transactions_aggregate: Transaction_Aggregate;
    transactionsCount: Scalars['String'];
};
export declare type BlockTransactionsArgs = {
    limit?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<Transaction_Order_By>>;
    offset?: Maybe<Scalars['Int']>;
    where?: Maybe<Transaction_Bool_Exp>;
};
export declare type BlockTransactions_AggregateArgs = {
    limit?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<Transaction_Order_By>>;
    offset?: Maybe<Scalars['Int']>;
    where?: Maybe<Transaction_Bool_Exp>;
};
export declare type Block_Aggregate = {
    __typename?: 'Block_aggregate';
    aggregate?: Maybe<Block_Aggregate_Fields>;
};
export declare type Block_Aggregate_Fields = {
    __typename?: 'Block_aggregate_fields';
    avg: Block_Avg_Fields;
    count: Scalars['String'];
    max: Block_Max_Fields;
    min: Block_Min_Fields;
    sum: Block_Sum_Fields;
};
export declare type Block_Avg_Fields = {
    __typename?: 'Block_avg_fields';
    fees?: Maybe<Scalars['Float']>;
    size?: Maybe<Scalars['Float']>;
};
export declare type Block_Bool_Exp = {
    _and?: Maybe<Array<Maybe<Block_Bool_Exp>>>;
    _not?: Maybe<Block_Bool_Exp>;
    _or?: Maybe<Array<Maybe<Block_Bool_Exp>>>;
    createdAt?: Maybe<Date_Comparison_Exp>;
    createdBy?: Maybe<Text_Comparison_Exp>;
    epoch?: Maybe<Epoch_Bool_Exp>;
    fees?: Maybe<BigInt_Comparison_Exp>;
    hash?: Maybe<Hash32HexString_Comparison_Exp>;
    number?: Maybe<Int_Comparison_Exp>;
    previousBlock?: Maybe<Block_Bool_Exp>;
    nextBlock?: Maybe<Block_Bool_Exp>;
    size?: Maybe<BigInt_Comparison_Exp>;
    slotNo?: Maybe<Int_Comparison_Exp>;
    slotWithinEpoch?: Maybe<Int_Comparison_Exp>;
    transactions?: Maybe<Transaction_Bool_Exp>;
    transactionsCount?: Maybe<Text_Comparison_Exp>;
};
export declare type Block_Max_Fields = {
    __typename?: 'Block_max_fields';
    fees?: Maybe<Scalars['String']>;
    size?: Maybe<Scalars['String']>;
};
export declare type Block_Min_Fields = {
    __typename?: 'Block_min_fields';
    fees?: Maybe<Scalars['String']>;
    size?: Maybe<Scalars['String']>;
};
export declare type Block_Order_By = {
    createdAt?: Maybe<Order_By>;
    createdBy?: Maybe<Order_By>;
    epoch?: Maybe<Epoch_Order_By>;
    fees?: Maybe<Order_By>;
    number?: Maybe<Order_By_With_Nulls>;
    size?: Maybe<Order_By>;
    slotNo?: Maybe<Order_By_With_Nulls>;
    slotWithinEpoch?: Maybe<Order_By_With_Nulls>;
    transactionsCount?: Maybe<Order_By>;
};
export declare type Block_Sum_Fields = {
    __typename?: 'Block_sum_fields';
    fees?: Maybe<Scalars['String']>;
    size?: Maybe<Scalars['String']>;
};
export declare type Cardano = {
    __typename?: 'Cardano';
    blockHeight: Scalars['Int'];
    currentEpoch: Epoch;
    networkName: Scalars['String'];
    protocolConst: Scalars['Int'];
    slotDuration: Scalars['Int'];
    startTime: Scalars['DateTime'];
};
export declare type Date_Comparison_Exp = {
    _eq?: Maybe<Scalars['DateTime']>;
    _gt?: Maybe<Scalars['DateTime']>;
    _gte?: Maybe<Scalars['DateTime']>;
    _in?: Maybe<Array<Maybe<Scalars['DateTime']>>>;
    _lt?: Maybe<Scalars['DateTime']>;
    _lte?: Maybe<Scalars['DateTime']>;
    _neq?: Maybe<Scalars['DateTime']>;
    _nin?: Maybe<Array<Maybe<Scalars['DateTime']>>>;
};
export declare type Epoch = {
    __typename?: 'Epoch';
    blocks: Array<Block>;
    blocks_aggregate: Block_Aggregate;
    blocksCount: Scalars['String'];
    output: Scalars['String'];
    number: Scalars['Int'];
    transactionsCount: Scalars['String'];
    startedAt: Scalars['DateTime'];
    lastBlockTime: Scalars['DateTime'];
};
export declare type EpochBlocksArgs = {
    limit?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<Block_Order_By>>;
    offset?: Maybe<Scalars['Int']>;
    where?: Maybe<Block_Bool_Exp>;
};
export declare type EpochBlocks_AggregateArgs = {
    limit?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<Block_Order_By>>;
    offset?: Maybe<Scalars['Int']>;
    where?: Maybe<Block_Bool_Exp>;
};
export declare type Epoch_Aggregate = {
    __typename?: 'Epoch_aggregate';
    aggregate: Epoch_Aggregate_Fields;
};
export declare type Epoch_Aggregate_Fields = {
    __typename?: 'Epoch_aggregate_fields';
    count: Scalars['String'];
    max: Epoch_Max_Fields;
    min: Epoch_Min_Fields;
    sum: Epoch_Sum_Fields;
};
export declare type Epoch_Bool_Exp = {
    _and?: Maybe<Array<Maybe<Epoch_Bool_Exp>>>;
    _not?: Maybe<Epoch_Bool_Exp>;
    _or?: Maybe<Array<Maybe<Epoch_Bool_Exp>>>;
    blocks?: Maybe<Block_Bool_Exp>;
    blocksCount?: Maybe<Text_Comparison_Exp>;
    number?: Maybe<Int_Comparison_Exp>;
    output?: Maybe<Text_Comparison_Exp>;
    transactionsCount?: Maybe<Text_Comparison_Exp>;
};
export declare type Epoch_Max_Fields = {
    __typename?: 'Epoch_max_fields';
    blocksCount: Scalars['String'];
    number: Scalars['Int'];
    output: Scalars['String'];
    transactionsCount: Scalars['String'];
};
export declare type Epoch_Min_Fields = {
    __typename?: 'Epoch_min_fields';
    blocksCount: Scalars['String'];
    output: Scalars['String'];
    transactionsCount: Scalars['String'];
};
export declare type Epoch_Order_By = {
    blocksCount?: Maybe<Order_By>;
    number?: Maybe<Order_By>;
    output?: Maybe<Order_By>;
    transactionsCount?: Maybe<Order_By>;
};
export declare type Epoch_Sum_Fields = {
    __typename?: 'Epoch_sum_fields';
    blocksCount: Scalars['String'];
    output: Scalars['String'];
    transactionsCount: Scalars['String'];
};
export declare type Hash32HexString_Comparison_Exp = {
    _eq?: Maybe<Scalars['Hash32HexString']>;
    _in?: Maybe<Array<Maybe<Scalars['Hash32HexString']>>>;
    _neq?: Maybe<Scalars['Hash32HexString']>;
    _nin?: Maybe<Array<Maybe<Scalars['Hash32HexString']>>>;
};
export declare type Int_Comparison_Exp = {
    _eq?: Maybe<Scalars['Int']>;
    _gt?: Maybe<Scalars['Int']>;
    _gte?: Maybe<Scalars['Int']>;
    _in?: Maybe<Array<Scalars['Int']>>;
    _is_null?: Maybe<Scalars['Boolean']>;
    _lt?: Maybe<Scalars['Int']>;
    _lte?: Maybe<Scalars['Int']>;
    _neq?: Maybe<Scalars['Int']>;
    _nin?: Maybe<Array<Scalars['Int']>>;
};
export declare type Lovelaces_Comparison_Exp = {
    _eq?: Maybe<Scalars['Lovelaces']>;
    _gt?: Maybe<Scalars['Lovelaces']>;
    _gte?: Maybe<Scalars['Lovelaces']>;
    _in?: Maybe<Array<Scalars['Lovelaces']>>;
    _lt?: Maybe<Scalars['Lovelaces']>;
    _lte?: Maybe<Scalars['Lovelaces']>;
    _neq?: Maybe<Scalars['Lovelaces']>;
    _nin?: Maybe<Array<Scalars['Lovelaces']>>;
};
export declare enum Order_By {
    Asc = "asc",
    Desc = "desc"
}
export declare enum Order_By_With_Nulls {
    Asc = "asc",
    AscNullsFirst = "asc_nulls_first",
    AscNullsLast = "asc_nulls_last",
    Desc = "desc",
    DescNullsFirst = "desc_nulls_first",
    DescNullsLast = "desc_nulls_last"
}
export declare type Percentage_Comparison_Exp = {
    _eq?: Maybe<Scalars['Percentage']>;
    _gt?: Maybe<Scalars['Percentage']>;
    _gte?: Maybe<Scalars['Percentage']>;
    _lt?: Maybe<Scalars['Percentage']>;
    _lte?: Maybe<Scalars['Percentage']>;
    _neq?: Maybe<Scalars['Percentage']>;
};
export declare type Query = {
    __typename?: 'Query';
    blocks: Array<Maybe<Block>>;
    blocks_aggregate: Block_Aggregate;
    epochs: Array<Maybe<Epoch>>;
    epochs_aggregate: Epoch_Aggregate;
    cardano: Cardano;
    transactions: Array<Maybe<Transaction>>;
    transactions_aggregate: Transaction_Aggregate;
    utxos: Array<Maybe<TransactionOutput>>;
    utxos_aggregate: TransactionOutput_Aggregate;
};
export declare type QueryBlocksArgs = {
    limit?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<Block_Order_By>>;
    offset?: Maybe<Scalars['Int']>;
    where?: Maybe<Block_Bool_Exp>;
};
export declare type QueryBlocks_AggregateArgs = {
    limit?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<Block_Order_By>>;
    offset?: Maybe<Scalars['Int']>;
    where?: Maybe<Block_Bool_Exp>;
};
export declare type QueryEpochsArgs = {
    limit?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<Epoch_Order_By>>;
    offset?: Maybe<Scalars['Int']>;
    where?: Maybe<Epoch_Bool_Exp>;
};
export declare type QueryEpochs_AggregateArgs = {
    limit?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<Epoch_Order_By>>;
    offset?: Maybe<Scalars['Int']>;
    where?: Maybe<Epoch_Bool_Exp>;
};
export declare type QueryTransactionsArgs = {
    limit?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<Transaction_Order_By>>;
    offset?: Maybe<Scalars['Int']>;
    where?: Maybe<Transaction_Bool_Exp>;
};
export declare type QueryTransactions_AggregateArgs = {
    limit?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<Transaction_Order_By>>;
    offset?: Maybe<Scalars['Int']>;
    where?: Maybe<Transaction_Bool_Exp>;
};
export declare type QueryUtxosArgs = {
    limit?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<TransactionOutput_Order_By>>;
    offset?: Maybe<Scalars['Int']>;
    where?: Maybe<TransactionOutput_Bool_Exp>;
};
export declare type QueryUtxos_AggregateArgs = {
    limit?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<TransactionOutput_Order_By>>;
    offset?: Maybe<Scalars['Int']>;
    where?: Maybe<TransactionOutput_Bool_Exp>;
};
export declare type Text_Comparison_Exp = {
    _eq?: Maybe<Scalars['String']>;
    _gt?: Maybe<Scalars['String']>;
    _gte?: Maybe<Scalars['String']>;
    _ilike?: Maybe<Scalars['String']>;
    _in?: Maybe<Array<Maybe<Scalars['String']>>>;
    _is_null?: Maybe<Scalars['Boolean']>;
    _like?: Maybe<Scalars['String']>;
    _lt?: Maybe<Scalars['String']>;
    _lte?: Maybe<Scalars['String']>;
    _neq?: Maybe<Scalars['String']>;
    _nilike?: Maybe<Scalars['String']>;
    _nin?: Maybe<Array<Maybe<Scalars['String']>>>;
    _nlike?: Maybe<Scalars['String']>;
    _nsimilar?: Maybe<Scalars['String']>;
    _similar?: Maybe<Scalars['String']>;
};
export declare type Transaction = {
    __typename?: 'Transaction';
    block?: Maybe<Block>;
    blockIndex: Scalars['Int'];
    fee: Scalars['BigInt'];
    hash: Scalars['Hash32HexString'];
    inputs: Array<TransactionInput>;
    inputs_aggregate?: Maybe<TransactionInput_Aggregate>;
    outputs: Array<TransactionOutput>;
    outputs_aggregate?: Maybe<TransactionOutput_Aggregate>;
    size: Scalars['BigInt'];
    totalOutput: Scalars['String'];
    includedAt: Scalars['DateTime'];
};
export declare type TransactionInputsArgs = {
    limit?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<Maybe<TransactionInput_Order_By>>>;
    offset?: Maybe<Scalars['Int']>;
    where?: Maybe<TransactionInput_Bool_Exp>;
};
export declare type TransactionInputs_AggregateArgs = {
    limit?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<Maybe<TransactionInput_Order_By>>>;
    offset?: Maybe<Scalars['Int']>;
    where?: Maybe<TransactionInput_Bool_Exp>;
};
export declare type TransactionOutputsArgs = {
    limit?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<Maybe<TransactionOutput_Order_By>>>;
    offset?: Maybe<Scalars['Int']>;
    where?: Maybe<TransactionOutput_Bool_Exp>;
};
export declare type TransactionOutputs_AggregateArgs = {
    limit?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<Maybe<TransactionOutput_Order_By>>>;
    offset?: Maybe<Scalars['Int']>;
    where?: Maybe<TransactionOutput_Bool_Exp>;
};
export declare type Transaction_Aggregate = {
    __typename?: 'Transaction_aggregate';
    aggregate?: Maybe<Transaction_Aggregate_Fields>;
};
export declare type Transaction_Aggregate_Fields = {
    __typename?: 'Transaction_aggregate_fields';
    avg: Transaction_Avg_Fields;
    count: Scalars['String'];
    max: Transaction_Max_Fields;
    min: Transaction_Min_Fields;
    sum: Transaction_Sum_Fields;
};
export declare type Transaction_Avg_Fields = {
    __typename?: 'Transaction_avg_fields';
    fee?: Maybe<Scalars['Float']>;
    size?: Maybe<Scalars['Float']>;
    totalOutput?: Maybe<Scalars['Float']>;
};
export declare type Transaction_Bool_Exp = {
    _and?: Maybe<Array<Maybe<Transaction_Bool_Exp>>>;
    _not?: Maybe<Transaction_Bool_Exp>;
    _or?: Maybe<Array<Maybe<Transaction_Bool_Exp>>>;
    block?: Maybe<Block_Bool_Exp>;
    blockIndex?: Maybe<Int_Comparison_Exp>;
    fee?: Maybe<BigInt_Comparison_Exp>;
    hash?: Maybe<Hash32HexString_Comparison_Exp>;
    includedAt?: Maybe<Date_Comparison_Exp>;
    inputs?: Maybe<TransactionInput_Bool_Exp>;
    outputs?: Maybe<TransactionOutput_Bool_Exp>;
    size?: Maybe<BigInt_Comparison_Exp>;
    totalOutput?: Maybe<Text_Comparison_Exp>;
};
export declare type Transaction_Max_Fields = {
    __typename?: 'Transaction_max_fields';
    fee?: Maybe<Scalars['String']>;
    size?: Maybe<Scalars['String']>;
    totalOutput?: Maybe<Scalars['String']>;
};
export declare type Transaction_Min_Fields = {
    __typename?: 'Transaction_min_fields';
    fee?: Maybe<Scalars['String']>;
    size?: Maybe<Scalars['String']>;
    totalOutput?: Maybe<Scalars['String']>;
};
export declare type Transaction_Order_By = {
    block?: Maybe<Order_By>;
    blockIndex?: Maybe<Order_By>;
    fee?: Maybe<Order_By>;
    includedAt?: Maybe<Order_By>;
    size?: Maybe<Order_By>;
    totalOutput?: Maybe<Order_By>;
};
export declare type Transaction_Sum_Fields = {
    __typename?: 'Transaction_sum_fields';
    fee?: Maybe<Scalars['String']>;
    size?: Maybe<Scalars['String']>;
    totalOutput?: Maybe<Scalars['String']>;
};
export declare type TransactionInput = {
    __typename?: 'TransactionInput';
    sourceTxHash: Scalars['Hash32HexString'];
    sourceTxIndex: Scalars['Int'];
    address: Scalars['String'];
    txHash: Scalars['Hash32HexString'];
    value: Scalars['String'];
};
export declare type TransactionInput_Aggregate = {
    __typename?: 'TransactionInput_aggregate';
    aggregate?: Maybe<TransactionInput_Aggregate_Fields>;
};
export declare type TransactionInput_Aggregate_Fields = {
    __typename?: 'TransactionInput_aggregate_fields';
    avg: TransactionInput_Avg_Fields;
    count: Scalars['String'];
    max: TransactionInput_Max_Fields;
    min: TransactionInput_Min_Fields;
    sum: TransactionInput_Sum_Fields;
};
export declare type TransactionInput_Avg_Fields = {
    __typename?: 'TransactionInput_avg_fields';
    value?: Maybe<Scalars['String']>;
};
export declare type TransactionInput_Bool_Exp = {
    _and?: Maybe<Array<Maybe<TransactionInput_Bool_Exp>>>;
    _not?: Maybe<TransactionInput_Bool_Exp>;
    _or?: Maybe<Array<Maybe<TransactionInput_Bool_Exp>>>;
    address?: Maybe<Text_Comparison_Exp>;
    value?: Maybe<Text_Comparison_Exp>;
};
export declare type TransactionInput_Max_Fields = {
    __typename?: 'TransactionInput_max_fields';
    value?: Maybe<Scalars['String']>;
};
export declare type TransactionInput_Min_Fields = {
    __typename?: 'TransactionInput_min_fields';
    value?: Maybe<Scalars['String']>;
};
export declare type TransactionInput_Order_By = {
    address?: Maybe<Order_By>;
    sourceTxHash?: Maybe<Order_By>;
    txHash?: Maybe<Order_By>;
    value?: Maybe<Order_By>;
};
export declare type TransactionInput_Sum_Fields = {
    __typename?: 'TransactionInput_sum_fields';
    value?: Maybe<Scalars['String']>;
};
export declare type TransactionOutput = {
    __typename?: 'TransactionOutput';
    address: Scalars['String'];
    index: Scalars['Int'];
    txHash: Scalars['Hash32HexString'];
    value: Scalars['String'];
};
export declare type TransactionOutput_Aggregate = {
    __typename?: 'TransactionOutput_aggregate';
    aggregate?: Maybe<TransactionOutput_Aggregate_Fields>;
};
export declare type TransactionOutput_Aggregate_Fields = {
    __typename?: 'TransactionOutput_aggregate_fields';
    avg: TransactionOutput_Avg_Fields;
    count: Scalars['String'];
    max: TransactionOutput_Max_Fields;
    min: TransactionOutput_Min_Fields;
    sum: TransactionOutput_Sum_Fields;
};
export declare type TransactionOutput_Avg_Fields = {
    __typename?: 'TransactionOutput_avg_fields';
    value?: Maybe<Scalars['String']>;
};
export declare type TransactionOutput_Bool_Exp = {
    _and?: Maybe<Array<Maybe<TransactionOutput_Bool_Exp>>>;
    _not?: Maybe<TransactionOutput_Bool_Exp>;
    _or?: Maybe<Array<Maybe<TransactionOutput_Bool_Exp>>>;
    address?: Maybe<Text_Comparison_Exp>;
    value?: Maybe<Text_Comparison_Exp>;
};
export declare type TransactionOutput_Max_Fields = {
    __typename?: 'TransactionOutput_max_fields';
    value?: Maybe<Scalars['String']>;
};
export declare type TransactionOutput_Min_Fields = {
    __typename?: 'TransactionOutput_min_fields';
    value?: Maybe<Scalars['String']>;
};
export declare type TransactionOutput_Order_By = {
    address?: Maybe<Order_By>;
    index?: Maybe<Order_By>;
    txHash?: Maybe<Order_By>;
    value?: Maybe<Order_By>;
};
export declare type TransactionOutput_Sum_Fields = {
    __typename?: 'TransactionOutput_sum_fields';
    value?: Maybe<Scalars['String']>;
};
export declare type WithIndex<TObject> = TObject & Record<string, any>;
export declare type ResolversObject<TObject> = WithIndex<TObject>;
export declare type ResolverTypeWrapper<T> = Promise<T> | T;
export declare type LegacyStitchingResolver<TResult, TParent, TContext, TArgs> = {
    fragment: string;
    resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
};
export declare type NewStitchingResolver<TResult, TParent, TContext, TArgs> = {
    selectionSet: string;
    resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
};
export declare type StitchingResolver<TResult, TParent, TContext, TArgs> = LegacyStitchingResolver<TResult, TParent, TContext, TArgs> | NewStitchingResolver<TResult, TParent, TContext, TArgs>;
export declare type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = ResolverFn<TResult, TParent, TContext, TArgs> | StitchingResolver<TResult, TParent, TContext, TArgs>;
export declare type ResolverFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<TResult> | TResult;
export declare type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => AsyncIterator<TResult> | Promise<AsyncIterator<TResult>>;
export declare type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
    subscribe: SubscriptionSubscribeFn<{
        [key in TKey]: TResult;
    }, TParent, TContext, TArgs>;
    resolve?: SubscriptionResolveFn<TResult, {
        [key in TKey]: TResult;
    }, TContext, TArgs>;
}
export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
    subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>;
    resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
}
export declare type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> = SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs> | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
export declare type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> = ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>) | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
export declare type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (parent: TParent, context: TContext, info: GraphQLResolveInfo) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
export declare type IsTypeOfResolverFn<T = {}> = (obj: T, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
export declare type NextResolverFn<T> = () => Promise<T>;
export declare type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (next: NextResolverFn<TResult>, parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
export declare type ResolversTypes = ResolversObject<{
    Query: ResolverTypeWrapper<{}>;
    Int: ResolverTypeWrapper<Scalars['Int']>;
    Block_order_by: Block_Order_By;
    order_by: Order_By;
    Epoch_order_by: Epoch_Order_By;
    order_by_with_nulls: Order_By_With_Nulls;
    Block_bool_exp: Block_Bool_Exp;
    Date_comparison_exp: Date_Comparison_Exp;
    DateTime: ResolverTypeWrapper<Scalars['DateTime']>;
    text_comparison_exp: Text_Comparison_Exp;
    String: ResolverTypeWrapper<Scalars['String']>;
    Boolean: ResolverTypeWrapper<Scalars['Boolean']>;
    Epoch_bool_exp: Epoch_Bool_Exp;
    Int_comparison_exp: Int_Comparison_Exp;
    BigInt_comparison_exp: BigInt_Comparison_Exp;
    BigInt: ResolverTypeWrapper<Scalars['BigInt']>;
    Hash32HexString_comparison_exp: Hash32HexString_Comparison_Exp;
    Hash32HexString: ResolverTypeWrapper<Scalars['Hash32HexString']>;
    Transaction_bool_exp: Transaction_Bool_Exp;
    TransactionInput_bool_exp: TransactionInput_Bool_Exp;
    TransactionOutput_bool_exp: TransactionOutput_Bool_Exp;
    Block: ResolverTypeWrapper<Block>;
    Epoch: ResolverTypeWrapper<Epoch>;
    Block_aggregate: ResolverTypeWrapper<Block_Aggregate>;
    Block_aggregate_fields: ResolverTypeWrapper<Block_Aggregate_Fields>;
    Block_avg_fields: ResolverTypeWrapper<Block_Avg_Fields>;
    Float: ResolverTypeWrapper<Scalars['Float']>;
    Block_max_fields: ResolverTypeWrapper<Block_Max_Fields>;
    Block_min_fields: ResolverTypeWrapper<Block_Min_Fields>;
    Block_sum_fields: ResolverTypeWrapper<Block_Sum_Fields>;
    Transaction_order_by: Transaction_Order_By;
    Transaction: ResolverTypeWrapper<Transaction>;
    TransactionInput_order_by: TransactionInput_Order_By;
    TransactionInput: ResolverTypeWrapper<TransactionInput>;
    TransactionInput_aggregate: ResolverTypeWrapper<TransactionInput_Aggregate>;
    TransactionInput_aggregate_fields: ResolverTypeWrapper<TransactionInput_Aggregate_Fields>;
    TransactionInput_avg_fields: ResolverTypeWrapper<TransactionInput_Avg_Fields>;
    TransactionInput_max_fields: ResolverTypeWrapper<TransactionInput_Max_Fields>;
    TransactionInput_min_fields: ResolverTypeWrapper<TransactionInput_Min_Fields>;
    TransactionInput_sum_fields: ResolverTypeWrapper<TransactionInput_Sum_Fields>;
    TransactionOutput_order_by: TransactionOutput_Order_By;
    TransactionOutput: ResolverTypeWrapper<TransactionOutput>;
    TransactionOutput_aggregate: ResolverTypeWrapper<TransactionOutput_Aggregate>;
    TransactionOutput_aggregate_fields: ResolverTypeWrapper<TransactionOutput_Aggregate_Fields>;
    TransactionOutput_avg_fields: ResolverTypeWrapper<TransactionOutput_Avg_Fields>;
    TransactionOutput_max_fields: ResolverTypeWrapper<TransactionOutput_Max_Fields>;
    TransactionOutput_min_fields: ResolverTypeWrapper<TransactionOutput_Min_Fields>;
    TransactionOutput_sum_fields: ResolverTypeWrapper<TransactionOutput_Sum_Fields>;
    Transaction_aggregate: ResolverTypeWrapper<Transaction_Aggregate>;
    Transaction_aggregate_fields: ResolverTypeWrapper<Transaction_Aggregate_Fields>;
    Transaction_avg_fields: ResolverTypeWrapper<Transaction_Avg_Fields>;
    Transaction_max_fields: ResolverTypeWrapper<Transaction_Max_Fields>;
    Transaction_min_fields: ResolverTypeWrapper<Transaction_Min_Fields>;
    Transaction_sum_fields: ResolverTypeWrapper<Transaction_Sum_Fields>;
    Epoch_aggregate: ResolverTypeWrapper<Epoch_Aggregate>;
    Epoch_aggregate_fields: ResolverTypeWrapper<Epoch_Aggregate_Fields>;
    Epoch_max_fields: ResolverTypeWrapper<Epoch_Max_Fields>;
    Epoch_min_fields: ResolverTypeWrapper<Epoch_Min_Fields>;
    Epoch_sum_fields: ResolverTypeWrapper<Epoch_Sum_Fields>;
    Cardano: ResolverTypeWrapper<Cardano>;
    Lovelaces: ResolverTypeWrapper<Scalars['Lovelaces']>;
    Percentage: ResolverTypeWrapper<Scalars['Percentage']>;
    Lovelaces_comparison_exp: Lovelaces_Comparison_Exp;
    Percentage_comparison_exp: Percentage_Comparison_Exp;
}>;
export declare type ResolversParentTypes = ResolversObject<{
    Query: {};
    Int: Scalars['Int'];
    Block_order_by: Block_Order_By;
    Epoch_order_by: Epoch_Order_By;
    Block_bool_exp: Block_Bool_Exp;
    Date_comparison_exp: Date_Comparison_Exp;
    DateTime: Scalars['DateTime'];
    text_comparison_exp: Text_Comparison_Exp;
    String: Scalars['String'];
    Boolean: Scalars['Boolean'];
    Epoch_bool_exp: Epoch_Bool_Exp;
    Int_comparison_exp: Int_Comparison_Exp;
    BigInt_comparison_exp: BigInt_Comparison_Exp;
    BigInt: Scalars['BigInt'];
    Hash32HexString_comparison_exp: Hash32HexString_Comparison_Exp;
    Hash32HexString: Scalars['Hash32HexString'];
    Transaction_bool_exp: Transaction_Bool_Exp;
    TransactionInput_bool_exp: TransactionInput_Bool_Exp;
    TransactionOutput_bool_exp: TransactionOutput_Bool_Exp;
    Block: Block;
    Epoch: Epoch;
    Block_aggregate: Block_Aggregate;
    Block_aggregate_fields: Block_Aggregate_Fields;
    Block_avg_fields: Block_Avg_Fields;
    Float: Scalars['Float'];
    Block_max_fields: Block_Max_Fields;
    Block_min_fields: Block_Min_Fields;
    Block_sum_fields: Block_Sum_Fields;
    Transaction_order_by: Transaction_Order_By;
    Transaction: Transaction;
    TransactionInput_order_by: TransactionInput_Order_By;
    TransactionInput: TransactionInput;
    TransactionInput_aggregate: TransactionInput_Aggregate;
    TransactionInput_aggregate_fields: TransactionInput_Aggregate_Fields;
    TransactionInput_avg_fields: TransactionInput_Avg_Fields;
    TransactionInput_max_fields: TransactionInput_Max_Fields;
    TransactionInput_min_fields: TransactionInput_Min_Fields;
    TransactionInput_sum_fields: TransactionInput_Sum_Fields;
    TransactionOutput_order_by: TransactionOutput_Order_By;
    TransactionOutput: TransactionOutput;
    TransactionOutput_aggregate: TransactionOutput_Aggregate;
    TransactionOutput_aggregate_fields: TransactionOutput_Aggregate_Fields;
    TransactionOutput_avg_fields: TransactionOutput_Avg_Fields;
    TransactionOutput_max_fields: TransactionOutput_Max_Fields;
    TransactionOutput_min_fields: TransactionOutput_Min_Fields;
    TransactionOutput_sum_fields: TransactionOutput_Sum_Fields;
    Transaction_aggregate: Transaction_Aggregate;
    Transaction_aggregate_fields: Transaction_Aggregate_Fields;
    Transaction_avg_fields: Transaction_Avg_Fields;
    Transaction_max_fields: Transaction_Max_Fields;
    Transaction_min_fields: Transaction_Min_Fields;
    Transaction_sum_fields: Transaction_Sum_Fields;
    Epoch_aggregate: Epoch_Aggregate;
    Epoch_aggregate_fields: Epoch_Aggregate_Fields;
    Epoch_max_fields: Epoch_Max_Fields;
    Epoch_min_fields: Epoch_Min_Fields;
    Epoch_sum_fields: Epoch_Sum_Fields;
    Cardano: Cardano;
    Lovelaces: Scalars['Lovelaces'];
    Percentage: Scalars['Percentage'];
    Lovelaces_comparison_exp: Lovelaces_Comparison_Exp;
    Percentage_comparison_exp: Percentage_Comparison_Exp;
}>;
export interface BigIntScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['BigInt'], any> {
    name: 'BigInt';
}
export declare type BlockResolvers<ContextType = any, ParentType extends ResolversParentTypes['Block'] = ResolversParentTypes['Block']> = ResolversObject<{
    createdAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
    createdBy?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    epoch?: Resolver<Maybe<ResolversTypes['Epoch']>, ParentType, ContextType>;
    epochNo?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
    fees?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
    hash?: Resolver<ResolversTypes['Hash32HexString'], ParentType, ContextType>;
    merkelRoot?: Resolver<Maybe<ResolversTypes['Hash32HexString']>, ParentType, ContextType>;
    number?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
    slotNo?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
    slotWithinEpoch?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
    previousBlock?: Resolver<Maybe<ResolversTypes['Block']>, ParentType, ContextType>;
    nextBlock?: Resolver<Maybe<ResolversTypes['Block']>, ParentType, ContextType>;
    size?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
    transactions?: Resolver<Array<Maybe<ResolversTypes['Transaction']>>, ParentType, ContextType, RequireFields<BlockTransactionsArgs, never>>;
    transactions_aggregate?: Resolver<ResolversTypes['Transaction_aggregate'], ParentType, ContextType, RequireFields<BlockTransactions_AggregateArgs, never>>;
    transactionsCount?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type Block_AggregateResolvers<ContextType = any, ParentType extends ResolversParentTypes['Block_aggregate'] = ResolversParentTypes['Block_aggregate']> = ResolversObject<{
    aggregate?: Resolver<Maybe<ResolversTypes['Block_aggregate_fields']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type Block_Aggregate_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['Block_aggregate_fields'] = ResolversParentTypes['Block_aggregate_fields']> = ResolversObject<{
    avg?: Resolver<ResolversTypes['Block_avg_fields'], ParentType, ContextType>;
    count?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    max?: Resolver<ResolversTypes['Block_max_fields'], ParentType, ContextType>;
    min?: Resolver<ResolversTypes['Block_min_fields'], ParentType, ContextType>;
    sum?: Resolver<ResolversTypes['Block_sum_fields'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type Block_Avg_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['Block_avg_fields'] = ResolversParentTypes['Block_avg_fields']> = ResolversObject<{
    fees?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
    size?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type Block_Max_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['Block_max_fields'] = ResolversParentTypes['Block_max_fields']> = ResolversObject<{
    fees?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    size?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type Block_Min_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['Block_min_fields'] = ResolversParentTypes['Block_min_fields']> = ResolversObject<{
    fees?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    size?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type Block_Sum_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['Block_sum_fields'] = ResolversParentTypes['Block_sum_fields']> = ResolversObject<{
    fees?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    size?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type CardanoResolvers<ContextType = any, ParentType extends ResolversParentTypes['Cardano'] = ResolversParentTypes['Cardano']> = ResolversObject<{
    blockHeight?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
    currentEpoch?: Resolver<ResolversTypes['Epoch'], ParentType, ContextType>;
    networkName?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    protocolConst?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
    slotDuration?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
    startTime?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export interface DateTimeScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['DateTime'], any> {
    name: 'DateTime';
}
export declare type EpochResolvers<ContextType = any, ParentType extends ResolversParentTypes['Epoch'] = ResolversParentTypes['Epoch']> = ResolversObject<{
    blocks?: Resolver<Array<ResolversTypes['Block']>, ParentType, ContextType, RequireFields<EpochBlocksArgs, never>>;
    blocks_aggregate?: Resolver<ResolversTypes['Block_aggregate'], ParentType, ContextType, RequireFields<EpochBlocks_AggregateArgs, never>>;
    blocksCount?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    output?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    number?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
    transactionsCount?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    startedAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
    lastBlockTime?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type Epoch_AggregateResolvers<ContextType = any, ParentType extends ResolversParentTypes['Epoch_aggregate'] = ResolversParentTypes['Epoch_aggregate']> = ResolversObject<{
    aggregate?: Resolver<ResolversTypes['Epoch_aggregate_fields'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type Epoch_Aggregate_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['Epoch_aggregate_fields'] = ResolversParentTypes['Epoch_aggregate_fields']> = ResolversObject<{
    count?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    max?: Resolver<ResolversTypes['Epoch_max_fields'], ParentType, ContextType>;
    min?: Resolver<ResolversTypes['Epoch_min_fields'], ParentType, ContextType>;
    sum?: Resolver<ResolversTypes['Epoch_sum_fields'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type Epoch_Max_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['Epoch_max_fields'] = ResolversParentTypes['Epoch_max_fields']> = ResolversObject<{
    blocksCount?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    number?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
    output?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    transactionsCount?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type Epoch_Min_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['Epoch_min_fields'] = ResolversParentTypes['Epoch_min_fields']> = ResolversObject<{
    blocksCount?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    output?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    transactionsCount?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type Epoch_Sum_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['Epoch_sum_fields'] = ResolversParentTypes['Epoch_sum_fields']> = ResolversObject<{
    blocksCount?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    output?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    transactionsCount?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export interface Hash32HexStringScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['Hash32HexString'], any> {
    name: 'Hash32HexString';
}
export interface LovelacesScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['Lovelaces'], any> {
    name: 'Lovelaces';
}
export interface PercentageScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['Percentage'], any> {
    name: 'Percentage';
}
export declare type QueryResolvers<ContextType = any, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = ResolversObject<{
    blocks?: Resolver<Array<Maybe<ResolversTypes['Block']>>, ParentType, ContextType, RequireFields<QueryBlocksArgs, never>>;
    blocks_aggregate?: Resolver<ResolversTypes['Block_aggregate'], ParentType, ContextType, RequireFields<QueryBlocks_AggregateArgs, never>>;
    epochs?: Resolver<Array<Maybe<ResolversTypes['Epoch']>>, ParentType, ContextType, RequireFields<QueryEpochsArgs, never>>;
    epochs_aggregate?: Resolver<ResolversTypes['Epoch_aggregate'], ParentType, ContextType, RequireFields<QueryEpochs_AggregateArgs, never>>;
    cardano?: Resolver<ResolversTypes['Cardano'], ParentType, ContextType>;
    transactions?: Resolver<Array<Maybe<ResolversTypes['Transaction']>>, ParentType, ContextType, RequireFields<QueryTransactionsArgs, never>>;
    transactions_aggregate?: Resolver<ResolversTypes['Transaction_aggregate'], ParentType, ContextType, RequireFields<QueryTransactions_AggregateArgs, never>>;
    utxos?: Resolver<Array<Maybe<ResolversTypes['TransactionOutput']>>, ParentType, ContextType, RequireFields<QueryUtxosArgs, never>>;
    utxos_aggregate?: Resolver<ResolversTypes['TransactionOutput_aggregate'], ParentType, ContextType, RequireFields<QueryUtxos_AggregateArgs, never>>;
}>;
export declare type TransactionResolvers<ContextType = any, ParentType extends ResolversParentTypes['Transaction'] = ResolversParentTypes['Transaction']> = ResolversObject<{
    block?: Resolver<Maybe<ResolversTypes['Block']>, ParentType, ContextType>;
    blockIndex?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
    fee?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
    hash?: Resolver<ResolversTypes['Hash32HexString'], ParentType, ContextType>;
    inputs?: Resolver<Array<ResolversTypes['TransactionInput']>, ParentType, ContextType, RequireFields<TransactionInputsArgs, never>>;
    inputs_aggregate?: Resolver<Maybe<ResolversTypes['TransactionInput_aggregate']>, ParentType, ContextType, RequireFields<TransactionInputs_AggregateArgs, never>>;
    outputs?: Resolver<Array<ResolversTypes['TransactionOutput']>, ParentType, ContextType, RequireFields<TransactionOutputsArgs, never>>;
    outputs_aggregate?: Resolver<Maybe<ResolversTypes['TransactionOutput_aggregate']>, ParentType, ContextType, RequireFields<TransactionOutputs_AggregateArgs, never>>;
    size?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
    totalOutput?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    includedAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type Transaction_AggregateResolvers<ContextType = any, ParentType extends ResolversParentTypes['Transaction_aggregate'] = ResolversParentTypes['Transaction_aggregate']> = ResolversObject<{
    aggregate?: Resolver<Maybe<ResolversTypes['Transaction_aggregate_fields']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type Transaction_Aggregate_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['Transaction_aggregate_fields'] = ResolversParentTypes['Transaction_aggregate_fields']> = ResolversObject<{
    avg?: Resolver<ResolversTypes['Transaction_avg_fields'], ParentType, ContextType>;
    count?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    max?: Resolver<ResolversTypes['Transaction_max_fields'], ParentType, ContextType>;
    min?: Resolver<ResolversTypes['Transaction_min_fields'], ParentType, ContextType>;
    sum?: Resolver<ResolversTypes['Transaction_sum_fields'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type Transaction_Avg_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['Transaction_avg_fields'] = ResolversParentTypes['Transaction_avg_fields']> = ResolversObject<{
    fee?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
    size?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
    totalOutput?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type Transaction_Max_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['Transaction_max_fields'] = ResolversParentTypes['Transaction_max_fields']> = ResolversObject<{
    fee?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    size?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    totalOutput?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type Transaction_Min_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['Transaction_min_fields'] = ResolversParentTypes['Transaction_min_fields']> = ResolversObject<{
    fee?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    size?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    totalOutput?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type Transaction_Sum_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['Transaction_sum_fields'] = ResolversParentTypes['Transaction_sum_fields']> = ResolversObject<{
    fee?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    size?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    totalOutput?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type TransactionInputResolvers<ContextType = any, ParentType extends ResolversParentTypes['TransactionInput'] = ResolversParentTypes['TransactionInput']> = ResolversObject<{
    sourceTxHash?: Resolver<ResolversTypes['Hash32HexString'], ParentType, ContextType>;
    sourceTxIndex?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
    address?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    txHash?: Resolver<ResolversTypes['Hash32HexString'], ParentType, ContextType>;
    value?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type TransactionInput_AggregateResolvers<ContextType = any, ParentType extends ResolversParentTypes['TransactionInput_aggregate'] = ResolversParentTypes['TransactionInput_aggregate']> = ResolversObject<{
    aggregate?: Resolver<Maybe<ResolversTypes['TransactionInput_aggregate_fields']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type TransactionInput_Aggregate_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['TransactionInput_aggregate_fields'] = ResolversParentTypes['TransactionInput_aggregate_fields']> = ResolversObject<{
    avg?: Resolver<ResolversTypes['TransactionInput_avg_fields'], ParentType, ContextType>;
    count?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    max?: Resolver<ResolversTypes['TransactionInput_max_fields'], ParentType, ContextType>;
    min?: Resolver<ResolversTypes['TransactionInput_min_fields'], ParentType, ContextType>;
    sum?: Resolver<ResolversTypes['TransactionInput_sum_fields'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type TransactionInput_Avg_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['TransactionInput_avg_fields'] = ResolversParentTypes['TransactionInput_avg_fields']> = ResolversObject<{
    value?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type TransactionInput_Max_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['TransactionInput_max_fields'] = ResolversParentTypes['TransactionInput_max_fields']> = ResolversObject<{
    value?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type TransactionInput_Min_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['TransactionInput_min_fields'] = ResolversParentTypes['TransactionInput_min_fields']> = ResolversObject<{
    value?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type TransactionInput_Sum_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['TransactionInput_sum_fields'] = ResolversParentTypes['TransactionInput_sum_fields']> = ResolversObject<{
    value?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type TransactionOutputResolvers<ContextType = any, ParentType extends ResolversParentTypes['TransactionOutput'] = ResolversParentTypes['TransactionOutput']> = ResolversObject<{
    address?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    index?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
    txHash?: Resolver<ResolversTypes['Hash32HexString'], ParentType, ContextType>;
    value?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type TransactionOutput_AggregateResolvers<ContextType = any, ParentType extends ResolversParentTypes['TransactionOutput_aggregate'] = ResolversParentTypes['TransactionOutput_aggregate']> = ResolversObject<{
    aggregate?: Resolver<Maybe<ResolversTypes['TransactionOutput_aggregate_fields']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type TransactionOutput_Aggregate_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['TransactionOutput_aggregate_fields'] = ResolversParentTypes['TransactionOutput_aggregate_fields']> = ResolversObject<{
    avg?: Resolver<ResolversTypes['TransactionOutput_avg_fields'], ParentType, ContextType>;
    count?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
    max?: Resolver<ResolversTypes['TransactionOutput_max_fields'], ParentType, ContextType>;
    min?: Resolver<ResolversTypes['TransactionOutput_min_fields'], ParentType, ContextType>;
    sum?: Resolver<ResolversTypes['TransactionOutput_sum_fields'], ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type TransactionOutput_Avg_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['TransactionOutput_avg_fields'] = ResolversParentTypes['TransactionOutput_avg_fields']> = ResolversObject<{
    value?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type TransactionOutput_Max_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['TransactionOutput_max_fields'] = ResolversParentTypes['TransactionOutput_max_fields']> = ResolversObject<{
    value?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type TransactionOutput_Min_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['TransactionOutput_min_fields'] = ResolversParentTypes['TransactionOutput_min_fields']> = ResolversObject<{
    value?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type TransactionOutput_Sum_FieldsResolvers<ContextType = any, ParentType extends ResolversParentTypes['TransactionOutput_sum_fields'] = ResolversParentTypes['TransactionOutput_sum_fields']> = ResolversObject<{
    value?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
    __isTypeOf?: IsTypeOfResolverFn<ParentType>;
}>;
export declare type Resolvers<ContextType = any> = ResolversObject<{
    BigInt?: GraphQLScalarType;
    Block?: BlockResolvers<ContextType>;
    Block_aggregate?: Block_AggregateResolvers<ContextType>;
    Block_aggregate_fields?: Block_Aggregate_FieldsResolvers<ContextType>;
    Block_avg_fields?: Block_Avg_FieldsResolvers<ContextType>;
    Block_max_fields?: Block_Max_FieldsResolvers<ContextType>;
    Block_min_fields?: Block_Min_FieldsResolvers<ContextType>;
    Block_sum_fields?: Block_Sum_FieldsResolvers<ContextType>;
    Cardano?: CardanoResolvers<ContextType>;
    DateTime?: GraphQLScalarType;
    Epoch?: EpochResolvers<ContextType>;
    Epoch_aggregate?: Epoch_AggregateResolvers<ContextType>;
    Epoch_aggregate_fields?: Epoch_Aggregate_FieldsResolvers<ContextType>;
    Epoch_max_fields?: Epoch_Max_FieldsResolvers<ContextType>;
    Epoch_min_fields?: Epoch_Min_FieldsResolvers<ContextType>;
    Epoch_sum_fields?: Epoch_Sum_FieldsResolvers<ContextType>;
    Hash32HexString?: GraphQLScalarType;
    Lovelaces?: GraphQLScalarType;
    Percentage?: GraphQLScalarType;
    Query?: QueryResolvers<ContextType>;
    Transaction?: TransactionResolvers<ContextType>;
    Transaction_aggregate?: Transaction_AggregateResolvers<ContextType>;
    Transaction_aggregate_fields?: Transaction_Aggregate_FieldsResolvers<ContextType>;
    Transaction_avg_fields?: Transaction_Avg_FieldsResolvers<ContextType>;
    Transaction_max_fields?: Transaction_Max_FieldsResolvers<ContextType>;
    Transaction_min_fields?: Transaction_Min_FieldsResolvers<ContextType>;
    Transaction_sum_fields?: Transaction_Sum_FieldsResolvers<ContextType>;
    TransactionInput?: TransactionInputResolvers<ContextType>;
    TransactionInput_aggregate?: TransactionInput_AggregateResolvers<ContextType>;
    TransactionInput_aggregate_fields?: TransactionInput_Aggregate_FieldsResolvers<ContextType>;
    TransactionInput_avg_fields?: TransactionInput_Avg_FieldsResolvers<ContextType>;
    TransactionInput_max_fields?: TransactionInput_Max_FieldsResolvers<ContextType>;
    TransactionInput_min_fields?: TransactionInput_Min_FieldsResolvers<ContextType>;
    TransactionInput_sum_fields?: TransactionInput_Sum_FieldsResolvers<ContextType>;
    TransactionOutput?: TransactionOutputResolvers<ContextType>;
    TransactionOutput_aggregate?: TransactionOutput_AggregateResolvers<ContextType>;
    TransactionOutput_aggregate_fields?: TransactionOutput_Aggregate_FieldsResolvers<ContextType>;
    TransactionOutput_avg_fields?: TransactionOutput_Avg_FieldsResolvers<ContextType>;
    TransactionOutput_max_fields?: TransactionOutput_Max_FieldsResolvers<ContextType>;
    TransactionOutput_min_fields?: TransactionOutput_Min_FieldsResolvers<ContextType>;
    TransactionOutput_sum_fields?: TransactionOutput_Sum_FieldsResolvers<ContextType>;
}>;
export declare type IResolvers<ContextType = any> = Resolvers<ContextType>;
//# sourceMappingURL=graphql_types.d.ts.map