import { DesiredOutcome, CloneTemplateToSuccessPlanDocument } from '../API';
import { CRUDService, ICrudService, MutationOptionsWithoutMutation } from '../core';
export declare class DesiredOutcomeService extends CRUDService<DesiredOutcome> {
    additionalDocuments: {
        statusBreakdownList: import("@graphql-typed-document-node/core").TypedDocumentNode<import("../API").DesiredOutcomeWithStatusBreakdownListQuery, import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>>;
        tableList: import("@graphql-typed-document-node/core").TypedDocumentNode<import("../API").DesiredOutcomeTableListQuery, import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>>;
    };
    protected hasOneModels: ICrudService<DesiredOutcome>['hasOneModels'];
    validateName: ({ name, isTemplate, successPlanID, }: {
        isTemplate?: boolean;
        name: string;
        successPlanID?: string;
    }) => Promise<boolean>;
    get create(): (input: Partial<Record<"automations" | "tasks" | "achievements" | "desiredOutcomes", import("../../..").ModelWithId[]> & Record<import("../core").HasOneRelationsOf<DesiredOutcome>, import("../../..").ModelWithId>> & Omit<import("../API").DesiredOutcomeInput, "automations" | "tasks" | "achievements" | "desiredOutcomes" | import("../core").HasOneRelationsOf<DesiredOutcome>>, options?: MutationOptionsWithoutMutation<import("@graphql-typed-document-node/core").TypedDocumentNode<import("../API").DesiredOutcomeCreateOneMutation, import("../API").Exact<{
        input: import("../API").DesiredOutcomeInput;
    }>>>) => Promise<{
        __typename?: "DesiredOutcome";
        id: string;
        name?: string;
        description?: string;
        icon?: string;
        order?: number;
        startDate?: any;
        status?: import("../API").DesiredOutcomeTrackingStatus;
        isTemplate?: boolean;
        targetTime?: number;
        completionType?: import("../API").CompletionType;
        activeDays?: number;
        markStalledAfterDays?: number;
        organizationID: string;
        successPlanID?: string;
        updated_at: any;
        created_at: any;
        successPlan?: {
            __typename?: "SuccessPlan";
            id: string;
            account: {
                __typename?: "Account";
                id: string;
                displayName?: string;
                vip?: boolean;
            };
        };
        folder?: {
            __typename?: "folder";
            id: string;
            name: string;
            type?: import("../API").FolderType;
            itemCount: number;
            created_at: any;
            updated_at: any;
        };
    }>;
    get reducedList(): (input: import("../API").Exact<{
        filter?: import("../API").DesiredOutcomeFilter;
        paging?: import("../API").CursorPaging;
        sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
    }>, options?: import("../core").ServiceQueryOptions<import("@graphql-typed-document-node/core").TypedDocumentNode<import("../API").DesiredOutcomeReducedListQuery, import("../API").Exact<{
        filter?: import("../API").DesiredOutcomeFilter;
        paging?: import("../API").CursorPaging;
        sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
    }>>>) => Promise<{
        __typename?: "DesiredOutcomeConnection";
        totalCount: number;
        pageInfo: {
            __typename?: "PageInfo";
            startCursor?: any;
            hasPreviousPage?: boolean;
            hasNextPage?: boolean;
            endCursor?: any;
        };
        edges: {
            __typename?: "DesiredOutcomeEdge";
            cursor: any;
            node: {
                __typename?: "DesiredOutcome";
                id: string;
                name?: string;
            };
        }[];
    }>;
    get list(): (input: import("../API").Exact<{
        filter?: import("../API").DesiredOutcomeFilter;
        paging?: import("../API").CursorPaging;
        sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
    }>, options?: import("../core").ServiceQueryOptions<import("@graphql-typed-document-node/core").TypedDocumentNode<import("../API").DesiredOutcomeListQuery, import("../API").Exact<{
        filter?: import("../API").DesiredOutcomeFilter;
        paging?: import("../API").CursorPaging;
        sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
    }>>>) => Promise<{
        __typename?: "DesiredOutcomeConnection";
        totalCount: number;
        pageInfo: {
            __typename?: "PageInfo";
            startCursor?: any;
            hasPreviousPage?: boolean;
            hasNextPage?: boolean;
            endCursor?: any;
        };
        edges: {
            __typename?: "DesiredOutcomeEdge";
            cursor: any;
            node: {
                __typename?: "DesiredOutcome";
                id: string;
                name?: string;
                description?: string;
                icon?: string;
                order?: number;
                startDate?: any;
                status?: import("../API").DesiredOutcomeTrackingStatus;
                isTemplate?: boolean;
                targetTime?: number;
                completionType?: import("../API").CompletionType;
                activeDays?: number;
                markStalledAfterDays?: number;
                organizationID: string;
                successPlanID?: string;
                updated_at: any;
                created_at: any;
                successPlan?: {
                    __typename?: "SuccessPlan";
                    id: string;
                    account: {
                        __typename?: "Account";
                        id: string;
                        displayName?: string;
                        vip?: boolean;
                    };
                };
                folder?: {
                    __typename?: "folder";
                    id: string;
                    name: string;
                    type?: import("../API").FolderType;
                    itemCount: number;
                    created_at: any;
                    updated_at: any;
                };
                totalAchievementsAggregate: {
                    __typename?: "DesiredOutcomeAchievementsAggregateResponse";
                    count?: {
                        __typename?: "DesiredOutcomeAchievementsCountAggregate";
                        id?: number;
                    };
                }[];
                totalTasksAggregate: {
                    __typename?: "DesiredOutcomeTasksAggregateResponse";
                    count?: {
                        __typename?: "DesiredOutcomeTasksCountAggregate";
                        id?: number;
                    };
                }[];
                isCompletedAchievementsAggregate: {
                    __typename?: "DesiredOutcomeAchievementsAggregateResponse";
                    count?: {
                        __typename?: "DesiredOutcomeAchievementsCountAggregate";
                        id?: number;
                    };
                }[];
                isCompletedTasksAggregate: {
                    __typename?: "DesiredOutcomeTasksAggregateResponse";
                    count?: {
                        __typename?: "DesiredOutcomeTasksCountAggregate";
                        id?: number;
                    };
                }[];
            };
        }[];
    }>;
    get update(): (input: Partial<Record<"automations" | "tasks" | "achievements" | "desiredOutcomes", import("../../..").ModelWithId[]> & Record<import("../core").HasOneRelationsOf<DesiredOutcome>, import("../../..").ModelWithId>> & Omit<import("../API").DesiredOutcomeInput, "automations" | "tasks" | "achievements" | "desiredOutcomes" | import("../core").HasOneRelationsOf<DesiredOutcome>> & {
        id: string;
    }, options?: MutationOptionsWithoutMutation<import("@graphql-typed-document-node/core").TypedDocumentNode<import("../API").DesiredOutcomeUpdateOneMutation, import("../API").Exact<{
        input: import("../API").UpdateOneDesiredOutcomeInput;
    }>>>) => Promise<{
        __typename?: "DesiredOutcome";
        id: string;
        name?: string;
        description?: string;
        icon?: string;
        order?: number;
        startDate?: any;
        status?: import("../API").DesiredOutcomeTrackingStatus;
        isTemplate?: boolean;
        targetTime?: number;
        completionType?: import("../API").CompletionType;
        activeDays?: number;
        markStalledAfterDays?: number;
        organizationID: string;
        successPlanID?: string;
        updated_at: any;
        created_at: any;
        successPlan?: {
            __typename?: "SuccessPlan";
            id: string;
            account: {
                __typename?: "Account";
                id: string;
                displayName?: string;
                vip?: boolean;
            };
        };
        folder?: {
            __typename?: "folder";
            id: string;
            name: string;
            type?: import("../API").FolderType;
            itemCount: number;
            created_at: any;
            updated_at: any;
        };
    }>;
    get useList(): (options: import("../core").CacheUpdateOptions<import("../core").ServiceQueryHookOptions<import("@graphql-typed-document-node/core").TypedDocumentNode<import("../API").DesiredOutcomeListQuery, import("../API").Exact<{
        filter?: import("../API").DesiredOutcomeFilter;
        paging?: import("../API").CursorPaging;
        sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
    }>>>>) => {
        isLoading: boolean;
        isRefetching: boolean;
        hasMore: any;
        refetching: boolean;
        client: import("@apollo/client").ApolloClient<any>;
        observable: import("@apollo/client").ObservableQuery<import("../API").DesiredOutcomeListQuery, import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>>;
        data: import("../API").DesiredOutcomeListQuery;
        previousData?: import("../API").DesiredOutcomeListQuery;
        error?: import("@apollo/client").ApolloError;
        errors?: readonly import("graphql").GraphQLFormattedError[];
        loading: boolean;
        networkStatus: import("@apollo/client").NetworkStatus;
        called: boolean;
        startPolling: (pollInterval: number) => void;
        stopPolling: () => void;
        subscribeToMore: <TSubscriptionData = import("../API").DesiredOutcomeListQuery, TSubscriptionVariables extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>>(options: import("@apollo/client").SubscribeToMoreOptions<import("../API").DesiredOutcomeListQuery, TSubscriptionVariables, TSubscriptionData>) => () => void;
        updateQuery: <TVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>>(mapFn: (previousQueryResult: import("../API").DesiredOutcomeListQuery, options: Pick<import("@apollo/client").WatchQueryOptions<TVars, import("../API").DesiredOutcomeListQuery>, "variables">) => import("../API").DesiredOutcomeListQuery) => void;
        refetch: (variables?: Partial<import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>>) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").DesiredOutcomeListQuery>>;
        reobserve: (newOptions?: Partial<import("@apollo/client").WatchQueryOptions<import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>, import("../API").DesiredOutcomeListQuery>>, newNetworkStatus?: import("@apollo/client").NetworkStatus) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").DesiredOutcomeListQuery>>;
        variables: import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>;
        fetchMore: <TFetchData = import("../API").DesiredOutcomeListQuery, TFetchVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>>(fetchMoreOptions: import("@apollo/client").FetchMoreQueryOptions<TFetchVars, TFetchData> & {
            updateQuery?: (previousQueryResult: import("../API").DesiredOutcomeListQuery, options: {
                fetchMoreResult: TFetchData;
                variables: TFetchVars;
            }) => import("../API").DesiredOutcomeListQuery;
        }) => Promise<import("@apollo/client").ApolloQueryResult<TFetchData>>;
    };
    get useListFromTemplate(): (options?: import("../core").CacheUpdateOptions<import("../core").ServiceQueryHookOptions<import("@graphql-typed-document-node/core").TypedDocumentNode<import("../API").DesiredOutcomesFromTemplateQuery, import("../API").Exact<{
        desiredOutcomeTemplateId: string;
        organizationId: string;
        accountName?: string;
        segmentId?: string;
        sortBy?: import("../API").DesiredOutcomeSortOption;
        sortDirection?: import("../API").SortingDirectionType;
        status?: import("../API").DesiredOutcomeTrackingStatus;
        skip?: number;
        take?: number;
    }>>>>) => {
        isLoading: boolean;
        isRefetching: boolean;
        hasMore: any;
        refetching: boolean;
        client: import("@apollo/client").ApolloClient<any>;
        observable: import("@apollo/client").ObservableQuery<import("../API").DesiredOutcomesFromTemplateQuery, import("../API").Exact<{
            desiredOutcomeTemplateId: string;
            organizationId: string;
            accountName?: string;
            segmentId?: string;
            sortBy?: import("../API").DesiredOutcomeSortOption;
            sortDirection?: import("../API").SortingDirectionType;
            status?: import("../API").DesiredOutcomeTrackingStatus;
            skip?: number;
            take?: number;
        }>>;
        data: import("../API").DesiredOutcomesFromTemplateQuery;
        previousData?: import("../API").DesiredOutcomesFromTemplateQuery;
        error?: import("@apollo/client").ApolloError;
        errors?: readonly import("graphql").GraphQLFormattedError[];
        loading: boolean;
        networkStatus: import("@apollo/client").NetworkStatus;
        called: boolean;
        startPolling: (pollInterval: number) => void;
        stopPolling: () => void;
        subscribeToMore: <TSubscriptionData = import("../API").DesiredOutcomesFromTemplateQuery, TSubscriptionVariables extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            desiredOutcomeTemplateId: string;
            organizationId: string;
            accountName?: string;
            segmentId?: string;
            sortBy?: import("../API").DesiredOutcomeSortOption;
            sortDirection?: import("../API").SortingDirectionType;
            status?: import("../API").DesiredOutcomeTrackingStatus;
            skip?: number;
            take?: number;
        }>>(options: import("@apollo/client").SubscribeToMoreOptions<import("../API").DesiredOutcomesFromTemplateQuery, TSubscriptionVariables, TSubscriptionData>) => () => void;
        updateQuery: <TVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            desiredOutcomeTemplateId: string;
            organizationId: string;
            accountName?: string;
            segmentId?: string;
            sortBy?: import("../API").DesiredOutcomeSortOption;
            sortDirection?: import("../API").SortingDirectionType;
            status?: import("../API").DesiredOutcomeTrackingStatus;
            skip?: number;
            take?: number;
        }>>(mapFn: (previousQueryResult: import("../API").DesiredOutcomesFromTemplateQuery, options: Pick<import("@apollo/client").WatchQueryOptions<TVars, import("../API").DesiredOutcomesFromTemplateQuery>, "variables">) => import("../API").DesiredOutcomesFromTemplateQuery) => void;
        refetch: (variables?: Partial<import("../API").Exact<{
            desiredOutcomeTemplateId: string;
            organizationId: string;
            accountName?: string;
            segmentId?: string;
            sortBy?: import("../API").DesiredOutcomeSortOption;
            sortDirection?: import("../API").SortingDirectionType;
            status?: import("../API").DesiredOutcomeTrackingStatus;
            skip?: number;
            take?: number;
        }>>) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").DesiredOutcomesFromTemplateQuery>>;
        reobserve: (newOptions?: Partial<import("@apollo/client").WatchQueryOptions<import("../API").Exact<{
            desiredOutcomeTemplateId: string;
            organizationId: string;
            accountName?: string;
            segmentId?: string;
            sortBy?: import("../API").DesiredOutcomeSortOption;
            sortDirection?: import("../API").SortingDirectionType;
            status?: import("../API").DesiredOutcomeTrackingStatus;
            skip?: number;
            take?: number;
        }>, import("../API").DesiredOutcomesFromTemplateQuery>>, newNetworkStatus?: import("@apollo/client").NetworkStatus) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").DesiredOutcomesFromTemplateQuery>>;
        variables: import("../API").Exact<{
            desiredOutcomeTemplateId: string;
            organizationId: string;
            accountName?: string;
            segmentId?: string;
            sortBy?: import("../API").DesiredOutcomeSortOption;
            sortDirection?: import("../API").SortingDirectionType;
            status?: import("../API").DesiredOutcomeTrackingStatus;
            skip?: number;
            take?: number;
        }>;
        fetchMore: <TFetchData = import("../API").DesiredOutcomesFromTemplateQuery, TFetchVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            desiredOutcomeTemplateId: string;
            organizationId: string;
            accountName?: string;
            segmentId?: string;
            sortBy?: import("../API").DesiredOutcomeSortOption;
            sortDirection?: import("../API").SortingDirectionType;
            status?: import("../API").DesiredOutcomeTrackingStatus;
            skip?: number;
            take?: number;
        }>>(fetchMoreOptions: import("@apollo/client").FetchMoreQueryOptions<TFetchVars, TFetchData> & {
            updateQuery?: (previousQueryResult: import("../API").DesiredOutcomesFromTemplateQuery, options: {
                fetchMoreResult: TFetchData;
                variables: TFetchVars;
            }) => import("../API").DesiredOutcomesFromTemplateQuery;
        }) => Promise<import("@apollo/client").ApolloQueryResult<TFetchData>>;
    };
    get useTableList(): (options: import("../core").CacheUpdateOptions<import("../core").ServiceQueryHookOptions<import("@graphql-typed-document-node/core").TypedDocumentNode<import("../API").DesiredOutcomeTableListQuery, import("../API").Exact<{
        filter?: import("../API").DesiredOutcomeFilter;
        paging?: import("../API").CursorPaging;
        sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
    }>>>>) => {
        isLoading: boolean;
        isRefetching: boolean;
        hasMore: any;
        refetching: boolean;
        client: import("@apollo/client").ApolloClient<any>;
        observable: import("@apollo/client").ObservableQuery<import("../API").DesiredOutcomeTableListQuery, import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>>;
        data: import("../API").DesiredOutcomeTableListQuery;
        previousData?: import("../API").DesiredOutcomeTableListQuery;
        error?: import("@apollo/client").ApolloError;
        errors?: readonly import("graphql").GraphQLFormattedError[];
        loading: boolean;
        networkStatus: import("@apollo/client").NetworkStatus;
        called: boolean;
        startPolling: (pollInterval: number) => void;
        stopPolling: () => void;
        subscribeToMore: <TSubscriptionData = import("../API").DesiredOutcomeTableListQuery, TSubscriptionVariables extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>>(options: import("@apollo/client").SubscribeToMoreOptions<import("../API").DesiredOutcomeTableListQuery, TSubscriptionVariables, TSubscriptionData>) => () => void;
        updateQuery: <TVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>>(mapFn: (previousQueryResult: import("../API").DesiredOutcomeTableListQuery, options: Pick<import("@apollo/client").WatchQueryOptions<TVars, import("../API").DesiredOutcomeTableListQuery>, "variables">) => import("../API").DesiredOutcomeTableListQuery) => void;
        refetch: (variables?: Partial<import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>>) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").DesiredOutcomeTableListQuery>>;
        reobserve: (newOptions?: Partial<import("@apollo/client").WatchQueryOptions<import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>, import("../API").DesiredOutcomeTableListQuery>>, newNetworkStatus?: import("@apollo/client").NetworkStatus) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").DesiredOutcomeTableListQuery>>;
        variables: import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>;
        fetchMore: <TFetchData = import("../API").DesiredOutcomeTableListQuery, TFetchVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>>(fetchMoreOptions: import("@apollo/client").FetchMoreQueryOptions<TFetchVars, TFetchData> & {
            updateQuery?: (previousQueryResult: import("../API").DesiredOutcomeTableListQuery, options: {
                fetchMoreResult: TFetchData;
                variables: TFetchVars;
            }) => import("../API").DesiredOutcomeTableListQuery;
        }) => Promise<import("@apollo/client").ApolloQueryResult<TFetchData>>;
    };
    get useStatusBreakdownList(): (options: import("../core").CacheUpdateOptions<import("../core").ServiceQueryHookOptions<import("@graphql-typed-document-node/core").TypedDocumentNode<import("../API").DesiredOutcomeWithStatusBreakdownListQuery, import("../API").Exact<{
        filter?: import("../API").DesiredOutcomeFilter;
        paging?: import("../API").CursorPaging;
        sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
    }>>>>) => {
        isLoading: boolean;
        isRefetching: boolean;
        hasMore: any;
        refetching: boolean;
        client: import("@apollo/client").ApolloClient<any>;
        observable: import("@apollo/client").ObservableQuery<import("../API").DesiredOutcomeWithStatusBreakdownListQuery, import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>>;
        data: import("../API").DesiredOutcomeWithStatusBreakdownListQuery;
        previousData?: import("../API").DesiredOutcomeWithStatusBreakdownListQuery;
        error?: import("@apollo/client").ApolloError;
        errors?: readonly import("graphql").GraphQLFormattedError[];
        loading: boolean;
        networkStatus: import("@apollo/client").NetworkStatus;
        called: boolean;
        startPolling: (pollInterval: number) => void;
        stopPolling: () => void;
        subscribeToMore: <TSubscriptionData = import("../API").DesiredOutcomeWithStatusBreakdownListQuery, TSubscriptionVariables extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>>(options: import("@apollo/client").SubscribeToMoreOptions<import("../API").DesiredOutcomeWithStatusBreakdownListQuery, TSubscriptionVariables, TSubscriptionData>) => () => void;
        updateQuery: <TVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>>(mapFn: (previousQueryResult: import("../API").DesiredOutcomeWithStatusBreakdownListQuery, options: Pick<import("@apollo/client").WatchQueryOptions<TVars, import("../API").DesiredOutcomeWithStatusBreakdownListQuery>, "variables">) => import("../API").DesiredOutcomeWithStatusBreakdownListQuery) => void;
        refetch: (variables?: Partial<import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>>) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").DesiredOutcomeWithStatusBreakdownListQuery>>;
        reobserve: (newOptions?: Partial<import("@apollo/client").WatchQueryOptions<import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>, import("../API").DesiredOutcomeWithStatusBreakdownListQuery>>, newNetworkStatus?: import("@apollo/client").NetworkStatus) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").DesiredOutcomeWithStatusBreakdownListQuery>>;
        variables: import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>;
        fetchMore: <TFetchData = import("../API").DesiredOutcomeWithStatusBreakdownListQuery, TFetchVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            filter?: import("../API").DesiredOutcomeFilter;
            paging?: import("../API").CursorPaging;
            sorting?: import("../API").DesiredOutcomeSort | import("../API").DesiredOutcomeSort[];
        }>>(fetchMoreOptions: import("@apollo/client").FetchMoreQueryOptions<TFetchVars, TFetchData> & {
            updateQuery?: (previousQueryResult: import("../API").DesiredOutcomeWithStatusBreakdownListQuery, options: {
                fetchMoreResult: TFetchData;
                variables: TFetchVars;
            }) => import("../API").DesiredOutcomeWithStatusBreakdownListQuery;
        }) => Promise<import("@apollo/client").ApolloQueryResult<TFetchData>>;
    };
    get delete(): (id: string, options?: MutationOptionsWithoutMutation<import("@graphql-typed-document-node/core").TypedDocumentNode<import("../API").DesiredOutcomeDeleteOneMutation, import("../API").Exact<{
        input: import("../API").DeleteOneDesiredOutcomeInput;
    }>>>) => Promise<{
        __typename?: "DesiredOutcomeDeleteResponse";
        id?: string;
    }>;
    get get(): (id: string, options?: Omit<import("@apollo/client").QueryOptions<import("../API").Exact<{
        id: string;
    }>, import("../API").GetDesiredOutcomeQuery>, "query">) => Promise<{
        __typename?: "DesiredOutcome";
        id: string;
        name?: string;
        description?: string;
        icon?: string;
        order?: number;
        startDate?: any;
        status?: import("../API").DesiredOutcomeTrackingStatus;
        isTemplate?: boolean;
        targetTime?: number;
        completionType?: import("../API").CompletionType;
        activeDays?: number;
        markStalledAfterDays?: number;
        organizationID: string;
        successPlanID?: string;
        updated_at: any;
        created_at: any;
        successPlan?: {
            __typename?: "SuccessPlan";
            id: string;
            account: {
                __typename?: "Account";
                id: string;
                displayName?: string;
                vip?: boolean;
            };
        };
        folder?: {
            __typename?: "folder";
            id: string;
            name: string;
            type?: import("../API").FolderType;
            itemCount: number;
            created_at: any;
            updated_at: any;
        };
    }>;
    get useGet(): (options: import("../core").ServiceQueryHookOptions<import("@graphql-typed-document-node/core").TypedDocumentNode<import("../API").GetDesiredOutcomeQuery, import("../API").Exact<{
        id: string;
    }>>>) => {
        isLoading: boolean;
        isRefetching: boolean;
        hasMore: any;
        refetching: boolean;
        client: import("@apollo/client").ApolloClient<any>;
        observable: import("@apollo/client").ObservableQuery<import("../API").GetDesiredOutcomeQuery, import("../API").Exact<{
            id: string;
        }>>;
        data: import("../API").GetDesiredOutcomeQuery;
        previousData?: import("../API").GetDesiredOutcomeQuery;
        error?: import("@apollo/client").ApolloError;
        errors?: readonly import("graphql").GraphQLFormattedError[];
        loading: boolean;
        networkStatus: import("@apollo/client").NetworkStatus;
        called: boolean;
        startPolling: (pollInterval: number) => void;
        stopPolling: () => void;
        subscribeToMore: <TSubscriptionData = import("../API").GetDesiredOutcomeQuery, TSubscriptionVariables extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            id: string;
        }>>(options: import("@apollo/client").SubscribeToMoreOptions<import("../API").GetDesiredOutcomeQuery, TSubscriptionVariables, TSubscriptionData>) => () => void;
        updateQuery: <TVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            id: string;
        }>>(mapFn: (previousQueryResult: import("../API").GetDesiredOutcomeQuery, options: Pick<import("@apollo/client").WatchQueryOptions<TVars, import("../API").GetDesiredOutcomeQuery>, "variables">) => import("../API").GetDesiredOutcomeQuery) => void;
        refetch: (variables?: Partial<import("../API").Exact<{
            id: string;
        }>>) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").GetDesiredOutcomeQuery>>;
        reobserve: (newOptions?: Partial<import("@apollo/client").WatchQueryOptions<import("../API").Exact<{
            id: string;
        }>, import("../API").GetDesiredOutcomeQuery>>, newNetworkStatus?: import("@apollo/client").NetworkStatus) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").GetDesiredOutcomeQuery>>;
        variables: import("../API").Exact<{
            id: string;
        }>;
        fetchMore: <TFetchData = import("../API").GetDesiredOutcomeQuery, TFetchVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            id: string;
        }>>(fetchMoreOptions: import("@apollo/client").FetchMoreQueryOptions<TFetchVars, TFetchData> & {
            updateQuery?: (previousQueryResult: import("../API").GetDesiredOutcomeQuery, options: {
                fetchMoreResult: TFetchData;
                variables: TFetchVars;
            }) => import("../API").GetDesiredOutcomeQuery;
        }) => Promise<import("@apollo/client").ApolloQueryResult<TFetchData>>;
    };
    get useGetStatusBreakdown(): (options: import("../core").ServiceQueryHookOptions<import("@graphql-typed-document-node/core").TypedDocumentNode<import("../API").GetDesiredOutcomeStatusBreakdownQuery, import("../API").Exact<{
        id: string;
    }>>>) => {
        isLoading: boolean;
        isRefetching: boolean;
        hasMore: any;
        refetching: boolean;
        client: import("@apollo/client").ApolloClient<any>;
        observable: import("@apollo/client").ObservableQuery<import("../API").GetDesiredOutcomeStatusBreakdownQuery, import("../API").Exact<{
            id: string;
        }>>;
        data: import("../API").GetDesiredOutcomeStatusBreakdownQuery;
        previousData?: import("../API").GetDesiredOutcomeStatusBreakdownQuery;
        error?: import("@apollo/client").ApolloError;
        errors?: readonly import("graphql").GraphQLFormattedError[];
        loading: boolean;
        networkStatus: import("@apollo/client").NetworkStatus;
        called: boolean;
        startPolling: (pollInterval: number) => void;
        stopPolling: () => void;
        subscribeToMore: <TSubscriptionData = import("../API").GetDesiredOutcomeStatusBreakdownQuery, TSubscriptionVariables extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            id: string;
        }>>(options: import("@apollo/client").SubscribeToMoreOptions<import("../API").GetDesiredOutcomeStatusBreakdownQuery, TSubscriptionVariables, TSubscriptionData>) => () => void;
        updateQuery: <TVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            id: string;
        }>>(mapFn: (previousQueryResult: import("../API").GetDesiredOutcomeStatusBreakdownQuery, options: Pick<import("@apollo/client").WatchQueryOptions<TVars, import("../API").GetDesiredOutcomeStatusBreakdownQuery>, "variables">) => import("../API").GetDesiredOutcomeStatusBreakdownQuery) => void;
        refetch: (variables?: Partial<import("../API").Exact<{
            id: string;
        }>>) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").GetDesiredOutcomeStatusBreakdownQuery>>;
        reobserve: (newOptions?: Partial<import("@apollo/client").WatchQueryOptions<import("../API").Exact<{
            id: string;
        }>, import("../API").GetDesiredOutcomeStatusBreakdownQuery>>, newNetworkStatus?: import("@apollo/client").NetworkStatus) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").GetDesiredOutcomeStatusBreakdownQuery>>;
        variables: import("../API").Exact<{
            id: string;
        }>;
        fetchMore: <TFetchData = import("../API").GetDesiredOutcomeStatusBreakdownQuery, TFetchVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            id: string;
        }>>(fetchMoreOptions: import("@apollo/client").FetchMoreQueryOptions<TFetchVars, TFetchData> & {
            updateQuery?: (previousQueryResult: import("../API").GetDesiredOutcomeStatusBreakdownQuery, options: {
                fetchMoreResult: TFetchData;
                variables: TFetchVars;
            }) => import("../API").GetDesiredOutcomeStatusBreakdownQuery;
        }) => Promise<import("@apollo/client").ApolloQueryResult<TFetchData>>;
    };
    get useGetReportTiles(): (options?: import("../core").CacheUpdateOptions<import("../core").ServiceQueryHookOptions<import("@graphql-typed-document-node/core").TypedDocumentNode<import("../API").GetDesiredOutcomeReportTilesQuery, import("../API").Exact<{
        organizationId: string;
        segmentId?: string;
    }>>>>) => {
        isLoading: boolean;
        isRefetching: boolean;
        hasMore: any;
        refetching: boolean;
        client: import("@apollo/client").ApolloClient<any>;
        observable: import("@apollo/client").ObservableQuery<import("../API").GetDesiredOutcomeReportTilesQuery, import("../API").Exact<{
            organizationId: string;
            segmentId?: string;
        }>>;
        data: import("../API").GetDesiredOutcomeReportTilesQuery;
        previousData?: import("../API").GetDesiredOutcomeReportTilesQuery;
        error?: import("@apollo/client").ApolloError;
        errors?: readonly import("graphql").GraphQLFormattedError[];
        loading: boolean;
        networkStatus: import("@apollo/client").NetworkStatus;
        called: boolean;
        startPolling: (pollInterval: number) => void;
        stopPolling: () => void;
        subscribeToMore: <TSubscriptionData = import("../API").GetDesiredOutcomeReportTilesQuery, TSubscriptionVariables extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            organizationId: string;
            segmentId?: string;
        }>>(options: import("@apollo/client").SubscribeToMoreOptions<import("../API").GetDesiredOutcomeReportTilesQuery, TSubscriptionVariables, TSubscriptionData>) => () => void;
        updateQuery: <TVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            organizationId: string;
            segmentId?: string;
        }>>(mapFn: (previousQueryResult: import("../API").GetDesiredOutcomeReportTilesQuery, options: Pick<import("@apollo/client").WatchQueryOptions<TVars, import("../API").GetDesiredOutcomeReportTilesQuery>, "variables">) => import("../API").GetDesiredOutcomeReportTilesQuery) => void;
        refetch: (variables?: Partial<import("../API").Exact<{
            organizationId: string;
            segmentId?: string;
        }>>) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").GetDesiredOutcomeReportTilesQuery>>;
        reobserve: (newOptions?: Partial<import("@apollo/client").WatchQueryOptions<import("../API").Exact<{
            organizationId: string;
            segmentId?: string;
        }>, import("../API").GetDesiredOutcomeReportTilesQuery>>, newNetworkStatus?: import("@apollo/client").NetworkStatus) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").GetDesiredOutcomeReportTilesQuery>>;
        variables: import("../API").Exact<{
            organizationId: string;
            segmentId?: string;
        }>;
        fetchMore: <TFetchData = import("../API").GetDesiredOutcomeReportTilesQuery, TFetchVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            organizationId: string;
            segmentId?: string;
        }>>(fetchMoreOptions: import("@apollo/client").FetchMoreQueryOptions<TFetchVars, TFetchData> & {
            updateQuery?: (previousQueryResult: import("../API").GetDesiredOutcomeReportTilesQuery, options: {
                fetchMoreResult: TFetchData;
                variables: TFetchVars;
            }) => import("../API").GetDesiredOutcomeReportTilesQuery;
        }) => Promise<import("@apollo/client").ApolloQueryResult<TFetchData>>;
    };
    get useGetHomeTiles(): (options?: import("../core").CacheUpdateOptions<import("../core").ServiceQueryHookOptions<import("@graphql-typed-document-node/core").TypedDocumentNode<import("../API").GetDesiredOutcomeHomeTilesQuery, import("../API").Exact<{
        adminId: string;
        organizationId: string;
    }>>>>) => {
        isLoading: boolean;
        isRefetching: boolean;
        hasMore: any;
        refetching: boolean;
        client: import("@apollo/client").ApolloClient<any>;
        observable: import("@apollo/client").ObservableQuery<import("../API").GetDesiredOutcomeHomeTilesQuery, import("../API").Exact<{
            adminId: string;
            organizationId: string;
        }>>;
        data: import("../API").GetDesiredOutcomeHomeTilesQuery;
        previousData?: import("../API").GetDesiredOutcomeHomeTilesQuery;
        error?: import("@apollo/client").ApolloError;
        errors?: readonly import("graphql").GraphQLFormattedError[];
        loading: boolean;
        networkStatus: import("@apollo/client").NetworkStatus;
        called: boolean;
        startPolling: (pollInterval: number) => void;
        stopPolling: () => void;
        subscribeToMore: <TSubscriptionData = import("../API").GetDesiredOutcomeHomeTilesQuery, TSubscriptionVariables extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            adminId: string;
            organizationId: string;
        }>>(options: import("@apollo/client").SubscribeToMoreOptions<import("../API").GetDesiredOutcomeHomeTilesQuery, TSubscriptionVariables, TSubscriptionData>) => () => void;
        updateQuery: <TVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            adminId: string;
            organizationId: string;
        }>>(mapFn: (previousQueryResult: import("../API").GetDesiredOutcomeHomeTilesQuery, options: Pick<import("@apollo/client").WatchQueryOptions<TVars, import("../API").GetDesiredOutcomeHomeTilesQuery>, "variables">) => import("../API").GetDesiredOutcomeHomeTilesQuery) => void;
        refetch: (variables?: Partial<import("../API").Exact<{
            adminId: string;
            organizationId: string;
        }>>) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").GetDesiredOutcomeHomeTilesQuery>>;
        reobserve: (newOptions?: Partial<import("@apollo/client").WatchQueryOptions<import("../API").Exact<{
            adminId: string;
            organizationId: string;
        }>, import("../API").GetDesiredOutcomeHomeTilesQuery>>, newNetworkStatus?: import("@apollo/client").NetworkStatus) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").GetDesiredOutcomeHomeTilesQuery>>;
        variables: import("../API").Exact<{
            adminId: string;
            organizationId: string;
        }>;
        fetchMore: <TFetchData = import("../API").GetDesiredOutcomeHomeTilesQuery, TFetchVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            adminId: string;
            organizationId: string;
        }>>(fetchMoreOptions: import("@apollo/client").FetchMoreQueryOptions<TFetchVars, TFetchData> & {
            updateQuery?: (previousQueryResult: import("../API").GetDesiredOutcomeHomeTilesQuery, options: {
                fetchMoreResult: TFetchData;
                variables: TFetchVars;
            }) => import("../API").GetDesiredOutcomeHomeTilesQuery;
        }) => Promise<import("@apollo/client").ApolloQueryResult<TFetchData>>;
    };
    get useGetOverTime(): (options?: import("../core").CacheUpdateOptions<import("../core").ServiceQueryHookOptions<import("@graphql-typed-document-node/core").TypedDocumentNode<import("../API").GetDesiredOutcomeOverTimeQuery, import("../API").Exact<{
        organizationId: string;
        range: import("../API").ThirtyNinetyAllTime;
        segmentId?: string;
    }>>>>) => {
        isLoading: boolean;
        isRefetching: boolean;
        hasMore: any;
        refetching: boolean;
        client: import("@apollo/client").ApolloClient<any>;
        observable: import("@apollo/client").ObservableQuery<import("../API").GetDesiredOutcomeOverTimeQuery, import("../API").Exact<{
            organizationId: string;
            range: import("../API").ThirtyNinetyAllTime;
            segmentId?: string;
        }>>;
        data: import("../API").GetDesiredOutcomeOverTimeQuery;
        previousData?: import("../API").GetDesiredOutcomeOverTimeQuery;
        error?: import("@apollo/client").ApolloError;
        errors?: readonly import("graphql").GraphQLFormattedError[];
        loading: boolean;
        networkStatus: import("@apollo/client").NetworkStatus;
        called: boolean;
        startPolling: (pollInterval: number) => void;
        stopPolling: () => void;
        subscribeToMore: <TSubscriptionData = import("../API").GetDesiredOutcomeOverTimeQuery, TSubscriptionVariables extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            organizationId: string;
            range: import("../API").ThirtyNinetyAllTime;
            segmentId?: string;
        }>>(options: import("@apollo/client").SubscribeToMoreOptions<import("../API").GetDesiredOutcomeOverTimeQuery, TSubscriptionVariables, TSubscriptionData>) => () => void;
        updateQuery: <TVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            organizationId: string;
            range: import("../API").ThirtyNinetyAllTime;
            segmentId?: string;
        }>>(mapFn: (previousQueryResult: import("../API").GetDesiredOutcomeOverTimeQuery, options: Pick<import("@apollo/client").WatchQueryOptions<TVars, import("../API").GetDesiredOutcomeOverTimeQuery>, "variables">) => import("../API").GetDesiredOutcomeOverTimeQuery) => void;
        refetch: (variables?: Partial<import("../API").Exact<{
            organizationId: string;
            range: import("../API").ThirtyNinetyAllTime;
            segmentId?: string;
        }>>) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").GetDesiredOutcomeOverTimeQuery>>;
        reobserve: (newOptions?: Partial<import("@apollo/client").WatchQueryOptions<import("../API").Exact<{
            organizationId: string;
            range: import("../API").ThirtyNinetyAllTime;
            segmentId?: string;
        }>, import("../API").GetDesiredOutcomeOverTimeQuery>>, newNetworkStatus?: import("@apollo/client").NetworkStatus) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").GetDesiredOutcomeOverTimeQuery>>;
        variables: import("../API").Exact<{
            organizationId: string;
            range: import("../API").ThirtyNinetyAllTime;
            segmentId?: string;
        }>;
        fetchMore: <TFetchData = import("../API").GetDesiredOutcomeOverTimeQuery, TFetchVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            organizationId: string;
            range: import("../API").ThirtyNinetyAllTime;
            segmentId?: string;
        }>>(fetchMoreOptions: import("@apollo/client").FetchMoreQueryOptions<TFetchVars, TFetchData> & {
            updateQuery?: (previousQueryResult: import("../API").GetDesiredOutcomeOverTimeQuery, options: {
                fetchMoreResult: TFetchData;
                variables: TFetchVars;
            }) => import("../API").GetDesiredOutcomeOverTimeQuery;
        }) => Promise<import("@apollo/client").ApolloQueryResult<TFetchData>>;
    };
    get useGetTopFiveTemplatesWithStatus(): (options?: import("../core").CacheUpdateOptions<import("../core").ServiceQueryHookOptions<import("@graphql-typed-document-node/core").TypedDocumentNode<import("../API").GetTopFiveTemplatesWithStatusQuery, import("../API").Exact<{
        organizationId: string;
        status: import("../API").DesiredOutcomeTrackingStatus;
        segmentId?: string;
    }>>>>) => {
        isLoading: boolean;
        isRefetching: boolean;
        hasMore: any;
        refetching: boolean;
        client: import("@apollo/client").ApolloClient<any>;
        observable: import("@apollo/client").ObservableQuery<import("../API").GetTopFiveTemplatesWithStatusQuery, import("../API").Exact<{
            organizationId: string;
            status: import("../API").DesiredOutcomeTrackingStatus;
            segmentId?: string;
        }>>;
        data: import("../API").GetTopFiveTemplatesWithStatusQuery;
        previousData?: import("../API").GetTopFiveTemplatesWithStatusQuery;
        error?: import("@apollo/client").ApolloError;
        errors?: readonly import("graphql").GraphQLFormattedError[];
        loading: boolean;
        networkStatus: import("@apollo/client").NetworkStatus;
        called: boolean;
        startPolling: (pollInterval: number) => void;
        stopPolling: () => void;
        subscribeToMore: <TSubscriptionData = import("../API").GetTopFiveTemplatesWithStatusQuery, TSubscriptionVariables extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            organizationId: string;
            status: import("../API").DesiredOutcomeTrackingStatus;
            segmentId?: string;
        }>>(options: import("@apollo/client").SubscribeToMoreOptions<import("../API").GetTopFiveTemplatesWithStatusQuery, TSubscriptionVariables, TSubscriptionData>) => () => void;
        updateQuery: <TVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            organizationId: string;
            status: import("../API").DesiredOutcomeTrackingStatus;
            segmentId?: string;
        }>>(mapFn: (previousQueryResult: import("../API").GetTopFiveTemplatesWithStatusQuery, options: Pick<import("@apollo/client").WatchQueryOptions<TVars, import("../API").GetTopFiveTemplatesWithStatusQuery>, "variables">) => import("../API").GetTopFiveTemplatesWithStatusQuery) => void;
        refetch: (variables?: Partial<import("../API").Exact<{
            organizationId: string;
            status: import("../API").DesiredOutcomeTrackingStatus;
            segmentId?: string;
        }>>) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").GetTopFiveTemplatesWithStatusQuery>>;
        reobserve: (newOptions?: Partial<import("@apollo/client").WatchQueryOptions<import("../API").Exact<{
            organizationId: string;
            status: import("../API").DesiredOutcomeTrackingStatus;
            segmentId?: string;
        }>, import("../API").GetTopFiveTemplatesWithStatusQuery>>, newNetworkStatus?: import("@apollo/client").NetworkStatus) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").GetTopFiveTemplatesWithStatusQuery>>;
        variables: import("../API").Exact<{
            organizationId: string;
            status: import("../API").DesiredOutcomeTrackingStatus;
            segmentId?: string;
        }>;
        fetchMore: <TFetchData = import("../API").GetTopFiveTemplatesWithStatusQuery, TFetchVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            organizationId: string;
            status: import("../API").DesiredOutcomeTrackingStatus;
            segmentId?: string;
        }>>(fetchMoreOptions: import("@apollo/client").FetchMoreQueryOptions<TFetchVars, TFetchData> & {
            updateQuery?: (previousQueryResult: import("../API").GetTopFiveTemplatesWithStatusQuery, options: {
                fetchMoreResult: TFetchData;
                variables: TFetchVars;
            }) => import("../API").GetTopFiveTemplatesWithStatusQuery;
        }) => Promise<import("@apollo/client").ApolloQueryResult<TFetchData>>;
    };
    get updateMany(): (input: import("../API").UpdateManyDesiredOutcomesInput, options?: MutationOptionsWithoutMutation<import("@graphql-typed-document-node/core").TypedDocumentNode<import("../API").DesiredOutcomeUpdateManyMutation, import("../API").Exact<{
        input: import("../API").UpdateManyDesiredOutcomesInput;
    }>>>) => Promise<{
        __typename?: "UpdateManyResponse";
        updatedCount: number;
    }>;
    cloneTemplateToSuccessPlan(options: MutationOptionsWithoutMutation<typeof CloneTemplateToSuccessPlanDocument>): Promise<import("@apollo/client").FetchResult<import("../API").CloneTemplateToSuccessPlanMutation>>;
    get useCounts(): (options: import("../core").CacheUpdateOptions<import("../core").ServiceQueryHookOptions<import("@graphql-typed-document-node/core").TypedDocumentNode<import("../API").DesiredOutcomeCountsQuery, import("../API").Exact<{
        desiredOutcomeID: string;
    }>>>>) => {
        taskCounts: {
            total: number;
            completed: number;
        };
        achievementCounts: {
            total: number;
            completed: number;
        };
        isLoading: boolean;
        isRefetching: boolean;
        hasMore: any;
        refetching: boolean;
        client: import("@apollo/client").ApolloClient<any>;
        observable: import("@apollo/client").ObservableQuery<import("../API").DesiredOutcomeCountsQuery, import("../API").Exact<{
            desiredOutcomeID: string;
        }>>;
        data: import("../API").DesiredOutcomeCountsQuery;
        previousData?: import("../API").DesiredOutcomeCountsQuery;
        error?: import("@apollo/client").ApolloError;
        errors?: readonly import("graphql").GraphQLFormattedError[];
        loading: boolean;
        networkStatus: import("@apollo/client").NetworkStatus;
        called: boolean;
        startPolling: (pollInterval: number) => void;
        stopPolling: () => void;
        subscribeToMore: <TSubscriptionData = import("../API").DesiredOutcomeCountsQuery, TSubscriptionVariables extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            desiredOutcomeID: string;
        }>>(options: import("@apollo/client").SubscribeToMoreOptions<import("../API").DesiredOutcomeCountsQuery, TSubscriptionVariables, TSubscriptionData>) => () => void;
        updateQuery: <TVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            desiredOutcomeID: string;
        }>>(mapFn: (previousQueryResult: import("../API").DesiredOutcomeCountsQuery, options: Pick<import("@apollo/client").WatchQueryOptions<TVars, import("../API").DesiredOutcomeCountsQuery>, "variables">) => import("../API").DesiredOutcomeCountsQuery) => void;
        refetch: (variables?: Partial<import("../API").Exact<{
            desiredOutcomeID: string;
        }>>) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").DesiredOutcomeCountsQuery>>;
        reobserve: (newOptions?: Partial<import("@apollo/client").WatchQueryOptions<import("../API").Exact<{
            desiredOutcomeID: string;
        }>, import("../API").DesiredOutcomeCountsQuery>>, newNetworkStatus?: import("@apollo/client").NetworkStatus) => Promise<import("@apollo/client").ApolloQueryResult<import("../API").DesiredOutcomeCountsQuery>>;
        variables: import("../API").Exact<{
            desiredOutcomeID: string;
        }>;
        fetchMore: <TFetchData = import("../API").DesiredOutcomeCountsQuery, TFetchVars extends import("@apollo/client").OperationVariables = import("../API").Exact<{
            desiredOutcomeID: string;
        }>>(fetchMoreOptions: import("@apollo/client").FetchMoreQueryOptions<TFetchVars, TFetchData> & {
            updateQuery?: (previousQueryResult: import("../API").DesiredOutcomeCountsQuery, options: {
                fetchMoreResult: TFetchData;
                variables: TFetchVars;
            }) => import("../API").DesiredOutcomeCountsQuery;
        }) => Promise<import("@apollo/client").ApolloQueryResult<TFetchData>>;
    };
}
