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]>;
};
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
    ID: string;
    String: string;
    Boolean: boolean;
    Int: number;
    Float: number;
    DateTime: any;
};
export type Apr = {
    __typename?: 'Apr';
    aprAllTime: Scalars['String'];
    aprDaily: Scalars['String'];
    aprThreeDay: Scalars['String'];
    aprWeekly: Scalars['String'];
    id: Scalars['ID'];
    tvl: Scalars['String'];
};
export type Health = {
    __typename?: 'Health';
    address?: Maybe<Scalars['String']>;
    borrowRate0?: Maybe<Scalars['String']>;
    borrowRate1?: Maybe<Scalars['String']>;
    capacity?: Maybe<Scalars['String']>;
    chain?: Maybe<Scalars['String']>;
    harvest?: Maybe<Scalars['String']>;
    harvestUpdatedAt?: Maybe<Scalars['DateTime']>;
    id: Scalars['ID'];
    lastHarvest?: Maybe<Scalars['DateTime']>;
    lastRebalance?: Maybe<Scalars['DateTime']>;
    loanHealth?: Maybe<Scalars['String']>;
    loanHealthUpdatedAt?: Maybe<Scalars['DateTime']>;
    rebalance?: Maybe<Scalars['String']>;
    rebalanceOffset?: Maybe<Scalars['String']>;
    rebalanceOffsetUpdatedAt?: Maybe<Scalars['DateTime']>;
    rebalanceTriggeredAt?: Maybe<Scalars['DateTime']>;
    rebalanceUpdatedAt?: Maybe<Scalars['DateTime']>;
    riskAssetPrice?: Maybe<Scalars['String']>;
    shareOfLp?: Maybe<Scalars['String']>;
    strategy?: Maybe<Scalars['String']>;
    symbol?: Maybe<Scalars['String']>;
    type?: Maybe<Scalars['String']>;
};
export type Query = {
    __typename?: 'Query';
    aprData: Apr;
    healthData: Array<Health>;
};
export type QueryAprDataArgs = {
    id: Scalars['String'];
};
export type ServerHealthQueryVariables = Exact<{
    [key: string]: never;
}>;
export type ServerHealthQuery = {
    __typename?: 'Query';
    healthData: Array<{
        __typename?: 'Health';
        id: string;
        harvestUpdatedAt?: any | null | undefined;
        harvest?: string | null | undefined;
        chain?: string | null | undefined;
        address?: string | null | undefined;
        type?: string | null | undefined;
        symbol?: string | null | undefined;
        strategy?: string | null | undefined;
        rebalanceUpdatedAt?: any | null | undefined;
        rebalanceOffsetUpdatedAt?: any | null | undefined;
        rebalanceTriggeredAt?: any | null | undefined;
        rebalanceOffset?: string | null | undefined;
        rebalance?: string | null | undefined;
        loanHealthUpdatedAt?: any | null | undefined;
        loanHealth?: string | null | undefined;
        lastRebalance?: any | null | undefined;
        lastHarvest?: any | null | undefined;
        riskAssetPrice?: string | null | undefined;
        capacity?: string | null | undefined;
        shareOfLp?: string | null | undefined;
        borrowRate0?: string | null | undefined;
        borrowRate1?: string | null | undefined;
    }>;
};
export type ServerScyAprQueryVariables = Exact<{
    id: Scalars['String'];
}>;
export type ServerScyAprQuery = {
    __typename?: 'Query';
    aprData: {
        __typename?: 'Apr';
        id: string;
        aprAllTime: string;
        aprDaily: string;
        aprThreeDay: string;
        aprWeekly: string;
        tvl: string;
    };
};
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>;
