@burdenoff/microfe-planmagnet 2026.1002.2 → 2026.1008.1

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

@@ -51,6 +51,70 @@ export type BoardSummaryFieldsFragment = {
     isDefault: boolean;
     projectId: string;
 };
+export type CustomerSatisfactionSummaryFieldsFragment = {
+    __typename?: 'PlanmagnetCustomerSatisfaction';
+    productId?: string | null;
+    releaseId?: string | null;
+    projectId?: string | null;
+    window: {
+        __typename?: 'PlanmagnetSatisfactionWindow';
+        preset: Types.PlanmagnetSatisfactionWindowPreset;
+        from: string;
+        to: string;
+    };
+    csat: {
+        __typename?: 'PlanmagnetCsatScore';
+        score?: number | null;
+        responseCount: number;
+        satisfiedCount: number;
+        minimumResponses: number;
+        notEnoughResponses: boolean;
+    };
+    nps: {
+        __typename?: 'PlanmagnetNpsScore';
+        score?: number | null;
+        responseCount: number;
+        promoterCount: number;
+        passiveCount: number;
+        detractorCount: number;
+        minimumResponses: number;
+        notEnoughResponses: boolean;
+    };
+};
+export type CustomerSatisfactionResponseFieldsFragment = {
+    __typename?: 'PlanmagnetCustomerSatisfactionResponse';
+    id: string;
+    metricType: Types.PlanmagnetSatisfactionMetricType;
+    score: number;
+    respondedAt: string;
+    comment?: string | null;
+    isAnonymous: boolean;
+    respondentName?: string | null;
+    respondentEmail?: string | null;
+    source: Types.PlanmagnetSatisfactionResponseSource;
+    externalId?: string | null;
+    productId?: string | null;
+    releaseId?: string | null;
+    projectId?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    product?: {
+        __typename?: 'Product';
+        id: string;
+        name: string;
+    } | null;
+    release?: {
+        __typename?: 'Release';
+        id: string;
+        name: string;
+        version: string;
+    } | null;
+    project?: {
+        __typename?: 'PlanmagnetProject';
+        id: string;
+        name: string;
+    } | null;
+};
 export type MilestoneFieldsFragment = {
     __typename?: 'Milestone';
     id: string;
@@ -844,6 +908,106 @@ export type DeleteExpenseMutation = {
     __typename?: 'Mutation';
     planmagnetDeleteExpense: boolean;
 };
+export type CreateCustomerSatisfactionResponseMutationVariables = Types.Exact<{
+    input: Types.PlanmagnetCreateCustomerSatisfactionResponseInput;
+}>;
+export type CreateCustomerSatisfactionResponseMutation = {
+    __typename?: 'Mutation';
+    planmagnetCreateCustomerSatisfactionResponse: {
+        __typename?: 'PlanmagnetCustomerSatisfactionResponse';
+        id: string;
+        metricType: Types.PlanmagnetSatisfactionMetricType;
+        score: number;
+        respondedAt: string;
+        comment?: string | null;
+        isAnonymous: boolean;
+        respondentName?: string | null;
+        respondentEmail?: string | null;
+        source: Types.PlanmagnetSatisfactionResponseSource;
+        externalId?: string | null;
+        productId?: string | null;
+        releaseId?: string | null;
+        projectId?: string | null;
+        createdAt: string;
+        updatedAt: string;
+        product?: {
+            __typename?: 'Product';
+            id: string;
+            name: string;
+        } | null;
+        release?: {
+            __typename?: 'Release';
+            id: string;
+            name: string;
+            version: string;
+        } | null;
+        project?: {
+            __typename?: 'PlanmagnetProject';
+            id: string;
+            name: string;
+        } | null;
+    };
+};
+export type UpdateCustomerSatisfactionResponseMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.PlanmagnetUpdateCustomerSatisfactionResponseInput;
+}>;
+export type UpdateCustomerSatisfactionResponseMutation = {
+    __typename?: 'Mutation';
+    planmagnetUpdateCustomerSatisfactionResponse: {
+        __typename?: 'PlanmagnetCustomerSatisfactionResponse';
+        id: string;
+        metricType: Types.PlanmagnetSatisfactionMetricType;
+        score: number;
+        respondedAt: string;
+        comment?: string | null;
+        isAnonymous: boolean;
+        respondentName?: string | null;
+        respondentEmail?: string | null;
+        source: Types.PlanmagnetSatisfactionResponseSource;
+        externalId?: string | null;
+        productId?: string | null;
+        releaseId?: string | null;
+        projectId?: string | null;
+        createdAt: string;
+        updatedAt: string;
+        product?: {
+            __typename?: 'Product';
+            id: string;
+            name: string;
+        } | null;
+        release?: {
+            __typename?: 'Release';
+            id: string;
+            name: string;
+            version: string;
+        } | null;
+        project?: {
+            __typename?: 'PlanmagnetProject';
+            id: string;
+            name: string;
+        } | null;
+    };
+};
+export type DeleteCustomerSatisfactionResponseMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type DeleteCustomerSatisfactionResponseMutation = {
+    __typename?: 'Mutation';
+    planmagnetDeleteCustomerSatisfactionResponse: boolean;
+};
+export type ImportCustomerSatisfactionResponsesMutationVariables = Types.Exact<{
+    input: Types.PlanmagnetImportCustomerSatisfactionResponsesInput;
+}>;
+export type ImportCustomerSatisfactionResponsesMutation = {
+    __typename?: 'Mutation';
+    planmagnetImportCustomerSatisfactionResponses: {
+        __typename?: 'PlanmagnetCustomerSatisfactionImportResult';
+        createdCount: number;
+        skippedCount: number;
+        skippedExternalIds: Array<string>;
+    };
+};
 export type CreateCustomFieldDefinitionMutationVariables = Types.Exact<{
     input: Types.PlanmagnetCreateCustomFieldDefinitionInput;
 }>;
@@ -2996,6 +3160,116 @@ export type ListBudgetExpensesQuery = {
         };
     };
 };
+export type CustomerSatisfactionSummaryQueryVariables = Types.Exact<{
+    workspaceId: Types.Scalars['ID']['input'];
+    filter?: Types.InputMaybe<Types.PlanmagnetCustomerSatisfactionFilter>;
+}>;
+export type CustomerSatisfactionSummaryQuery = {
+    __typename?: 'Query';
+    planmagnetCustomerSatisfaction: {
+        __typename?: 'PlanmagnetCustomerSatisfaction';
+        productId?: string | null;
+        releaseId?: string | null;
+        projectId?: string | null;
+        window: {
+            __typename?: 'PlanmagnetSatisfactionWindow';
+            preset: Types.PlanmagnetSatisfactionWindowPreset;
+            from: string;
+            to: string;
+        };
+        csat: {
+            __typename?: 'PlanmagnetCsatScore';
+            score?: number | null;
+            responseCount: number;
+            satisfiedCount: number;
+            minimumResponses: number;
+            notEnoughResponses: boolean;
+        };
+        nps: {
+            __typename?: 'PlanmagnetNpsScore';
+            score?: number | null;
+            responseCount: number;
+            promoterCount: number;
+            passiveCount: number;
+            detractorCount: number;
+            minimumResponses: number;
+            notEnoughResponses: boolean;
+        };
+    };
+};
+export type CustomerSatisfactionResponsesQueryVariables = Types.Exact<{
+    workspaceId: Types.Scalars['ID']['input'];
+    filter?: Types.InputMaybe<Types.PlanmagnetCustomerSatisfactionResponseFilter>;
+    pagination?: Types.InputMaybe<Types.PlanmagnetPaginationInput>;
+}>;
+export type CustomerSatisfactionResponsesQuery = {
+    __typename?: 'Query';
+    planmagnetCustomerSatisfactionResponses: {
+        __typename?: 'PlanmagnetCustomerSatisfactionResponseList';
+        totalCount: number;
+        items: Array<{
+            __typename?: 'PlanmagnetCustomerSatisfactionResponse';
+            id: string;
+            metricType: Types.PlanmagnetSatisfactionMetricType;
+            score: number;
+            respondedAt: string;
+            comment?: string | null;
+            isAnonymous: boolean;
+            respondentName?: string | null;
+            respondentEmail?: string | null;
+            source: Types.PlanmagnetSatisfactionResponseSource;
+            externalId?: string | null;
+            productId?: string | null;
+            releaseId?: string | null;
+            projectId?: string | null;
+            createdAt: string;
+            updatedAt: string;
+            product?: {
+                __typename?: 'Product';
+                id: string;
+                name: string;
+            } | null;
+            release?: {
+                __typename?: 'Release';
+                id: string;
+                name: string;
+                version: string;
+            } | null;
+            project?: {
+                __typename?: 'PlanmagnetProject';
+                id: string;
+                name: string;
+            } | null;
+        }>;
+        pageInfo: {
+            __typename?: 'PlanmagnetPageInfo';
+            hasNextPage: boolean;
+            endCursor?: string | null;
+        };
+    };
+};
+export type CustomerSatisfactionReleaseOptionsQueryVariables = Types.Exact<{
+    workspaceId: Types.Scalars['ID']['input'];
+    pagination?: Types.InputMaybe<Types.PlanmagnetPaginationInput>;
+}>;
+export type CustomerSatisfactionReleaseOptionsQuery = {
+    __typename?: 'Query';
+    planmagnetReleases: {
+        __typename?: 'PlanmagnetReleaseList';
+        items: Array<{
+            __typename?: 'Release';
+            id: string;
+            name: string;
+            version: string;
+            productId?: string | null;
+        }>;
+        pageInfo: {
+            __typename?: 'PlanmagnetPageInfo';
+            hasNextPage: boolean;
+            endCursor?: string | null;
+        };
+    };
+};
 export type ListCustomFieldDefinitionsQueryVariables = Types.Exact<{
     workspaceId: Types.Scalars['ID']['input'];
     filter?: Types.InputMaybe<Types.PlanmagnetCustomFieldDefinitionFilter>;
@@ -4305,6 +4579,56 @@ export type GetRiskMatrixQuery = {
         byStatus: Record<string, unknown>;
     };
 };
+export type WorkItemRequiredSkillsQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type WorkItemRequiredSkillsQuery = {
+    __typename?: 'Query';
+    planmagnetWorkItem?: {
+        __typename?: 'WorkItem';
+        id: string;
+        type: Types.WorkItemType;
+        requiredSkills: Array<string>;
+        aggregatedRequiredSkills: Array<string>;
+    } | null;
+};
+export type SkillCoverageQueryVariables = Types.Exact<{
+    workspaceId: Types.Scalars['ID']['input'];
+    filter?: Types.InputMaybe<Types.PlanmagnetSkillCoverageFilter>;
+}>;
+export type SkillCoverageQuery = {
+    __typename?: 'Query';
+    planmagnetSkillCoverage: {
+        __typename?: 'PlanmagnetSkillCoverageResult';
+        crewfoundryUnavailable: boolean;
+        membersUnavailable: boolean;
+        truncated: boolean;
+        skills: Array<{
+            __typename?: 'PlanmagnetSkillCoverage';
+            skill: string;
+            status: Types.PlanmagnetSkillCoverageStatus;
+            qualifiedMemberCount: number;
+            unassignedQualifiedCount: number;
+            openDemand: {
+                __typename?: 'PlanmagnetSkillDemand';
+                workItemCount: number;
+                storyPoints: number;
+            };
+            assignedDemand: {
+                __typename?: 'PlanmagnetSkillDemand';
+                workItemCount: number;
+                storyPoints: number;
+            };
+            qualifiedMembers: Array<{
+                __typename?: 'PlanmagnetSkillQualifiedMember';
+                actorId: string;
+                employeeId: string;
+                employeeName: string;
+                assignedDemandCount: number;
+            }>;
+        }>;
+    };
+};
 export type ListSprintsQueryVariables = Types.Exact<{
     workspaceId: Types.Scalars['ID']['input'];
     filter?: Types.InputMaybe<Types.PlanmagnetSprintFilter>;
@@ -4891,6 +5215,8 @@ export type ListDependenciesQuery = {
 export declare const BoardColumnFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const BoardFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const BoardSummaryFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const CustomerSatisfactionSummaryFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const CustomerSatisfactionResponseFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const MilestoneFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const MilestoneSummaryFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const PortfolioFieldsFragmentDoc: Apollo.DocumentNode;
@@ -5384,6 +5710,99 @@ export declare function useDeleteExpenseMutation(baseOptions?: ApolloReactHooks.
 export type DeleteExpenseMutationHookResult = ReturnType<typeof useDeleteExpenseMutation>;
 export type DeleteExpenseMutationResult = Apollo.MutationResult<Types.DeleteExpenseMutation>;
 export type DeleteExpenseMutationOptions = Apollo.BaseMutationOptions<Types.DeleteExpenseMutation, Types.DeleteExpenseMutationVariables>;
+export declare const CreateCustomerSatisfactionResponseDocument: Apollo.DocumentNode;
+export type CreateCustomerSatisfactionResponseMutationFn = Apollo.MutationFunction<Types.CreateCustomerSatisfactionResponseMutation, Types.CreateCustomerSatisfactionResponseMutationVariables>;
+/**
+ * __useCreateCustomerSatisfactionResponseMutation__
+ *
+ * To run a mutation, you first call `useCreateCustomerSatisfactionResponseMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateCustomerSatisfactionResponseMutation` 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 [createCustomerSatisfactionResponseMutation, { data, loading, error }] = useCreateCustomerSatisfactionResponseMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateCustomerSatisfactionResponseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateCustomerSatisfactionResponseMutation, Types.CreateCustomerSatisfactionResponseMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateCustomerSatisfactionResponseMutation, any, Apollo.ApolloCache>;
+export type CreateCustomerSatisfactionResponseMutationHookResult = ReturnType<typeof useCreateCustomerSatisfactionResponseMutation>;
+export type CreateCustomerSatisfactionResponseMutationResult = Apollo.MutationResult<Types.CreateCustomerSatisfactionResponseMutation>;
+export type CreateCustomerSatisfactionResponseMutationOptions = Apollo.BaseMutationOptions<Types.CreateCustomerSatisfactionResponseMutation, Types.CreateCustomerSatisfactionResponseMutationVariables>;
+export declare const UpdateCustomerSatisfactionResponseDocument: Apollo.DocumentNode;
+export type UpdateCustomerSatisfactionResponseMutationFn = Apollo.MutationFunction<Types.UpdateCustomerSatisfactionResponseMutation, Types.UpdateCustomerSatisfactionResponseMutationVariables>;
+/**
+ * __useUpdateCustomerSatisfactionResponseMutation__
+ *
+ * To run a mutation, you first call `useUpdateCustomerSatisfactionResponseMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateCustomerSatisfactionResponseMutation` 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 [updateCustomerSatisfactionResponseMutation, { data, loading, error }] = useUpdateCustomerSatisfactionResponseMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateCustomerSatisfactionResponseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateCustomerSatisfactionResponseMutation, Types.UpdateCustomerSatisfactionResponseMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateCustomerSatisfactionResponseMutation, any, Apollo.ApolloCache>;
+export type UpdateCustomerSatisfactionResponseMutationHookResult = ReturnType<typeof useUpdateCustomerSatisfactionResponseMutation>;
+export type UpdateCustomerSatisfactionResponseMutationResult = Apollo.MutationResult<Types.UpdateCustomerSatisfactionResponseMutation>;
+export type UpdateCustomerSatisfactionResponseMutationOptions = Apollo.BaseMutationOptions<Types.UpdateCustomerSatisfactionResponseMutation, Types.UpdateCustomerSatisfactionResponseMutationVariables>;
+export declare const DeleteCustomerSatisfactionResponseDocument: Apollo.DocumentNode;
+export type DeleteCustomerSatisfactionResponseMutationFn = Apollo.MutationFunction<Types.DeleteCustomerSatisfactionResponseMutation, Types.DeleteCustomerSatisfactionResponseMutationVariables>;
+/**
+ * __useDeleteCustomerSatisfactionResponseMutation__
+ *
+ * To run a mutation, you first call `useDeleteCustomerSatisfactionResponseMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteCustomerSatisfactionResponseMutation` 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 [deleteCustomerSatisfactionResponseMutation, { data, loading, error }] = useDeleteCustomerSatisfactionResponseMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useDeleteCustomerSatisfactionResponseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteCustomerSatisfactionResponseMutation, Types.DeleteCustomerSatisfactionResponseMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteCustomerSatisfactionResponseMutation, any, Apollo.ApolloCache>;
+export type DeleteCustomerSatisfactionResponseMutationHookResult = ReturnType<typeof useDeleteCustomerSatisfactionResponseMutation>;
+export type DeleteCustomerSatisfactionResponseMutationResult = Apollo.MutationResult<Types.DeleteCustomerSatisfactionResponseMutation>;
+export type DeleteCustomerSatisfactionResponseMutationOptions = Apollo.BaseMutationOptions<Types.DeleteCustomerSatisfactionResponseMutation, Types.DeleteCustomerSatisfactionResponseMutationVariables>;
+export declare const ImportCustomerSatisfactionResponsesDocument: Apollo.DocumentNode;
+export type ImportCustomerSatisfactionResponsesMutationFn = Apollo.MutationFunction<Types.ImportCustomerSatisfactionResponsesMutation, Types.ImportCustomerSatisfactionResponsesMutationVariables>;
+/**
+ * __useImportCustomerSatisfactionResponsesMutation__
+ *
+ * To run a mutation, you first call `useImportCustomerSatisfactionResponsesMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useImportCustomerSatisfactionResponsesMutation` 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 [importCustomerSatisfactionResponsesMutation, { data, loading, error }] = useImportCustomerSatisfactionResponsesMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useImportCustomerSatisfactionResponsesMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ImportCustomerSatisfactionResponsesMutation, Types.ImportCustomerSatisfactionResponsesMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ImportCustomerSatisfactionResponsesMutation, any, Apollo.ApolloCache>;
+export type ImportCustomerSatisfactionResponsesMutationHookResult = ReturnType<typeof useImportCustomerSatisfactionResponsesMutation>;
+export type ImportCustomerSatisfactionResponsesMutationResult = Apollo.MutationResult<Types.ImportCustomerSatisfactionResponsesMutation>;
+export type ImportCustomerSatisfactionResponsesMutationOptions = Apollo.BaseMutationOptions<Types.ImportCustomerSatisfactionResponsesMutation, Types.ImportCustomerSatisfactionResponsesMutationVariables>;
 export declare const CreateCustomFieldDefinitionDocument: Apollo.DocumentNode;
 export type CreateCustomFieldDefinitionMutationFn = Apollo.MutationFunction<Types.CreateCustomFieldDefinitionMutation, Types.CreateCustomFieldDefinitionMutationVariables>;
 /**
@@ -7855,6 +8274,100 @@ export type ListBudgetExpensesQueryHookResult = ReturnType<typeof useListBudgetE
 export type ListBudgetExpensesLazyQueryHookResult = ReturnType<typeof useListBudgetExpensesLazyQuery>;
 export type ListBudgetExpensesSuspenseQueryHookResult = ReturnType<typeof useListBudgetExpensesSuspenseQuery>;
 export type ListBudgetExpensesQueryResult = Apollo.QueryResult<Types.ListBudgetExpensesQuery, Types.ListBudgetExpensesQueryVariables>;
+export declare const CustomerSatisfactionSummaryDocument: Apollo.DocumentNode;
+/**
+ * __useCustomerSatisfactionSummaryQuery__
+ *
+ * To run a query within a React component, call `useCustomerSatisfactionSummaryQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCustomerSatisfactionSummaryQuery` 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 } = useCustomerSatisfactionSummaryQuery({
+ *   variables: {
+ *      workspaceId: // value for 'workspaceId'
+ *      filter: // value for 'filter'
+ *   },
+ * });
+ */
+export declare function useCustomerSatisfactionSummaryQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.CustomerSatisfactionSummaryQuery, Types.CustomerSatisfactionSummaryQueryVariables> & ({
+    variables: Types.CustomerSatisfactionSummaryQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.CustomerSatisfactionSummaryQuery, Types.CustomerSatisfactionSummaryQueryVariables, "empty" | "complete" | "streaming", Types.CustomerSatisfactionSummaryQueryVariables>;
+export declare function useCustomerSatisfactionSummaryLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.CustomerSatisfactionSummaryQuery, Types.CustomerSatisfactionSummaryQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.CustomerSatisfactionSummaryQuery, Types.CustomerSatisfactionSummaryQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useCustomerSatisfactionSummarySuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.CustomerSatisfactionSummaryQuery, Types.CustomerSatisfactionSummaryQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.CustomerSatisfactionSummaryQuery, Types.CustomerSatisfactionSummaryQueryVariables>;
+export declare function useCustomerSatisfactionSummarySuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.CustomerSatisfactionSummaryQuery, Types.CustomerSatisfactionSummaryQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.CustomerSatisfactionSummaryQuery | undefined, Types.CustomerSatisfactionSummaryQueryVariables>;
+export type CustomerSatisfactionSummaryQueryHookResult = ReturnType<typeof useCustomerSatisfactionSummaryQuery>;
+export type CustomerSatisfactionSummaryLazyQueryHookResult = ReturnType<typeof useCustomerSatisfactionSummaryLazyQuery>;
+export type CustomerSatisfactionSummarySuspenseQueryHookResult = ReturnType<typeof useCustomerSatisfactionSummarySuspenseQuery>;
+export type CustomerSatisfactionSummaryQueryResult = Apollo.QueryResult<Types.CustomerSatisfactionSummaryQuery, Types.CustomerSatisfactionSummaryQueryVariables>;
+export declare const CustomerSatisfactionResponsesDocument: Apollo.DocumentNode;
+/**
+ * __useCustomerSatisfactionResponsesQuery__
+ *
+ * To run a query within a React component, call `useCustomerSatisfactionResponsesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCustomerSatisfactionResponsesQuery` 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 } = useCustomerSatisfactionResponsesQuery({
+ *   variables: {
+ *      workspaceId: // value for 'workspaceId'
+ *      filter: // value for 'filter'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useCustomerSatisfactionResponsesQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.CustomerSatisfactionResponsesQuery, Types.CustomerSatisfactionResponsesQueryVariables> & ({
+    variables: Types.CustomerSatisfactionResponsesQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.CustomerSatisfactionResponsesQuery, Types.CustomerSatisfactionResponsesQueryVariables, "empty" | "complete" | "streaming", Types.CustomerSatisfactionResponsesQueryVariables>;
+export declare function useCustomerSatisfactionResponsesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.CustomerSatisfactionResponsesQuery, Types.CustomerSatisfactionResponsesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.CustomerSatisfactionResponsesQuery, Types.CustomerSatisfactionResponsesQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useCustomerSatisfactionResponsesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.CustomerSatisfactionResponsesQuery, Types.CustomerSatisfactionResponsesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.CustomerSatisfactionResponsesQuery, Types.CustomerSatisfactionResponsesQueryVariables>;
+export declare function useCustomerSatisfactionResponsesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.CustomerSatisfactionResponsesQuery, Types.CustomerSatisfactionResponsesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.CustomerSatisfactionResponsesQuery | undefined, Types.CustomerSatisfactionResponsesQueryVariables>;
+export type CustomerSatisfactionResponsesQueryHookResult = ReturnType<typeof useCustomerSatisfactionResponsesQuery>;
+export type CustomerSatisfactionResponsesLazyQueryHookResult = ReturnType<typeof useCustomerSatisfactionResponsesLazyQuery>;
+export type CustomerSatisfactionResponsesSuspenseQueryHookResult = ReturnType<typeof useCustomerSatisfactionResponsesSuspenseQuery>;
+export type CustomerSatisfactionResponsesQueryResult = Apollo.QueryResult<Types.CustomerSatisfactionResponsesQuery, Types.CustomerSatisfactionResponsesQueryVariables>;
+export declare const CustomerSatisfactionReleaseOptionsDocument: Apollo.DocumentNode;
+/**
+ * __useCustomerSatisfactionReleaseOptionsQuery__
+ *
+ * To run a query within a React component, call `useCustomerSatisfactionReleaseOptionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCustomerSatisfactionReleaseOptionsQuery` 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 } = useCustomerSatisfactionReleaseOptionsQuery({
+ *   variables: {
+ *      workspaceId: // value for 'workspaceId'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useCustomerSatisfactionReleaseOptionsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.CustomerSatisfactionReleaseOptionsQuery, Types.CustomerSatisfactionReleaseOptionsQueryVariables> & ({
+    variables: Types.CustomerSatisfactionReleaseOptionsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.CustomerSatisfactionReleaseOptionsQuery, Types.CustomerSatisfactionReleaseOptionsQueryVariables, "empty" | "complete" | "streaming", Types.CustomerSatisfactionReleaseOptionsQueryVariables>;
+export declare function useCustomerSatisfactionReleaseOptionsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.CustomerSatisfactionReleaseOptionsQuery, Types.CustomerSatisfactionReleaseOptionsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.CustomerSatisfactionReleaseOptionsQuery, Types.CustomerSatisfactionReleaseOptionsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useCustomerSatisfactionReleaseOptionsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.CustomerSatisfactionReleaseOptionsQuery, Types.CustomerSatisfactionReleaseOptionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.CustomerSatisfactionReleaseOptionsQuery, Types.CustomerSatisfactionReleaseOptionsQueryVariables>;
+export declare function useCustomerSatisfactionReleaseOptionsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.CustomerSatisfactionReleaseOptionsQuery, Types.CustomerSatisfactionReleaseOptionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.CustomerSatisfactionReleaseOptionsQuery | undefined, Types.CustomerSatisfactionReleaseOptionsQueryVariables>;
+export type CustomerSatisfactionReleaseOptionsQueryHookResult = ReturnType<typeof useCustomerSatisfactionReleaseOptionsQuery>;
+export type CustomerSatisfactionReleaseOptionsLazyQueryHookResult = ReturnType<typeof useCustomerSatisfactionReleaseOptionsLazyQuery>;
+export type CustomerSatisfactionReleaseOptionsSuspenseQueryHookResult = ReturnType<typeof useCustomerSatisfactionReleaseOptionsSuspenseQuery>;
+export type CustomerSatisfactionReleaseOptionsQueryResult = Apollo.QueryResult<Types.CustomerSatisfactionReleaseOptionsQuery, Types.CustomerSatisfactionReleaseOptionsQueryVariables>;
 export declare const ListCustomFieldDefinitionsDocument: Apollo.DocumentNode;
 /**
  * __useListCustomFieldDefinitionsQuery__
@@ -9129,6 +9642,67 @@ export type GetRiskMatrixQueryHookResult = ReturnType<typeof useGetRiskMatrixQue
 export type GetRiskMatrixLazyQueryHookResult = ReturnType<typeof useGetRiskMatrixLazyQuery>;
 export type GetRiskMatrixSuspenseQueryHookResult = ReturnType<typeof useGetRiskMatrixSuspenseQuery>;
 export type GetRiskMatrixQueryResult = Apollo.QueryResult<Types.GetRiskMatrixQuery, Types.GetRiskMatrixQueryVariables>;
+export declare const WorkItemRequiredSkillsDocument: Apollo.DocumentNode;
+/**
+ * __useWorkItemRequiredSkillsQuery__
+ *
+ * To run a query within a React component, call `useWorkItemRequiredSkillsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useWorkItemRequiredSkillsQuery` 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 } = useWorkItemRequiredSkillsQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useWorkItemRequiredSkillsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.WorkItemRequiredSkillsQuery, Types.WorkItemRequiredSkillsQueryVariables> & ({
+    variables: Types.WorkItemRequiredSkillsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.WorkItemRequiredSkillsQuery, Types.WorkItemRequiredSkillsQueryVariables, "empty" | "complete" | "streaming", Types.WorkItemRequiredSkillsQueryVariables>;
+export declare function useWorkItemRequiredSkillsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.WorkItemRequiredSkillsQuery, Types.WorkItemRequiredSkillsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.WorkItemRequiredSkillsQuery, Types.WorkItemRequiredSkillsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useWorkItemRequiredSkillsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.WorkItemRequiredSkillsQuery, Types.WorkItemRequiredSkillsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.WorkItemRequiredSkillsQuery, Types.WorkItemRequiredSkillsQueryVariables>;
+export declare function useWorkItemRequiredSkillsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.WorkItemRequiredSkillsQuery, Types.WorkItemRequiredSkillsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.WorkItemRequiredSkillsQuery | undefined, Types.WorkItemRequiredSkillsQueryVariables>;
+export type WorkItemRequiredSkillsQueryHookResult = ReturnType<typeof useWorkItemRequiredSkillsQuery>;
+export type WorkItemRequiredSkillsLazyQueryHookResult = ReturnType<typeof useWorkItemRequiredSkillsLazyQuery>;
+export type WorkItemRequiredSkillsSuspenseQueryHookResult = ReturnType<typeof useWorkItemRequiredSkillsSuspenseQuery>;
+export type WorkItemRequiredSkillsQueryResult = Apollo.QueryResult<Types.WorkItemRequiredSkillsQuery, Types.WorkItemRequiredSkillsQueryVariables>;
+export declare const SkillCoverageDocument: Apollo.DocumentNode;
+/**
+ * __useSkillCoverageQuery__
+ *
+ * To run a query within a React component, call `useSkillCoverageQuery` and pass it any options that fit your needs.
+ * When your component renders, `useSkillCoverageQuery` 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 } = useSkillCoverageQuery({
+ *   variables: {
+ *      workspaceId: // value for 'workspaceId'
+ *      filter: // value for 'filter'
+ *   },
+ * });
+ */
+export declare function useSkillCoverageQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.SkillCoverageQuery, Types.SkillCoverageQueryVariables> & ({
+    variables: Types.SkillCoverageQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.SkillCoverageQuery, Types.SkillCoverageQueryVariables, "empty" | "complete" | "streaming", Types.SkillCoverageQueryVariables>;
+export declare function useSkillCoverageLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.SkillCoverageQuery, Types.SkillCoverageQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.SkillCoverageQuery, Types.SkillCoverageQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useSkillCoverageSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.SkillCoverageQuery, Types.SkillCoverageQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.SkillCoverageQuery, Types.SkillCoverageQueryVariables>;
+export declare function useSkillCoverageSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.SkillCoverageQuery, Types.SkillCoverageQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.SkillCoverageQuery | undefined, Types.SkillCoverageQueryVariables>;
+export type SkillCoverageQueryHookResult = ReturnType<typeof useSkillCoverageQuery>;
+export type SkillCoverageLazyQueryHookResult = ReturnType<typeof useSkillCoverageLazyQuery>;
+export type SkillCoverageSuspenseQueryHookResult = ReturnType<typeof useSkillCoverageSuspenseQuery>;
+export type SkillCoverageQueryResult = Apollo.QueryResult<Types.SkillCoverageQuery, Types.SkillCoverageQueryVariables>;
 export declare const ListSprintsDocument: Apollo.DocumentNode;
 /**
  * __useListSprintsQuery__