import * as Types from '../global/types.generated';
import * as ApolloReactCommon from '@apollo/client';
import * as ApolloReactHooks from '@apollo/client';
export type GetTransactionQueryVariables = Types.Exact<{
    hash: Types.Scalars['String'];
}>;
export type GetTransactionQuery = {
    __typename?: 'Query';
    transaction?: {
        __typename?: 'Transaction';
        status: Types.TransactionStatus;
        hash: string;
        updatedAt: any;
        createdAt: any;
        id: string;
    } | null;
};
export type ResolveTransactionQueryVariables = Types.Exact<{
    hash: Types.Scalars['String'];
}>;
export type ResolveTransactionQuery = {
    __typename?: 'Query';
    resolveTransaction?: {
        __typename?: 'Transaction';
        status: Types.TransactionStatus;
        hash: string;
        updatedAt: any;
        createdAt: any;
        id: string;
    } | null;
};
export type GetGlobalsQueryVariables = Types.Exact<{
    input: Types.GlobalDataInput;
}>;
export type GetGlobalsQuery = {
    __typename?: 'Query';
    globals: {
        __typename?: 'GlobalData';
        alchemyKey: string;
        networkId: string;
        contractConfigs: {
            __typename?: 'ContractConfigs';
            gasUnitsForDeployment: string;
            gasUnitsForJoin: string;
            gasUnitsForDeposit: string;
            gasUnitsForLeaveProposition: string;
            gasFees30SecondsInterval: string;
            percentageDivider: string;
        };
        addresses: {
            __typename?: 'Addresses';
            anticWalletAddress: string;
            joinDataCodec: string;
            soDominiumProxyFactoryAddress: string;
        };
    };
};
export type GetPartnerDataQueryVariables = Types.Exact<{
    partnerId: Types.Scalars['String'];
}>;
export type GetPartnerDataQuery = {
    __typename?: 'Query';
    getPartner: {
        __typename?: 'Partner';
        quorumPercentage: number;
        singleSharePercentage: number;
        maxShares: number;
        sellPassRate: number;
        proposalTtlInHours: number;
        sellFee: number;
        joinFee: number;
    };
};
export type ReportMutationVariables = Types.Exact<{
    input: Types.SdkReportInput;
}>;
export type ReportMutation = {
    __typename?: 'Mutation';
    sdkReport: {
        __typename?: 'SdkReportResponse';
        reported: boolean;
    };
};
export declare const GetTransactionDocument: ApolloReactCommon.DocumentNode;
/**
 * __useGetTransactionQuery__
 *
 * To run a query within a React component, call `useGetTransactionQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetTransactionQuery` 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 } = useGetTransactionQuery({
 *   variables: {
 *      hash: // value for 'hash'
 *   },
 * });
 */
export declare function useGetTransactionQuery(baseOptions: ApolloReactHooks.QueryHookOptions<GetTransactionQuery, GetTransactionQueryVariables>): ApolloReactCommon.QueryResult<GetTransactionQuery, Types.Exact<{
    hash: string;
}>>;
export declare function useGetTransactionLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<GetTransactionQuery, GetTransactionQueryVariables>): ApolloReactCommon.LazyQueryResultTuple<GetTransactionQuery, Types.Exact<{
    hash: string;
}>>;
export type GetTransactionQueryHookResult = ReturnType<typeof useGetTransactionQuery>;
export type GetTransactionLazyQueryHookResult = ReturnType<typeof useGetTransactionLazyQuery>;
export type GetTransactionQueryResult = ApolloReactCommon.QueryResult<GetTransactionQuery, GetTransactionQueryVariables>;
export declare const ResolveTransactionDocument: ApolloReactCommon.DocumentNode;
/**
 * __useResolveTransactionQuery__
 *
 * To run a query within a React component, call `useResolveTransactionQuery` and pass it any options that fit your needs.
 * When your component renders, `useResolveTransactionQuery` 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 } = useResolveTransactionQuery({
 *   variables: {
 *      hash: // value for 'hash'
 *   },
 * });
 */
export declare function useResolveTransactionQuery(baseOptions: ApolloReactHooks.QueryHookOptions<ResolveTransactionQuery, ResolveTransactionQueryVariables>): ApolloReactCommon.QueryResult<ResolveTransactionQuery, Types.Exact<{
    hash: string;
}>>;
export declare function useResolveTransactionLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<ResolveTransactionQuery, ResolveTransactionQueryVariables>): ApolloReactCommon.LazyQueryResultTuple<ResolveTransactionQuery, Types.Exact<{
    hash: string;
}>>;
export type ResolveTransactionQueryHookResult = ReturnType<typeof useResolveTransactionQuery>;
export type ResolveTransactionLazyQueryHookResult = ReturnType<typeof useResolveTransactionLazyQuery>;
export type ResolveTransactionQueryResult = ApolloReactCommon.QueryResult<ResolveTransactionQuery, ResolveTransactionQueryVariables>;
export declare const GetGlobalsDocument: ApolloReactCommon.DocumentNode;
/**
 * __useGetGlobalsQuery__
 *
 * To run a query within a React component, call `useGetGlobalsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetGlobalsQuery` 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 } = useGetGlobalsQuery({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useGetGlobalsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<GetGlobalsQuery, GetGlobalsQueryVariables>): ApolloReactCommon.QueryResult<GetGlobalsQuery, Types.Exact<{
    input: Types.GlobalDataInput;
}>>;
export declare function useGetGlobalsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<GetGlobalsQuery, GetGlobalsQueryVariables>): ApolloReactCommon.LazyQueryResultTuple<GetGlobalsQuery, Types.Exact<{
    input: Types.GlobalDataInput;
}>>;
export type GetGlobalsQueryHookResult = ReturnType<typeof useGetGlobalsQuery>;
export type GetGlobalsLazyQueryHookResult = ReturnType<typeof useGetGlobalsLazyQuery>;
export type GetGlobalsQueryResult = ApolloReactCommon.QueryResult<GetGlobalsQuery, GetGlobalsQueryVariables>;
export declare const GetPartnerDataDocument: ApolloReactCommon.DocumentNode;
/**
 * __useGetPartnerDataQuery__
 *
 * To run a query within a React component, call `useGetPartnerDataQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetPartnerDataQuery` 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 } = useGetPartnerDataQuery({
 *   variables: {
 *      partnerId: // value for 'partnerId'
 *   },
 * });
 */
export declare function useGetPartnerDataQuery(baseOptions: ApolloReactHooks.QueryHookOptions<GetPartnerDataQuery, GetPartnerDataQueryVariables>): ApolloReactCommon.QueryResult<GetPartnerDataQuery, Types.Exact<{
    partnerId: string;
}>>;
export declare function useGetPartnerDataLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<GetPartnerDataQuery, GetPartnerDataQueryVariables>): ApolloReactCommon.LazyQueryResultTuple<GetPartnerDataQuery, Types.Exact<{
    partnerId: string;
}>>;
export type GetPartnerDataQueryHookResult = ReturnType<typeof useGetPartnerDataQuery>;
export type GetPartnerDataLazyQueryHookResult = ReturnType<typeof useGetPartnerDataLazyQuery>;
export type GetPartnerDataQueryResult = ApolloReactCommon.QueryResult<GetPartnerDataQuery, GetPartnerDataQueryVariables>;
export declare const ReportDocument: ApolloReactCommon.DocumentNode;
export type ReportMutationFn = ApolloReactCommon.MutationFunction<ReportMutation, ReportMutationVariables>;
/**
 * __useReportMutation__
 *
 * To run a mutation, you first call `useReportMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useReportMutation` 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 [reportMutation, { data, loading, error }] = useReportMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useReportMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<ReportMutation, ReportMutationVariables>): ApolloReactCommon.MutationTuple<ReportMutation, Types.Exact<{
    input: Types.SdkReportInput;
}>, ApolloReactCommon.DefaultContext, ApolloReactCommon.ApolloCache<any>>;
export type ReportMutationHookResult = ReturnType<typeof useReportMutation>;
export type ReportMutationResult = ApolloReactCommon.MutationResult<ReportMutation>;
export type ReportMutationOptions = ApolloReactCommon.BaseMutationOptions<ReportMutation, ReportMutationVariables>;