import * as Apollo from '@apollo/client';
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;
    };
    DateTime: {
        input: any;
        output: any;
    };
};
export type Apr = {
    __typename?: 'Apr';
    aprAllTime: Scalars['String']['output'];
    aprDaily: Scalars['String']['output'];
    aprThreeDay: Scalars['String']['output'];
    aprWeekly: Scalars['String']['output'];
    id: Scalars['ID']['output'];
    tvl: Scalars['String']['output'];
};
export type Health = {
    __typename?: 'Health';
    address?: Maybe<Scalars['String']['output']>;
    borrowRate0?: Maybe<Scalars['String']['output']>;
    borrowRate1?: Maybe<Scalars['String']['output']>;
    capacity?: Maybe<Scalars['String']['output']>;
    chain?: Maybe<Scalars['String']['output']>;
    harvest?: Maybe<Scalars['String']['output']>;
    harvestUpdatedAt?: Maybe<Scalars['DateTime']['output']>;
    id: Scalars['ID']['output'];
    lastHarvest?: Maybe<Scalars['DateTime']['output']>;
    lastRebalance?: Maybe<Scalars['DateTime']['output']>;
    loanHealth?: Maybe<Scalars['String']['output']>;
    loanHealthUpdatedAt?: Maybe<Scalars['DateTime']['output']>;
    rebalance?: Maybe<Scalars['String']['output']>;
    rebalanceOffset?: Maybe<Scalars['String']['output']>;
    rebalanceOffsetUpdatedAt?: Maybe<Scalars['DateTime']['output']>;
    rebalanceTriggeredAt?: Maybe<Scalars['DateTime']['output']>;
    rebalanceUpdatedAt?: Maybe<Scalars['DateTime']['output']>;
    riskAssetPrice?: Maybe<Scalars['String']['output']>;
    shareOfLp?: Maybe<Scalars['String']['output']>;
    strategy?: Maybe<Scalars['String']['output']>;
    symbol?: Maybe<Scalars['String']['output']>;
    type?: Maybe<Scalars['String']['output']>;
};
export type MmHealth = {
    __typename?: 'MMHealth';
    address?: Maybe<Scalars['String']['output']>;
    chain?: Maybe<Scalars['String']['output']>;
    id: Scalars['ID']['output'];
    lastRebalance?: Maybe<Scalars['DateTime']['output']>;
    movingAvg?: Maybe<Scalars['Float']['output']>;
    movingAvgUpdatedAt?: Maybe<Scalars['DateTime']['output']>;
    name?: Maybe<Scalars['String']['output']>;
    prevBalances?: Maybe<Array<Scalars['Float']['output']>>;
    prevRebalance?: Maybe<Scalars['Float']['output']>;
    rebalance?: Maybe<Scalars['String']['output']>;
    rebalanceTriggeredAt?: Maybe<Scalars['DateTime']['output']>;
    rebalanceUpdatedAt?: Maybe<Scalars['DateTime']['output']>;
    rebalances?: Maybe<Array<RebRecord>>;
    symbol?: Maybe<Scalars['String']['output']>;
    type?: Maybe<Scalars['String']['output']>;
};
export type Mutation = {
    __typename?: 'Mutation';
    optIn: WlResult;
};
export type MutationOptInArgs = {
    data: WlInput;
};
export type Query = {
    __typename?: 'Query';
    aprData: Apr;
    healthData: Array<Health>;
    isWhitelisted: Scalars['Boolean']['output'];
    mmHealthData: Array<MmHealth>;
};
export type QueryAprDataArgs = {
    id: Scalars['String']['input'];
};
export type QueryIsWhitelistedArgs = {
    address: Scalars['String']['input'];
};
export type RebRecord = {
    __typename?: 'RebRecord';
    costBasis: Scalars['Float']['output'];
    dBase: Scalars['Float']['output'];
    dQuote: Scalars['Float']['output'];
};
export type WlInput = {
    message: Scalars['String']['input'];
    signedMessage: Scalars['String']['input'];
};
export type WlResult = {
    __typename?: 'WlResult';
    success: Scalars['Boolean']['output'];
};
export type MmHealthQueryVariables = Exact<{
    [key: string]: never;
}>;
export type MmHealthQuery = {
    __typename?: 'Query';
    mmHealthData: Array<{
        __typename?: 'MMHealth';
        id: string;
        chain?: string | null;
        address?: string | null;
        lastRebalance?: any | null;
        movingAvg?: number | null;
        name?: string | null;
        movingAvgUpdatedAt?: any | null;
        prevBalances?: Array<number> | null;
        rebalance?: string | null;
        rebalanceTriggeredAt?: any | null;
        rebalanceUpdatedAt?: any | null;
        symbol?: string | null;
        type?: string | null;
        prevRebalance?: number | null;
        rebalances?: Array<{
            __typename?: 'RebRecord';
            costBasis: number;
            dQuote: number;
            dBase: number;
        }> | null;
    }>;
};
export type ServerHealthQueryVariables = Exact<{
    [key: string]: never;
}>;
export type ServerHealthQuery = {
    __typename?: 'Query';
    healthData: Array<{
        __typename?: 'Health';
        id: string;
        harvestUpdatedAt?: any | null;
        harvest?: string | null;
        chain?: string | null;
        address?: string | null;
        type?: string | null;
        symbol?: string | null;
        strategy?: string | null;
        rebalanceUpdatedAt?: any | null;
        rebalanceOffsetUpdatedAt?: any | null;
        rebalanceTriggeredAt?: any | null;
        rebalanceOffset?: string | null;
        rebalance?: string | null;
        loanHealthUpdatedAt?: any | null;
        loanHealth?: string | null;
        lastRebalance?: any | null;
        lastHarvest?: any | null;
        riskAssetPrice?: string | null;
        capacity?: string | null;
        shareOfLp?: string | null;
        borrowRate0?: string | null;
        borrowRate1?: string | null;
    }>;
};
export type ServerScyAprQueryVariables = Exact<{
    id: Scalars['String']['input'];
}>;
export type ServerScyAprQuery = {
    __typename?: 'Query';
    aprData: {
        __typename?: 'Apr';
        id: string;
        aprAllTime: string;
        aprDaily: string;
        aprThreeDay: string;
        aprWeekly: string;
        tvl: string;
    };
};
export type OptInMutationVariables = Exact<{
    data: WlInput;
}>;
export type OptInMutation = {
    __typename?: 'Mutation';
    optIn: {
        __typename?: 'WlResult';
        success: boolean;
    };
};
export type IsWhitelistedQueryVariables = Exact<{
    address: Scalars['String']['input'];
}>;
export type IsWhitelistedQuery = {
    __typename?: 'Query';
    isWhitelisted: boolean;
};
export declare const MmHealthDocument: Apollo.DocumentNode;
/**
 * __useMmHealthQuery__
 *
 * To run a query within a React component, call `useMmHealthQuery` and pass it any options that fit your needs.
 * When your component renders, `useMmHealthQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useMmHealthQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useMmHealthQuery(baseOptions?: Apollo.QueryHookOptions<MmHealthQuery, MmHealthQueryVariables>): Apollo.QueryResult<MmHealthQuery, Exact<{
    [key: string]: never;
}>>;
export declare function useMmHealthLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<MmHealthQuery, MmHealthQueryVariables>): Apollo.LazyQueryResultTuple<MmHealthQuery, Exact<{
    [key: string]: never;
}>>;
export type MmHealthQueryHookResult = ReturnType<typeof useMmHealthQuery>;
export type MmHealthLazyQueryHookResult = ReturnType<typeof useMmHealthLazyQuery>;
export type MmHealthQueryResult = Apollo.QueryResult<MmHealthQuery, MmHealthQueryVariables>;
export declare const ServerHealthDocument: Apollo.DocumentNode;
/**
 * __useServerHealthQuery__
 *
 * To run a query within a React component, call `useServerHealthQuery` and pass it any options that fit your needs.
 * When your component renders, `useServerHealthQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useServerHealthQuery({
 *   variables: {
 *   },
 * });
 */
export declare function useServerHealthQuery(baseOptions?: Apollo.QueryHookOptions<ServerHealthQuery, ServerHealthQueryVariables>): Apollo.QueryResult<ServerHealthQuery, Exact<{
    [key: string]: never;
}>>;
export declare function useServerHealthLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ServerHealthQuery, ServerHealthQueryVariables>): Apollo.LazyQueryResultTuple<ServerHealthQuery, Exact<{
    [key: string]: never;
}>>;
export type ServerHealthQueryHookResult = ReturnType<typeof useServerHealthQuery>;
export type ServerHealthLazyQueryHookResult = ReturnType<typeof useServerHealthLazyQuery>;
export type ServerHealthQueryResult = Apollo.QueryResult<ServerHealthQuery, ServerHealthQueryVariables>;
export declare const ServerScyAprDocument: Apollo.DocumentNode;
/**
 * __useServerScyAprQuery__
 *
 * To run a query within a React component, call `useServerScyAprQuery` and pass it any options that fit your needs.
 * When your component renders, `useServerScyAprQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useServerScyAprQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useServerScyAprQuery(baseOptions: Apollo.QueryHookOptions<ServerScyAprQuery, ServerScyAprQueryVariables>): Apollo.QueryResult<ServerScyAprQuery, Exact<{
    id: string;
}>>;
export declare function useServerScyAprLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ServerScyAprQuery, ServerScyAprQueryVariables>): Apollo.LazyQueryResultTuple<ServerScyAprQuery, Exact<{
    id: string;
}>>;
export type ServerScyAprQueryHookResult = ReturnType<typeof useServerScyAprQuery>;
export type ServerScyAprLazyQueryHookResult = ReturnType<typeof useServerScyAprLazyQuery>;
export type ServerScyAprQueryResult = Apollo.QueryResult<ServerScyAprQuery, ServerScyAprQueryVariables>;
export declare const OptInDocument: Apollo.DocumentNode;
export type OptInMutationFn = Apollo.MutationFunction<OptInMutation, OptInMutationVariables>;
/**
 * __useOptInMutation__
 *
 * To run a mutation, you first call `useOptInMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useOptInMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [optInMutation, { data, loading, error }] = useOptInMutation({
 *   variables: {
 *      data: // value for 'data'
 *   },
 * });
 */
export declare function useOptInMutation(baseOptions?: Apollo.MutationHookOptions<OptInMutation, OptInMutationVariables>): Apollo.MutationTuple<OptInMutation, Exact<{
    data: WlInput;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type OptInMutationHookResult = ReturnType<typeof useOptInMutation>;
export type OptInMutationResult = Apollo.MutationResult<OptInMutation>;
export type OptInMutationOptions = Apollo.BaseMutationOptions<OptInMutation, OptInMutationVariables>;
export declare const IsWhitelistedDocument: Apollo.DocumentNode;
/**
 * __useIsWhitelistedQuery__
 *
 * To run a query within a React component, call `useIsWhitelistedQuery` and pass it any options that fit your needs.
 * When your component renders, `useIsWhitelistedQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useIsWhitelistedQuery({
 *   variables: {
 *      address: // value for 'address'
 *   },
 * });
 */
export declare function useIsWhitelistedQuery(baseOptions: Apollo.QueryHookOptions<IsWhitelistedQuery, IsWhitelistedQueryVariables>): Apollo.QueryResult<IsWhitelistedQuery, Exact<{
    address: string;
}>>;
export declare function useIsWhitelistedLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IsWhitelistedQuery, IsWhitelistedQueryVariables>): Apollo.LazyQueryResultTuple<IsWhitelistedQuery, Exact<{
    address: string;
}>>;
export type IsWhitelistedQueryHookResult = ReturnType<typeof useIsWhitelistedQuery>;
export type IsWhitelistedLazyQueryHookResult = ReturnType<typeof useIsWhitelistedLazyQuery>;
export type IsWhitelistedQueryResult = Apollo.QueryResult<IsWhitelistedQuery, IsWhitelistedQueryVariables>;
