@htsoft/reactjs-hooks/dist/graph-queries/aiza-indexer-types.d.ts

NFT information hepler for ReactJS

export declare type Maybe<T> = T | null;
export declare type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
export declare type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]: Maybe<T[SubKey]>;
};
/** All built-in and custom scalars, mapped to their actual values */
export declare type Scalars = {
    ID: string;
    String: string;
    Boolean: boolean;
    Int: number;
    Float: number;
    ask_event_status_enum: any;
    bid_event_status_enum: any;
    bid_status_enum: any;
    jsonb: any;
    timestamp: any;
    timestamptz: any;
    uuid: any;
};
/** columns and relationships of "auction" */
export declare type Auction = {
    __typename?: 'Auction';
    amountTokenOwnerReceived?: Maybe<Scalars['String']>;
    /** An array relationship */
    approvalEvents: Array<AuctionApprovalUpdatedEvent>;
    /** An aggregate relationship */
    approvalEvents_aggregate: AuctionApprovalUpdatedEvent_Aggregate;
    approved?: Maybe<Scalars['Boolean']>;
    auctionCurrency?: Maybe<Scalars['String']>;
    auctionId: Scalars['String'];
    /** An array relationship */
    bidEvents: Array<AuctionBidEvent>;
    /** An aggregate relationship */
    bidEvents_aggregate: AuctionBidEvent_Aggregate;
    /** An object relationship */
    canceledEvent?: Maybe<AuctionCanceledEvent>;
    /** An object relationship */
    createdEvent?: Maybe<AuctionCreatedEvent>;
    curator?: Maybe<Scalars['String']>;
    curatorFee?: Maybe<Scalars['String']>;
    curatorFeePercentage?: Maybe<Scalars['Int']>;
    /** An object relationship */
    currency?: Maybe<Currency>;
    duration?: Maybe<Scalars['String']>;
    /** An array relationship */
    durationExtendedEvents: Array<AuctionDurationExtendedEvent>;
    /** An aggregate relationship */
    durationExtendedEvents_aggregate: AuctionDurationExtendedEvent_Aggregate;
    /** An object relationship */
    endedEvent?: Maybe<AuctionEndedEvent>;
    expiresAt?: Maybe<Scalars['timestamptz']>;
    firstBidTime?: Maybe<Scalars['String']>;
    lastBidAmount?: Maybe<Scalars['String']>;
    lastBidder?: Maybe<Scalars['String']>;
    /** An object relationship */
    media?: Maybe<Media>;
    reservePrice?: Maybe<Scalars['String']>;
    /** An array relationship */
    reservePriceUpdatedEvents: Array<AuctionReservePriceUpdatedEvent>;
    /** An aggregate relationship */
    reservePriceUpdatedEvents_aggregate: AuctionReservePriceUpdatedEvent_Aggregate;
    /** An object relationship */
    token?: Maybe<Token>;
    tokenContract: Scalars['String'];
    tokenId: Scalars['String'];
    tokenOwner?: Maybe<Scalars['String']>;
    winner?: Maybe<Scalars['String']>;
};
/** columns and relationships of "auction" */
export declare type AuctionApprovalEventsArgs = {
    distinct_on?: Maybe<Array<AuctionApprovalUpdatedEvent_Select_Column>>;
    limit?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<AuctionApprovalUpdatedEvent_Order_By>>;
    where?: Maybe<AuctionApprovalUpdatedEvent_Bool_Exp>;
};
/** columns and relationships of "auction" */
export declare type AuctionApprovalEvents_AggregateArgs = {
    distinct_on?: Maybe<Array<AuctionApprovalUpdatedEvent_Select_Column>>;
    limit?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<AuctionApprovalUpdatedEvent_Order_By>>;
    where?: Maybe<AuctionApprovalUpdatedEvent_Bool_Exp>;
};
/** columns and relationships of "auction" */
export declare type AuctionBidEventsArgs = {
    distinct_on?: Maybe<Array<AuctionBidEvent_Select_Column>>;
    limit?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<AuctionBidEvent_Order_By>>;
    where?: Maybe<AuctionBidEvent_Bool_Exp>;
};
/** columns and relationships of "auction" */
export declare type AuctionBidEvents_AggregateArgs = {
    distinct_on?: Maybe<Array<AuctionBidEvent_Select_Column>>;
    limit?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<AuctionBidEvent_Order_By>>;
    where?: Maybe<AuctionBidEvent_Bool_Exp>;
};
/** columns and relationships of "auction" */
export declare type AuctionDurationExtendedEventsArgs = {
    distinct_on?: Maybe<Array<AuctionDurationExtendedEvent_Select_Column>>;
    limit?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<AuctionDurationExtendedEvent_Order_By>>;
    where?: Maybe<AuctionDurationExtendedEvent_Bool_Exp>;
};
/** columns and relationships of "auction" */
export declare type AuctionDurationExtendedEvents_AggregateArgs = {
    distinct_on?: Maybe<Array<AuctionDurationExtendedEvent_Select_Column>>;
    limit?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<AuctionDurationExtendedEvent_Order_By>>;
    where?: Maybe<AuctionDurationExtendedEvent_Bool_Exp>;
};
/** columns and relationships of "auction" */
export declare type AuctionReservePriceUpdatedEventsArgs = {
    distinct_on?: Maybe<Array<AuctionReservePriceUpdatedEvent_Select_Column>>;
    limit?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<AuctionReservePriceUpdatedEvent_Order_By>>;
    where?: Maybe<AuctionReservePriceUpdatedEvent_Bool_Exp>;
};
/** columns and relationships of "auction" */
export declare type AuctionReservePriceUpdatedEvents_AggregateArgs = {
    distinct_on?: Maybe<Array<AuctionReservePriceUpdatedEvent_Select_Column>>;
    limit?: Maybe<Scalars['Int']>;
    offset?: Maybe<Scalars['Int']>;
    order_by?: Maybe<Array<AuctionReservePriceUpdatedEvent_Order_By>>;
    where?: Maybe<AuctionReservePriceUpdatedEvent_Bool_Exp>;
};
/** columns and relationships of "auction_approval_updated_event" */
export declare type AuctionApprovalUpdatedEvent = {
    __typename?: 'AuctionApprovalUpdatedEvent';
    address: Scalars['String'];
    approved: Scalars['Boolean'];
    /** An object relationship */
    auction?: Maybe<Auction>;
    auctionId: Scalars['String'];
    blockNumber: Scalars['Int'];
    blockTimestamp: Scalars['timestamp'];
    /** An object relationship */
    eventLog: EventLog;
    eventLogId: Scalars['String'];
    id: Scalars['String'];
    logIndex: Scalars['Int'];
    /** An object relationship */
    media?: Maybe<Media>;
    /** An object relationship */
    token?: Maybe<Token>;
    tokenContract: Scalars['String'];
    tokenId: Scalars['String'];
    /** An object relationship */
    transaction: Transaction;
    transactionHash: Scalars['String'];
};
/** aggregated selection of "auction_approval_updated_event" */
export declare type AuctionApprovalUpdatedEvent_Aggregate = {
    __typename?: 'AuctionApprovalUpdatedEvent_aggregate';
    aggregate?: Maybe<AuctionApprovalUpdatedEvent_Aggregate_Fields>;
    nodes: Array<AuctionApprovalUpdatedEvent>;
};
/** aggregate fields of "auction_approval_updated_event" */
export declare type AuctionApprovalUpdatedEvent_Aggregate_Fields = {
    __typename?: 'AuctionApprovalUpdatedEvent_aggregate_fields';
    avg?: Maybe<AuctionApprovalUpdatedEvent_Avg_Fields>;
    count: Scalars['Int'];
    max?: Maybe<AuctionApprovalUpdatedEvent_Max_Fields>;
    min?: Maybe<AuctionApprovalUpdatedEvent_Min_Fields>;
    stddev?: Maybe<AuctionApprovalUpdatedEvent_Stddev_Fields>;
    stddev_pop?: Maybe<AuctionApprovalUpdatedEvent_Stddev_Pop_Fields>;
    stddev_samp?: Maybe<AuctionApprovalUpdatedEvent_Stddev_Samp_Fields>;
    sum?: Maybe<AuctionApprovalUpdatedEvent_Sum_Fields>;
    var_pop?: Maybe<AuctionApprovalUpdatedEvent_Var_Pop_Fields>;
    var_samp?: Maybe<AuctionApprovalUpdatedEvent_Var_Samp_Fields>;
    variance?: Maybe<AuctionApprovalUpdatedEvent_Variance_Fields>;
};
/** aggregate fields of "auction_approval_updated_event" */
export declare type AuctionApprovalUpdatedEvent_Aggregate_FieldsCountArgs = {
    columns?: Maybe<Array<AuctionApprovalUpdatedEvent_Select_Column>>;
    distinct?: Maybe<Scalars['Boolean']>;
};
/** order by aggregate values of table "auction_approval_updated_event" */
export declare type AuctionApprovalUpdatedEvent_Aggregate_Order_By = {
    avg?: Maybe<AuctionApprovalUpdatedEvent_Avg_Order_By>;
    count?: Maybe<Order_By>;
    max?: Maybe<AuctionApprovalUpdatedEvent_Max_Order_By>;
    min?: Maybe<AuctionApprovalUpdatedEvent_Min_Order_By>;
    stddev?: Maybe<AuctionApprovalUpdatedEvent_Stddev_Order_By>;
    stddev_pop?: Maybe<AuctionApprovalUpdatedEvent_Stddev_Pop_Order_By>;
    stddev_samp?: Maybe<AuctionApprovalUpdatedEvent_Stddev_Samp_Order_By>;
    sum?: Maybe<AuctionApprovalUpdatedEvent_Sum_Order_By>;
    var_pop?: Maybe<AuctionApprovalUpdatedEvent_Var_Pop_Order_By>;
    var_samp?: Maybe<AuctionApprovalUpdatedEvent_Var_Samp_Order_By>;
    variance?: Maybe<AuctionApprovalUpdatedEvent_Variance_Order_By>;
};
/** aggregate avg on columns */
export declare type AuctionApprovalUpdatedEvent_Avg_Fields = {
    __typename?: 'AuctionApprovalUpdatedEvent_avg_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by avg() on columns of table "auction_approval_updated_event" */
export declare type AuctionApprovalUpdatedEvent_Avg_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/**
 * Boolean expression to filter rows from the table
 * "auction_approval_updated_event". All fields are combined with a logical 'AND'.
 */
export declare type AuctionApprovalUpdatedEvent_Bool_Exp = {
    _and?: Maybe<Array<AuctionApprovalUpdatedEvent_Bool_Exp>>;
    _not?: Maybe<AuctionApprovalUpdatedEvent_Bool_Exp>;
    _or?: Maybe<Array<AuctionApprovalUpdatedEvent_Bool_Exp>>;
    address?: Maybe<String_Comparison_Exp>;
    approved?: Maybe<Boolean_Comparison_Exp>;
    auction?: Maybe<Auction_Bool_Exp>;
    auctionId?: Maybe<String_Comparison_Exp>;
    blockNumber?: Maybe<Int_Comparison_Exp>;
    blockTimestamp?: Maybe<Timestamp_Comparison_Exp>;
    eventLog?: Maybe<EventLog_Bool_Exp>;
    eventLogId?: Maybe<String_Comparison_Exp>;
    id?: Maybe<String_Comparison_Exp>;
    logIndex?: Maybe<Int_Comparison_Exp>;
    media?: Maybe<Media_Bool_Exp>;
    token?: Maybe<Token_Bool_Exp>;
    tokenContract?: Maybe<String_Comparison_Exp>;
    tokenId?: Maybe<String_Comparison_Exp>;
    transaction?: Maybe<Transaction_Bool_Exp>;
    transactionHash?: Maybe<String_Comparison_Exp>;
};
/** aggregate max on columns */
export declare type AuctionApprovalUpdatedEvent_Max_Fields = {
    __typename?: 'AuctionApprovalUpdatedEvent_max_fields';
    address?: Maybe<Scalars['String']>;
    auctionId?: Maybe<Scalars['String']>;
    blockNumber?: Maybe<Scalars['Int']>;
    blockTimestamp?: Maybe<Scalars['timestamp']>;
    eventLogId?: Maybe<Scalars['String']>;
    id?: Maybe<Scalars['String']>;
    logIndex?: Maybe<Scalars['Int']>;
    tokenContract?: Maybe<Scalars['String']>;
    tokenId?: Maybe<Scalars['String']>;
    transactionHash?: Maybe<Scalars['String']>;
};
/** order by max() on columns of table "auction_approval_updated_event" */
export declare type AuctionApprovalUpdatedEvent_Max_Order_By = {
    address?: Maybe<Order_By>;
    auctionId?: Maybe<Order_By>;
    blockNumber?: Maybe<Order_By>;
    blockTimestamp?: Maybe<Order_By>;
    eventLogId?: Maybe<Order_By>;
    id?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
    tokenContract?: Maybe<Order_By>;
    tokenId?: Maybe<Order_By>;
    transactionHash?: Maybe<Order_By>;
};
/** aggregate min on columns */
export declare type AuctionApprovalUpdatedEvent_Min_Fields = {
    __typename?: 'AuctionApprovalUpdatedEvent_min_fields';
    address?: Maybe<Scalars['String']>;
    auctionId?: Maybe<Scalars['String']>;
    blockNumber?: Maybe<Scalars['Int']>;
    blockTimestamp?: Maybe<Scalars['timestamp']>;
    eventLogId?: Maybe<Scalars['String']>;
    id?: Maybe<Scalars['String']>;
    logIndex?: Maybe<Scalars['Int']>;
    tokenContract?: Maybe<Scalars['String']>;
    tokenId?: Maybe<Scalars['String']>;
    transactionHash?: Maybe<Scalars['String']>;
};
/** order by min() on columns of table "auction_approval_updated_event" */
export declare type AuctionApprovalUpdatedEvent_Min_Order_By = {
    address?: Maybe<Order_By>;
    auctionId?: Maybe<Order_By>;
    blockNumber?: Maybe<Order_By>;
    blockTimestamp?: Maybe<Order_By>;
    eventLogId?: Maybe<Order_By>;
    id?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
    tokenContract?: Maybe<Order_By>;
    tokenId?: Maybe<Order_By>;
    transactionHash?: Maybe<Order_By>;
};
/** Ordering options when selecting data from "auction_approval_updated_event". */
export declare type AuctionApprovalUpdatedEvent_Order_By = {
    address?: Maybe<Order_By>;
    approved?: Maybe<Order_By>;
    auction?: Maybe<Auction_Order_By>;
    auctionId?: Maybe<Order_By>;
    blockNumber?: Maybe<Order_By>;
    blockTimestamp?: Maybe<Order_By>;
    eventLog?: Maybe<EventLog_Order_By>;
    eventLogId?: Maybe<Order_By>;
    id?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
    media?: Maybe<Media_Order_By>;
    token?: Maybe<Token_Order_By>;
    tokenContract?: Maybe<Order_By>;
    tokenId?: Maybe<Order_By>;
    transaction?: Maybe<Transaction_Order_By>;
    transactionHash?: Maybe<Order_By>;
};
/** select columns of table "auction_approval_updated_event" */
export declare enum AuctionApprovalUpdatedEvent_Select_Column {
    /** column name */
    Address = "address",
    /** column name */
    Approved = "approved",
    /** column name */
    AuctionId = "auctionId",
    /** column name */
    BlockNumber = "blockNumber",
    /** column name */
    BlockTimestamp = "blockTimestamp",
    /** column name */
    EventLogId = "eventLogId",
    /** column name */
    Id = "id",
    /** column name */
    LogIndex = "logIndex",
    /** column name */
    TokenContract = "tokenContract",
    /** column name */
    TokenId = "tokenId",
    /** column name */
    TransactionHash = "transactionHash"
}
/** aggregate stddev on columns */
export declare type AuctionApprovalUpdatedEvent_Stddev_Fields = {
    __typename?: 'AuctionApprovalUpdatedEvent_stddev_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by stddev() on columns of table "auction_approval_updated_event" */
export declare type AuctionApprovalUpdatedEvent_Stddev_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** aggregate stddev_pop on columns */
export declare type AuctionApprovalUpdatedEvent_Stddev_Pop_Fields = {
    __typename?: 'AuctionApprovalUpdatedEvent_stddev_pop_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by stddev_pop() on columns of table "auction_approval_updated_event" */
export declare type AuctionApprovalUpdatedEvent_Stddev_Pop_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** aggregate stddev_samp on columns */
export declare type AuctionApprovalUpdatedEvent_Stddev_Samp_Fields = {
    __typename?: 'AuctionApprovalUpdatedEvent_stddev_samp_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by stddev_samp() on columns of table "auction_approval_updated_event" */
export declare type AuctionApprovalUpdatedEvent_Stddev_Samp_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** aggregate sum on columns */
export declare type AuctionApprovalUpdatedEvent_Sum_Fields = {
    __typename?: 'AuctionApprovalUpdatedEvent_sum_fields';
    blockNumber?: Maybe<Scalars['Int']>;
    logIndex?: Maybe<Scalars['Int']>;
};
/** order by sum() on columns of table "auction_approval_updated_event" */
export declare type AuctionApprovalUpdatedEvent_Sum_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** aggregate var_pop on columns */
export declare type AuctionApprovalUpdatedEvent_Var_Pop_Fields = {
    __typename?: 'AuctionApprovalUpdatedEvent_var_pop_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by var_pop() on columns of table "auction_approval_updated_event" */
export declare type AuctionApprovalUpdatedEvent_Var_Pop_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** aggregate var_samp on columns */
export declare type AuctionApprovalUpdatedEvent_Var_Samp_Fields = {
    __typename?: 'AuctionApprovalUpdatedEvent_var_samp_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by var_samp() on columns of table "auction_approval_updated_event" */
export declare type AuctionApprovalUpdatedEvent_Var_Samp_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** aggregate variance on columns */
export declare type AuctionApprovalUpdatedEvent_Variance_Fields = {
    __typename?: 'AuctionApprovalUpdatedEvent_variance_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by variance() on columns of table "auction_approval_updated_event" */
export declare type AuctionApprovalUpdatedEvent_Variance_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** columns and relationships of "auction_bid_event" */
export declare type AuctionBidEvent = {
    __typename?: 'AuctionBidEvent';
    address: Scalars['String'];
    /** An object relationship */
    auction?: Maybe<Auction>;
    auctionId: Scalars['String'];
    blockNumber: Scalars['Int'];
    blockTimestamp: Scalars['timestamp'];
    /** An object relationship */
    eventLog: EventLog;
    eventLogId: Scalars['String'];
    extended: Scalars['Boolean'];
    firstBid: Scalars['Boolean'];
    id: Scalars['String'];
    logIndex: Scalars['Int'];
    /** An object relationship */
    media?: Maybe<Media>;
    sender: Scalars['String'];
    /** An object relationship */
    token?: Maybe<Token>;
    tokenContract: Scalars['String'];
    tokenId: Scalars['String'];
    /** An object relationship */
    transaction: Transaction;
    transactionHash: Scalars['String'];
    value: Scalars['String'];
};
/** aggregated selection of "auction_bid_event" */
export declare type AuctionBidEvent_Aggregate = {
    __typename?: 'AuctionBidEvent_aggregate';
    aggregate?: Maybe<AuctionBidEvent_Aggregate_Fields>;
    nodes: Array<AuctionBidEvent>;
};
/** aggregate fields of "auction_bid_event" */
export declare type AuctionBidEvent_Aggregate_Fields = {
    __typename?: 'AuctionBidEvent_aggregate_fields';
    avg?: Maybe<AuctionBidEvent_Avg_Fields>;
    count: Scalars['Int'];
    max?: Maybe<AuctionBidEvent_Max_Fields>;
    min?: Maybe<AuctionBidEvent_Min_Fields>;
    stddev?: Maybe<AuctionBidEvent_Stddev_Fields>;
    stddev_pop?: Maybe<AuctionBidEvent_Stddev_Pop_Fields>;
    stddev_samp?: Maybe<AuctionBidEvent_Stddev_Samp_Fields>;
    sum?: Maybe<AuctionBidEvent_Sum_Fields>;
    var_pop?: Maybe<AuctionBidEvent_Var_Pop_Fields>;
    var_samp?: Maybe<AuctionBidEvent_Var_Samp_Fields>;
    variance?: Maybe<AuctionBidEvent_Variance_Fields>;
};
/** aggregate fields of "auction_bid_event" */
export declare type AuctionBidEvent_Aggregate_FieldsCountArgs = {
    columns?: Maybe<Array<AuctionBidEvent_Select_Column>>;
    distinct?: Maybe<Scalars['Boolean']>;
};
/** order by aggregate values of table "auction_bid_event" */
export declare type AuctionBidEvent_Aggregate_Order_By = {
    avg?: Maybe<AuctionBidEvent_Avg_Order_By>;
    count?: Maybe<Order_By>;
    max?: Maybe<AuctionBidEvent_Max_Order_By>;
    min?: Maybe<AuctionBidEvent_Min_Order_By>;
    stddev?: Maybe<AuctionBidEvent_Stddev_Order_By>;
    stddev_pop?: Maybe<AuctionBidEvent_Stddev_Pop_Order_By>;
    stddev_samp?: Maybe<AuctionBidEvent_Stddev_Samp_Order_By>;
    sum?: Maybe<AuctionBidEvent_Sum_Order_By>;
    var_pop?: Maybe<AuctionBidEvent_Var_Pop_Order_By>;
    var_samp?: Maybe<AuctionBidEvent_Var_Samp_Order_By>;
    variance?: Maybe<AuctionBidEvent_Variance_Order_By>;
};
/** aggregate avg on columns */
export declare type AuctionBidEvent_Avg_Fields = {
    __typename?: 'AuctionBidEvent_avg_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by avg() on columns of table "auction_bid_event" */
export declare type AuctionBidEvent_Avg_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** Boolean expression to filter rows from the table "auction_bid_event". All fields are combined with a logical 'AND'. */
export declare type AuctionBidEvent_Bool_Exp = {
    _and?: Maybe<Array<AuctionBidEvent_Bool_Exp>>;
    _not?: Maybe<AuctionBidEvent_Bool_Exp>;
    _or?: Maybe<Array<AuctionBidEvent_Bool_Exp>>;
    address?: Maybe<String_Comparison_Exp>;
    auction?: Maybe<Auction_Bool_Exp>;
    auctionId?: Maybe<String_Comparison_Exp>;
    blockNumber?: Maybe<Int_Comparison_Exp>;
    blockTimestamp?: Maybe<Timestamp_Comparison_Exp>;
    eventLog?: Maybe<EventLog_Bool_Exp>;
    eventLogId?: Maybe<String_Comparison_Exp>;
    extended?: Maybe<Boolean_Comparison_Exp>;
    firstBid?: Maybe<Boolean_Comparison_Exp>;
    id?: Maybe<String_Comparison_Exp>;
    logIndex?: Maybe<Int_Comparison_Exp>;
    media?: Maybe<Media_Bool_Exp>;
    sender?: Maybe<String_Comparison_Exp>;
    token?: Maybe<Token_Bool_Exp>;
    tokenContract?: Maybe<String_Comparison_Exp>;
    tokenId?: Maybe<String_Comparison_Exp>;
    transaction?: Maybe<Transaction_Bool_Exp>;
    transactionHash?: Maybe<String_Comparison_Exp>;
    value?: Maybe<String_Comparison_Exp>;
};
/** aggregate max on columns */
export declare type AuctionBidEvent_Max_Fields = {
    __typename?: 'AuctionBidEvent_max_fields';
    address?: Maybe<Scalars['String']>;
    auctionId?: Maybe<Scalars['String']>;
    blockNumber?: Maybe<Scalars['Int']>;
    blockTimestamp?: Maybe<Scalars['timestamp']>;
    eventLogId?: Maybe<Scalars['String']>;
    id?: Maybe<Scalars['String']>;
    logIndex?: Maybe<Scalars['Int']>;
    sender?: Maybe<Scalars['String']>;
    tokenContract?: Maybe<Scalars['String']>;
    tokenId?: Maybe<Scalars['String']>;
    transactionHash?: Maybe<Scalars['String']>;
    value?: Maybe<Scalars['String']>;
};
/** order by max() on columns of table "auction_bid_event" */
export declare type AuctionBidEvent_Max_Order_By = {
    address?: Maybe<Order_By>;
    auctionId?: Maybe<Order_By>;
    blockNumber?: Maybe<Order_By>;
    blockTimestamp?: Maybe<Order_By>;
    eventLogId?: Maybe<Order_By>;
    id?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
    sender?: Maybe<Order_By>;
    tokenContract?: Maybe<Order_By>;
    tokenId?: Maybe<Order_By>;
    transactionHash?: Maybe<Order_By>;
    value?: Maybe<Order_By>;
};
/** aggregate min on columns */
export declare type AuctionBidEvent_Min_Fields = {
    __typename?: 'AuctionBidEvent_min_fields';
    address?: Maybe<Scalars['String']>;
    auctionId?: Maybe<Scalars['String']>;
    blockNumber?: Maybe<Scalars['Int']>;
    blockTimestamp?: Maybe<Scalars['timestamp']>;
    eventLogId?: Maybe<Scalars['String']>;
    id?: Maybe<Scalars['String']>;
    logIndex?: Maybe<Scalars['Int']>;
    sender?: Maybe<Scalars['String']>;
    tokenContract?: Maybe<Scalars['String']>;
    tokenId?: Maybe<Scalars['String']>;
    transactionHash?: Maybe<Scalars['String']>;
    value?: Maybe<Scalars['String']>;
};
/** order by min() on columns of table "auction_bid_event" */
export declare type AuctionBidEvent_Min_Order_By = {
    address?: Maybe<Order_By>;
    auctionId?: Maybe<Order_By>;
    blockNumber?: Maybe<Order_By>;
    blockTimestamp?: Maybe<Order_By>;
    eventLogId?: Maybe<Order_By>;
    id?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
    sender?: Maybe<Order_By>;
    tokenContract?: Maybe<Order_By>;
    tokenId?: Maybe<Order_By>;
    transactionHash?: Maybe<Order_By>;
    value?: Maybe<Order_By>;
};
/** Ordering options when selecting data from "auction_bid_event". */
export declare type AuctionBidEvent_Order_By = {
    address?: Maybe<Order_By>;
    auction?: Maybe<Auction_Order_By>;
    auctionId?: Maybe<Order_By>;
    blockNumber?: Maybe<Order_By>;
    blockTimestamp?: Maybe<Order_By>;
    eventLog?: Maybe<EventLog_Order_By>;
    eventLogId?: Maybe<Order_By>;
    extended?: Maybe<Order_By>;
    firstBid?: Maybe<Order_By>;
    id?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
    media?: Maybe<Media_Order_By>;
    sender?: Maybe<Order_By>;
    token?: Maybe<Token_Order_By>;
    tokenContract?: Maybe<Order_By>;
    tokenId?: Maybe<Order_By>;
    transaction?: Maybe<Transaction_Order_By>;
    transactionHash?: Maybe<Order_By>;
    value?: Maybe<Order_By>;
};
/** select columns of table "auction_bid_event" */
export declare enum AuctionBidEvent_Select_Column {
    /** column name */
    Address = "address",
    /** column name */
    AuctionId = "auctionId",
    /** column name */
    BlockNumber = "blockNumber",
    /** column name */
    BlockTimestamp = "blockTimestamp",
    /** column name */
    EventLogId = "eventLogId",
    /** column name */
    Extended = "extended",
    /** column name */
    FirstBid = "firstBid",
    /** column name */
    Id = "id",
    /** column name */
    LogIndex = "logIndex",
    /** column name */
    Sender = "sender",
    /** column name */
    TokenContract = "tokenContract",
    /** column name */
    TokenId = "tokenId",
    /** column name */
    TransactionHash = "transactionHash",
    /** column name */
    Value = "value"
}
/** aggregate stddev on columns */
export declare type AuctionBidEvent_Stddev_Fields = {
    __typename?: 'AuctionBidEvent_stddev_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by stddev() on columns of table "auction_bid_event" */
export declare type AuctionBidEvent_Stddev_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** aggregate stddev_pop on columns */
export declare type AuctionBidEvent_Stddev_Pop_Fields = {
    __typename?: 'AuctionBidEvent_stddev_pop_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by stddev_pop() on columns of table "auction_bid_event" */
export declare type AuctionBidEvent_Stddev_Pop_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** aggregate stddev_samp on columns */
export declare type AuctionBidEvent_Stddev_Samp_Fields = {
    __typename?: 'AuctionBidEvent_stddev_samp_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by stddev_samp() on columns of table "auction_bid_event" */
export declare type AuctionBidEvent_Stddev_Samp_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** aggregate sum on columns */
export declare type AuctionBidEvent_Sum_Fields = {
    __typename?: 'AuctionBidEvent_sum_fields';
    blockNumber?: Maybe<Scalars['Int']>;
    logIndex?: Maybe<Scalars['Int']>;
};
/** order by sum() on columns of table "auction_bid_event" */
export declare type AuctionBidEvent_Sum_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** aggregate var_pop on columns */
export declare type AuctionBidEvent_Var_Pop_Fields = {
    __typename?: 'AuctionBidEvent_var_pop_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by var_pop() on columns of table "auction_bid_event" */
export declare type AuctionBidEvent_Var_Pop_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** aggregate var_samp on columns */
export declare type AuctionBidEvent_Var_Samp_Fields = {
    __typename?: 'AuctionBidEvent_var_samp_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by var_samp() on columns of table "auction_bid_event" */
export declare type AuctionBidEvent_Var_Samp_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** aggregate variance on columns */
export declare type AuctionBidEvent_Variance_Fields = {
    __typename?: 'AuctionBidEvent_variance_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by variance() on columns of table "auction_bid_event" */
export declare type AuctionBidEvent_Variance_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** columns and relationships of "auction_canceled_event" */
export declare type AuctionCanceledEvent = {
    __typename?: 'AuctionCanceledEvent';
    address: Scalars['String'];
    /** An object relationship */
    auction?: Maybe<Auction>;
    auctionId: Scalars['String'];
    blockNumber: Scalars['Int'];
    blockTimestamp: Scalars['timestamp'];
    /** An object relationship */
    eventLog: EventLog;
    eventLogId: Scalars['String'];
    id: Scalars['String'];
    logIndex: Scalars['Int'];
    /** An object relationship */
    media?: Maybe<Media>;
    /** An object relationship */
    token?: Maybe<Token>;
    tokenContract: Scalars['String'];
    tokenId: Scalars['String'];
    tokenOwner: Scalars['String'];
    /** An object relationship */
    transaction: Transaction;
    transactionHash: Scalars['String'];
};
/** aggregated selection of "auction_canceled_event" */
export declare type AuctionCanceledEvent_Aggregate = {
    __typename?: 'AuctionCanceledEvent_aggregate';
    aggregate?: Maybe<AuctionCanceledEvent_Aggregate_Fields>;
    nodes: Array<AuctionCanceledEvent>;
};
/** aggregate fields of "auction_canceled_event" */
export declare type AuctionCanceledEvent_Aggregate_Fields = {
    __typename?: 'AuctionCanceledEvent_aggregate_fields';
    avg?: Maybe<AuctionCanceledEvent_Avg_Fields>;
    count: Scalars['Int'];
    max?: Maybe<AuctionCanceledEvent_Max_Fields>;
    min?: Maybe<AuctionCanceledEvent_Min_Fields>;
    stddev?: Maybe<AuctionCanceledEvent_Stddev_Fields>;
    stddev_pop?: Maybe<AuctionCanceledEvent_Stddev_Pop_Fields>;
    stddev_samp?: Maybe<AuctionCanceledEvent_Stddev_Samp_Fields>;
    sum?: Maybe<AuctionCanceledEvent_Sum_Fields>;
    var_pop?: Maybe<AuctionCanceledEvent_Var_Pop_Fields>;
    var_samp?: Maybe<AuctionCanceledEvent_Var_Samp_Fields>;
    variance?: Maybe<AuctionCanceledEvent_Variance_Fields>;
};
/** aggregate fields of "auction_canceled_event" */
export declare type AuctionCanceledEvent_Aggregate_FieldsCountArgs = {
    columns?: Maybe<Array<AuctionCanceledEvent_Select_Column>>;
    distinct?: Maybe<Scalars['Boolean']>;
};
/** order by aggregate values of table "auction_canceled_event" */
export declare type AuctionCanceledEvent_Aggregate_Order_By = {
    avg?: Maybe<AuctionCanceledEvent_Avg_Order_By>;
    count?: Maybe<Order_By>;
    max?: Maybe<AuctionCanceledEvent_Max_Order_By>;
    min?: Maybe<AuctionCanceledEvent_Min_Order_By>;
    stddev?: Maybe<AuctionCanceledEvent_Stddev_Order_By>;
    stddev_pop?: Maybe<AuctionCanceledEvent_Stddev_Pop_Order_By>;
    stddev_samp?: Maybe<AuctionCanceledEvent_Stddev_Samp_Order_By>;
    sum?: Maybe<AuctionCanceledEvent_Sum_Order_By>;
    var_pop?: Maybe<AuctionCanceledEvent_Var_Pop_Order_By>;
    var_samp?: Maybe<AuctionCanceledEvent_Var_Samp_Order_By>;
    variance?: Maybe<AuctionCanceledEvent_Variance_Order_By>;
};
/** aggregate avg on columns */
export declare type AuctionCanceledEvent_Avg_Fields = {
    __typename?: 'AuctionCanceledEvent_avg_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by avg() on columns of table "auction_canceled_event" */
export declare type AuctionCanceledEvent_Avg_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** Boolean expression to filter rows from the table "auction_canceled_event". All fields are combined with a logical 'AND'. */
export declare type AuctionCanceledEvent_Bool_Exp = {
    _and?: Maybe<Array<AuctionCanceledEvent_Bool_Exp>>;
    _not?: Maybe<AuctionCanceledEvent_Bool_Exp>;
    _or?: Maybe<Array<AuctionCanceledEvent_Bool_Exp>>;
    address?: Maybe<String_Comparison_Exp>;
    auction?: Maybe<Auction_Bool_Exp>;
    auctionId?: Maybe<String_Comparison_Exp>;
    blockNumber?: Maybe<Int_Comparison_Exp>;
    blockTimestamp?: Maybe<Timestamp_Comparison_Exp>;
    eventLog?: Maybe<EventLog_Bool_Exp>;
    eventLogId?: Maybe<String_Comparison_Exp>;
    id?: Maybe<String_Comparison_Exp>;
    logIndex?: Maybe<Int_Comparison_Exp>;
    media?: Maybe<Media_Bool_Exp>;
    token?: Maybe<Token_Bool_Exp>;
    tokenContract?: Maybe<String_Comparison_Exp>;
    tokenId?: Maybe<String_Comparison_Exp>;
    tokenOwner?: Maybe<String_Comparison_Exp>;
    transaction?: Maybe<Transaction_Bool_Exp>;
    transactionHash?: Maybe<String_Comparison_Exp>;
};
/** aggregate max on columns */
export declare type AuctionCanceledEvent_Max_Fields = {
    __typename?: 'AuctionCanceledEvent_max_fields';
    address?: Maybe<Scalars['String']>;
    auctionId?: Maybe<Scalars['String']>;
    blockNumber?: Maybe<Scalars['Int']>;
    blockTimestamp?: Maybe<Scalars['timestamp']>;
    eventLogId?: Maybe<Scalars['String']>;
    id?: Maybe<Scalars['String']>;
    logIndex?: Maybe<Scalars['Int']>;
    tokenContract?: Maybe<Scalars['String']>;
    tokenId?: Maybe<Scalars['String']>;
    tokenOwner?: Maybe<Scalars['String']>;
    transactionHash?: Maybe<Scalars['String']>;
};
/** order by max() on columns of table "auction_canceled_event" */
export declare type AuctionCanceledEvent_Max_Order_By = {
    address?: Maybe<Order_By>;
    auctionId?: Maybe<Order_By>;
    blockNumber?: Maybe<Order_By>;
    blockTimestamp?: Maybe<Order_By>;
    eventLogId?: Maybe<Order_By>;
    id?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
    tokenContract?: Maybe<Order_By>;
    tokenId?: Maybe<Order_By>;
    tokenOwner?: Maybe<Order_By>;
    transactionHash?: Maybe<Order_By>;
};
/** aggregate min on columns */
export declare type AuctionCanceledEvent_Min_Fields = {
    __typename?: 'AuctionCanceledEvent_min_fields';
    address?: Maybe<Scalars['String']>;
    auctionId?: Maybe<Scalars['String']>;
    blockNumber?: Maybe<Scalars['Int']>;
    blockTimestamp?: Maybe<Scalars['timestamp']>;
    eventLogId?: Maybe<Scalars['String']>;
    id?: Maybe<Scalars['String']>;
    logIndex?: Maybe<Scalars['Int']>;
    tokenContract?: Maybe<Scalars['String']>;
    tokenId?: Maybe<Scalars['String']>;
    tokenOwner?: Maybe<Scalars['String']>;
    transactionHash?: Maybe<Scalars['String']>;
};
/** order by min() on columns of table "auction_canceled_event" */
export declare type AuctionCanceledEvent_Min_Order_By = {
    address?: Maybe<Order_By>;
    auctionId?: Maybe<Order_By>;
    blockNumber?: Maybe<Order_By>;
    blockTimestamp?: Maybe<Order_By>;
    eventLogId?: Maybe<Order_By>;
    id?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
    tokenContract?: Maybe<Order_By>;
    tokenId?: Maybe<Order_By>;
    tokenOwner?: Maybe<Order_By>;
    transactionHash?: Maybe<Order_By>;
};
/** Ordering options when selecting data from "auction_canceled_event". */
export declare type AuctionCanceledEvent_Order_By = {
    address?: Maybe<Order_By>;
    auction?: Maybe<Auction_Order_By>;
    auctionId?: Maybe<Order_By>;
    blockNumber?: Maybe<Order_By>;
    blockTimestamp?: Maybe<Order_By>;
    eventLog?: Maybe<EventLog_Order_By>;
    eventLogId?: Maybe<Order_By>;
    id?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
    media?: Maybe<Media_Order_By>;
    token?: Maybe<Token_Order_By>;
    tokenContract?: Maybe<Order_By>;
    tokenId?: Maybe<Order_By>;
    tokenOwner?: Maybe<Order_By>;
    transaction?: Maybe<Transaction_Order_By>;
    transactionHash?: Maybe<Order_By>;
};
/** select columns of table "auction_canceled_event" */
export declare enum AuctionCanceledEvent_Select_Column {
    /** column name */
    Address = "address",
    /** column name */
    AuctionId = "auctionId",
    /** column name */
    BlockNumber = "blockNumber",
    /** column name */
    BlockTimestamp = "blockTimestamp",
    /** column name */
    EventLogId = "eventLogId",
    /** column name */
    Id = "id",
    /** column name */
    LogIndex = "logIndex",
    /** column name */
    TokenContract = "tokenContract",
    /** column name */
    TokenId = "tokenId",
    /** column name */
    TokenOwner = "tokenOwner",
    /** column name */
    TransactionHash = "transactionHash"
}
/** aggregate stddev on columns */
export declare type AuctionCanceledEvent_Stddev_Fields = {
    __typename?: 'AuctionCanceledEvent_stddev_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by stddev() on columns of table "auction_canceled_event" */
export declare type AuctionCanceledEvent_Stddev_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** aggregate stddev_pop on columns */
export declare type AuctionCanceledEvent_Stddev_Pop_Fields = {
    __typename?: 'AuctionCanceledEvent_stddev_pop_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by stddev_pop() on columns of table "auction_canceled_event" */
export declare type AuctionCanceledEvent_Stddev_Pop_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** aggregate stddev_samp on columns */
export declare type AuctionCanceledEvent_Stddev_Samp_Fields = {
    __typename?: 'AuctionCanceledEvent_stddev_samp_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by stddev_samp() on columns of table "auction_canceled_event" */
export declare type AuctionCanceledEvent_Stddev_Samp_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** aggregate sum on columns */
export declare type AuctionCanceledEvent_Sum_Fields = {
    __typename?: 'AuctionCanceledEvent_sum_fields';
    blockNumber?: Maybe<Scalars['Int']>;
    logIndex?: Maybe<Scalars['Int']>;
};
/** order by sum() on columns of table "auction_canceled_event" */
export declare type AuctionCanceledEvent_Sum_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** aggregate var_pop on columns */
export declare type AuctionCanceledEvent_Var_Pop_Fields = {
    __typename?: 'AuctionCanceledEvent_var_pop_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by var_pop() on columns of table "auction_canceled_event" */
export declare type AuctionCanceledEvent_Var_Pop_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** aggregate var_samp on columns */
export declare type AuctionCanceledEvent_Var_Samp_Fields = {
    __typename?: 'AuctionCanceledEvent_var_samp_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by var_samp() on columns of table "auction_canceled_event" */
export declare type AuctionCanceledEvent_Var_Samp_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** aggregate variance on columns */
export declare type AuctionCanceledEvent_Variance_Fields = {
    __typename?: 'AuctionCanceledEvent_variance_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by variance() on columns of table "auction_canceled_event" */
export declare type AuctionCanceledEvent_Variance_Order_By = {
    blockNumber?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** columns and relationships of "auction_created_event" */
export declare type AuctionCreatedEvent = {
    __typename?: 'AuctionCreatedEvent';
    address: Scalars['String'];
    /** An object relationship */
    auction?: Maybe<Auction>;
    auctionCurrency: Scalars['String'];
    auctionId: Scalars['String'];
    blockNumber: Scalars['Int'];
    blockTimestamp: Scalars['timestamp'];
    curator: Scalars['String'];
    curatorFeePercentage: Scalars['Int'];
    duration: Scalars['String'];
    /** An object relationship */
    eventLog: EventLog;
    eventLogId: Scalars['String'];
    id: Scalars['String'];
    logIndex: Scalars['Int'];
    /** An object relationship */
    media?: Maybe<Media>;
    reservePrice: Scalars['String'];
    /** An object relationship */
    token?: Maybe<Token>;
    tokenContract: Scalars['String'];
    tokenId: Scalars['String'];
    tokenOwner: Scalars['String'];
    /** An object relationship */
    transaction: Transaction;
    transactionHash: Scalars['String'];
};
/** aggregated selection of "auction_created_event" */
export declare type AuctionCreatedEvent_Aggregate = {
    __typename?: 'AuctionCreatedEvent_aggregate';
    aggregate?: Maybe<AuctionCreatedEvent_Aggregate_Fields>;
    nodes: Array<AuctionCreatedEvent>;
};
/** aggregate fields of "auction_created_event" */
export declare type AuctionCreatedEvent_Aggregate_Fields = {
    __typename?: 'AuctionCreatedEvent_aggregate_fields';
    avg?: Maybe<AuctionCreatedEvent_Avg_Fields>;
    count: Scalars['Int'];
    max?: Maybe<AuctionCreatedEvent_Max_Fields>;
    min?: Maybe<AuctionCreatedEvent_Min_Fields>;
    stddev?: Maybe<AuctionCreatedEvent_Stddev_Fields>;
    stddev_pop?: Maybe<AuctionCreatedEvent_Stddev_Pop_Fields>;
    stddev_samp?: Maybe<AuctionCreatedEvent_Stddev_Samp_Fields>;
    sum?: Maybe<AuctionCreatedEvent_Sum_Fields>;
    var_pop?: Maybe<AuctionCreatedEvent_Var_Pop_Fields>;
    var_samp?: Maybe<AuctionCreatedEvent_Var_Samp_Fields>;
    variance?: Maybe<AuctionCreatedEvent_Variance_Fields>;
};
/** aggregate fields of "auction_created_event" */
export declare type AuctionCreatedEvent_Aggregate_FieldsCountArgs = {
    columns?: Maybe<Array<AuctionCreatedEvent_Select_Column>>;
    distinct?: Maybe<Scalars['Boolean']>;
};
/** order by aggregate values of table "auction_created_event" */
export declare type AuctionCreatedEvent_Aggregate_Order_By = {
    avg?: Maybe<AuctionCreatedEvent_Avg_Order_By>;
    count?: Maybe<Order_By>;
    max?: Maybe<AuctionCreatedEvent_Max_Order_By>;
    min?: Maybe<AuctionCreatedEvent_Min_Order_By>;
    stddev?: Maybe<AuctionCreatedEvent_Stddev_Order_By>;
    stddev_pop?: Maybe<AuctionCreatedEvent_Stddev_Pop_Order_By>;
    stddev_samp?: Maybe<AuctionCreatedEvent_Stddev_Samp_Order_By>;
    sum?: Maybe<AuctionCreatedEvent_Sum_Order_By>;
    var_pop?: Maybe<AuctionCreatedEvent_Var_Pop_Order_By>;
    var_samp?: Maybe<AuctionCreatedEvent_Var_Samp_Order_By>;
    variance?: Maybe<AuctionCreatedEvent_Variance_Order_By>;
};
/** aggregate avg on columns */
export declare type AuctionCreatedEvent_Avg_Fields = {
    __typename?: 'AuctionCreatedEvent_avg_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    curatorFeePercentage?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by avg() on columns of table "auction_created_event" */
export declare type AuctionCreatedEvent_Avg_Order_By = {
    blockNumber?: Maybe<Order_By>;
    curatorFeePercentage?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** Boolean expression to filter rows from the table "auction_created_event". All fields are combined with a logical 'AND'. */
export declare type AuctionCreatedEvent_Bool_Exp = {
    _and?: Maybe<Array<AuctionCreatedEvent_Bool_Exp>>;
    _not?: Maybe<AuctionCreatedEvent_Bool_Exp>;
    _or?: Maybe<Array<AuctionCreatedEvent_Bool_Exp>>;
    address?: Maybe<String_Comparison_Exp>;
    auction?: Maybe<Auction_Bool_Exp>;
    auctionCurrency?: Maybe<String_Comparison_Exp>;
    auctionId?: Maybe<String_Comparison_Exp>;
    blockNumber?: Maybe<Int_Comparison_Exp>;
    blockTimestamp?: Maybe<Timestamp_Comparison_Exp>;
    curator?: Maybe<String_Comparison_Exp>;
    curatorFeePercentage?: Maybe<Int_Comparison_Exp>;
    duration?: Maybe<String_Comparison_Exp>;
    eventLog?: Maybe<EventLog_Bool_Exp>;
    eventLogId?: Maybe<String_Comparison_Exp>;
    id?: Maybe<String_Comparison_Exp>;
    logIndex?: Maybe<Int_Comparison_Exp>;
    media?: Maybe<Media_Bool_Exp>;
    reservePrice?: Maybe<String_Comparison_Exp>;
    token?: Maybe<Token_Bool_Exp>;
    tokenContract?: Maybe<String_Comparison_Exp>;
    tokenId?: Maybe<String_Comparison_Exp>;
    tokenOwner?: Maybe<String_Comparison_Exp>;
    transaction?: Maybe<Transaction_Bool_Exp>;
    transactionHash?: Maybe<String_Comparison_Exp>;
};
/** aggregate max on columns */
export declare type AuctionCreatedEvent_Max_Fields = {
    __typename?: 'AuctionCreatedEvent_max_fields';
    address?: Maybe<Scalars['String']>;
    auctionCurrency?: Maybe<Scalars['String']>;
    auctionId?: Maybe<Scalars['String']>;
    blockNumber?: Maybe<Scalars['Int']>;
    blockTimestamp?: Maybe<Scalars['timestamp']>;
    curator?: Maybe<Scalars['String']>;
    curatorFeePercentage?: Maybe<Scalars['Int']>;
    duration?: Maybe<Scalars['String']>;
    eventLogId?: Maybe<Scalars['String']>;
    id?: Maybe<Scalars['String']>;
    logIndex?: Maybe<Scalars['Int']>;
    reservePrice?: Maybe<Scalars['String']>;
    tokenContract?: Maybe<Scalars['String']>;
    tokenId?: Maybe<Scalars['String']>;
    tokenOwner?: Maybe<Scalars['String']>;
    transactionHash?: Maybe<Scalars['String']>;
};
/** order by max() on columns of table "auction_created_event" */
export declare type AuctionCreatedEvent_Max_Order_By = {
    address?: Maybe<Order_By>;
    auctionCurrency?: Maybe<Order_By>;
    auctionId?: Maybe<Order_By>;
    blockNumber?: Maybe<Order_By>;
    blockTimestamp?: Maybe<Order_By>;
    curator?: Maybe<Order_By>;
    curatorFeePercentage?: Maybe<Order_By>;
    duration?: Maybe<Order_By>;
    eventLogId?: Maybe<Order_By>;
    id?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
    reservePrice?: Maybe<Order_By>;
    tokenContract?: Maybe<Order_By>;
    tokenId?: Maybe<Order_By>;
    tokenOwner?: Maybe<Order_By>;
    transactionHash?: Maybe<Order_By>;
};
/** aggregate min on columns */
export declare type AuctionCreatedEvent_Min_Fields = {
    __typename?: 'AuctionCreatedEvent_min_fields';
    address?: Maybe<Scalars['String']>;
    auctionCurrency?: Maybe<Scalars['String']>;
    auctionId?: Maybe<Scalars['String']>;
    blockNumber?: Maybe<Scalars['Int']>;
    blockTimestamp?: Maybe<Scalars['timestamp']>;
    curator?: Maybe<Scalars['String']>;
    curatorFeePercentage?: Maybe<Scalars['Int']>;
    duration?: Maybe<Scalars['String']>;
    eventLogId?: Maybe<Scalars['String']>;
    id?: Maybe<Scalars['String']>;
    logIndex?: Maybe<Scalars['Int']>;
    reservePrice?: Maybe<Scalars['String']>;
    tokenContract?: Maybe<Scalars['String']>;
    tokenId?: Maybe<Scalars['String']>;
    tokenOwner?: Maybe<Scalars['String']>;
    transactionHash?: Maybe<Scalars['String']>;
};
/** order by min() on columns of table "auction_created_event" */
export declare type AuctionCreatedEvent_Min_Order_By = {
    address?: Maybe<Order_By>;
    auctionCurrency?: Maybe<Order_By>;
    auctionId?: Maybe<Order_By>;
    blockNumber?: Maybe<Order_By>;
    blockTimestamp?: Maybe<Order_By>;
    curator?: Maybe<Order_By>;
    curatorFeePercentage?: Maybe<Order_By>;
    duration?: Maybe<Order_By>;
    eventLogId?: Maybe<Order_By>;
    id?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
    reservePrice?: Maybe<Order_By>;
    tokenContract?: Maybe<Order_By>;
    tokenId?: Maybe<Order_By>;
    tokenOwner?: Maybe<Order_By>;
    transactionHash?: Maybe<Order_By>;
};
/** Ordering options when selecting data from "auction_created_event". */
export declare type AuctionCreatedEvent_Order_By = {
    address?: Maybe<Order_By>;
    auction?: Maybe<Auction_Order_By>;
    auctionCurrency?: Maybe<Order_By>;
    auctionId?: Maybe<Order_By>;
    blockNumber?: Maybe<Order_By>;
    blockTimestamp?: Maybe<Order_By>;
    curator?: Maybe<Order_By>;
    curatorFeePercentage?: Maybe<Order_By>;
    duration?: Maybe<Order_By>;
    eventLog?: Maybe<EventLog_Order_By>;
    eventLogId?: Maybe<Order_By>;
    id?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
    media?: Maybe<Media_Order_By>;
    reservePrice?: Maybe<Order_By>;
    token?: Maybe<Token_Order_By>;
    tokenContract?: Maybe<Order_By>;
    tokenId?: Maybe<Order_By>;
    tokenOwner?: Maybe<Order_By>;
    transaction?: Maybe<Transaction_Order_By>;
    transactionHash?: Maybe<Order_By>;
};
/** select columns of table "auction_created_event" */
export declare enum AuctionCreatedEvent_Select_Column {
    /** column name */
    Address = "address",
    /** column name */
    AuctionCurrency = "auctionCurrency",
    /** column name */
    AuctionId = "auctionId",
    /** column name */
    BlockNumber = "blockNumber",
    /** column name */
    BlockTimestamp = "blockTimestamp",
    /** column name */
    Curator = "curator",
    /** column name */
    CuratorFeePercentage = "curatorFeePercentage",
    /** column name */
    Duration = "duration",
    /** column name */
    EventLogId = "eventLogId",
    /** column name */
    Id = "id",
    /** column name */
    LogIndex = "logIndex",
    /** column name */
    ReservePrice = "reservePrice",
    /** column name */
    TokenContract = "tokenContract",
    /** column name */
    TokenId = "tokenId",
    /** column name */
    TokenOwner = "tokenOwner",
    /** column name */
    TransactionHash = "transactionHash"
}
/** aggregate stddev on columns */
export declare type AuctionCreatedEvent_Stddev_Fields = {
    __typename?: 'AuctionCreatedEvent_stddev_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    curatorFeePercentage?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by stddev() on columns of table "auction_created_event" */
export declare type AuctionCreatedEvent_Stddev_Order_By = {
    blockNumber?: Maybe<Order_By>;
    curatorFeePercentage?: Maybe<Order_By>;
    logIndex?: Maybe<Order_By>;
};
/** aggregate stddev_pop on columns */
export declare type AuctionCreatedEvent_Stddev_Pop_Fields = {
    __typename?: 'AuctionCreatedEvent_stddev_pop_fields';
    blockNumber?: Maybe<Scalars['Float']>;
    curatorFeePercentage?: Maybe<Scalars['Float']>;
    logIndex?: Maybe<Scalars['Float']>;
};
/** order by st