@burdenoff/microfe-tours 2026.510.112

package/dist/generated/global-operations.d.ts

@@ -0,0 +1,1270 @@
+import * as Types from './global-types';
+import * as Apollo from '@apollo/client';
+import * as ApolloReactHooks from '@apollo/client/react';
+export type DeleteTourMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type DeleteTourMutation = {
+    __typename?: 'Mutation';
+    deleteTour: boolean;
+};
+export type SyncTourStepsMutationVariables = Types.Exact<{
+    tourId: Types.Scalars['ID']['input'];
+    steps: Array<Types.SyncTourStepInput> | Types.SyncTourStepInput;
+}>;
+export type SyncTourStepsMutation = {
+    __typename?: 'Mutation';
+    syncTourSteps: Array<{
+        __typename?: 'TourStep';
+        id: string;
+        tourId: string;
+        title: string;
+        content: string;
+        stepOrder: number;
+        targetSelector?: string | null;
+        placement: Types.TourStepPlacement;
+        targetSelectorMobile?: string | null;
+        targetSelectorTablet?: string | null;
+        targetSelectorDesktop?: string | null;
+        customData?: Record<string, unknown> | null;
+        actions?: Record<string, unknown> | null;
+        requireInteraction: boolean;
+        waitForSelector?: string | null;
+        waitForEvent?: string | null;
+        waitForTimeout?: number | null;
+        skipConditions?: Record<string, unknown> | null;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+};
+export type ArchiveTourMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type ArchiveTourMutation = {
+    __typename?: 'Mutation';
+    archiveTour: {
+        __typename?: 'Tour';
+        id: string;
+        name: string;
+        slug: string;
+        status: Types.TourStatus;
+        isActive: boolean;
+        updatedAt: string;
+    };
+};
+export type AttachMediaToStepMutationVariables = Types.Exact<{
+    input: Types.AttachMediaToStepInput;
+}>;
+export type AttachMediaToStepMutation = {
+    __typename?: 'Mutation';
+    attachMediaToStep: {
+        __typename?: 'TourStepMedia';
+        id: string;
+        tourStepId: string;
+        mediaId: string;
+        position: Types.MediaPosition;
+        createdAt: string;
+        media: {
+            __typename?: 'TourMedia';
+            id: string;
+            name: string;
+            type: Types.TourMediaType;
+            cdnUrl?: string | null;
+        };
+    };
+};
+export type CreateTourMutationVariables = Types.Exact<{
+    input: Types.CreateTourInput;
+}>;
+export type CreateTourMutation = {
+    __typename?: 'Mutation';
+    createTour: {
+        __typename?: 'Tour';
+        id: string;
+        name: string;
+        slug: string;
+        productId: string;
+        status: Types.TourStatus;
+        createdAt: string;
+    };
+};
+export type CreateTourFromTemplateMutationVariables = Types.Exact<{
+    templateId: Types.Scalars['ID']['input'];
+}>;
+export type CreateTourFromTemplateMutation = {
+    __typename?: 'Mutation';
+    createTourFromTemplate: {
+        __typename?: 'Tour';
+        id: string;
+        name: string;
+        slug: string;
+        status: Types.TourStatus;
+        steps: Array<{
+            __typename?: 'TourStep';
+            id: string;
+            title: string;
+            stepOrder: number;
+            content: string;
+            targetSelector?: string | null;
+            placement: Types.TourStepPlacement;
+        }>;
+    };
+};
+export type UploadTourMediaMutationVariables = Types.Exact<{
+    input: Types.CreateTourMediaInput;
+}>;
+export type UploadTourMediaMutation = {
+    __typename?: 'Mutation';
+    uploadTourMedia: {
+        __typename?: 'TourMedia';
+        id: string;
+        name: string;
+        type: Types.TourMediaType;
+        storageUrl: string;
+        cdnUrl?: string | null;
+        storagePath: string;
+        mimeType: string;
+        size: number;
+        duration?: number | null;
+        width?: number | null;
+        height?: number | null;
+        altText?: string | null;
+        caption?: string | null;
+        transcript?: string | null;
+        uploadedBy?: string | null;
+        createdAt: string;
+    };
+};
+export type CreateTourScheduleMutationVariables = Types.Exact<{
+    input: Types.CreateTourScheduleInput;
+}>;
+export type CreateTourScheduleMutation = {
+    __typename?: 'Mutation';
+    createTourSchedule: {
+        __typename?: 'TourSchedule';
+        id: string;
+        tourId: string;
+        startDate: string;
+        endDate?: string | null;
+        recurrenceRule?: string | null;
+        timezone: string;
+        isActive: boolean;
+        nextExecutionAt?: string | null;
+        executionCount: number;
+        createdAt: string;
+    };
+};
+export type DeleteTourMediaMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type DeleteTourMediaMutation = {
+    __typename?: 'Mutation';
+    deleteTourMedia: boolean;
+};
+export type DeleteTourTemplateMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type DeleteTourTemplateMutation = {
+    __typename?: 'Mutation';
+    deleteTourTemplate: boolean;
+};
+export type DuplicateTourMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    newName?: Types.InputMaybe<Types.Scalars['String']['input']>;
+}>;
+export type DuplicateTourMutation = {
+    __typename?: 'Mutation';
+    duplicateTour: {
+        __typename?: 'Tour';
+        id: string;
+        name: string;
+        slug: string;
+        status: Types.TourStatus;
+        productId: string;
+        createdAt: string;
+    };
+};
+export type PublishTourMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type PublishTourMutation = {
+    __typename?: 'Mutation';
+    publishTour: {
+        __typename?: 'Tour';
+        id: string;
+        name: string;
+        slug: string;
+        status: Types.TourStatus;
+        isActive: boolean;
+        updatedAt: string;
+    };
+};
+export type SaveTourAsTemplateMutationVariables = Types.Exact<{
+    tourId: Types.Scalars['ID']['input'];
+    input: Types.SaveTourAsTemplateInput;
+}>;
+export type SaveTourAsTemplateMutation = {
+    __typename?: 'Mutation';
+    saveTourAsTemplate: {
+        __typename?: 'TourTemplate';
+        id: string;
+        name: string;
+        slug: string;
+        description?: string | null;
+        category?: string | null;
+        isPublic: boolean;
+        isPremium: boolean;
+        useCount: number;
+        createdAt: string;
+    };
+};
+export type UnpublishTourMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type UnpublishTourMutation = {
+    __typename?: 'Mutation';
+    unpublishTour: {
+        __typename?: 'Tour';
+        id: string;
+        name: string;
+        slug: string;
+        status: Types.TourStatus;
+        isActive: boolean;
+        updatedAt: string;
+    };
+};
+export type UpdateTourMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.UpdateTourInput;
+}>;
+export type UpdateTourMutation = {
+    __typename?: 'Mutation';
+    updateTour: {
+        __typename?: 'Tour';
+        id: string;
+        name: string;
+        slug: string;
+        status: Types.TourStatus;
+        updatedAt: string;
+    };
+};
+export type GetProductTourStatisticsQueryVariables = Types.Exact<{
+    productId: Types.Scalars['String']['input'];
+}>;
+export type GetProductTourStatisticsQuery = {
+    __typename?: 'Query';
+    productTourStatistics: {
+        __typename?: 'ProductTourStatistics';
+        productId: string;
+        totalTours: number;
+        publishedTours: number;
+        totalViews: number;
+        totalCompletions: number;
+        totalSkips: number;
+        averageCompletionRate: number;
+        tourBreakdown: Array<{
+            __typename?: 'TourStatSummary';
+            tourId: string;
+            tourName: string;
+            viewCount: number;
+            completionCount: number;
+            skipCount: number;
+            completionRate: number;
+        }>;
+    };
+};
+export type GetTourQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetTourQuery = {
+    __typename?: 'Query';
+    tour?: {
+        __typename?: 'Tour';
+        id: string;
+        name: string;
+        slug: string;
+        description?: string | null;
+        productId: string;
+        moduleId?: string | null;
+        pageId?: string | null;
+        status: Types.TourStatus;
+        isActive: boolean;
+        triggerType: Types.TourTriggerType;
+        triggerConfig?: Record<string, unknown> | null;
+        mobileConfig?: Record<string, unknown> | null;
+        tabletConfig?: Record<string, unknown> | null;
+        desktopConfig?: Record<string, unknown> | null;
+        priority: number;
+        displayOrder: number;
+        startDate?: string | null;
+        endDate?: string | null;
+        viewCount: number;
+        completionCount: number;
+        skipCount: number;
+        metadata?: Record<string, unknown> | null;
+        version: number;
+        createdBy?: string | null;
+        updatedBy?: string | null;
+        createdAt: string;
+        updatedAt: string;
+        steps: Array<{
+            __typename?: 'TourStep';
+            id: string;
+            tourId: string;
+            title: string;
+            content: string;
+            stepOrder: number;
+            targetSelector?: string | null;
+            placement: Types.TourStepPlacement;
+            targetSelectorMobile?: string | null;
+            targetSelectorTablet?: string | null;
+            targetSelectorDesktop?: string | null;
+            customData?: Record<string, unknown> | null;
+            actions?: Record<string, unknown> | null;
+            requireInteraction: boolean;
+            waitForSelector?: string | null;
+            waitForEvent?: string | null;
+            waitForTimeout?: number | null;
+            skipConditions?: Record<string, unknown> | null;
+            metadata?: Record<string, unknown> | null;
+            createdAt: string;
+            updatedAt: string;
+            media?: Array<{
+                __typename?: 'TourStepMedia';
+                id: string;
+                position: Types.MediaPosition;
+                mediaId: string;
+                media: {
+                    __typename?: 'TourMedia';
+                    id: string;
+                    name: string;
+                    type: Types.TourMediaType;
+                    cdnUrl?: string | null;
+                    mimeType: string;
+                    size: number;
+                    duration?: number | null;
+                    width?: number | null;
+                    height?: number | null;
+                    altText?: string | null;
+                    caption?: string | null;
+                    transcript?: string | null;
+                };
+            }> | null;
+        }>;
+        schedules?: Array<{
+            __typename?: 'TourSchedule';
+            id: string;
+            startDate: string;
+            endDate?: string | null;
+            recurrenceRule?: string | null;
+            timezone: string;
+            isActive: boolean;
+            nextExecutionAt?: string | null;
+        }> | null;
+    } | null;
+};
+export type GetTourAnalyticsQueryVariables = Types.Exact<{
+    tourId: Types.Scalars['ID']['input'];
+}>;
+export type GetTourAnalyticsQuery = {
+    __typename?: 'Query';
+    tourAnalytics: {
+        __typename?: 'TourAnalyticsAggregation';
+        totalViews: number;
+        totalCompletions: number;
+        totalSkips: number;
+        averageCompletionRate: number;
+        averageDuration: number;
+        byDeviceType: Array<{
+            __typename?: 'DeviceTypeStats';
+            deviceType: Types.DeviceType;
+            count: number;
+            completionRate: number;
+        }>;
+        byEventType: Array<{
+            __typename?: 'TourEventTypeStats';
+            eventType: Types.TourAnalyticsEventType;
+            count: number;
+        }>;
+    };
+    tourStepAnalytics: Array<{
+        __typename?: 'TourStepAnalytics';
+        stepId: string;
+        viewCount: number;
+        completionCount: number;
+        skipCount: number;
+        averageDuration: number;
+    }>;
+};
+export type GetTourMediaQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type GetTourMediaQuery = {
+    __typename?: 'Query';
+    tourMedia: Array<{
+        __typename?: 'TourMedia';
+        id: string;
+        name: string;
+        type: Types.TourMediaType;
+        storageUrl: string;
+        cdnUrl?: string | null;
+        storagePath: string;
+        mimeType: string;
+        size: number;
+        duration?: number | null;
+        width?: number | null;
+        height?: number | null;
+        altText?: string | null;
+        caption?: string | null;
+        transcript?: string | null;
+        isPublic: boolean;
+        metadata?: Record<string, unknown> | null;
+        uploadedBy?: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+};
+export type GetTourSchedulesQueryVariables = Types.Exact<{
+    tourId: Types.Scalars['ID']['input'];
+}>;
+export type GetTourSchedulesQuery = {
+    __typename?: 'Query';
+    tourSchedules: Array<{
+        __typename?: 'TourSchedule';
+        id: string;
+        tourId: string;
+        startDate: string;
+        endDate?: string | null;
+        recurrenceRule?: string | null;
+        timezone: string;
+        isActive: boolean;
+        lastExecutedAt?: string | null;
+        nextExecutionAt?: string | null;
+        executionCount: number;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+};
+export type GetTourTemplatesQueryVariables = Types.Exact<{
+    isPublic?: Types.InputMaybe<Types.Scalars['Boolean']['input']>;
+    category?: Types.InputMaybe<Types.Scalars['String']['input']>;
+}>;
+export type GetTourTemplatesQuery = {
+    __typename?: 'Query';
+    tourTemplates: Array<{
+        __typename?: 'TourTemplate';
+        id: string;
+        name: string;
+        slug: string;
+        description?: string | null;
+        category?: string | null;
+        tags: Array<string>;
+        thumbnail?: string | null;
+        config: Record<string, unknown>;
+        isPublic: boolean;
+        isPremium: boolean;
+        useCount: number;
+        createdBy?: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+};
+export type GetTourUserProgressQueryVariables = Types.Exact<{
+    tourId: Types.Scalars['ID']['input'];
+    userId: Types.Scalars['ID']['input'];
+}>;
+export type GetTourUserProgressQuery = {
+    __typename?: 'Query';
+    tourUserProgress?: {
+        __typename?: 'TourUserProgress';
+        id: string;
+        tourId: string;
+        userId: string;
+        status: Types.TourUserStatus;
+        currentStepId?: string | null;
+        currentStepOrder?: number | null;
+        completedSteps?: Record<string, unknown> | null;
+        skippedSteps?: Record<string, unknown> | null;
+        deviceType?: Types.DeviceType | null;
+        startedAt?: string | null;
+        completedAt?: string | null;
+        lastViewedAt?: string | null;
+    } | null;
+};
+export type GetToursQueryVariables = Types.Exact<{
+    filters?: Types.InputMaybe<Types.TourFilters>;
+    pagination?: Types.InputMaybe<Types.TourPagination>;
+}>;
+export type GetToursQuery = {
+    __typename?: 'Query';
+    tours: {
+        __typename?: 'ToursResponse';
+        total: number;
+        hasMore: boolean;
+        tours: Array<{
+            __typename?: 'Tour';
+            id: string;
+            name: string;
+            slug: string;
+            description?: string | null;
+            productId: string;
+            moduleId?: string | null;
+            pageId?: string | null;
+            status: Types.TourStatus;
+            isActive: boolean;
+            triggerType: Types.TourTriggerType;
+            priority: number;
+            displayOrder: number;
+            startDate?: string | null;
+            endDate?: string | null;
+            viewCount: number;
+            completionCount: number;
+            skipCount: number;
+            version: number;
+            createdBy?: string | null;
+            updatedBy?: string | null;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+};
+export type GetToursForContextQueryVariables = Types.Exact<{
+    context: Types.TourContextInput;
+}>;
+export type GetToursForContextQuery = {
+    __typename?: 'Query';
+    toursForContext: Array<{
+        __typename?: 'Tour';
+        id: string;
+        name: string;
+        slug: string;
+        description?: string | null;
+        productId: string;
+        moduleId?: string | null;
+        pageId?: string | null;
+        status: Types.TourStatus;
+        isActive: boolean;
+        triggerType: Types.TourTriggerType;
+        priority: number;
+        displayOrder: number;
+        startDate?: string | null;
+        endDate?: string | null;
+        myProgress?: {
+            __typename?: 'TourUserProgress';
+            id: string;
+            tourId: string;
+            status: Types.TourUserStatus;
+            currentStepId?: string | null;
+            currentStepOrder?: number | null;
+            startedAt?: string | null;
+            completedAt?: string | null;
+            lastViewedAt?: string | null;
+        } | null;
+    }>;
+};
+export type GetUserTourProgressesQueryVariables = Types.Exact<{
+    userId?: Types.InputMaybe<Types.Scalars['ID']['input']>;
+    pagination?: Types.InputMaybe<Types.TourPagination>;
+}>;
+export type GetUserTourProgressesQuery = {
+    __typename?: 'Query';
+    userTourProgresses: Array<{
+        __typename?: 'TourUserProgress';
+        id: string;
+        tourId: string;
+        userId: string;
+        status: Types.TourUserStatus;
+        currentStepId?: string | null;
+        currentStepOrder?: number | null;
+        completedSteps?: Record<string, unknown> | null;
+        skippedSteps?: Record<string, unknown> | null;
+        deviceType?: Types.DeviceType | null;
+        startedAt?: string | null;
+        completedAt?: string | null;
+        lastViewedAt?: string | null;
+        createdAt: string;
+        updatedAt: string;
+        tour: {
+            __typename?: 'Tour';
+            id: string;
+            name: string;
+            slug: string;
+            description?: string | null;
+            productId: string;
+            moduleId?: string | null;
+            pageId?: string | null;
+            status: Types.TourStatus;
+        };
+    }>;
+};
+export type GetWorkspaceAnalyticsSummaryQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type GetWorkspaceAnalyticsSummaryQuery = {
+    __typename?: 'Query';
+    workspaceAnalyticsSummary: {
+        __typename?: 'WorkspaceTourAnalyticsSummary';
+        totalTours: number;
+        publishedTours: number;
+        totalViews: number;
+        totalCompletions: number;
+        overallCompletionRate: number;
+    };
+};
+export declare const DeleteTourDocument: Apollo.DocumentNode;
+export type DeleteTourMutationFn = Apollo.MutationFunction<Types.DeleteTourMutation, Types.DeleteTourMutationVariables>;
+/**
+ * __useDeleteTourMutation__
+ *
+ * To run a mutation, you first call `useDeleteTourMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteTourMutation` 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 [deleteTourMutation, { data, loading, error }] = useDeleteTourMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useDeleteTourMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteTourMutation, Types.DeleteTourMutationVariables>): Apollo.MutationTuple<Types.DeleteTourMutation, Types.DeleteTourMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type DeleteTourMutationHookResult = ReturnType<typeof useDeleteTourMutation>;
+export type DeleteTourMutationResult = Apollo.MutationResult<Types.DeleteTourMutation>;
+export type DeleteTourMutationOptions = Apollo.BaseMutationOptions<Types.DeleteTourMutation, Types.DeleteTourMutationVariables>;
+export declare const SyncTourStepsDocument: Apollo.DocumentNode;
+export type SyncTourStepsMutationFn = Apollo.MutationFunction<Types.SyncTourStepsMutation, Types.SyncTourStepsMutationVariables>;
+/**
+ * __useSyncTourStepsMutation__
+ *
+ * To run a mutation, you first call `useSyncTourStepsMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSyncTourStepsMutation` 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 [syncTourStepsMutation, { data, loading, error }] = useSyncTourStepsMutation({
+ *   variables: {
+ *      tourId: // value for 'tourId'
+ *      steps: // value for 'steps'
+ *   },
+ * });
+ */
+export declare function useSyncTourStepsMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SyncTourStepsMutation, Types.SyncTourStepsMutationVariables>): Apollo.MutationTuple<Types.SyncTourStepsMutation, Types.SyncTourStepsMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type SyncTourStepsMutationHookResult = ReturnType<typeof useSyncTourStepsMutation>;
+export type SyncTourStepsMutationResult = Apollo.MutationResult<Types.SyncTourStepsMutation>;
+export type SyncTourStepsMutationOptions = Apollo.BaseMutationOptions<Types.SyncTourStepsMutation, Types.SyncTourStepsMutationVariables>;
+export declare const ArchiveTourDocument: Apollo.DocumentNode;
+export type ArchiveTourMutationFn = Apollo.MutationFunction<Types.ArchiveTourMutation, Types.ArchiveTourMutationVariables>;
+/**
+ * __useArchiveTourMutation__
+ *
+ * To run a mutation, you first call `useArchiveTourMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useArchiveTourMutation` 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 [archiveTourMutation, { data, loading, error }] = useArchiveTourMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useArchiveTourMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ArchiveTourMutation, Types.ArchiveTourMutationVariables>): Apollo.MutationTuple<Types.ArchiveTourMutation, Types.ArchiveTourMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type ArchiveTourMutationHookResult = ReturnType<typeof useArchiveTourMutation>;
+export type ArchiveTourMutationResult = Apollo.MutationResult<Types.ArchiveTourMutation>;
+export type ArchiveTourMutationOptions = Apollo.BaseMutationOptions<Types.ArchiveTourMutation, Types.ArchiveTourMutationVariables>;
+export declare const AttachMediaToStepDocument: Apollo.DocumentNode;
+export type AttachMediaToStepMutationFn = Apollo.MutationFunction<Types.AttachMediaToStepMutation, Types.AttachMediaToStepMutationVariables>;
+/**
+ * __useAttachMediaToStepMutation__
+ *
+ * To run a mutation, you first call `useAttachMediaToStepMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAttachMediaToStepMutation` 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 [attachMediaToStepMutation, { data, loading, error }] = useAttachMediaToStepMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useAttachMediaToStepMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AttachMediaToStepMutation, Types.AttachMediaToStepMutationVariables>): Apollo.MutationTuple<Types.AttachMediaToStepMutation, Types.AttachMediaToStepMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type AttachMediaToStepMutationHookResult = ReturnType<typeof useAttachMediaToStepMutation>;
+export type AttachMediaToStepMutationResult = Apollo.MutationResult<Types.AttachMediaToStepMutation>;
+export type AttachMediaToStepMutationOptions = Apollo.BaseMutationOptions<Types.AttachMediaToStepMutation, Types.AttachMediaToStepMutationVariables>;
+export declare const CreateTourDocument: Apollo.DocumentNode;
+export type CreateTourMutationFn = Apollo.MutationFunction<Types.CreateTourMutation, Types.CreateTourMutationVariables>;
+/**
+ * __useCreateTourMutation__
+ *
+ * To run a mutation, you first call `useCreateTourMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateTourMutation` 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 [createTourMutation, { data, loading, error }] = useCreateTourMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateTourMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateTourMutation, Types.CreateTourMutationVariables>): Apollo.MutationTuple<Types.CreateTourMutation, Types.CreateTourMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type CreateTourMutationHookResult = ReturnType<typeof useCreateTourMutation>;
+export type CreateTourMutationResult = Apollo.MutationResult<Types.CreateTourMutation>;
+export type CreateTourMutationOptions = Apollo.BaseMutationOptions<Types.CreateTourMutation, Types.CreateTourMutationVariables>;
+export declare const CreateTourFromTemplateDocument: Apollo.DocumentNode;
+export type CreateTourFromTemplateMutationFn = Apollo.MutationFunction<Types.CreateTourFromTemplateMutation, Types.CreateTourFromTemplateMutationVariables>;
+/**
+ * __useCreateTourFromTemplateMutation__
+ *
+ * To run a mutation, you first call `useCreateTourFromTemplateMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateTourFromTemplateMutation` 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 [createTourFromTemplateMutation, { data, loading, error }] = useCreateTourFromTemplateMutation({
+ *   variables: {
+ *      templateId: // value for 'templateId'
+ *   },
+ * });
+ */
+export declare function useCreateTourFromTemplateMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateTourFromTemplateMutation, Types.CreateTourFromTemplateMutationVariables>): Apollo.MutationTuple<Types.CreateTourFromTemplateMutation, Types.CreateTourFromTemplateMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type CreateTourFromTemplateMutationHookResult = ReturnType<typeof useCreateTourFromTemplateMutation>;
+export type CreateTourFromTemplateMutationResult = Apollo.MutationResult<Types.CreateTourFromTemplateMutation>;
+export type CreateTourFromTemplateMutationOptions = Apollo.BaseMutationOptions<Types.CreateTourFromTemplateMutation, Types.CreateTourFromTemplateMutationVariables>;
+export declare const UploadTourMediaDocument: Apollo.DocumentNode;
+export type UploadTourMediaMutationFn = Apollo.MutationFunction<Types.UploadTourMediaMutation, Types.UploadTourMediaMutationVariables>;
+/**
+ * __useUploadTourMediaMutation__
+ *
+ * To run a mutation, you first call `useUploadTourMediaMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUploadTourMediaMutation` 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 [uploadTourMediaMutation, { data, loading, error }] = useUploadTourMediaMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUploadTourMediaMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UploadTourMediaMutation, Types.UploadTourMediaMutationVariables>): Apollo.MutationTuple<Types.UploadTourMediaMutation, Types.UploadTourMediaMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type UploadTourMediaMutationHookResult = ReturnType<typeof useUploadTourMediaMutation>;
+export type UploadTourMediaMutationResult = Apollo.MutationResult<Types.UploadTourMediaMutation>;
+export type UploadTourMediaMutationOptions = Apollo.BaseMutationOptions<Types.UploadTourMediaMutation, Types.UploadTourMediaMutationVariables>;
+export declare const CreateTourScheduleDocument: Apollo.DocumentNode;
+export type CreateTourScheduleMutationFn = Apollo.MutationFunction<Types.CreateTourScheduleMutation, Types.CreateTourScheduleMutationVariables>;
+/**
+ * __useCreateTourScheduleMutation__
+ *
+ * To run a mutation, you first call `useCreateTourScheduleMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateTourScheduleMutation` 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 [createTourScheduleMutation, { data, loading, error }] = useCreateTourScheduleMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateTourScheduleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateTourScheduleMutation, Types.CreateTourScheduleMutationVariables>): Apollo.MutationTuple<Types.CreateTourScheduleMutation, Types.CreateTourScheduleMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type CreateTourScheduleMutationHookResult = ReturnType<typeof useCreateTourScheduleMutation>;
+export type CreateTourScheduleMutationResult = Apollo.MutationResult<Types.CreateTourScheduleMutation>;
+export type CreateTourScheduleMutationOptions = Apollo.BaseMutationOptions<Types.CreateTourScheduleMutation, Types.CreateTourScheduleMutationVariables>;
+export declare const DeleteTourMediaDocument: Apollo.DocumentNode;
+export type DeleteTourMediaMutationFn = Apollo.MutationFunction<Types.DeleteTourMediaMutation, Types.DeleteTourMediaMutationVariables>;
+/**
+ * __useDeleteTourMediaMutation__
+ *
+ * To run a mutation, you first call `useDeleteTourMediaMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteTourMediaMutation` 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 [deleteTourMediaMutation, { data, loading, error }] = useDeleteTourMediaMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useDeleteTourMediaMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteTourMediaMutation, Types.DeleteTourMediaMutationVariables>): Apollo.MutationTuple<Types.DeleteTourMediaMutation, Types.DeleteTourMediaMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type DeleteTourMediaMutationHookResult = ReturnType<typeof useDeleteTourMediaMutation>;
+export type DeleteTourMediaMutationResult = Apollo.MutationResult<Types.DeleteTourMediaMutation>;
+export type DeleteTourMediaMutationOptions = Apollo.BaseMutationOptions<Types.DeleteTourMediaMutation, Types.DeleteTourMediaMutationVariables>;
+export declare const DeleteTourTemplateDocument: Apollo.DocumentNode;
+export type DeleteTourTemplateMutationFn = Apollo.MutationFunction<Types.DeleteTourTemplateMutation, Types.DeleteTourTemplateMutationVariables>;
+/**
+ * __useDeleteTourTemplateMutation__
+ *
+ * To run a mutation, you first call `useDeleteTourTemplateMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteTourTemplateMutation` 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 [deleteTourTemplateMutation, { data, loading, error }] = useDeleteTourTemplateMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useDeleteTourTemplateMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteTourTemplateMutation, Types.DeleteTourTemplateMutationVariables>): Apollo.MutationTuple<Types.DeleteTourTemplateMutation, Types.DeleteTourTemplateMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type DeleteTourTemplateMutationHookResult = ReturnType<typeof useDeleteTourTemplateMutation>;
+export type DeleteTourTemplateMutationResult = Apollo.MutationResult<Types.DeleteTourTemplateMutation>;
+export type DeleteTourTemplateMutationOptions = Apollo.BaseMutationOptions<Types.DeleteTourTemplateMutation, Types.DeleteTourTemplateMutationVariables>;
+export declare const DuplicateTourDocument: Apollo.DocumentNode;
+export type DuplicateTourMutationFn = Apollo.MutationFunction<Types.DuplicateTourMutation, Types.DuplicateTourMutationVariables>;
+/**
+ * __useDuplicateTourMutation__
+ *
+ * To run a mutation, you first call `useDuplicateTourMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDuplicateTourMutation` 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 [duplicateTourMutation, { data, loading, error }] = useDuplicateTourMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      newName: // value for 'newName'
+ *   },
+ * });
+ */
+export declare function useDuplicateTourMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DuplicateTourMutation, Types.DuplicateTourMutationVariables>): Apollo.MutationTuple<Types.DuplicateTourMutation, Types.DuplicateTourMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type DuplicateTourMutationHookResult = ReturnType<typeof useDuplicateTourMutation>;
+export type DuplicateTourMutationResult = Apollo.MutationResult<Types.DuplicateTourMutation>;
+export type DuplicateTourMutationOptions = Apollo.BaseMutationOptions<Types.DuplicateTourMutation, Types.DuplicateTourMutationVariables>;
+export declare const PublishTourDocument: Apollo.DocumentNode;
+export type PublishTourMutationFn = Apollo.MutationFunction<Types.PublishTourMutation, Types.PublishTourMutationVariables>;
+/**
+ * __usePublishTourMutation__
+ *
+ * To run a mutation, you first call `usePublishTourMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `usePublishTourMutation` 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 [publishTourMutation, { data, loading, error }] = usePublishTourMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function usePublishTourMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.PublishTourMutation, Types.PublishTourMutationVariables>): Apollo.MutationTuple<Types.PublishTourMutation, Types.PublishTourMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type PublishTourMutationHookResult = ReturnType<typeof usePublishTourMutation>;
+export type PublishTourMutationResult = Apollo.MutationResult<Types.PublishTourMutation>;
+export type PublishTourMutationOptions = Apollo.BaseMutationOptions<Types.PublishTourMutation, Types.PublishTourMutationVariables>;
+export declare const SaveTourAsTemplateDocument: Apollo.DocumentNode;
+export type SaveTourAsTemplateMutationFn = Apollo.MutationFunction<Types.SaveTourAsTemplateMutation, Types.SaveTourAsTemplateMutationVariables>;
+/**
+ * __useSaveTourAsTemplateMutation__
+ *
+ * To run a mutation, you first call `useSaveTourAsTemplateMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSaveTourAsTemplateMutation` 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 [saveTourAsTemplateMutation, { data, loading, error }] = useSaveTourAsTemplateMutation({
+ *   variables: {
+ *      tourId: // value for 'tourId'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useSaveTourAsTemplateMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SaveTourAsTemplateMutation, Types.SaveTourAsTemplateMutationVariables>): Apollo.MutationTuple<Types.SaveTourAsTemplateMutation, Types.SaveTourAsTemplateMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type SaveTourAsTemplateMutationHookResult = ReturnType<typeof useSaveTourAsTemplateMutation>;
+export type SaveTourAsTemplateMutationResult = Apollo.MutationResult<Types.SaveTourAsTemplateMutation>;
+export type SaveTourAsTemplateMutationOptions = Apollo.BaseMutationOptions<Types.SaveTourAsTemplateMutation, Types.SaveTourAsTemplateMutationVariables>;
+export declare const UnpublishTourDocument: Apollo.DocumentNode;
+export type UnpublishTourMutationFn = Apollo.MutationFunction<Types.UnpublishTourMutation, Types.UnpublishTourMutationVariables>;
+/**
+ * __useUnpublishTourMutation__
+ *
+ * To run a mutation, you first call `useUnpublishTourMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUnpublishTourMutation` 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 [unpublishTourMutation, { data, loading, error }] = useUnpublishTourMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useUnpublishTourMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UnpublishTourMutation, Types.UnpublishTourMutationVariables>): Apollo.MutationTuple<Types.UnpublishTourMutation, Types.UnpublishTourMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type UnpublishTourMutationHookResult = ReturnType<typeof useUnpublishTourMutation>;
+export type UnpublishTourMutationResult = Apollo.MutationResult<Types.UnpublishTourMutation>;
+export type UnpublishTourMutationOptions = Apollo.BaseMutationOptions<Types.UnpublishTourMutation, Types.UnpublishTourMutationVariables>;
+export declare const UpdateTourDocument: Apollo.DocumentNode;
+export type UpdateTourMutationFn = Apollo.MutationFunction<Types.UpdateTourMutation, Types.UpdateTourMutationVariables>;
+/**
+ * __useUpdateTourMutation__
+ *
+ * To run a mutation, you first call `useUpdateTourMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateTourMutation` 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 [updateTourMutation, { data, loading, error }] = useUpdateTourMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateTourMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateTourMutation, Types.UpdateTourMutationVariables>): Apollo.MutationTuple<Types.UpdateTourMutation, Types.UpdateTourMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type UpdateTourMutationHookResult = ReturnType<typeof useUpdateTourMutation>;
+export type UpdateTourMutationResult = Apollo.MutationResult<Types.UpdateTourMutation>;
+export type UpdateTourMutationOptions = Apollo.BaseMutationOptions<Types.UpdateTourMutation, Types.UpdateTourMutationVariables>;
+export declare const GetProductTourStatisticsDocument: Apollo.DocumentNode;
+/**
+ * __useGetProductTourStatisticsQuery__
+ *
+ * To run a query within a React component, call `useGetProductTourStatisticsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetProductTourStatisticsQuery` 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 } = useGetProductTourStatisticsQuery({
+ *   variables: {
+ *      productId: // value for 'productId'
+ *   },
+ * });
+ */
+export declare function useGetProductTourStatisticsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetProductTourStatisticsQuery, Types.GetProductTourStatisticsQueryVariables> & ({
+    variables: Types.GetProductTourStatisticsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): Apollo.InteropQueryResult<Types.GetProductTourStatisticsQuery, Types.GetProductTourStatisticsQueryVariables>;
+export declare function useGetProductTourStatisticsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetProductTourStatisticsQuery, Types.GetProductTourStatisticsQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetProductTourStatisticsQuery, Types.GetProductTourStatisticsQueryVariables>;
+export declare function useGetProductTourStatisticsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProductTourStatisticsQuery, Types.GetProductTourStatisticsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProductTourStatisticsQuery, Types.GetProductTourStatisticsQueryVariables>;
+export declare function useGetProductTourStatisticsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProductTourStatisticsQuery, Types.GetProductTourStatisticsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProductTourStatisticsQuery | undefined, Types.GetProductTourStatisticsQueryVariables>;
+export type GetProductTourStatisticsQueryHookResult = ReturnType<typeof useGetProductTourStatisticsQuery>;
+export type GetProductTourStatisticsLazyQueryHookResult = ReturnType<typeof useGetProductTourStatisticsLazyQuery>;
+export type GetProductTourStatisticsSuspenseQueryHookResult = ReturnType<typeof useGetProductTourStatisticsSuspenseQuery>;
+export type GetProductTourStatisticsQueryResult = Apollo.QueryResult<Types.GetProductTourStatisticsQuery, Types.GetProductTourStatisticsQueryVariables>;
+export declare const GetTourDocument: Apollo.DocumentNode;
+/**
+ * __useGetTourQuery__
+ *
+ * To run a query within a React component, call `useGetTourQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetTourQuery` 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 } = useGetTourQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetTourQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetTourQuery, Types.GetTourQueryVariables> & ({
+    variables: Types.GetTourQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): Apollo.InteropQueryResult<Types.GetTourQuery, Types.GetTourQueryVariables>;
+export declare function useGetTourLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetTourQuery, Types.GetTourQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetTourQuery, Types.GetTourQueryVariables>;
+export declare function useGetTourSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTourQuery, Types.GetTourQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTourQuery, Types.GetTourQueryVariables>;
+export declare function useGetTourSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTourQuery, Types.GetTourQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTourQuery | undefined, Types.GetTourQueryVariables>;
+export type GetTourQueryHookResult = ReturnType<typeof useGetTourQuery>;
+export type GetTourLazyQueryHookResult = ReturnType<typeof useGetTourLazyQuery>;
+export type GetTourSuspenseQueryHookResult = ReturnType<typeof useGetTourSuspenseQuery>;
+export type GetTourQueryResult = Apollo.QueryResult<Types.GetTourQuery, Types.GetTourQueryVariables>;
+export declare const GetTourAnalyticsDocument: Apollo.DocumentNode;
+/**
+ * __useGetTourAnalyticsQuery__
+ *
+ * To run a query within a React component, call `useGetTourAnalyticsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetTourAnalyticsQuery` 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 } = useGetTourAnalyticsQuery({
+ *   variables: {
+ *      tourId: // value for 'tourId'
+ *   },
+ * });
+ */
+export declare function useGetTourAnalyticsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetTourAnalyticsQuery, Types.GetTourAnalyticsQueryVariables> & ({
+    variables: Types.GetTourAnalyticsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): Apollo.InteropQueryResult<Types.GetTourAnalyticsQuery, Types.GetTourAnalyticsQueryVariables>;
+export declare function useGetTourAnalyticsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetTourAnalyticsQuery, Types.GetTourAnalyticsQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetTourAnalyticsQuery, Types.GetTourAnalyticsQueryVariables>;
+export declare function useGetTourAnalyticsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTourAnalyticsQuery, Types.GetTourAnalyticsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTourAnalyticsQuery, Types.GetTourAnalyticsQueryVariables>;
+export declare function useGetTourAnalyticsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTourAnalyticsQuery, Types.GetTourAnalyticsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTourAnalyticsQuery | undefined, Types.GetTourAnalyticsQueryVariables>;
+export type GetTourAnalyticsQueryHookResult = ReturnType<typeof useGetTourAnalyticsQuery>;
+export type GetTourAnalyticsLazyQueryHookResult = ReturnType<typeof useGetTourAnalyticsLazyQuery>;
+export type GetTourAnalyticsSuspenseQueryHookResult = ReturnType<typeof useGetTourAnalyticsSuspenseQuery>;
+export type GetTourAnalyticsQueryResult = Apollo.QueryResult<Types.GetTourAnalyticsQuery, Types.GetTourAnalyticsQueryVariables>;
+export declare const GetTourMediaDocument: Apollo.DocumentNode;
+/**
+ * __useGetTourMediaQuery__
+ *
+ * To run a query within a React component, call `useGetTourMediaQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetTourMediaQuery` 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 } = useGetTourMediaQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useGetTourMediaQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetTourMediaQuery, Types.GetTourMediaQueryVariables>): Apollo.InteropQueryResult<Types.GetTourMediaQuery, Types.GetTourMediaQueryVariables>;
+export declare function useGetTourMediaLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetTourMediaQuery, Types.GetTourMediaQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetTourMediaQuery, Types.GetTourMediaQueryVariables>;
+export declare function useGetTourMediaSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTourMediaQuery, Types.GetTourMediaQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTourMediaQuery, Types.GetTourMediaQueryVariables>;
+export declare function useGetTourMediaSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTourMediaQuery, Types.GetTourMediaQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTourMediaQuery | undefined, Types.GetTourMediaQueryVariables>;
+export type GetTourMediaQueryHookResult = ReturnType<typeof useGetTourMediaQuery>;
+export type GetTourMediaLazyQueryHookResult = ReturnType<typeof useGetTourMediaLazyQuery>;
+export type GetTourMediaSuspenseQueryHookResult = ReturnType<typeof useGetTourMediaSuspenseQuery>;
+export type GetTourMediaQueryResult = Apollo.QueryResult<Types.GetTourMediaQuery, Types.GetTourMediaQueryVariables>;
+export declare const GetTourSchedulesDocument: Apollo.DocumentNode;
+/**
+ * __useGetTourSchedulesQuery__
+ *
+ * To run a query within a React component, call `useGetTourSchedulesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetTourSchedulesQuery` 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 } = useGetTourSchedulesQuery({
+ *   variables: {
+ *      tourId: // value for 'tourId'
+ *   },
+ * });
+ */
+export declare function useGetTourSchedulesQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetTourSchedulesQuery, Types.GetTourSchedulesQueryVariables> & ({
+    variables: Types.GetTourSchedulesQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): Apollo.InteropQueryResult<Types.GetTourSchedulesQuery, Types.GetTourSchedulesQueryVariables>;
+export declare function useGetTourSchedulesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetTourSchedulesQuery, Types.GetTourSchedulesQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetTourSchedulesQuery, Types.GetTourSchedulesQueryVariables>;
+export declare function useGetTourSchedulesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTourSchedulesQuery, Types.GetTourSchedulesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTourSchedulesQuery, Types.GetTourSchedulesQueryVariables>;
+export declare function useGetTourSchedulesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTourSchedulesQuery, Types.GetTourSchedulesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTourSchedulesQuery | undefined, Types.GetTourSchedulesQueryVariables>;
+export type GetTourSchedulesQueryHookResult = ReturnType<typeof useGetTourSchedulesQuery>;
+export type GetTourSchedulesLazyQueryHookResult = ReturnType<typeof useGetTourSchedulesLazyQuery>;
+export type GetTourSchedulesSuspenseQueryHookResult = ReturnType<typeof useGetTourSchedulesSuspenseQuery>;
+export type GetTourSchedulesQueryResult = Apollo.QueryResult<Types.GetTourSchedulesQuery, Types.GetTourSchedulesQueryVariables>;
+export declare const GetTourTemplatesDocument: Apollo.DocumentNode;
+/**
+ * __useGetTourTemplatesQuery__
+ *
+ * To run a query within a React component, call `useGetTourTemplatesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetTourTemplatesQuery` 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 } = useGetTourTemplatesQuery({
+ *   variables: {
+ *      isPublic: // value for 'isPublic'
+ *      category: // value for 'category'
+ *   },
+ * });
+ */
+export declare function useGetTourTemplatesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetTourTemplatesQuery, Types.GetTourTemplatesQueryVariables>): Apollo.InteropQueryResult<Types.GetTourTemplatesQuery, Types.GetTourTemplatesQueryVariables>;
+export declare function useGetTourTemplatesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetTourTemplatesQuery, Types.GetTourTemplatesQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetTourTemplatesQuery, Types.GetTourTemplatesQueryVariables>;
+export declare function useGetTourTemplatesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTourTemplatesQuery, Types.GetTourTemplatesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTourTemplatesQuery, Types.GetTourTemplatesQueryVariables>;
+export declare function useGetTourTemplatesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTourTemplatesQuery, Types.GetTourTemplatesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTourTemplatesQuery | undefined, Types.GetTourTemplatesQueryVariables>;
+export type GetTourTemplatesQueryHookResult = ReturnType<typeof useGetTourTemplatesQuery>;
+export type GetTourTemplatesLazyQueryHookResult = ReturnType<typeof useGetTourTemplatesLazyQuery>;
+export type GetTourTemplatesSuspenseQueryHookResult = ReturnType<typeof useGetTourTemplatesSuspenseQuery>;
+export type GetTourTemplatesQueryResult = Apollo.QueryResult<Types.GetTourTemplatesQuery, Types.GetTourTemplatesQueryVariables>;
+export declare const GetTourUserProgressDocument: Apollo.DocumentNode;
+/**
+ * __useGetTourUserProgressQuery__
+ *
+ * To run a query within a React component, call `useGetTourUserProgressQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetTourUserProgressQuery` 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 } = useGetTourUserProgressQuery({
+ *   variables: {
+ *      tourId: // value for 'tourId'
+ *      userId: // value for 'userId'
+ *   },
+ * });
+ */
+export declare function useGetTourUserProgressQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetTourUserProgressQuery, Types.GetTourUserProgressQueryVariables> & ({
+    variables: Types.GetTourUserProgressQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): Apollo.InteropQueryResult<Types.GetTourUserProgressQuery, Types.GetTourUserProgressQueryVariables>;
+export declare function useGetTourUserProgressLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetTourUserProgressQuery, Types.GetTourUserProgressQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetTourUserProgressQuery, Types.GetTourUserProgressQueryVariables>;
+export declare function useGetTourUserProgressSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTourUserProgressQuery, Types.GetTourUserProgressQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTourUserProgressQuery, Types.GetTourUserProgressQueryVariables>;
+export declare function useGetTourUserProgressSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTourUserProgressQuery, Types.GetTourUserProgressQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTourUserProgressQuery | undefined, Types.GetTourUserProgressQueryVariables>;
+export type GetTourUserProgressQueryHookResult = ReturnType<typeof useGetTourUserProgressQuery>;
+export type GetTourUserProgressLazyQueryHookResult = ReturnType<typeof useGetTourUserProgressLazyQuery>;
+export type GetTourUserProgressSuspenseQueryHookResult = ReturnType<typeof useGetTourUserProgressSuspenseQuery>;
+export type GetTourUserProgressQueryResult = Apollo.QueryResult<Types.GetTourUserProgressQuery, Types.GetTourUserProgressQueryVariables>;
+export declare const GetToursDocument: Apollo.DocumentNode;
+/**
+ * __useGetToursQuery__
+ *
+ * To run a query within a React component, call `useGetToursQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetToursQuery` 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 } = useGetToursQuery({
+ *   variables: {
+ *      filters: // value for 'filters'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useGetToursQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetToursQuery, Types.GetToursQueryVariables>): Apollo.InteropQueryResult<Types.GetToursQuery, Types.GetToursQueryVariables>;
+export declare function useGetToursLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetToursQuery, Types.GetToursQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetToursQuery, Types.GetToursQueryVariables>;
+export declare function useGetToursSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetToursQuery, Types.GetToursQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetToursQuery, Types.GetToursQueryVariables>;
+export declare function useGetToursSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetToursQuery, Types.GetToursQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetToursQuery | undefined, Types.GetToursQueryVariables>;
+export type GetToursQueryHookResult = ReturnType<typeof useGetToursQuery>;
+export type GetToursLazyQueryHookResult = ReturnType<typeof useGetToursLazyQuery>;
+export type GetToursSuspenseQueryHookResult = ReturnType<typeof useGetToursSuspenseQuery>;
+export type GetToursQueryResult = Apollo.QueryResult<Types.GetToursQuery, Types.GetToursQueryVariables>;
+export declare const GetToursForContextDocument: Apollo.DocumentNode;
+/**
+ * __useGetToursForContextQuery__
+ *
+ * To run a query within a React component, call `useGetToursForContextQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetToursForContextQuery` 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 } = useGetToursForContextQuery({
+ *   variables: {
+ *      context: // value for 'context'
+ *   },
+ * });
+ */
+export declare function useGetToursForContextQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetToursForContextQuery, Types.GetToursForContextQueryVariables> & ({
+    variables: Types.GetToursForContextQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): Apollo.InteropQueryResult<Types.GetToursForContextQuery, Types.GetToursForContextQueryVariables>;
+export declare function useGetToursForContextLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetToursForContextQuery, Types.GetToursForContextQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetToursForContextQuery, Types.GetToursForContextQueryVariables>;
+export declare function useGetToursForContextSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetToursForContextQuery, Types.GetToursForContextQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetToursForContextQuery, Types.GetToursForContextQueryVariables>;
+export declare function useGetToursForContextSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetToursForContextQuery, Types.GetToursForContextQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetToursForContextQuery | undefined, Types.GetToursForContextQueryVariables>;
+export type GetToursForContextQueryHookResult = ReturnType<typeof useGetToursForContextQuery>;
+export type GetToursForContextLazyQueryHookResult = ReturnType<typeof useGetToursForContextLazyQuery>;
+export type GetToursForContextSuspenseQueryHookResult = ReturnType<typeof useGetToursForContextSuspenseQuery>;
+export type GetToursForContextQueryResult = Apollo.QueryResult<Types.GetToursForContextQuery, Types.GetToursForContextQueryVariables>;
+export declare const GetUserTourProgressesDocument: Apollo.DocumentNode;
+/**
+ * __useGetUserTourProgressesQuery__
+ *
+ * To run a query within a React component, call `useGetUserTourProgressesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetUserTourProgressesQuery` 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 } = useGetUserTourProgressesQuery({
+ *   variables: {
+ *      userId: // value for 'userId'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useGetUserTourProgressesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetUserTourProgressesQuery, Types.GetUserTourProgressesQueryVariables>): Apollo.InteropQueryResult<Types.GetUserTourProgressesQuery, Types.GetUserTourProgressesQueryVariables>;
+export declare function useGetUserTourProgressesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetUserTourProgressesQuery, Types.GetUserTourProgressesQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetUserTourProgressesQuery, Types.GetUserTourProgressesQueryVariables>;
+export declare function useGetUserTourProgressesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetUserTourProgressesQuery, Types.GetUserTourProgressesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetUserTourProgressesQuery, Types.GetUserTourProgressesQueryVariables>;
+export declare function useGetUserTourProgressesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetUserTourProgressesQuery, Types.GetUserTourProgressesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetUserTourProgressesQuery | undefined, Types.GetUserTourProgressesQueryVariables>;
+export type GetUserTourProgressesQueryHookResult = ReturnType<typeof useGetUserTourProgressesQuery>;
+export type GetUserTourProgressesLazyQueryHookResult = ReturnType<typeof useGetUserTourProgressesLazyQuery>;
+export type GetUserTourProgressesSuspenseQueryHookResult = ReturnType<typeof useGetUserTourProgressesSuspenseQuery>;
+export type GetUserTourProgressesQueryResult = Apollo.QueryResult<Types.GetUserTourProgressesQuery, Types.GetUserTourProgressesQueryVariables>;
+export declare const GetWorkspaceAnalyticsSummaryDocument: Apollo.DocumentNode;
+/**
+ * __useGetWorkspaceAnalyticsSummaryQuery__
+ *
+ * To run a query within a React component, call `useGetWorkspaceAnalyticsSummaryQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkspaceAnalyticsSummaryQuery` 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 } = useGetWorkspaceAnalyticsSummaryQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useGetWorkspaceAnalyticsSummaryQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetWorkspaceAnalyticsSummaryQuery, Types.GetWorkspaceAnalyticsSummaryQueryVariables>): Apollo.InteropQueryResult<Types.GetWorkspaceAnalyticsSummaryQuery, Types.GetWorkspaceAnalyticsSummaryQueryVariables>;
+export declare function useGetWorkspaceAnalyticsSummaryLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetWorkspaceAnalyticsSummaryQuery, Types.GetWorkspaceAnalyticsSummaryQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetWorkspaceAnalyticsSummaryQuery, Types.GetWorkspaceAnalyticsSummaryQueryVariables>;
+export declare function useGetWorkspaceAnalyticsSummarySuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkspaceAnalyticsSummaryQuery, Types.GetWorkspaceAnalyticsSummaryQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkspaceAnalyticsSummaryQuery, Types.GetWorkspaceAnalyticsSummaryQueryVariables>;
+export declare function useGetWorkspaceAnalyticsSummarySuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkspaceAnalyticsSummaryQuery, Types.GetWorkspaceAnalyticsSummaryQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkspaceAnalyticsSummaryQuery | undefined, Types.GetWorkspaceAnalyticsSummaryQueryVariables>;
+export type GetWorkspaceAnalyticsSummaryQueryHookResult = ReturnType<typeof useGetWorkspaceAnalyticsSummaryQuery>;
+export type GetWorkspaceAnalyticsSummaryLazyQueryHookResult = ReturnType<typeof useGetWorkspaceAnalyticsSummaryLazyQuery>;
+export type GetWorkspaceAnalyticsSummarySuspenseQueryHookResult = ReturnType<typeof useGetWorkspaceAnalyticsSummarySuspenseQuery>;
+export type GetWorkspaceAnalyticsSummaryQueryResult = Apollo.QueryResult<Types.GetWorkspaceAnalyticsSummaryQuery, Types.GetWorkspaceAnalyticsSummaryQueryVariables>;
+//# sourceMappingURL=global-operations.d.ts.map