type Maybe<T> = T | null;
type InputMaybe<T> = Maybe<T>;
type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]: Maybe<T[SubKey]>;
};
type MakeEmpty<T extends {
    [key: string]: unknown;
}, K extends keyof T> = {
    [_ in K]?: never;
};
type Incremental<T> = T | {
    [P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never;
};
/** All built-in and custom scalars, mapped to their actual values */
type Scalars = {
    ID: {
        input: string;
        output: string;
    };
    String: {
        input: string;
        output: string;
    };
    Boolean: {
        input: boolean;
        output: boolean;
    };
    Int: {
        input: number;
        output: number;
    };
    Float: {
        input: number;
        output: number;
    };
};
type Query = {
    __typename?: "Query";
    transaction?: Maybe<Transaction>;
    transactions: TransactionConnection;
    block?: Maybe<Block>;
    blocks: BlockConnection;
};
type QueryTransactionArgs = {
    id: Scalars["ID"]["input"];
};
type QueryTransactionsArgs = {
    ids?: InputMaybe<Array<Scalars["ID"]["input"]>>;
    owners?: InputMaybe<Array<Scalars["String"]["input"]>>;
    recipients?: InputMaybe<Array<Scalars["String"]["input"]>>;
    tags?: InputMaybe<Array<TagFilter>>;
    bundledIn?: InputMaybe<Array<Scalars["ID"]["input"]>>;
    block?: InputMaybe<BlockFilter>;
    first?: InputMaybe<Scalars["Int"]["input"]>;
    after?: InputMaybe<Scalars["String"]["input"]>;
    sort?: InputMaybe<SortOrder>;
};
type QueryBlockArgs = {
    id?: InputMaybe<Scalars["String"]["input"]>;
};
type QueryBlocksArgs = {
    ids?: InputMaybe<Array<Scalars["ID"]["input"]>>;
    height?: InputMaybe<BlockFilter>;
    first?: InputMaybe<Scalars["Int"]["input"]>;
    after?: InputMaybe<Scalars["String"]["input"]>;
    sort?: InputMaybe<SortOrder>;
};
declare enum SortOrder {
    HeightAsc = "HEIGHT_ASC",
    HeightDesc = "HEIGHT_DESC"
}
type TagFilter = {
    name: Scalars["String"]["input"];
    values: Array<Scalars["String"]["input"]>;
    op?: InputMaybe<TagOperator>;
};
type BlockFilter = {
    min?: InputMaybe<Scalars["Int"]["input"]>;
    max?: InputMaybe<Scalars["Int"]["input"]>;
};
type BlockConnection = {
    __typename?: "BlockConnection";
    pageInfo: PageInfo;
    edges: Array<BlockEdge>;
};
type BlockEdge = {
    __typename?: "BlockEdge";
    cursor: Scalars["String"]["output"];
    node: Block;
};
type TransactionConnection = {
    __typename?: "TransactionConnection";
    pageInfo: PageInfo;
    edges: Array<TransactionEdge>;
};
type TransactionEdge = {
    __typename?: "TransactionEdge";
    cursor: Scalars["String"]["output"];
    node: Transaction;
};
type PageInfo = {
    __typename?: "PageInfo";
    hasNextPage: Scalars["Boolean"]["output"];
};
type Transaction = {
    __typename?: "Transaction";
    id: Scalars["ID"]["output"];
    anchor: Scalars["String"]["output"];
    signature: Scalars["String"]["output"];
    recipient: Scalars["String"]["output"];
    owner: Owner;
    fee: Amount;
    quantity: Amount;
    data: MetaData;
    tags: Array<Tag>;
    block?: Maybe<Block>;
    /** @deprecated Use `bundledIn` */
    parent?: Maybe<Parent>;
    bundledIn?: Maybe<Bundle>;
};
type Parent = {
    __typename?: "Parent";
    id: Scalars["ID"]["output"];
};
type Bundle = {
    __typename?: "Bundle";
    id: Scalars["ID"]["output"];
};
type Block = {
    __typename?: "Block";
    id: Scalars["ID"]["output"];
    timestamp: Scalars["Int"]["output"];
    height: Scalars["Int"]["output"];
    previous: Scalars["ID"]["output"];
};
type MetaData = {
    __typename?: "MetaData";
    size: Scalars["String"]["output"];
    type?: Maybe<Scalars["String"]["output"]>;
};
type Amount = {
    __typename?: "Amount";
    winston: Scalars["String"]["output"];
    ar: Scalars["String"]["output"];
};
type Owner = {
    __typename?: "Owner";
    address: Scalars["String"]["output"];
    key: Scalars["String"]["output"];
};
type Tag = {
    __typename?: "Tag";
    name: Scalars["String"]["output"];
    value: Scalars["String"]["output"];
};
declare enum TagOperator {
    Eq = "EQ",
    Neq = "NEQ"
}

export { Amount, Block, BlockConnection, BlockEdge, BlockFilter, Bundle, Exact, Incremental, InputMaybe, MakeEmpty, MakeMaybe, MakeOptional, Maybe, MetaData, Owner, PageInfo, Parent, Query, QueryBlockArgs, QueryBlocksArgs, QueryTransactionArgs, QueryTransactionsArgs, Scalars, SortOrder, Tag, TagFilter, TagOperator, Transaction, TransactionConnection, TransactionEdge };