import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
export type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]: Maybe<T[SubKey]>;
};
export type MakeEmpty<T extends {
    [key: string]: unknown;
}, K extends keyof T> = {
    [_ in K]?: never;
};
export type Incremental<T> = T | {
    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
};
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
    ID: {
        input: string;
        output: string;
    };
    String: {
        input: string;
        output: string;
    };
    Boolean: {
        input: boolean;
        output: boolean;
    };
    Int: {
        input: number;
        output: number;
    };
    Float: {
        input: number;
        output: number;
    };
    Any: {
        input: any;
        output: any;
    };
    /** A date-time string at UTC, such as 2007-12-03T10:15:30Z, compliant with the `date-time` format outlined in section 5.6 of the RFC 3339 profile of the ISO 8601 standard for representation of dates and times using the Gregorian calendar.This scalar is serialized to a string in ISO 8601 format and parsed from a string in ISO 8601 format. */
    DateTimeISO: {
        input: any;
        output: any;
    };
    File: {
        input: any;
        output: any;
    };
    /** The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
    JSON: {
        input: any;
        output: any;
    };
    /** The `JSONObject` scalar type represents JSON objects as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
    JSONObject: {
        input: any;
        output: any;
    };
    /** Custom scalar that handles both integers and floats */
    Number: {
        input: any;
        output: any;
    };
    /** Represents NULL values */
    Void: {
        input: any;
        output: any;
    };
};
export type Apy = {
    __typename?: 'Apy';
    base: Scalars['Float']['output'];
    rewards: Array<RewardApy>;
    total: Scalars['Float']['output'];
};
export type Chain = {
    __typename?: 'Chain';
    icon: Scalars['String']['output'];
    id: Scalars['Int']['output'];
    name: Scalars['String']['output'];
    nativeToken?: Maybe<Token>;
    wrappedNativeToken?: Maybe<Token>;
};
export type Identity = {
    __typename?: 'Identity';
    aggregate: IdentityResolverOutput;
    base: IdentityResolverOutput;
    ens: IdentityResolverOutput;
    farcaster: IdentityResolverOutput;
    lens: IdentityResolverOutput;
    nns: IdentityResolverOutput;
    uni: IdentityResolverOutput;
    world: IdentityResolverOutput;
};
export declare enum IdentityResolverInput {
    Base = "base",
    Ens = "ens",
    Farcaster = "farcaster",
    Lens = "lens",
    Nns = "nns",
    Uni = "uni",
    World = "world"
}
export type IdentityResolverOutput = {
    __typename?: 'IdentityResolverOutput';
    avatar?: Maybe<Scalars['String']['output']>;
    bio?: Maybe<Scalars['String']['output']>;
    discord?: Maybe<Scalars['String']['output']>;
    github?: Maybe<Scalars['String']['output']>;
    name?: Maybe<Scalars['String']['output']>;
    telegram?: Maybe<Scalars['String']['output']>;
    website?: Maybe<Scalars['String']['output']>;
    x?: Maybe<Scalars['String']['output']>;
};
export type ItemsInput = {
    address: Scalars['Any']['input'];
    chainId: Scalars['Number']['input'];
};
export type Protocol = {
    __typename?: 'Protocol';
    icon: Scalars['String']['output'];
    name: Scalars['String']['output'];
};
export type Query = {
    __typename?: 'Query';
    chain: Chain;
    chains: Array<Chain>;
    identities: Array<Identity>;
    identity: Identity;
    token?: Maybe<Token>;
    tokens: Array<Maybe<Token>>;
    vault?: Maybe<Vault>;
    vaults: Array<Maybe<Vault>>;
};
export type QueryChainArgs = {
    id: Scalars['Int']['input'];
};
export type QueryIdentitiesArgs = {
    addresses: Array<Scalars['String']['input']>;
    resolverOrder?: InputMaybe<Array<IdentityResolverInput>>;
};
export type QueryIdentityArgs = {
    address: Scalars['String']['input'];
    resolverOrder?: InputMaybe<Array<IdentityResolverInput>>;
};
export type QueryTokenArgs = {
    address: Scalars['Any']['input'];
    chainId: Scalars['Number']['input'];
};
export type QueryTokensArgs = {
    items: Array<ItemsInput>;
};
export type QueryVaultArgs = {
    address: Scalars['String']['input'];
    chainId: Scalars['Int']['input'];
    protocol: VaultProtocolInput;
};
export type QueryVaultsArgs = {
    vaultItems: Array<VaultItemsInput>;
};
export type RewardApy = {
    __typename?: 'RewardApy';
    apy: Scalars['Float']['output'];
    token?: Maybe<Token>;
};
export type Token = {
    __typename?: 'Token';
    address: Scalars['String']['output'];
    chain: Chain;
    decimals: Scalars['Number']['output'];
    icon?: Maybe<Scalars['String']['output']>;
    name: Scalars['String']['output'];
    priceUsd?: Maybe<Scalars['Number']['output']>;
    symbol: Scalars['String']['output'];
};
export type Vault = {
    __typename?: 'Vault';
    address: Scalars['String']['output'];
    chain: Chain;
    description?: Maybe<Scalars['String']['output']>;
    name: Scalars['String']['output'];
    protocol: Protocol;
    supplyApy: Apy;
    totalSupplied: Scalars['Float']['output'];
    totalSuppliedUsd?: Maybe<Scalars['Float']['output']>;
    type: VaultType;
    underlyingAsset?: Maybe<Token>;
    url: Scalars['String']['output'];
};
export type VaultItemsInput = {
    address: Scalars['String']['input'];
    chainId: Scalars['Int']['input'];
    protocol: VaultProtocolInput;
};
export declare enum VaultProtocolInput {
    Enzyme = "enzyme",
    EulerV2 = "euler_v2",
    Mellow = "mellow",
    Morpho = "morpho"
}
export declare enum VaultType {
    Lending = "lending",
    Staking = "staking"
}
export type Avatar_IdentityQueryQueryVariables = Exact<{
    address: Scalars['String']['input'];
    resolverOrder?: InputMaybe<Array<IdentityResolverInput> | IdentityResolverInput>;
}>;
export type Avatar_IdentityQueryQuery = {
    __typename?: 'Query';
    identity: {
        __typename?: 'Identity';
        aggregate: {
            __typename?: 'IdentityResolverOutput';
            avatar?: string | null;
        };
    };
};
export type Name_IdentityQueryQueryVariables = Exact<{
    address: Scalars['String']['input'];
    resolverOrder?: InputMaybe<Array<IdentityResolverInput> | IdentityResolverInput>;
}>;
export type Name_IdentityQueryQuery = {
    __typename?: 'Query';
    identity: {
        __typename?: 'Identity';
        aggregate: {
            __typename?: 'IdentityResolverOutput';
            name?: string | null;
        };
    };
};
export type Profile_IdentityFragmentFragment = {
    __typename?: 'Identity';
    aggregate: {
        __typename?: 'IdentityResolverOutput';
        name?: string | null;
        avatar?: string | null;
        bio?: string | null;
        website?: string | null;
        x?: string | null;
        github?: string | null;
        discord?: string | null;
        telegram?: string | null;
    };
    ens: {
        __typename?: 'IdentityResolverOutput';
        name?: string | null;
    };
    farcaster: {
        __typename?: 'IdentityResolverOutput';
        name?: string | null;
    };
    nns: {
        __typename?: 'IdentityResolverOutput';
        name?: string | null;
    };
    base: {
        __typename?: 'IdentityResolverOutput';
        name?: string | null;
    };
    uni: {
        __typename?: 'IdentityResolverOutput';
        name?: string | null;
    };
    lens: {
        __typename?: 'IdentityResolverOutput';
        name?: string | null;
    };
    world: {
        __typename?: 'IdentityResolverOutput';
        name?: string | null;
    };
} & {
    ' $fragmentName'?: 'Profile_IdentityFragmentFragment';
};
export type Profile_IdentityQueryQueryVariables = Exact<{
    address: Scalars['String']['input'];
    resolverOrder?: InputMaybe<Array<IdentityResolverInput> | IdentityResolverInput>;
}>;
export type Profile_IdentityQueryQuery = {
    __typename?: 'Query';
    identity: ({
        __typename?: 'Identity';
    } & {
        ' $fragmentRefs'?: {
            'Profile_IdentityFragmentFragment': Profile_IdentityFragmentFragment;
        };
    });
};
export declare const Profile_IdentityFragmentFragmentDoc: DocumentNode<Profile_IdentityFragmentFragment, unknown>;
export declare const Avatar_IdentityQueryDocument: DocumentNode<Avatar_IdentityQueryQuery, Avatar_IdentityQueryQueryVariables>;
export declare const Name_IdentityQueryDocument: DocumentNode<Name_IdentityQueryQuery, Name_IdentityQueryQueryVariables>;
export declare const Profile_IdentityQueryDocument: DocumentNode<Profile_IdentityQueryQuery, Profile_IdentityQueryQueryVariables>;