import { ApolloClient, DocumentNode, LazyQueryHookOptions, MutationHookOptions, MutationOptions, NetworkStatus, OperationVariables, QueryHookOptions, RefetchQueriesOptions, useLazyQuery, useMutation } from '@apollo/client';
import { ResultOf, TypedDocumentNode, VariablesOf } from '@graphql-typed-document-node/core';
import { ApolloCacheService } from '../apollo-cache-services';
import { CacheUpdateOptions, ServiceQueryHookOptions } from '../core';
import { Documents } from '../types';
export declare class ApolloClientService {
    private client;
    __typename: string;
    apolloCacheService: ApolloCacheService;
    constructor(client: ApolloClient<unknown>, __typename: string, apolloCacheService?: ApolloCacheService);
    get cache(): import("@apollo/client").ApolloCache<unknown>;
    get mutate(): <TData = any, TVariables = OperationVariables, TContext = import("@apollo/client").DefaultContext, TCache extends import("@apollo/client").ApolloCache<any> = import("@apollo/client").ApolloCache<any>>(options: MutationOptions<TData, TVariables, TContext, import("@apollo/client").ApolloCache<any>>) => Promise<import("@apollo/client").FetchResult<TData>>;
    get useMutation(): typeof useMutation;
    get readFragment(): <T = any, TVariables = OperationVariables>(options: import("@apollo/client").DataProxy.Fragment<TVariables, T>, optimistic?: boolean) => T;
    generateReference(id: string): string;
    refetch: (options: RefetchQueriesOptions<any, any>) => import("@apollo/client").RefetchQueriesResult<any>;
    create: (options: CacheUpdateOptions<MutationOptions>) => Promise<import("@apollo/client").FetchResult<any>>;
    useCreate: <T extends Documents.Create>(document: T, options: CacheUpdateOptions<MutationHookOptions>) => import("@apollo/client").MutationTuple<any, OperationVariables, import("@apollo/client").DefaultContext, import("@apollo/client").ApolloCache<any>>;
    get: (typeof this.client)['query'];
    getBySegmentID: (typeof this.client)['query'];
    delete: (typeof this.client)['mutate'];
    update: (options: CacheUpdateOptions<MutationOptions>) => Promise<import("@apollo/client").FetchResult<any>>;
    useUpdate: <T extends Documents.Update>(document: T, options?: CacheUpdateOptions<MutationHookOptions>) => import("@apollo/client").MutationTuple<any, OperationVariables, import("@apollo/client").DefaultContext, import("@apollo/client").ApolloCache<any>>;
    list: (typeof this.client)['query'];
    useList: <T extends Documents.List>(document: T, options: CacheUpdateOptions<QueryHookOptions<ResultOf<T>, VariablesOf<T>>>) => {
        isLoading: boolean;
        isRefetching: boolean;
        hasMore: any;
        refetching: boolean;
        client: ApolloClient<any>;
        observable: import("@apollo/client").ObservableQuery<ResultOf<T>, VariablesOf<T>>;
        data: ResultOf<T>;
        previousData?: ResultOf<T>;
        error?: import("@apollo/client").ApolloError;
        loading: boolean;
        networkStatus: NetworkStatus;
        called: boolean;
        variables: VariablesOf<T>;
        startPolling: (pollInterval: number) => void;
        stopPolling: () => void;
        subscribeToMore: <TSubscriptionData = ResultOf<T>, TSubscriptionVariables = VariablesOf<T>>(options: import("@apollo/client").SubscribeToMoreOptions<ResultOf<T>, TSubscriptionVariables, TSubscriptionData>) => () => void;
        updateQuery: <TVars = VariablesOf<T>>(mapFn: (previousQueryResult: ResultOf<T>, options: Pick<import("@apollo/client").WatchQueryOptions<TVars, ResultOf<T>>, "variables">) => ResultOf<T>) => void;
        refetch: (variables?: Partial<VariablesOf<T>>) => Promise<import("@apollo/client").ApolloQueryResult<ResultOf<T>>>;
        reobserve: (newOptions?: Partial<import("@apollo/client").WatchQueryOptions<VariablesOf<T>, ResultOf<T>>>, newNetworkStatus?: NetworkStatus) => Promise<import("@apollo/client").ApolloQueryResult<ResultOf<T>>>;
        fetchMore: <TFetchData = ResultOf<T>, TFetchVars = VariablesOf<T>>(fetchMoreOptions: import("@apollo/client").FetchMoreQueryOptions<TFetchVars, TFetchData> & {
            updateQuery?: (previousQueryResult: ResultOf<T>, options: {
                fetchMoreResult: TFetchData;
                variables: TFetchVars;
            }) => ResultOf<T>;
        }) => Promise<import("@apollo/client").ApolloQueryResult<TFetchData>>;
    };
    useGet: <T extends Documents.Get>(document: T, options: CacheUpdateOptions<QueryHookOptions<ResultOf<T>, VariablesOf<T>>>) => {
        isLoading: boolean;
        isRefetching: boolean;
        hasMore: any;
        refetching: boolean;
        client: ApolloClient<any>;
        observable: import("@apollo/client").ObservableQuery<ResultOf<T>, VariablesOf<T>>;
        data: ResultOf<T>;
        previousData?: ResultOf<T>;
        error?: import("@apollo/client").ApolloError;
        loading: boolean;
        networkStatus: NetworkStatus;
        called: boolean;
        variables: VariablesOf<T>;
        startPolling: (pollInterval: number) => void;
        stopPolling: () => void;
        subscribeToMore: <TSubscriptionData = ResultOf<T>, TSubscriptionVariables = VariablesOf<T>>(options: import("@apollo/client").SubscribeToMoreOptions<ResultOf<T>, TSubscriptionVariables, TSubscriptionData>) => () => void;
        updateQuery: <TVars = VariablesOf<T>>(mapFn: (previousQueryResult: ResultOf<T>, options: Pick<import("@apollo/client").WatchQueryOptions<TVars, ResultOf<T>>, "variables">) => ResultOf<T>) => void;
        refetch: (variables?: Partial<VariablesOf<T>>) => Promise<import("@apollo/client").ApolloQueryResult<ResultOf<T>>>;
        reobserve: (newOptions?: Partial<import("@apollo/client").WatchQueryOptions<VariablesOf<T>, ResultOf<T>>>, newNetworkStatus?: NetworkStatus) => Promise<import("@apollo/client").ApolloQueryResult<ResultOf<T>>>;
        fetchMore: <TFetchData = ResultOf<T>, TFetchVars = VariablesOf<T>>(fetchMoreOptions: import("@apollo/client").FetchMoreQueryOptions<TFetchVars, TFetchData> & {
            updateQuery?: (previousQueryResult: ResultOf<T>, options: {
                fetchMoreResult: TFetchData;
                variables: TFetchVars;
            }) => ResultOf<T>;
        }) => Promise<import("@apollo/client").ApolloQueryResult<TFetchData>>;
    };
    useLazyGet: <T extends Documents.Get>(document: T, options: CacheUpdateOptions<LazyQueryHookOptions<ResultOf<T>, VariablesOf<T>>>) => import("@apollo/client").LazyQueryResultTuple<ResultOf<T>, VariablesOf<T>>;
    useQuery: <TData = any, TVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: Omit<QueryHookOptions<TData, TVariables>, "query">) => {
        isLoading: boolean;
        isRefetching: boolean;
        hasMore: any;
        refetching: boolean;
        client: ApolloClient<any>;
        observable: import("@apollo/client").ObservableQuery<TData, TVariables>;
        data: TData;
        previousData?: TData;
        error?: import("@apollo/client").ApolloError;
        loading: boolean;
        networkStatus: NetworkStatus;
        called: boolean;
        variables: TVariables;
        startPolling: (pollInterval: number) => void;
        stopPolling: () => void;
        subscribeToMore: <TSubscriptionData = TData, TSubscriptionVariables = TVariables>(options: import("@apollo/client").SubscribeToMoreOptions<TData, TSubscriptionVariables, TSubscriptionData>) => () => void;
        updateQuery: <TVars = TVariables>(mapFn: (previousQueryResult: TData, options: Pick<import("@apollo/client").WatchQueryOptions<TVars, TData>, "variables">) => TData) => void;
        refetch: (variables?: Partial<TVariables>) => Promise<import("@apollo/client").ApolloQueryResult<TData>>;
        reobserve: (newOptions?: Partial<import("@apollo/client").WatchQueryOptions<TVariables, TData>>, newNetworkStatus?: NetworkStatus) => Promise<import("@apollo/client").ApolloQueryResult<TData>>;
        fetchMore: <TFetchData = TData, TFetchVars = TVariables>(fetchMoreOptions: import("@apollo/client").FetchMoreQueryOptions<TFetchVars, TFetchData> & {
            updateQuery?: (previousQueryResult: TData, options: {
                fetchMoreResult: TFetchData;
                variables: TFetchVars;
            }) => TData;
        }) => Promise<import("@apollo/client").ApolloQueryResult<TFetchData>>;
    };
    useLazyQuery: typeof useLazyQuery;
    useLazyList: <T extends Documents.List>(document: T, options: CacheUpdateOptions<LazyQueryHookOptions<ResultOf<T>, VariablesOf<T>>>) => import("@apollo/client").LazyQueryResultTuple<ResultOf<T>, VariablesOf<T>>;
    protected onCompletedListWrapper: (document: Documents.List, options: CacheUpdateOptions<ServiceQueryHookOptions<Documents.List>>) => (data: {
        list: Record<string, unknown>;
    }) => void;
    setRelations: (relationKey: string, options: MutationOptions<any, {
        input: {
            id: string;
            relationIds: string[];
        };
    }>) => Promise<void> | Promise<import("@apollo/client").FetchResult<any>>;
}
