@burdenoff/microfe-export 2026.510.111

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

@@ -0,0 +1,773 @@
+import * as Types from './wspace-types';
+import * as Apollo from '@apollo/client';
+import * as ApolloReactHooks from '@apollo/client/react';
+export type CancelExportJobMutationVariables = Types.Exact<{
+    context?: Types.InputMaybe<Types.ContextInput>;
+    id: Types.Scalars['ID']['input'];
+}>;
+export type CancelExportJobMutation = {
+    __typename?: 'Mutation';
+    cancelExportJob: {
+        __typename?: 'ExportJob';
+        id: string;
+        status: Types.ExportJobStatus;
+        updatedAt: string;
+    };
+};
+export type CreateExportJobMutationVariables = Types.Exact<{
+    context?: Types.InputMaybe<Types.ContextInput>;
+    input: Types.CreateExportJobInput;
+}>;
+export type CreateExportJobMutation = {
+    __typename?: 'Mutation';
+    createExportJob: {
+        __typename?: 'ExportJob';
+        id: string;
+        name: string;
+        description?: string | null;
+        status: Types.ExportJobStatus;
+        format: Types.ExportFormat;
+        archiveFormat: Types.ExportArchiveFormat;
+        entityTypes: Array<string>;
+        entityFilters?: Record<string, unknown> | null;
+        includeMedia: boolean;
+        includeMetadata: boolean;
+        dateRangeStart?: string | null;
+        dateRangeEnd?: string | null;
+        processedEntities: number;
+        totalEntities: number;
+        totalSizeBytes: string;
+        progress: number;
+        templateId?: string | null;
+        workspaceId: string;
+        tenantId?: string | null;
+        createdBy: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type CreateExportTemplateMutationVariables = Types.Exact<{
+    context?: Types.InputMaybe<Types.ContextInput>;
+    input: Types.CreateExportTemplateInput;
+}>;
+export type CreateExportTemplateMutation = {
+    __typename?: 'Mutation';
+    createExportTemplate: {
+        __typename?: 'ExportTemplate';
+        id: string;
+        name: string;
+        description?: string | null;
+        entityTypes: Array<string>;
+        format: Types.ExportFormat;
+        entityFilters?: Record<string, unknown> | null;
+        includeMedia: boolean;
+        includeMetadata: boolean;
+        isDefault: boolean;
+        workspaceId: string;
+        tenantId?: string | null;
+        createdBy: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type DeleteExportJobMutationVariables = Types.Exact<{
+    context?: Types.InputMaybe<Types.ContextInput>;
+    id: Types.Scalars['ID']['input'];
+}>;
+export type DeleteExportJobMutation = {
+    __typename?: 'Mutation';
+    deleteExportJob: boolean;
+};
+export type DeleteExportTemplateMutationVariables = Types.Exact<{
+    context?: Types.InputMaybe<Types.ContextInput>;
+    id: Types.Scalars['ID']['input'];
+}>;
+export type DeleteExportTemplateMutation = {
+    __typename?: 'Mutation';
+    deleteExportTemplate: boolean;
+};
+export type RetryExportJobMutationVariables = Types.Exact<{
+    context?: Types.InputMaybe<Types.ContextInput>;
+    id: Types.Scalars['ID']['input'];
+}>;
+export type RetryExportJobMutation = {
+    __typename?: 'Mutation';
+    retryExportJob: {
+        __typename?: 'ExportJob';
+        id: string;
+        name: string;
+        description?: string | null;
+        status: Types.ExportJobStatus;
+        archiveFormat: Types.ExportArchiveFormat;
+        progress: number;
+        entityTypes: Array<string>;
+        format: Types.ExportFormat;
+        processedEntities: number;
+        totalEntities: number;
+        totalSizeBytes: string;
+        templateId?: string | null;
+        workspaceId: string;
+        createdBy: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type UpdateExportTemplateMutationVariables = Types.Exact<{
+    context?: Types.InputMaybe<Types.ContextInput>;
+    id: Types.Scalars['ID']['input'];
+    input: Types.UpdateExportTemplateInput;
+}>;
+export type UpdateExportTemplateMutation = {
+    __typename?: 'Mutation';
+    updateExportTemplate: {
+        __typename?: 'ExportTemplate';
+        id: string;
+        name: string;
+        description?: string | null;
+        entityTypes: Array<string>;
+        format: Types.ExportFormat;
+        isDefault: boolean;
+        workspaceId: string;
+        createdBy: string;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type GetAvailableExportEntitiesQueryVariables = Types.Exact<{
+    context: Types.ContextInput;
+    pagination?: Types.InputMaybe<Types.ExportPaginationInput>;
+}>;
+export type GetAvailableExportEntitiesQuery = {
+    __typename?: 'Query';
+    getAvailableExportEntities: {
+        __typename?: 'ExportAvailableEntityConnection';
+        totalCount: number;
+        edges: Array<{
+            __typename?: 'ExportAvailableEntityEdge';
+            cursor: string;
+            node: {
+                __typename?: 'ExportAvailableEntity';
+                entityType: string;
+                displayName: string;
+                description?: string | null;
+                enabled: boolean;
+                estimatedSize?: string | null;
+                supportsDateRange: boolean;
+                supportsMediaExport: boolean;
+            };
+        }>;
+        pageInfo: {
+            __typename?: 'PageInfo';
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            startCursor?: string | null;
+            endCursor?: string | null;
+        };
+    };
+};
+export type GetExportJobQueryVariables = Types.Exact<{
+    context?: Types.InputMaybe<Types.ContextInput>;
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetExportJobQuery = {
+    __typename?: 'Query';
+    getExportJob?: {
+        __typename?: 'ExportJob';
+        id: string;
+        name: string;
+        description?: string | null;
+        status: Types.ExportJobStatus;
+        format: Types.ExportFormat;
+        archiveFormat: Types.ExportArchiveFormat;
+        entityTypes: Array<string>;
+        entityFilters?: Record<string, unknown> | null;
+        includeMedia: boolean;
+        includeMetadata: boolean;
+        dateRangeStart?: string | null;
+        dateRangeEnd?: string | null;
+        processedEntities: number;
+        totalEntities: number;
+        totalSizeBytes: string;
+        progress: number;
+        errorMessage?: string | null;
+        errorCode?: string | null;
+        startedAt?: string | null;
+        completedAt?: string | null;
+        expiresAt?: string | null;
+        templateId?: string | null;
+        temporalWorkflowId?: string | null;
+        workspaceId: string;
+        tenantId?: string | null;
+        createdBy: string;
+        createdAt: string;
+        updatedAt: string;
+        updatedBy?: string | null;
+        parts: Array<{
+            __typename?: 'ExportPart';
+            id: string;
+            partNumber: number;
+            fileName: string;
+            sizeBytes: string;
+            entityTypes: Array<string>;
+            downloadUrl?: string | null;
+            downloadExpiresAt?: string | null;
+            checksum?: string | null;
+        }>;
+        template?: {
+            __typename?: 'ExportTemplate';
+            id: string;
+            name: string;
+            description?: string | null;
+        } | null;
+    } | null;
+};
+export type GetExportPartQueryVariables = Types.Exact<{
+    context?: Types.InputMaybe<Types.ContextInput>;
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetExportPartQuery = {
+    __typename?: 'Query';
+    getExportPart?: {
+        __typename?: 'ExportPart';
+        id: string;
+        jobId: string;
+        partNumber: number;
+        fileName: string;
+        sizeBytes: string;
+        entityTypes: Array<string>;
+        downloadUrl?: string | null;
+        downloadExpiresAt?: string | null;
+        checksum?: string | null;
+        createdAt: string;
+    } | null;
+};
+export type GetExportTemplateQueryVariables = Types.Exact<{
+    context?: Types.InputMaybe<Types.ContextInput>;
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetExportTemplateQuery = {
+    __typename?: 'Query';
+    getExportTemplate?: {
+        __typename?: 'ExportTemplate';
+        id: string;
+        name: string;
+        description?: string | null;
+        entityTypes: Array<string>;
+        format: Types.ExportFormat;
+        entityFilters?: Record<string, unknown> | null;
+        includeMedia: boolean;
+        includeMetadata: boolean;
+        isDefault: boolean;
+        workspaceId: string;
+        tenantId?: string | null;
+        createdBy: string;
+        createdAt: string;
+        updatedAt: string;
+        updatedBy?: string | null;
+    } | null;
+};
+export type ListExportTemplatesQueryVariables = Types.Exact<{
+    context: Types.ContextInput;
+    pagination?: Types.InputMaybe<Types.ExportPaginationInput>;
+}>;
+export type ListExportTemplatesQuery = {
+    __typename?: 'Query';
+    listExportTemplates: {
+        __typename?: 'ExportTemplateConnection';
+        totalCount: number;
+        edges: Array<{
+            __typename?: 'ExportTemplateEdge';
+            cursor: string;
+            node: {
+                __typename?: 'ExportTemplate';
+                id: string;
+                name: string;
+                description?: string | null;
+                entityTypes: Array<string>;
+                format: Types.ExportFormat;
+                isDefault: boolean;
+                workspaceId: string;
+                tenantId?: string | null;
+                createdBy: string;
+                createdAt: string;
+                updatedAt: string;
+                updatedBy?: string | null;
+            };
+        }>;
+        pageInfo: {
+            __typename?: 'PageInfo';
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            startCursor?: string | null;
+            endCursor?: string | null;
+        };
+    };
+};
+export type ListExportJobsQueryVariables = Types.Exact<{
+    filter?: Types.InputMaybe<Types.ExportJobFilterInput>;
+    pagination?: Types.InputMaybe<Types.ExportPaginationInput>;
+    context: Types.ContextInput;
+}>;
+export type ListExportJobsQuery = {
+    __typename?: 'Query';
+    listExportJobs: {
+        __typename?: 'ExportJobConnection';
+        totalCount: number;
+        edges: Array<{
+            __typename?: 'ExportJobEdge';
+            cursor: string;
+            node: {
+                __typename?: 'ExportJob';
+                id: string;
+                name: string;
+                description?: string | null;
+                status: Types.ExportJobStatus;
+                format: Types.ExportFormat;
+                archiveFormat: Types.ExportArchiveFormat;
+                entityTypes: Array<string>;
+                progress: number;
+                totalEntities: number;
+                processedEntities: number;
+                totalSizeBytes: string;
+                errorMessage?: string | null;
+                startedAt?: string | null;
+                completedAt?: string | null;
+                expiresAt?: string | null;
+                templateId?: string | null;
+                workspaceId: string;
+                createdBy: string;
+                createdAt: string;
+                updatedAt: string;
+            };
+        }>;
+        pageInfo: {
+            __typename?: 'PageInfo';
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            startCursor?: string | null;
+            endCursor?: string | null;
+        };
+    };
+};
+export type ExportJobProgressSubscriptionVariables = Types.Exact<{
+    jobId: Types.Scalars['ID']['input'];
+}>;
+export type ExportJobProgressSubscription = {
+    __typename?: 'Subscription';
+    exportJobProgress: {
+        __typename?: 'ExportJob';
+        id: string;
+        name: string;
+        description?: string | null;
+        status: Types.ExportJobStatus;
+        format: Types.ExportFormat;
+        archiveFormat: Types.ExportArchiveFormat;
+        entityTypes: Array<string>;
+        progress: number;
+        processedEntities: number;
+        totalEntities: number;
+        totalSizeBytes: string;
+        errorMessage?: string | null;
+        startedAt?: string | null;
+        completedAt?: string | null;
+        expiresAt?: string | null;
+        templateId?: string | null;
+        workspaceId: string;
+        createdBy: string;
+        createdAt: string;
+        updatedAt: string;
+        parts: Array<{
+            __typename?: 'ExportPart';
+            id: string;
+            partNumber: number;
+            fileName: string;
+            sizeBytes: string;
+            entityTypes: Array<string>;
+            downloadUrl?: string | null;
+            downloadExpiresAt?: string | null;
+            checksum?: string | null;
+        }>;
+    };
+};
+export declare const CancelExportJobDocument: Apollo.DocumentNode;
+export type CancelExportJobMutationFn = Apollo.MutationFunction<Types.CancelExportJobMutation, Types.CancelExportJobMutationVariables>;
+/**
+ * __useCancelExportJobMutation__
+ *
+ * To run a mutation, you first call `useCancelExportJobMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCancelExportJobMutation` 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 [cancelExportJobMutation, { data, loading, error }] = useCancelExportJobMutation({
+ *   variables: {
+ *      context: // value for 'context'
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useCancelExportJobMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CancelExportJobMutation, Types.CancelExportJobMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CancelExportJobMutation, any, Apollo.ApolloCache>;
+export type CancelExportJobMutationHookResult = ReturnType<typeof useCancelExportJobMutation>;
+export type CancelExportJobMutationResult = Apollo.MutationResult<Types.CancelExportJobMutation>;
+export type CancelExportJobMutationOptions = Apollo.BaseMutationOptions<Types.CancelExportJobMutation, Types.CancelExportJobMutationVariables>;
+export declare const CreateExportJobDocument: Apollo.DocumentNode;
+export type CreateExportJobMutationFn = Apollo.MutationFunction<Types.CreateExportJobMutation, Types.CreateExportJobMutationVariables>;
+/**
+ * __useCreateExportJobMutation__
+ *
+ * To run a mutation, you first call `useCreateExportJobMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateExportJobMutation` 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 [createExportJobMutation, { data, loading, error }] = useCreateExportJobMutation({
+ *   variables: {
+ *      context: // value for 'context'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateExportJobMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateExportJobMutation, Types.CreateExportJobMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateExportJobMutation, any, Apollo.ApolloCache>;
+export type CreateExportJobMutationHookResult = ReturnType<typeof useCreateExportJobMutation>;
+export type CreateExportJobMutationResult = Apollo.MutationResult<Types.CreateExportJobMutation>;
+export type CreateExportJobMutationOptions = Apollo.BaseMutationOptions<Types.CreateExportJobMutation, Types.CreateExportJobMutationVariables>;
+export declare const CreateExportTemplateDocument: Apollo.DocumentNode;
+export type CreateExportTemplateMutationFn = Apollo.MutationFunction<Types.CreateExportTemplateMutation, Types.CreateExportTemplateMutationVariables>;
+/**
+ * __useCreateExportTemplateMutation__
+ *
+ * To run a mutation, you first call `useCreateExportTemplateMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateExportTemplateMutation` 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 [createExportTemplateMutation, { data, loading, error }] = useCreateExportTemplateMutation({
+ *   variables: {
+ *      context: // value for 'context'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateExportTemplateMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateExportTemplateMutation, Types.CreateExportTemplateMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateExportTemplateMutation, any, Apollo.ApolloCache>;
+export type CreateExportTemplateMutationHookResult = ReturnType<typeof useCreateExportTemplateMutation>;
+export type CreateExportTemplateMutationResult = Apollo.MutationResult<Types.CreateExportTemplateMutation>;
+export type CreateExportTemplateMutationOptions = Apollo.BaseMutationOptions<Types.CreateExportTemplateMutation, Types.CreateExportTemplateMutationVariables>;
+export declare const DeleteExportJobDocument: Apollo.DocumentNode;
+export type DeleteExportJobMutationFn = Apollo.MutationFunction<Types.DeleteExportJobMutation, Types.DeleteExportJobMutationVariables>;
+/**
+ * __useDeleteExportJobMutation__
+ *
+ * To run a mutation, you first call `useDeleteExportJobMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteExportJobMutation` 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 [deleteExportJobMutation, { data, loading, error }] = useDeleteExportJobMutation({
+ *   variables: {
+ *      context: // value for 'context'
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useDeleteExportJobMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteExportJobMutation, Types.DeleteExportJobMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteExportJobMutation, any, Apollo.ApolloCache>;
+export type DeleteExportJobMutationHookResult = ReturnType<typeof useDeleteExportJobMutation>;
+export type DeleteExportJobMutationResult = Apollo.MutationResult<Types.DeleteExportJobMutation>;
+export type DeleteExportJobMutationOptions = Apollo.BaseMutationOptions<Types.DeleteExportJobMutation, Types.DeleteExportJobMutationVariables>;
+export declare const DeleteExportTemplateDocument: Apollo.DocumentNode;
+export type DeleteExportTemplateMutationFn = Apollo.MutationFunction<Types.DeleteExportTemplateMutation, Types.DeleteExportTemplateMutationVariables>;
+/**
+ * __useDeleteExportTemplateMutation__
+ *
+ * To run a mutation, you first call `useDeleteExportTemplateMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteExportTemplateMutation` 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 [deleteExportTemplateMutation, { data, loading, error }] = useDeleteExportTemplateMutation({
+ *   variables: {
+ *      context: // value for 'context'
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useDeleteExportTemplateMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteExportTemplateMutation, Types.DeleteExportTemplateMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteExportTemplateMutation, any, Apollo.ApolloCache>;
+export type DeleteExportTemplateMutationHookResult = ReturnType<typeof useDeleteExportTemplateMutation>;
+export type DeleteExportTemplateMutationResult = Apollo.MutationResult<Types.DeleteExportTemplateMutation>;
+export type DeleteExportTemplateMutationOptions = Apollo.BaseMutationOptions<Types.DeleteExportTemplateMutation, Types.DeleteExportTemplateMutationVariables>;
+export declare const RetryExportJobDocument: Apollo.DocumentNode;
+export type RetryExportJobMutationFn = Apollo.MutationFunction<Types.RetryExportJobMutation, Types.RetryExportJobMutationVariables>;
+/**
+ * __useRetryExportJobMutation__
+ *
+ * To run a mutation, you first call `useRetryExportJobMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRetryExportJobMutation` 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 [retryExportJobMutation, { data, loading, error }] = useRetryExportJobMutation({
+ *   variables: {
+ *      context: // value for 'context'
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useRetryExportJobMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RetryExportJobMutation, Types.RetryExportJobMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RetryExportJobMutation, any, Apollo.ApolloCache>;
+export type RetryExportJobMutationHookResult = ReturnType<typeof useRetryExportJobMutation>;
+export type RetryExportJobMutationResult = Apollo.MutationResult<Types.RetryExportJobMutation>;
+export type RetryExportJobMutationOptions = Apollo.BaseMutationOptions<Types.RetryExportJobMutation, Types.RetryExportJobMutationVariables>;
+export declare const UpdateExportTemplateDocument: Apollo.DocumentNode;
+export type UpdateExportTemplateMutationFn = Apollo.MutationFunction<Types.UpdateExportTemplateMutation, Types.UpdateExportTemplateMutationVariables>;
+/**
+ * __useUpdateExportTemplateMutation__
+ *
+ * To run a mutation, you first call `useUpdateExportTemplateMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateExportTemplateMutation` 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 [updateExportTemplateMutation, { data, loading, error }] = useUpdateExportTemplateMutation({
+ *   variables: {
+ *      context: // value for 'context'
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateExportTemplateMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateExportTemplateMutation, Types.UpdateExportTemplateMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateExportTemplateMutation, any, Apollo.ApolloCache>;
+export type UpdateExportTemplateMutationHookResult = ReturnType<typeof useUpdateExportTemplateMutation>;
+export type UpdateExportTemplateMutationResult = Apollo.MutationResult<Types.UpdateExportTemplateMutation>;
+export type UpdateExportTemplateMutationOptions = Apollo.BaseMutationOptions<Types.UpdateExportTemplateMutation, Types.UpdateExportTemplateMutationVariables>;
+export declare const GetAvailableExportEntitiesDocument: Apollo.DocumentNode;
+/**
+ * __useGetAvailableExportEntitiesQuery__
+ *
+ * To run a query within a React component, call `useGetAvailableExportEntitiesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetAvailableExportEntitiesQuery` 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 } = useGetAvailableExportEntitiesQuery({
+ *   variables: {
+ *      context: // value for 'context'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useGetAvailableExportEntitiesQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetAvailableExportEntitiesQuery, Types.GetAvailableExportEntitiesQueryVariables> & ({
+    variables: Types.GetAvailableExportEntitiesQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetAvailableExportEntitiesQuery, Types.GetAvailableExportEntitiesQueryVariables, "complete" | "empty" | "streaming", Types.GetAvailableExportEntitiesQueryVariables>;
+export declare function useGetAvailableExportEntitiesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetAvailableExportEntitiesQuery, Types.GetAvailableExportEntitiesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetAvailableExportEntitiesQuery, Types.GetAvailableExportEntitiesQueryVariables, "complete" | "empty" | "streaming">;
+export declare function useGetAvailableExportEntitiesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetAvailableExportEntitiesQuery, Types.GetAvailableExportEntitiesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetAvailableExportEntitiesQuery, Types.GetAvailableExportEntitiesQueryVariables>;
+export declare function useGetAvailableExportEntitiesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetAvailableExportEntitiesQuery, Types.GetAvailableExportEntitiesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetAvailableExportEntitiesQuery | undefined, Types.GetAvailableExportEntitiesQueryVariables>;
+export type GetAvailableExportEntitiesQueryHookResult = ReturnType<typeof useGetAvailableExportEntitiesQuery>;
+export type GetAvailableExportEntitiesLazyQueryHookResult = ReturnType<typeof useGetAvailableExportEntitiesLazyQuery>;
+export type GetAvailableExportEntitiesSuspenseQueryHookResult = ReturnType<typeof useGetAvailableExportEntitiesSuspenseQuery>;
+export type GetAvailableExportEntitiesQueryResult = Apollo.QueryResult<Types.GetAvailableExportEntitiesQuery, Types.GetAvailableExportEntitiesQueryVariables>;
+export declare const GetExportJobDocument: Apollo.DocumentNode;
+/**
+ * __useGetExportJobQuery__
+ *
+ * To run a query within a React component, call `useGetExportJobQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetExportJobQuery` 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 } = useGetExportJobQuery({
+ *   variables: {
+ *      context: // value for 'context'
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetExportJobQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetExportJobQuery, Types.GetExportJobQueryVariables> & ({
+    variables: Types.GetExportJobQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetExportJobQuery, Types.GetExportJobQueryVariables, "complete" | "empty" | "streaming", Types.GetExportJobQueryVariables>;
+export declare function useGetExportJobLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetExportJobQuery, Types.GetExportJobQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetExportJobQuery, Types.GetExportJobQueryVariables, "complete" | "empty" | "streaming">;
+export declare function useGetExportJobSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetExportJobQuery, Types.GetExportJobQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetExportJobQuery, Types.GetExportJobQueryVariables>;
+export declare function useGetExportJobSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetExportJobQuery, Types.GetExportJobQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetExportJobQuery | undefined, Types.GetExportJobQueryVariables>;
+export type GetExportJobQueryHookResult = ReturnType<typeof useGetExportJobQuery>;
+export type GetExportJobLazyQueryHookResult = ReturnType<typeof useGetExportJobLazyQuery>;
+export type GetExportJobSuspenseQueryHookResult = ReturnType<typeof useGetExportJobSuspenseQuery>;
+export type GetExportJobQueryResult = Apollo.QueryResult<Types.GetExportJobQuery, Types.GetExportJobQueryVariables>;
+export declare const GetExportPartDocument: Apollo.DocumentNode;
+/**
+ * __useGetExportPartQuery__
+ *
+ * To run a query within a React component, call `useGetExportPartQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetExportPartQuery` 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 } = useGetExportPartQuery({
+ *   variables: {
+ *      context: // value for 'context'
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetExportPartQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetExportPartQuery, Types.GetExportPartQueryVariables> & ({
+    variables: Types.GetExportPartQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetExportPartQuery, Types.GetExportPartQueryVariables, "complete" | "empty" | "streaming", Types.GetExportPartQueryVariables>;
+export declare function useGetExportPartLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetExportPartQuery, Types.GetExportPartQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetExportPartQuery, Types.GetExportPartQueryVariables, "complete" | "empty" | "streaming">;
+export declare function useGetExportPartSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetExportPartQuery, Types.GetExportPartQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetExportPartQuery, Types.GetExportPartQueryVariables>;
+export declare function useGetExportPartSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetExportPartQuery, Types.GetExportPartQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetExportPartQuery | undefined, Types.GetExportPartQueryVariables>;
+export type GetExportPartQueryHookResult = ReturnType<typeof useGetExportPartQuery>;
+export type GetExportPartLazyQueryHookResult = ReturnType<typeof useGetExportPartLazyQuery>;
+export type GetExportPartSuspenseQueryHookResult = ReturnType<typeof useGetExportPartSuspenseQuery>;
+export type GetExportPartQueryResult = Apollo.QueryResult<Types.GetExportPartQuery, Types.GetExportPartQueryVariables>;
+export declare const GetExportTemplateDocument: Apollo.DocumentNode;
+/**
+ * __useGetExportTemplateQuery__
+ *
+ * To run a query within a React component, call `useGetExportTemplateQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetExportTemplateQuery` 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 } = useGetExportTemplateQuery({
+ *   variables: {
+ *      context: // value for 'context'
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetExportTemplateQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetExportTemplateQuery, Types.GetExportTemplateQueryVariables> & ({
+    variables: Types.GetExportTemplateQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetExportTemplateQuery, Types.GetExportTemplateQueryVariables, "complete" | "empty" | "streaming", Types.GetExportTemplateQueryVariables>;
+export declare function useGetExportTemplateLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetExportTemplateQuery, Types.GetExportTemplateQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetExportTemplateQuery, Types.GetExportTemplateQueryVariables, "complete" | "empty" | "streaming">;
+export declare function useGetExportTemplateSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetExportTemplateQuery, Types.GetExportTemplateQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetExportTemplateQuery, Types.GetExportTemplateQueryVariables>;
+export declare function useGetExportTemplateSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetExportTemplateQuery, Types.GetExportTemplateQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetExportTemplateQuery | undefined, Types.GetExportTemplateQueryVariables>;
+export type GetExportTemplateQueryHookResult = ReturnType<typeof useGetExportTemplateQuery>;
+export type GetExportTemplateLazyQueryHookResult = ReturnType<typeof useGetExportTemplateLazyQuery>;
+export type GetExportTemplateSuspenseQueryHookResult = ReturnType<typeof useGetExportTemplateSuspenseQuery>;
+export type GetExportTemplateQueryResult = Apollo.QueryResult<Types.GetExportTemplateQuery, Types.GetExportTemplateQueryVariables>;
+export declare const ListExportTemplatesDocument: Apollo.DocumentNode;
+/**
+ * __useListExportTemplatesQuery__
+ *
+ * To run a query within a React component, call `useListExportTemplatesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListExportTemplatesQuery` 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 } = useListExportTemplatesQuery({
+ *   variables: {
+ *      context: // value for 'context'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useListExportTemplatesQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListExportTemplatesQuery, Types.ListExportTemplatesQueryVariables> & ({
+    variables: Types.ListExportTemplatesQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.ListExportTemplatesQuery, Types.ListExportTemplatesQueryVariables, "complete" | "empty" | "streaming", Types.ListExportTemplatesQueryVariables>;
+export declare function useListExportTemplatesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListExportTemplatesQuery, Types.ListExportTemplatesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListExportTemplatesQuery, Types.ListExportTemplatesQueryVariables, "complete" | "empty" | "streaming">;
+export declare function useListExportTemplatesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListExportTemplatesQuery, Types.ListExportTemplatesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListExportTemplatesQuery, Types.ListExportTemplatesQueryVariables>;
+export declare function useListExportTemplatesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListExportTemplatesQuery, Types.ListExportTemplatesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListExportTemplatesQuery | undefined, Types.ListExportTemplatesQueryVariables>;
+export type ListExportTemplatesQueryHookResult = ReturnType<typeof useListExportTemplatesQuery>;
+export type ListExportTemplatesLazyQueryHookResult = ReturnType<typeof useListExportTemplatesLazyQuery>;
+export type ListExportTemplatesSuspenseQueryHookResult = ReturnType<typeof useListExportTemplatesSuspenseQuery>;
+export type ListExportTemplatesQueryResult = Apollo.QueryResult<Types.ListExportTemplatesQuery, Types.ListExportTemplatesQueryVariables>;
+export declare const ListExportJobsDocument: Apollo.DocumentNode;
+/**
+ * __useListExportJobsQuery__
+ *
+ * To run a query within a React component, call `useListExportJobsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListExportJobsQuery` 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 } = useListExportJobsQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      pagination: // value for 'pagination'
+ *      context: // value for 'context'
+ *   },
+ * });
+ */
+export declare function useListExportJobsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListExportJobsQuery, Types.ListExportJobsQueryVariables> & ({
+    variables: Types.ListExportJobsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.ListExportJobsQuery, Types.ListExportJobsQueryVariables, "complete" | "empty" | "streaming", Types.ListExportJobsQueryVariables>;
+export declare function useListExportJobsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListExportJobsQuery, Types.ListExportJobsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListExportJobsQuery, Types.ListExportJobsQueryVariables, "complete" | "empty" | "streaming">;
+export declare function useListExportJobsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListExportJobsQuery, Types.ListExportJobsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListExportJobsQuery, Types.ListExportJobsQueryVariables>;
+export declare function useListExportJobsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListExportJobsQuery, Types.ListExportJobsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListExportJobsQuery | undefined, Types.ListExportJobsQueryVariables>;
+export type ListExportJobsQueryHookResult = ReturnType<typeof useListExportJobsQuery>;
+export type ListExportJobsLazyQueryHookResult = ReturnType<typeof useListExportJobsLazyQuery>;
+export type ListExportJobsSuspenseQueryHookResult = ReturnType<typeof useListExportJobsSuspenseQuery>;
+export type ListExportJobsQueryResult = Apollo.QueryResult<Types.ListExportJobsQuery, Types.ListExportJobsQueryVariables>;
+export declare const ExportJobProgressDocument: Apollo.DocumentNode;
+/**
+ * __useExportJobProgressSubscription__
+ *
+ * To run a query within a React component, call `useExportJobProgressSubscription` and pass it any options that fit your needs.
+ * When your component renders, `useExportJobProgressSubscription` 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 subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useExportJobProgressSubscription({
+ *   variables: {
+ *      jobId: // value for 'jobId'
+ *   },
+ * });
+ */
+export declare function useExportJobProgressSubscription(baseOptions: ApolloReactHooks.SubscriptionHookOptions<Types.ExportJobProgressSubscription, Types.ExportJobProgressSubscriptionVariables> & ({
+    variables: Types.ExportJobProgressSubscriptionVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useSubscription.Result<Types.ExportJobProgressSubscription>;
+export type ExportJobProgressSubscriptionHookResult = ReturnType<typeof useExportJobProgressSubscription>;
+export type ExportJobProgressSubscriptionResult = Apollo.SubscriptionResult<Types.ExportJobProgressSubscription>;
+//# sourceMappingURL=wspace-operations.d.ts.map