@burdenoff/microfe-timecampus 2026.904.1 → 2026.1025.1

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

@@ -97,6 +97,45 @@ export type ExpenseFieldsFragment = {
     createdAt: string;
     updatedAt: string;
 };
+export type FocusSessionFieldsFragment = {
+    __typename?: 'TimeCampusFocusSession';
+    id: string;
+    status: Types.TimeCampusFocusSessionStatus;
+    protectionLevel: Types.TimeCampusFocusProtectionLevel;
+    startTime: string;
+    endTime?: string | null;
+    plannedDurationSeconds?: number | null;
+    focusBlockId?: string | null;
+    interruptionCount: number;
+    blockedAttemptCount: number;
+    protectedSeconds: number;
+    interruptedSeconds: number;
+};
+export type FocusBlockFieldsFragment = {
+    __typename?: 'TimeCampusFocusBlock';
+    id: string;
+    startTime: string;
+    endTime: string;
+    durationMinutes: number;
+    status: Types.TimeCampusFocusBlockStatus;
+    source: Types.TimeCampusFocusBlockSource;
+    score?: number | null;
+    reasons: Array<Types.TimeCampusFocusBlockReason>;
+    snoozedUntil?: string | null;
+    focusSessionId?: string | null;
+};
+export type FocusPreferencesFieldsFragment = {
+    __typename?: 'TimeCampusFocusPreferences';
+    workdayStartMinute: number;
+    workdayEndMinute: number;
+    preferredBlockMinutes: number;
+    minBlockMinutes: number;
+    maxBlocksPerDay: number;
+    meetingBufferMinutes: number;
+    blockingEnabled: boolean;
+    blockedDomains: Array<string>;
+    customised: boolean;
+};
 export type FocusScoreFieldsFragment = {
     __typename?: 'FocusScore';
     id: string;
@@ -1276,6 +1315,127 @@ export type RejectExpenseMutation = {
         updatedAt: string;
     };
 };
+export type StartFocusSessionMutationVariables = Types.Exact<{
+    plannedDurationSeconds?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    protectionLevel?: Types.InputMaybe<Types.TimeCampusFocusProtectionLevel>;
+    focusBlockId?: Types.InputMaybe<Types.Scalars['ID']['input']>;
+}>;
+export type StartFocusSessionMutation = {
+    __typename?: 'Mutation';
+    startTimeCampusFocusSession: {
+        __typename?: 'TimeCampusFocusSession';
+        id: string;
+        status: Types.TimeCampusFocusSessionStatus;
+        protectionLevel: Types.TimeCampusFocusProtectionLevel;
+        startTime: string;
+        endTime?: string | null;
+        plannedDurationSeconds?: number | null;
+        focusBlockId?: string | null;
+        interruptionCount: number;
+        blockedAttemptCount: number;
+        protectedSeconds: number;
+        interruptedSeconds: number;
+    };
+};
+export type EndFocusSessionMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    status: Types.TimeCampusFocusSessionStatus;
+}>;
+export type EndFocusSessionMutation = {
+    __typename?: 'Mutation';
+    endTimeCampusFocusSession: {
+        __typename?: 'TimeCampusFocusSession';
+        id: string;
+        status: Types.TimeCampusFocusSessionStatus;
+        protectionLevel: Types.TimeCampusFocusProtectionLevel;
+        startTime: string;
+        endTime?: string | null;
+        plannedDurationSeconds?: number | null;
+        focusBlockId?: string | null;
+        interruptionCount: number;
+        blockedAttemptCount: number;
+        protectedSeconds: number;
+        interruptedSeconds: number;
+    };
+};
+export type LogFocusInterruptionMutationVariables = Types.Exact<{
+    focusSessionId: Types.Scalars['ID']['input'];
+    app?: Types.InputMaybe<Types.Scalars['String']['input']>;
+    note?: Types.InputMaybe<Types.Scalars['String']['input']>;
+}>;
+export type LogFocusInterruptionMutation = {
+    __typename?: 'Mutation';
+    logTimeCampusFocusInterruption: {
+        __typename?: 'TimeCampusFocusSession';
+        id: string;
+        status: Types.TimeCampusFocusSessionStatus;
+        protectionLevel: Types.TimeCampusFocusProtectionLevel;
+        startTime: string;
+        endTime?: string | null;
+        plannedDurationSeconds?: number | null;
+        focusBlockId?: string | null;
+        interruptionCount: number;
+        blockedAttemptCount: number;
+        protectedSeconds: number;
+        interruptedSeconds: number;
+    };
+};
+export type RespondToFocusBlockSuggestionMutationVariables = Types.Exact<{
+    input: Types.TimeCampusFocusBlockResponseInput;
+}>;
+export type RespondToFocusBlockSuggestionMutation = {
+    __typename?: 'Mutation';
+    respondToTimeCampusFocusBlockSuggestion: {
+        __typename?: 'TimeCampusFocusBlock';
+        id: string;
+        startTime: string;
+        endTime: string;
+        durationMinutes: number;
+        status: Types.TimeCampusFocusBlockStatus;
+        source: Types.TimeCampusFocusBlockSource;
+        score?: number | null;
+        reasons: Array<Types.TimeCampusFocusBlockReason>;
+        snoozedUntil?: string | null;
+        focusSessionId?: string | null;
+    };
+};
+export type CancelFocusBlockMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type CancelFocusBlockMutation = {
+    __typename?: 'Mutation';
+    cancelTimeCampusFocusBlock: {
+        __typename?: 'TimeCampusFocusBlock';
+        id: string;
+        startTime: string;
+        endTime: string;
+        durationMinutes: number;
+        status: Types.TimeCampusFocusBlockStatus;
+        source: Types.TimeCampusFocusBlockSource;
+        score?: number | null;
+        reasons: Array<Types.TimeCampusFocusBlockReason>;
+        snoozedUntil?: string | null;
+        focusSessionId?: string | null;
+    };
+};
+export type UpdateFocusPreferencesMutationVariables = Types.Exact<{
+    input: Types.TimeCampusFocusPreferencesInput;
+}>;
+export type UpdateFocusPreferencesMutation = {
+    __typename?: 'Mutation';
+    updateTimeCampusFocusPreferences: {
+        __typename?: 'TimeCampusFocusPreferences';
+        workdayStartMinute: number;
+        workdayEndMinute: number;
+        preferredBlockMinutes: number;
+        minBlockMinutes: number;
+        maxBlocksPerDay: number;
+        meetingBufferMinutes: number;
+        blockingEnabled: boolean;
+        blockedDomains: Array<string>;
+        customised: boolean;
+    };
+};
 export type RecordFocusScoreMutationVariables = Types.Exact<{
     input: Types.RecordFocusScoreInput;
 }>;
@@ -3559,6 +3719,95 @@ export type ListExpenseCategoriesQuery = {
     __typename?: 'Query';
     expenseCategories: Array<string>;
 };
+export type GetActiveFocusSessionQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type GetActiveFocusSessionQuery = {
+    __typename?: 'Query';
+    timeCampusActiveFocusSession?: {
+        __typename?: 'TimeCampusFocusSession';
+        id: string;
+        status: Types.TimeCampusFocusSessionStatus;
+        protectionLevel: Types.TimeCampusFocusProtectionLevel;
+        startTime: string;
+        endTime?: string | null;
+        plannedDurationSeconds?: number | null;
+        focusBlockId?: string | null;
+        interruptionCount: number;
+        blockedAttemptCount: number;
+        protectedSeconds: number;
+        interruptedSeconds: number;
+    } | null;
+};
+export type GetFocusBlockSuggestionsQueryVariables = Types.Exact<{
+    dayStart: Types.Scalars['DateTime']['input'];
+}>;
+export type GetFocusBlockSuggestionsQuery = {
+    __typename?: 'Query';
+    timeCampusFocusBlockSuggestions: Array<{
+        __typename?: 'TimeCampusFocusBlockSuggestion';
+        startTime: string;
+        endTime: string;
+        durationMinutes: number;
+        score: number;
+        reasons: Array<Types.TimeCampusFocusBlockReason>;
+    }>;
+};
+export type ListFocusBlocksQueryVariables = Types.Exact<{
+    from: Types.Scalars['DateTime']['input'];
+    to: Types.Scalars['DateTime']['input'];
+}>;
+export type ListFocusBlocksQuery = {
+    __typename?: 'Query';
+    timeCampusFocusBlocks: Array<{
+        __typename?: 'TimeCampusFocusBlock';
+        id: string;
+        startTime: string;
+        endTime: string;
+        durationMinutes: number;
+        status: Types.TimeCampusFocusBlockStatus;
+        source: Types.TimeCampusFocusBlockSource;
+        score?: number | null;
+        reasons: Array<Types.TimeCampusFocusBlockReason>;
+        snoozedUntil?: string | null;
+        focusSessionId?: string | null;
+    }>;
+};
+export type GetFocusPreferencesQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type GetFocusPreferencesQuery = {
+    __typename?: 'Query';
+    timeCampusFocusPreferences: {
+        __typename?: 'TimeCampusFocusPreferences';
+        workdayStartMinute: number;
+        workdayEndMinute: number;
+        preferredBlockMinutes: number;
+        minBlockMinutes: number;
+        maxBlocksPerDay: number;
+        meetingBufferMinutes: number;
+        blockingEnabled: boolean;
+        blockedDomains: Array<string>;
+        customised: boolean;
+    };
+};
+export type GetFocusProtectionSummaryQueryVariables = Types.Exact<{
+    from: Types.Scalars['DateTime']['input'];
+    to: Types.Scalars['DateTime']['input'];
+}>;
+export type GetFocusProtectionSummaryQuery = {
+    __typename?: 'Query';
+    timeCampusFocusSummary: {
+        __typename?: 'TimeCampusFocusSummary';
+        totalSessions: number;
+        completedSessions: number;
+        abandonedSessions: number;
+        totalProtectedSeconds: number;
+        totalInterruptedSeconds: number;
+        totalInterruptionCount: number;
+        averageProtectionRatio: number;
+    };
+};
 export type ListFocusScoresQueryVariables = Types.Exact<{
     userId?: Types.InputMaybe<Types.Scalars['ID']['input']>;
     startDate?: Types.InputMaybe<Types.Scalars['DateTime']['input']>;
@@ -5293,6 +5542,9 @@ export declare const ApplicationUsageFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const ClientPortalFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const EmailTimeEntryFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const ExpenseFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const FocusSessionFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const FocusBlockFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const FocusPreferencesFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const FocusScoreFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const InvoiceLineItemFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const InvoiceFieldsFragmentDoc: Apollo.DocumentNode;
@@ -6090,6 +6342,161 @@ export declare function useRejectExpenseMutation(baseOptions?: ApolloReactHooks.
 export type RejectExpenseMutationHookResult = ReturnType<typeof useRejectExpenseMutation>;
 export type RejectExpenseMutationResult = Apollo.MutationResult<Types.RejectExpenseMutation>;
 export type RejectExpenseMutationOptions = Apollo.BaseMutationOptions<Types.RejectExpenseMutation, Types.RejectExpenseMutationVariables>;
+export declare const StartFocusSessionDocument: Apollo.DocumentNode;
+export type StartFocusSessionMutationFn = Apollo.MutationFunction<Types.StartFocusSessionMutation, Types.StartFocusSessionMutationVariables>;
+/**
+ * __useStartFocusSessionMutation__
+ *
+ * To run a mutation, you first call `useStartFocusSessionMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useStartFocusSessionMutation` 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 [startFocusSessionMutation, { data, loading, error }] = useStartFocusSessionMutation({
+ *   variables: {
+ *      plannedDurationSeconds: // value for 'plannedDurationSeconds'
+ *      protectionLevel: // value for 'protectionLevel'
+ *      focusBlockId: // value for 'focusBlockId'
+ *   },
+ * });
+ */
+export declare function useStartFocusSessionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.StartFocusSessionMutation, Types.StartFocusSessionMutationVariables>): ApolloReactHooks.useMutation.ResultForOptions<Types.StartFocusSessionMutation, Types.StartFocusSessionMutationVariables, Apollo.ApolloCache, ApolloReactHooks.useMutation.Options<import('@apollo/client/utilities/internal').NoInfer<TData>, import('@apollo/client/utilities/internal').NoInfer<TVariables>, TCache, Partial<import('@apollo/client/utilities/internal').NoInfer<TVariables>>> & {
+    variables?: { [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never; };
+}, undefined>;
+export type StartFocusSessionMutationHookResult = ReturnType<typeof useStartFocusSessionMutation>;
+export type StartFocusSessionMutationResult = Apollo.MutationResult<Types.StartFocusSessionMutation>;
+export type StartFocusSessionMutationOptions = Apollo.BaseMutationOptions<Types.StartFocusSessionMutation, Types.StartFocusSessionMutationVariables>;
+export declare const EndFocusSessionDocument: Apollo.DocumentNode;
+export type EndFocusSessionMutationFn = Apollo.MutationFunction<Types.EndFocusSessionMutation, Types.EndFocusSessionMutationVariables>;
+/**
+ * __useEndFocusSessionMutation__
+ *
+ * To run a mutation, you first call `useEndFocusSessionMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useEndFocusSessionMutation` 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 [endFocusSessionMutation, { data, loading, error }] = useEndFocusSessionMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      status: // value for 'status'
+ *   },
+ * });
+ */
+export declare function useEndFocusSessionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.EndFocusSessionMutation, Types.EndFocusSessionMutationVariables>): ApolloReactHooks.useMutation.ResultForOptions<Types.EndFocusSessionMutation, Types.EndFocusSessionMutationVariables, Apollo.ApolloCache, ApolloReactHooks.useMutation.Options<import('@apollo/client/utilities/internal').NoInfer<TData>, import('@apollo/client/utilities/internal').NoInfer<TVariables>, TCache, Partial<import('@apollo/client/utilities/internal').NoInfer<TVariables>>> & {
+    variables?: { [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never; };
+}, undefined>;
+export type EndFocusSessionMutationHookResult = ReturnType<typeof useEndFocusSessionMutation>;
+export type EndFocusSessionMutationResult = Apollo.MutationResult<Types.EndFocusSessionMutation>;
+export type EndFocusSessionMutationOptions = Apollo.BaseMutationOptions<Types.EndFocusSessionMutation, Types.EndFocusSessionMutationVariables>;
+export declare const LogFocusInterruptionDocument: Apollo.DocumentNode;
+export type LogFocusInterruptionMutationFn = Apollo.MutationFunction<Types.LogFocusInterruptionMutation, Types.LogFocusInterruptionMutationVariables>;
+/**
+ * __useLogFocusInterruptionMutation__
+ *
+ * To run a mutation, you first call `useLogFocusInterruptionMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useLogFocusInterruptionMutation` 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 [logFocusInterruptionMutation, { data, loading, error }] = useLogFocusInterruptionMutation({
+ *   variables: {
+ *      focusSessionId: // value for 'focusSessionId'
+ *      app: // value for 'app'
+ *      note: // value for 'note'
+ *   },
+ * });
+ */
+export declare function useLogFocusInterruptionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.LogFocusInterruptionMutation, Types.LogFocusInterruptionMutationVariables>): ApolloReactHooks.useMutation.ResultForOptions<Types.LogFocusInterruptionMutation, Types.LogFocusInterruptionMutationVariables, Apollo.ApolloCache, ApolloReactHooks.useMutation.Options<import('@apollo/client/utilities/internal').NoInfer<TData>, import('@apollo/client/utilities/internal').NoInfer<TVariables>, TCache, Partial<import('@apollo/client/utilities/internal').NoInfer<TVariables>>> & {
+    variables?: { [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never; };
+}, undefined>;
+export type LogFocusInterruptionMutationHookResult = ReturnType<typeof useLogFocusInterruptionMutation>;
+export type LogFocusInterruptionMutationResult = Apollo.MutationResult<Types.LogFocusInterruptionMutation>;
+export type LogFocusInterruptionMutationOptions = Apollo.BaseMutationOptions<Types.LogFocusInterruptionMutation, Types.LogFocusInterruptionMutationVariables>;
+export declare const RespondToFocusBlockSuggestionDocument: Apollo.DocumentNode;
+export type RespondToFocusBlockSuggestionMutationFn = Apollo.MutationFunction<Types.RespondToFocusBlockSuggestionMutation, Types.RespondToFocusBlockSuggestionMutationVariables>;
+/**
+ * __useRespondToFocusBlockSuggestionMutation__
+ *
+ * To run a mutation, you first call `useRespondToFocusBlockSuggestionMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRespondToFocusBlockSuggestionMutation` 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 [respondToFocusBlockSuggestionMutation, { data, loading, error }] = useRespondToFocusBlockSuggestionMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useRespondToFocusBlockSuggestionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RespondToFocusBlockSuggestionMutation, Types.RespondToFocusBlockSuggestionMutationVariables>): ApolloReactHooks.useMutation.ResultForOptions<Types.RespondToFocusBlockSuggestionMutation, Types.RespondToFocusBlockSuggestionMutationVariables, Apollo.ApolloCache, ApolloReactHooks.useMutation.Options<import('@apollo/client/utilities/internal').NoInfer<TData>, import('@apollo/client/utilities/internal').NoInfer<TVariables>, TCache, Partial<import('@apollo/client/utilities/internal').NoInfer<TVariables>>> & {
+    variables?: { [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never; };
+}, undefined>;
+export type RespondToFocusBlockSuggestionMutationHookResult = ReturnType<typeof useRespondToFocusBlockSuggestionMutation>;
+export type RespondToFocusBlockSuggestionMutationResult = Apollo.MutationResult<Types.RespondToFocusBlockSuggestionMutation>;
+export type RespondToFocusBlockSuggestionMutationOptions = Apollo.BaseMutationOptions<Types.RespondToFocusBlockSuggestionMutation, Types.RespondToFocusBlockSuggestionMutationVariables>;
+export declare const CancelFocusBlockDocument: Apollo.DocumentNode;
+export type CancelFocusBlockMutationFn = Apollo.MutationFunction<Types.CancelFocusBlockMutation, Types.CancelFocusBlockMutationVariables>;
+/**
+ * __useCancelFocusBlockMutation__
+ *
+ * To run a mutation, you first call `useCancelFocusBlockMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCancelFocusBlockMutation` 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 [cancelFocusBlockMutation, { data, loading, error }] = useCancelFocusBlockMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useCancelFocusBlockMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CancelFocusBlockMutation, Types.CancelFocusBlockMutationVariables>): ApolloReactHooks.useMutation.ResultForOptions<Types.CancelFocusBlockMutation, Types.CancelFocusBlockMutationVariables, Apollo.ApolloCache, ApolloReactHooks.useMutation.Options<import('@apollo/client/utilities/internal').NoInfer<TData>, import('@apollo/client/utilities/internal').NoInfer<TVariables>, TCache, Partial<import('@apollo/client/utilities/internal').NoInfer<TVariables>>> & {
+    variables?: { [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never; };
+}, undefined>;
+export type CancelFocusBlockMutationHookResult = ReturnType<typeof useCancelFocusBlockMutation>;
+export type CancelFocusBlockMutationResult = Apollo.MutationResult<Types.CancelFocusBlockMutation>;
+export type CancelFocusBlockMutationOptions = Apollo.BaseMutationOptions<Types.CancelFocusBlockMutation, Types.CancelFocusBlockMutationVariables>;
+export declare const UpdateFocusPreferencesDocument: Apollo.DocumentNode;
+export type UpdateFocusPreferencesMutationFn = Apollo.MutationFunction<Types.UpdateFocusPreferencesMutation, Types.UpdateFocusPreferencesMutationVariables>;
+/**
+ * __useUpdateFocusPreferencesMutation__
+ *
+ * To run a mutation, you first call `useUpdateFocusPreferencesMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateFocusPreferencesMutation` 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 [updateFocusPreferencesMutation, { data, loading, error }] = useUpdateFocusPreferencesMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateFocusPreferencesMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateFocusPreferencesMutation, Types.UpdateFocusPreferencesMutationVariables>): ApolloReactHooks.useMutation.ResultForOptions<Types.UpdateFocusPreferencesMutation, Types.UpdateFocusPreferencesMutationVariables, Apollo.ApolloCache, ApolloReactHooks.useMutation.Options<import('@apollo/client/utilities/internal').NoInfer<TData>, import('@apollo/client/utilities/internal').NoInfer<TVariables>, TCache, Partial<import('@apollo/client/utilities/internal').NoInfer<TVariables>>> & {
+    variables?: { [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never; };
+}, undefined>;
+export type UpdateFocusPreferencesMutationHookResult = ReturnType<typeof useUpdateFocusPreferencesMutation>;
+export type UpdateFocusPreferencesMutationResult = Apollo.MutationResult<Types.UpdateFocusPreferencesMutation>;
+export type UpdateFocusPreferencesMutationOptions = Apollo.BaseMutationOptions<Types.UpdateFocusPreferencesMutation, Types.UpdateFocusPreferencesMutationVariables>;
 export declare const RecordFocusScoreDocument: Apollo.DocumentNode;
 export type RecordFocusScoreMutationFn = Apollo.MutationFunction<Types.RecordFocusScoreMutation, Types.RecordFocusScoreMutationVariables>;
 /**
@@ -8770,6 +9177,146 @@ export type ListExpenseCategoriesQueryHookResult = ReturnType<typeof useListExpe
 export type ListExpenseCategoriesLazyQueryHookResult = ReturnType<typeof useListExpenseCategoriesLazyQuery>;
 export type ListExpenseCategoriesSuspenseQueryHookResult = ReturnType<typeof useListExpenseCategoriesSuspenseQuery>;
 export type ListExpenseCategoriesQueryResult = Apollo.QueryResult<Types.ListExpenseCategoriesQuery, Types.ListExpenseCategoriesQueryVariables>;
+export declare const GetActiveFocusSessionDocument: Apollo.DocumentNode;
+/**
+ * __useGetActiveFocusSessionQuery__
+ *
+ * To run a query within a React component, call `useGetActiveFocusSessionQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetActiveFocusSessionQuery` 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 } = useGetActiveFocusSessionQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useGetActiveFocusSessionQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetActiveFocusSessionQuery, Types.GetActiveFocusSessionQueryVariables>): ApolloReactHooks.useQuery.ResultForOptions<Types.GetActiveFocusSessionQuery, Types.GetActiveFocusSessionQueryVariables, ApolloReactHooks.useQuery.Base.Options<TData, import('@apollo/client/utilities/internal').NoInfer<TVariables>>>;
+export declare function useGetActiveFocusSessionLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetActiveFocusSessionQuery, Types.GetActiveFocusSessionQueryVariables>): ApolloReactHooks.useLazyQuery.ResultForOptions<Types.GetActiveFocusSessionQuery, Types.GetActiveFocusSessionQueryVariables, ApolloReactHooks.useLazyQuery.Options<import('@apollo/client/utilities/internal').NoInfer<TData>, import('@apollo/client/utilities/internal').NoInfer<TVariables>>>;
+export declare function useGetActiveFocusSessionSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetActiveFocusSessionQuery, Types.GetActiveFocusSessionQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetActiveFocusSessionQuery, Types.GetActiveFocusSessionQueryVariables>;
+export declare function useGetActiveFocusSessionSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetActiveFocusSessionQuery, Types.GetActiveFocusSessionQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetActiveFocusSessionQuery | undefined, Types.GetActiveFocusSessionQueryVariables>;
+export type GetActiveFocusSessionQueryHookResult = ReturnType<typeof useGetActiveFocusSessionQuery>;
+export type GetActiveFocusSessionLazyQueryHookResult = ReturnType<typeof useGetActiveFocusSessionLazyQuery>;
+export type GetActiveFocusSessionSuspenseQueryHookResult = ReturnType<typeof useGetActiveFocusSessionSuspenseQuery>;
+export type GetActiveFocusSessionQueryResult = Apollo.QueryResult<Types.GetActiveFocusSessionQuery, Types.GetActiveFocusSessionQueryVariables>;
+export declare const GetFocusBlockSuggestionsDocument: Apollo.DocumentNode;
+/**
+ * __useGetFocusBlockSuggestionsQuery__
+ *
+ * To run a query within a React component, call `useGetFocusBlockSuggestionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetFocusBlockSuggestionsQuery` 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 } = useGetFocusBlockSuggestionsQuery({
+ *   variables: {
+ *      dayStart: // value for 'dayStart'
+ *   },
+ * });
+ */
+export declare function useGetFocusBlockSuggestionsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetFocusBlockSuggestionsQuery, Types.GetFocusBlockSuggestionsQueryVariables> & ({
+    variables: Types.GetFocusBlockSuggestionsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.ResultForOptions<Types.GetFocusBlockSuggestionsQuery, Types.GetFocusBlockSuggestionsQueryVariables, ApolloReactHooks.useQuery.Base.Options<TData, import('@apollo/client/utilities/internal').NoInfer<TVariables>>>;
+export declare function useGetFocusBlockSuggestionsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetFocusBlockSuggestionsQuery, Types.GetFocusBlockSuggestionsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultForOptions<Types.GetFocusBlockSuggestionsQuery, Types.GetFocusBlockSuggestionsQueryVariables, ApolloReactHooks.useLazyQuery.Options<import('@apollo/client/utilities/internal').NoInfer<TData>, import('@apollo/client/utilities/internal').NoInfer<TVariables>>>;
+export declare function useGetFocusBlockSuggestionsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFocusBlockSuggestionsQuery, Types.GetFocusBlockSuggestionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFocusBlockSuggestionsQuery, Types.GetFocusBlockSuggestionsQueryVariables>;
+export declare function useGetFocusBlockSuggestionsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFocusBlockSuggestionsQuery, Types.GetFocusBlockSuggestionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFocusBlockSuggestionsQuery | undefined, Types.GetFocusBlockSuggestionsQueryVariables>;
+export type GetFocusBlockSuggestionsQueryHookResult = ReturnType<typeof useGetFocusBlockSuggestionsQuery>;
+export type GetFocusBlockSuggestionsLazyQueryHookResult = ReturnType<typeof useGetFocusBlockSuggestionsLazyQuery>;
+export type GetFocusBlockSuggestionsSuspenseQueryHookResult = ReturnType<typeof useGetFocusBlockSuggestionsSuspenseQuery>;
+export type GetFocusBlockSuggestionsQueryResult = Apollo.QueryResult<Types.GetFocusBlockSuggestionsQuery, Types.GetFocusBlockSuggestionsQueryVariables>;
+export declare const ListFocusBlocksDocument: Apollo.DocumentNode;
+/**
+ * __useListFocusBlocksQuery__
+ *
+ * To run a query within a React component, call `useListFocusBlocksQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListFocusBlocksQuery` 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 } = useListFocusBlocksQuery({
+ *   variables: {
+ *      from: // value for 'from'
+ *      to: // value for 'to'
+ *   },
+ * });
+ */
+export declare function useListFocusBlocksQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListFocusBlocksQuery, Types.ListFocusBlocksQueryVariables> & ({
+    variables: Types.ListFocusBlocksQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.ResultForOptions<Types.ListFocusBlocksQuery, Types.ListFocusBlocksQueryVariables, ApolloReactHooks.useQuery.Base.Options<TData, import('@apollo/client/utilities/internal').NoInfer<TVariables>>>;
+export declare function useListFocusBlocksLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListFocusBlocksQuery, Types.ListFocusBlocksQueryVariables>): ApolloReactHooks.useLazyQuery.ResultForOptions<Types.ListFocusBlocksQuery, Types.ListFocusBlocksQueryVariables, ApolloReactHooks.useLazyQuery.Options<import('@apollo/client/utilities/internal').NoInfer<TData>, import('@apollo/client/utilities/internal').NoInfer<TVariables>>>;
+export declare function useListFocusBlocksSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListFocusBlocksQuery, Types.ListFocusBlocksQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListFocusBlocksQuery, Types.ListFocusBlocksQueryVariables>;
+export declare function useListFocusBlocksSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListFocusBlocksQuery, Types.ListFocusBlocksQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListFocusBlocksQuery | undefined, Types.ListFocusBlocksQueryVariables>;
+export type ListFocusBlocksQueryHookResult = ReturnType<typeof useListFocusBlocksQuery>;
+export type ListFocusBlocksLazyQueryHookResult = ReturnType<typeof useListFocusBlocksLazyQuery>;
+export type ListFocusBlocksSuspenseQueryHookResult = ReturnType<typeof useListFocusBlocksSuspenseQuery>;
+export type ListFocusBlocksQueryResult = Apollo.QueryResult<Types.ListFocusBlocksQuery, Types.ListFocusBlocksQueryVariables>;
+export declare const GetFocusPreferencesDocument: Apollo.DocumentNode;
+/**
+ * __useGetFocusPreferencesQuery__
+ *
+ * To run a query within a React component, call `useGetFocusPreferencesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetFocusPreferencesQuery` 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 } = useGetFocusPreferencesQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useGetFocusPreferencesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetFocusPreferencesQuery, Types.GetFocusPreferencesQueryVariables>): ApolloReactHooks.useQuery.ResultForOptions<Types.GetFocusPreferencesQuery, Types.GetFocusPreferencesQueryVariables, ApolloReactHooks.useQuery.Base.Options<TData, import('@apollo/client/utilities/internal').NoInfer<TVariables>>>;
+export declare function useGetFocusPreferencesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetFocusPreferencesQuery, Types.GetFocusPreferencesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultForOptions<Types.GetFocusPreferencesQuery, Types.GetFocusPreferencesQueryVariables, ApolloReactHooks.useLazyQuery.Options<import('@apollo/client/utilities/internal').NoInfer<TData>, import('@apollo/client/utilities/internal').NoInfer<TVariables>>>;
+export declare function useGetFocusPreferencesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFocusPreferencesQuery, Types.GetFocusPreferencesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFocusPreferencesQuery, Types.GetFocusPreferencesQueryVariables>;
+export declare function useGetFocusPreferencesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFocusPreferencesQuery, Types.GetFocusPreferencesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFocusPreferencesQuery | undefined, Types.GetFocusPreferencesQueryVariables>;
+export type GetFocusPreferencesQueryHookResult = ReturnType<typeof useGetFocusPreferencesQuery>;
+export type GetFocusPreferencesLazyQueryHookResult = ReturnType<typeof useGetFocusPreferencesLazyQuery>;
+export type GetFocusPreferencesSuspenseQueryHookResult = ReturnType<typeof useGetFocusPreferencesSuspenseQuery>;
+export type GetFocusPreferencesQueryResult = Apollo.QueryResult<Types.GetFocusPreferencesQuery, Types.GetFocusPreferencesQueryVariables>;
+export declare const GetFocusProtectionSummaryDocument: Apollo.DocumentNode;
+/**
+ * __useGetFocusProtectionSummaryQuery__
+ *
+ * To run a query within a React component, call `useGetFocusProtectionSummaryQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetFocusProtectionSummaryQuery` 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 } = useGetFocusProtectionSummaryQuery({
+ *   variables: {
+ *      from: // value for 'from'
+ *      to: // value for 'to'
+ *   },
+ * });
+ */
+export declare function useGetFocusProtectionSummaryQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetFocusProtectionSummaryQuery, Types.GetFocusProtectionSummaryQueryVariables> & ({
+    variables: Types.GetFocusProtectionSummaryQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.ResultForOptions<Types.GetFocusProtectionSummaryQuery, Types.GetFocusProtectionSummaryQueryVariables, ApolloReactHooks.useQuery.Base.Options<TData, import('@apollo/client/utilities/internal').NoInfer<TVariables>>>;
+export declare function useGetFocusProtectionSummaryLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetFocusProtectionSummaryQuery, Types.GetFocusProtectionSummaryQueryVariables>): ApolloReactHooks.useLazyQuery.ResultForOptions<Types.GetFocusProtectionSummaryQuery, Types.GetFocusProtectionSummaryQueryVariables, ApolloReactHooks.useLazyQuery.Options<import('@apollo/client/utilities/internal').NoInfer<TData>, import('@apollo/client/utilities/internal').NoInfer<TVariables>>>;
+export declare function useGetFocusProtectionSummarySuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFocusProtectionSummaryQuery, Types.GetFocusProtectionSummaryQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFocusProtectionSummaryQuery, Types.GetFocusProtectionSummaryQueryVariables>;
+export declare function useGetFocusProtectionSummarySuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFocusProtectionSummaryQuery, Types.GetFocusProtectionSummaryQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFocusProtectionSummaryQuery | undefined, Types.GetFocusProtectionSummaryQueryVariables>;
+export type GetFocusProtectionSummaryQueryHookResult = ReturnType<typeof useGetFocusProtectionSummaryQuery>;
+export type GetFocusProtectionSummaryLazyQueryHookResult = ReturnType<typeof useGetFocusProtectionSummaryLazyQuery>;
+export type GetFocusProtectionSummarySuspenseQueryHookResult = ReturnType<typeof useGetFocusProtectionSummarySuspenseQuery>;
+export type GetFocusProtectionSummaryQueryResult = Apollo.QueryResult<Types.GetFocusProtectionSummaryQuery, Types.GetFocusProtectionSummaryQueryVariables>;
 export declare const ListFocusScoresDocument: Apollo.DocumentNode;
 /**
  * __useListFocusScoresQuery__