@burdenoff/microfe-planmagnet 2026.1001.8 → 2026.1002.2

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

@@ -254,6 +254,28 @@ export type CompetitorFieldsFragment = {
     updatedAt: string;
     deletedAt?: string | null;
 };
+export type ProductLineFieldsFragment = {
+    __typename?: 'PlanmagnetProductLine';
+    id: string;
+    name: string;
+    description?: string | null;
+    ownerId?: string | null;
+    archivedAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+export type ProductFeatureFieldsFragment = {
+    __typename?: 'PlanmagnetProductFeature';
+    id: string;
+    productId: string;
+    name: string;
+    description?: string | null;
+    status: Types.PlanmagnetProductFeatureStatus;
+    ownerId?: string | null;
+    archivedAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
 export type ProjectFieldsFragment = {
     __typename?: 'PlanmagnetProject';
     id: string;
@@ -293,7 +315,7 @@ export type SprintFieldsFragment = {
     __typename?: 'Sprint';
     id: string;
     workspaceId: string;
-    projectId: string;
+    projectId?: string | null;
     name: string;
     goal?: string | null;
     status: Types.SprintStatus;
@@ -960,6 +982,212 @@ export type DeleteMilestoneMutation = {
     __typename?: 'Mutation';
     planmagnetDeleteMilestone: boolean;
 };
+export type CreateProductLineMutationVariables = Types.Exact<{
+    input: Types.PlanmagnetCreateProductLineInput;
+}>;
+export type CreateProductLineMutation = {
+    __typename?: 'Mutation';
+    planmagnetCreateProductLine: {
+        __typename?: 'PlanmagnetProductLine';
+        id: string;
+        name: string;
+        description?: string | null;
+        ownerId?: string | null;
+        archivedAt?: string | null;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type UpdateProductLineMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.PlanmagnetUpdateProductLineInput;
+}>;
+export type UpdateProductLineMutation = {
+    __typename?: 'Mutation';
+    planmagnetUpdateProductLine: {
+        __typename?: 'PlanmagnetProductLine';
+        id: string;
+        name: string;
+        description?: string | null;
+        ownerId?: string | null;
+        archivedAt?: string | null;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type ArchiveProductLineMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type ArchiveProductLineMutation = {
+    __typename?: 'Mutation';
+    planmagnetArchiveProductLine: {
+        __typename?: 'PlanmagnetProductLine';
+        id: string;
+        archivedAt?: string | null;
+    };
+};
+export type UnarchiveProductLineMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type UnarchiveProductLineMutation = {
+    __typename?: 'Mutation';
+    planmagnetUnarchiveProductLine: {
+        __typename?: 'PlanmagnetProductLine';
+        id: string;
+        archivedAt?: string | null;
+    };
+};
+export type DeleteProductLineMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type DeleteProductLineMutation = {
+    __typename?: 'Mutation';
+    planmagnetDeleteProductLine: boolean;
+};
+export type AssignProductLineMutationVariables = Types.Exact<{
+    productId: Types.Scalars['ID']['input'];
+    productLineId?: Types.InputMaybe<Types.Scalars['ID']['input']>;
+}>;
+export type AssignProductLineMutation = {
+    __typename?: 'Mutation';
+    planmagnetAssignProductLine: {
+        __typename?: 'Product';
+        id: string;
+        productLineId?: string | null;
+        productLine?: {
+            __typename?: 'PlanmagnetProductLine';
+            id: string;
+            name: string;
+            archivedAt?: string | null;
+        } | null;
+    };
+};
+export type LinkProductTeamMutationVariables = Types.Exact<{
+    productId: Types.Scalars['ID']['input'];
+    teamId: Types.Scalars['ID']['input'];
+}>;
+export type LinkProductTeamMutation = {
+    __typename?: 'Mutation';
+    planmagnetLinkProductTeam: {
+        __typename?: 'Product';
+        id: string;
+    };
+};
+export type UnlinkProductTeamMutationVariables = Types.Exact<{
+    productId: Types.Scalars['ID']['input'];
+    teamId: Types.Scalars['ID']['input'];
+}>;
+export type UnlinkProductTeamMutation = {
+    __typename?: 'Mutation';
+    planmagnetUnlinkProductTeam: boolean;
+};
+export type CreateProductFeatureMutationVariables = Types.Exact<{
+    input: Types.PlanmagnetCreateProductFeatureInput;
+}>;
+export type CreateProductFeatureMutation = {
+    __typename?: 'Mutation';
+    planmagnetCreateProductFeature: {
+        __typename?: 'PlanmagnetProductFeature';
+        id: string;
+        productId: string;
+        name: string;
+        description?: string | null;
+        status: Types.PlanmagnetProductFeatureStatus;
+        ownerId?: string | null;
+        archivedAt?: string | null;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type UpdateProductFeatureMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.PlanmagnetUpdateProductFeatureInput;
+}>;
+export type UpdateProductFeatureMutation = {
+    __typename?: 'Mutation';
+    planmagnetUpdateProductFeature: {
+        __typename?: 'PlanmagnetProductFeature';
+        id: string;
+        productId: string;
+        name: string;
+        description?: string | null;
+        status: Types.PlanmagnetProductFeatureStatus;
+        ownerId?: string | null;
+        archivedAt?: string | null;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type ArchiveProductFeatureMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type ArchiveProductFeatureMutation = {
+    __typename?: 'Mutation';
+    planmagnetArchiveProductFeature: {
+        __typename?: 'PlanmagnetProductFeature';
+        id: string;
+        archivedAt?: string | null;
+    };
+};
+export type UnarchiveProductFeatureMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type UnarchiveProductFeatureMutation = {
+    __typename?: 'Mutation';
+    planmagnetUnarchiveProductFeature: {
+        __typename?: 'PlanmagnetProductFeature';
+        id: string;
+        archivedAt?: string | null;
+    };
+};
+export type DeleteProductFeatureMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type DeleteProductFeatureMutation = {
+    __typename?: 'Mutation';
+    planmagnetDeleteProductFeature: boolean;
+};
+export type LinkFeatureRequestToProductFeatureMutationVariables = Types.Exact<{
+    featureRequestId: Types.Scalars['ID']['input'];
+    productFeatureId: Types.Scalars['ID']['input'];
+}>;
+export type LinkFeatureRequestToProductFeatureMutation = {
+    __typename?: 'Mutation';
+    planmagnetLinkFeatureRequestToProductFeature: {
+        __typename?: 'PlanmagnetProductFeature';
+        id: string;
+    };
+};
+export type UnlinkFeatureRequestFromProductFeatureMutationVariables = Types.Exact<{
+    featureRequestId: Types.Scalars['ID']['input'];
+    productFeatureId: Types.Scalars['ID']['input'];
+}>;
+export type UnlinkFeatureRequestFromProductFeatureMutation = {
+    __typename?: 'Mutation';
+    planmagnetUnlinkFeatureRequestFromProductFeature: {
+        __typename?: 'PlanmagnetProductFeature';
+        id: string;
+    };
+};
+export type LinkEpicToProductFeatureMutationVariables = Types.Exact<{
+    productFeatureId: Types.Scalars['ID']['input'];
+    workItemId: Types.Scalars['ID']['input'];
+}>;
+export type LinkEpicToProductFeatureMutation = {
+    __typename?: 'Mutation';
+    planmagnetLinkEpicToProductFeature: {
+        __typename?: 'PlanmagnetProductFeature';
+        id: string;
+    };
+};
+export type UnlinkEpicFromProductFeatureMutationVariables = Types.Exact<{
+    productFeatureId: Types.Scalars['ID']['input'];
+    workItemId: Types.Scalars['ID']['input'];
+}>;
+export type UnlinkEpicFromProductFeatureMutation = {
+    __typename?: 'Mutation';
+    planmagnetUnlinkEpicFromProductFeature: boolean;
+};
 export type CreateRoadmapMutationVariables = Types.Exact<{
     input: Types.PlanmagnetCreateRoadmapInput;
 }>;
@@ -1606,7 +1834,7 @@ export type CreateSprintMutation = {
         __typename?: 'Sprint';
         id: string;
         workspaceId: string;
-        projectId: string;
+        projectId?: string | null;
         name: string;
         goal?: string | null;
         status: Types.SprintStatus;
@@ -1633,7 +1861,7 @@ export type UpdateSprintMutation = {
         __typename?: 'Sprint';
         id: string;
         workspaceId: string;
-        projectId: string;
+        projectId?: string | null;
         name: string;
         goal?: string | null;
         status: Types.SprintStatus;
@@ -1666,7 +1894,7 @@ export type StartSprintMutation = {
         __typename?: 'Sprint';
         id: string;
         workspaceId: string;
-        projectId: string;
+        projectId?: string | null;
         name: string;
         goal?: string | null;
         status: Types.SprintStatus;
@@ -1692,7 +1920,7 @@ export type CompleteSprintMutation = {
         __typename?: 'Sprint';
         id: string;
         workspaceId: string;
-        projectId: string;
+        projectId?: string | null;
         name: string;
         goal?: string | null;
         status: Types.SprintStatus;
@@ -1718,7 +1946,7 @@ export type CancelSprintMutation = {
         __typename?: 'Sprint';
         id: string;
         workspaceId: string;
-        projectId: string;
+        projectId?: string | null;
         name: string;
         goal?: string | null;
         status: Types.SprintStatus;
@@ -1745,7 +1973,7 @@ export type AddWorkItemsToSprintMutation = {
         __typename?: 'Sprint';
         id: string;
         workspaceId: string;
-        projectId: string;
+        projectId?: string | null;
         name: string;
         goal?: string | null;
         status: Types.SprintStatus;
@@ -1786,7 +2014,7 @@ export type RemoveWorkItemsFromSprintMutation = {
         __typename?: 'Sprint';
         id: string;
         workspaceId: string;
-        projectId: string;
+        projectId?: string | null;
         name: string;
         goal?: string | null;
         status: Types.SprintStatus;
@@ -2910,7 +3138,7 @@ export type DashboardSprintsQuery = {
         totalCount: number;
         items: Array<{
             __typename?: 'Sprint';
-            projectId: string;
+            projectId?: string | null;
             id: string;
             name: string;
             status: Types.SprintStatus;
@@ -3141,148 +3369,408 @@ export type GetPortfolioOverviewQuery = {
         projectsByStatus: Record<string, unknown>;
     };
 };
-export type ListRoadmapsQueryVariables = Types.Exact<{
+export type ProductLinesPageQueryVariables = Types.Exact<{
     workspaceId: Types.Scalars['ID']['input'];
-    filter?: Types.InputMaybe<Types.PlanmagnetRoadmapFilter>;
-    pagination?: Types.InputMaybe<Types.PlanmagnetPaginationInput>;
+    filter?: Types.InputMaybe<Types.PlanmagnetProductLineFilter>;
 }>;
-export type ListRoadmapsQuery = {
+export type ProductLinesPageQuery = {
     __typename?: 'Query';
-    planmagnetRoadmaps: {
-        __typename?: 'PlanmagnetRoadmapList';
+    planmagnetProductLines: {
+        __typename?: 'PlanmagnetProductLineList';
         totalCount: number;
         items: Array<{
-            __typename?: 'Roadmap';
+            __typename?: 'PlanmagnetProductLine';
             id: string;
-            workspaceId: string;
             name: string;
             description?: string | null;
-            type: Types.RoadmapType;
-            isPublic: boolean;
-            ownerId: string;
-            metadata?: Record<string, unknown> | null;
-            createdBy: string;
+            ownerId?: string | null;
+            archivedAt?: string | null;
             createdAt: string;
             updatedAt: string;
-            updatedBy?: string | null;
-            deletedAt?: string | null;
+            products: Array<{
+                __typename?: 'Product';
+                id: string;
+                name: string;
+                archivedAt?: string | null;
+            }>;
         }>;
         pageInfo: {
             __typename?: 'PlanmagnetPageInfo';
             hasNextPage: boolean;
-            hasPreviousPage: boolean;
-            startCursor?: string | null;
-            endCursor?: string | null;
-            totalCount: number;
         };
     };
 };
-export type GetRoadmapQueryVariables = Types.Exact<{
-    id: Types.Scalars['ID']['input'];
+export type ProductLineOptionsQueryVariables = Types.Exact<{
+    workspaceId: Types.Scalars['ID']['input'];
 }>;
-export type GetRoadmapQuery = {
+export type ProductLineOptionsQuery = {
     __typename?: 'Query';
-    planmagnetRoadmap?: {
-        __typename?: 'Roadmap';
+    planmagnetProductLines: {
+        __typename?: 'PlanmagnetProductLineList';
+        totalCount: number;
+        items: Array<{
+            __typename?: 'PlanmagnetProductLine';
+            id: string;
+            name: string;
+        }>;
+    };
+};
+export type ProductLineAssignmentQueryVariables = Types.Exact<{
+    productId: Types.Scalars['ID']['input'];
+}>;
+export type ProductLineAssignmentQuery = {
+    __typename?: 'Query';
+    planmagnetProduct?: {
+        __typename?: 'Product';
         id: string;
-        workspaceId: string;
-        name: string;
-        description?: string | null;
-        type: Types.RoadmapType;
-        isPublic: boolean;
-        ownerId: string;
-        metadata?: Record<string, unknown> | null;
-        createdBy: string;
-        createdAt: string;
-        updatedAt: string;
-        updatedBy?: string | null;
-        deletedAt?: string | null;
+        productLineId?: string | null;
+        productLine?: {
+            __typename?: 'PlanmagnetProductLine';
+            id: string;
+            name: string;
+            archivedAt?: string | null;
+        } | null;
+    } | null;
+};
+export type ProductLineCandidateProductsQueryVariables = Types.Exact<{
+    workspaceId: Types.Scalars['ID']['input'];
+}>;
+export type ProductLineCandidateProductsQuery = {
+    __typename?: 'Query';
+    planmagnetProducts: {
+        __typename?: 'PlanmagnetProductList';
+        totalCount: number;
         items: Array<{
-            __typename?: 'RoadmapItem';
+            __typename?: 'Product';
             id: string;
-            roadmapId: string;
-            title: string;
+            name: string;
+            archivedAt?: string | null;
+            productLine?: {
+                __typename?: 'PlanmagnetProductLine';
+                id: string;
+                name: string;
+            } | null;
+        }>;
+    };
+};
+export type ProductTeamsQueryVariables = Types.Exact<{
+    productId: Types.Scalars['ID']['input'];
+}>;
+export type ProductTeamsQuery = {
+    __typename?: 'Query';
+    planmagnetProduct?: {
+        __typename?: 'Product';
+        id: string;
+        archivedAt?: string | null;
+        teams: Array<{
+            __typename?: 'Team';
+            id: string;
+            name: string;
             description?: string | null;
-            status: Types.RoadmapItemStatus;
-            startDate?: string | null;
-            endDate?: string | null;
-            color?: string | null;
-            swimlane?: string | null;
-            sortOrder: number;
-            projectId?: string | null;
-            milestoneId?: string | null;
-            workItemId?: string | null;
-            metadata?: Record<string, unknown> | null;
-            createdBy: string;
-            createdAt: string;
-            updatedAt: string;
+            members: Array<{
+                __typename?: 'TeamMember';
+                id: string;
+            }>;
         }>;
     } | null;
 };
-export type ListRoadmapItemsQueryVariables = Types.Exact<{
+export type ProductFeaturesListQueryVariables = Types.Exact<{
     workspaceId: Types.Scalars['ID']['input'];
-    filter?: Types.InputMaybe<Types.PlanmagnetRoadmapItemFilter>;
-    pagination?: Types.InputMaybe<Types.PlanmagnetPaginationInput>;
+    productId: Types.Scalars['ID']['input'];
+    filter?: Types.InputMaybe<Types.PlanmagnetProductFeatureFilter>;
 }>;
-export type ListRoadmapItemsQuery = {
+export type ProductFeaturesListQuery = {
     __typename?: 'Query';
-    planmagnetRoadmapItems: {
-        __typename?: 'PlanmagnetRoadmapItemList';
+    planmagnetProductFeatures: {
+        __typename?: 'PlanmagnetProductFeatureList';
         totalCount: number;
         items: Array<{
-            __typename?: 'RoadmapItem';
+            __typename?: 'PlanmagnetProductFeature';
             id: string;
-            roadmapId: string;
-            title: string;
+            productId: string;
+            name: string;
             description?: string | null;
-            status: Types.RoadmapItemStatus;
-            startDate?: string | null;
-            endDate?: string | null;
-            color?: string | null;
-            swimlane?: string | null;
-            sortOrder: number;
-            projectId?: string | null;
-            milestoneId?: string | null;
-            workItemId?: string | null;
-            metadata?: Record<string, unknown> | null;
-            createdBy: string;
+            status: Types.PlanmagnetProductFeatureStatus;
+            ownerId?: string | null;
+            archivedAt?: string | null;
             createdAt: string;
             updatedAt: string;
+            epics: Array<{
+                __typename?: 'WorkItem';
+                id: string;
+            }>;
+            featureRequests: Array<{
+                __typename?: 'FeatureRequest';
+                id: string;
+            }>;
         }>;
         pageInfo: {
             __typename?: 'PlanmagnetPageInfo';
             hasNextPage: boolean;
-            hasPreviousPage: boolean;
-            startCursor?: string | null;
-            endCursor?: string | null;
-            totalCount: number;
         };
     };
 };
-export type ListReleasesQueryVariables = Types.Exact<{
+export type ProductFeatureDetailQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type ProductFeatureDetailQuery = {
+    __typename?: 'Query';
+    planmagnetProductFeature?: {
+        __typename?: 'PlanmagnetProductFeature';
+        id: string;
+        productId: string;
+        name: string;
+        description?: string | null;
+        status: Types.PlanmagnetProductFeatureStatus;
+        ownerId?: string | null;
+        archivedAt?: string | null;
+        createdAt: string;
+        updatedAt: string;
+        product?: {
+            __typename?: 'Product';
+            id: string;
+            name: string;
+            archivedAt?: string | null;
+            productLine?: {
+                __typename?: 'PlanmagnetProductLine';
+                id: string;
+                name: string;
+            } | null;
+        } | null;
+        epics: Array<{
+            __typename?: 'WorkItem';
+            id: string;
+            key: string;
+            title: string;
+            type: Types.WorkItemType;
+            status: Types.WorkItemStatus;
+            children: Array<{
+                __typename?: 'WorkItem';
+                id: string;
+                key: string;
+                title: string;
+                type: Types.WorkItemType;
+                status: Types.WorkItemStatus;
+            }>;
+        }>;
+        featureRequests: Array<{
+            __typename?: 'FeatureRequest';
+            id: string;
+            title: string;
+            status: Types.FeatureRequestStatus;
+            voteCount: number;
+            productId?: string | null;
+        }>;
+    } | null;
+};
+export type ProductFeatureEpicCandidatesQueryVariables = Types.Exact<{
     workspaceId: Types.Scalars['ID']['input'];
-    filter?: Types.InputMaybe<Types.PlanmagnetReleaseFilter>;
+    filter?: Types.InputMaybe<Types.PlanmagnetWorkItemFilter>;
+}>;
+export type ProductFeatureEpicCandidatesQuery = {
+    __typename?: 'Query';
+    planmagnetWorkItems: {
+        __typename?: 'PlanmagnetWorkItemList';
+        totalCount: number;
+        items: Array<{
+            __typename?: 'WorkItem';
+            id: string;
+            key: string;
+            title: string;
+            type: Types.WorkItemType;
+            productFeature?: {
+                __typename?: 'PlanmagnetProductFeature';
+                id: string;
+                name: string;
+            } | null;
+        }>;
+    };
+};
+export type ProductFeatureRequestCandidatesQueryVariables = Types.Exact<{
+    workspaceId: Types.Scalars['ID']['input'];
+    sameProduct: Types.PlanmagnetFeatureRequestFilter;
+    anyProduct?: Types.InputMaybe<Types.PlanmagnetFeatureRequestFilter>;
+}>;
+export type ProductFeatureRequestCandidatesQuery = {
+    __typename?: 'Query';
+    sameProduct: {
+        __typename?: 'PlanmagnetFeatureRequestList';
+        totalCount: number;
+        items: Array<{
+            __typename?: 'FeatureRequest';
+            id: string;
+            title: string;
+            status: Types.FeatureRequestStatus;
+            productId?: string | null;
+            productFeature?: {
+                __typename?: 'PlanmagnetProductFeature';
+                id: string;
+                name: string;
+            } | null;
+        }>;
+    };
+    anyProduct: {
+        __typename?: 'PlanmagnetFeatureRequestList';
+        totalCount: number;
+        items: Array<{
+            __typename?: 'FeatureRequest';
+            id: string;
+            title: string;
+            status: Types.FeatureRequestStatus;
+            productId?: string | null;
+            productFeature?: {
+                __typename?: 'PlanmagnetProductFeature';
+                id: string;
+                name: string;
+            } | null;
+        }>;
+    };
+};
+export type ProductHierarchyQueryVariables = Types.Exact<{
+    workspaceId: Types.Scalars['ID']['input'];
+    lineFilter?: Types.InputMaybe<Types.PlanmagnetProductLineFilter>;
+    productFilter?: Types.InputMaybe<Types.PlanmagnetProductFilter>;
+    includeArchivedFeatures?: Types.InputMaybe<Types.Scalars['Boolean']['input']>;
+}>;
+export type ProductHierarchyQuery = {
+    __typename?: 'Query';
+    planmagnetProductLines: {
+        __typename?: 'PlanmagnetProductLineList';
+        totalCount: number;
+        items: Array<{
+            __typename?: 'PlanmagnetProductLine';
+            id: string;
+            name: string;
+            archivedAt?: string | null;
+        }>;
+    };
+    planmagnetProducts: {
+        __typename?: 'PlanmagnetProductList';
+        totalCount: number;
+        items: Array<{
+            __typename?: 'Product';
+            id: string;
+            name: string;
+            lifecycleStage: Types.PlanmagnetProductLifecycleStage;
+            archivedAt?: string | null;
+            productLine?: {
+                __typename?: 'PlanmagnetProductLine';
+                id: string;
+                name: string;
+                archivedAt?: string | null;
+            } | null;
+            features: Array<{
+                __typename?: 'PlanmagnetProductFeature';
+                id: string;
+                name: string;
+                status: Types.PlanmagnetProductFeatureStatus;
+                archivedAt?: string | null;
+                epics: Array<{
+                    __typename?: 'WorkItem';
+                    id: string;
+                    key: string;
+                    title: string;
+                    type: Types.WorkItemType;
+                    status: Types.WorkItemStatus;
+                    children: Array<{
+                        __typename?: 'WorkItem';
+                        id: string;
+                        key: string;
+                        title: string;
+                        type: Types.WorkItemType;
+                        status: Types.WorkItemStatus;
+                    }>;
+                }>;
+            }>;
+        }>;
+    };
+};
+export type FeatureRequestProductFeatureQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type FeatureRequestProductFeatureQuery = {
+    __typename?: 'Query';
+    planmagnetFeatureRequest?: {
+        __typename?: 'FeatureRequest';
+        id: string;
+        productId?: string | null;
+        productFeature?: {
+            __typename?: 'PlanmagnetProductFeature';
+            id: string;
+            name: string;
+            status: Types.PlanmagnetProductFeatureStatus;
+            archivedAt?: string | null;
+            product?: {
+                __typename?: 'Product';
+                id: string;
+                name: string;
+            } | null;
+        } | null;
+    } | null;
+};
+export type FeatureRequestFeatureOptionsQueryVariables = Types.Exact<{
+    workspaceId: Types.Scalars['ID']['input'];
+    productId: Types.Scalars['ID']['input'];
+}>;
+export type FeatureRequestFeatureOptionsQuery = {
+    __typename?: 'Query';
+    planmagnetProductFeatures: {
+        __typename?: 'PlanmagnetProductFeatureList';
+        totalCount: number;
+        items: Array<{
+            __typename?: 'PlanmagnetProductFeature';
+            id: string;
+            name: string;
+            status: Types.PlanmagnetProductFeatureStatus;
+        }>;
+    };
+};
+export type WorkItemProductFeatureQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type WorkItemProductFeatureQuery = {
+    __typename?: 'Query';
+    planmagnetWorkItem?: {
+        __typename?: 'WorkItem';
+        id: string;
+        type: Types.WorkItemType;
+        productFeature?: {
+            __typename?: 'PlanmagnetProductFeature';
+            id: string;
+            name: string;
+        } | null;
+        parent?: {
+            __typename?: 'WorkItem';
+            id: string;
+            key: string;
+            type: Types.WorkItemType;
+            productFeature?: {
+                __typename?: 'PlanmagnetProductFeature';
+                id: string;
+                name: string;
+            } | null;
+        } | null;
+    } | null;
+};
+export type ListRoadmapsQueryVariables = Types.Exact<{
+    workspaceId: Types.Scalars['ID']['input'];
+    filter?: Types.InputMaybe<Types.PlanmagnetRoadmapFilter>;
     pagination?: Types.InputMaybe<Types.PlanmagnetPaginationInput>;
 }>;
-export type ListReleasesQuery = {
+export type ListRoadmapsQuery = {
     __typename?: 'Query';
-    planmagnetReleases: {
-        __typename?: 'PlanmagnetReleaseList';
+    planmagnetRoadmaps: {
+        __typename?: 'PlanmagnetRoadmapList';
         totalCount: number;
         items: Array<{
-            __typename?: 'Release';
+            __typename?: 'Roadmap';
             id: string;
             workspaceId: string;
-            projectId: string;
             name: string;
             description?: string | null;
-            version: string;
-            status: Types.ReleaseStatus;
-            plannedDate?: string | null;
-            releasedAt?: string | null;
-            releaseNotes?: string | null;
-            ownerId?: string | null;
-            tags: Array<string>;
+            type: Types.RoadmapType;
+            isPublic: boolean;
+            ownerId: string;
             metadata?: Record<string, unknown> | null;
             createdBy: string;
             createdAt: string;
@@ -3300,78 +3788,77 @@ export type ListReleasesQuery = {
         };
     };
 };
-export type GetReleaseQueryVariables = Types.Exact<{
+export type GetRoadmapQueryVariables = Types.Exact<{
     id: Types.Scalars['ID']['input'];
 }>;
-export type GetReleaseQuery = {
+export type GetRoadmapQuery = {
     __typename?: 'Query';
-    planmagnetRelease?: {
-        __typename?: 'Release';
+    planmagnetRoadmap?: {
+        __typename?: 'Roadmap';
         id: string;
         workspaceId: string;
-        projectId: string;
         name: string;
         description?: string | null;
-        version: string;
-        status: Types.ReleaseStatus;
-        plannedDate?: string | null;
-        releasedAt?: string | null;
-        releaseNotes?: string | null;
-        ownerId?: string | null;
-        tags: Array<string>;
+        type: Types.RoadmapType;
+        isPublic: boolean;
+        ownerId: string;
         metadata?: Record<string, unknown> | null;
         createdBy: string;
         createdAt: string;
         updatedAt: string;
         updatedBy?: string | null;
         deletedAt?: string | null;
-        workItems: Array<{
-            __typename?: 'WorkItem';
+        items: Array<{
+            __typename?: 'RoadmapItem';
             id: string;
-            key: string;
+            roadmapId: string;
             title: string;
-            type: Types.WorkItemType;
-            status: Types.WorkItemStatus;
-            priority: Types.WorkItemPriority;
-            assigneeId?: string | null;
-            sprintId?: string | null;
-            storyPoints?: number | null;
-            dueDate?: string | null;
-            labels: Array<string>;
+            description?: string | null;
+            status: Types.RoadmapItemStatus;
+            startDate?: string | null;
+            endDate?: string | null;
+            color?: string | null;
+            swimlane?: string | null;
+            sortOrder: number;
+            projectId?: string | null;
+            milestoneId?: string | null;
+            workItemId?: string | null;
+            metadata?: Record<string, unknown> | null;
+            createdBy: string;
+            createdAt: string;
+            updatedAt: string;
         }>;
     } | null;
 };
-export type ListFeatureRequestsQueryVariables = Types.Exact<{
+export type ListRoadmapItemsQueryVariables = Types.Exact<{
     workspaceId: Types.Scalars['ID']['input'];
-    filter?: Types.InputMaybe<Types.PlanmagnetFeatureRequestFilter>;
+    filter?: Types.InputMaybe<Types.PlanmagnetRoadmapItemFilter>;
     pagination?: Types.InputMaybe<Types.PlanmagnetPaginationInput>;
 }>;
-export type ListFeatureRequestsQuery = {
+export type ListRoadmapItemsQuery = {
     __typename?: 'Query';
-    planmagnetFeatureRequests: {
-        __typename?: 'PlanmagnetFeatureRequestList';
+    planmagnetRoadmapItems: {
+        __typename?: 'PlanmagnetRoadmapItemList';
         totalCount: number;
         items: Array<{
-            __typename?: 'FeatureRequest';
+            __typename?: 'RoadmapItem';
             id: string;
-            workspaceId: string;
-            projectId?: string | null;
+            roadmapId: string;
             title: string;
             description?: string | null;
-            status: Types.FeatureRequestStatus;
-            businessValue?: number | null;
-            effortEstimate?: string | null;
-            priorityScore?: number | null;
-            voteCount: number;
-            submittedBy: string;
+            status: Types.RoadmapItemStatus;
+            startDate?: string | null;
+            endDate?: string | null;
+            color?: string | null;
+            swimlane?: string | null;
+            sortOrder: number;
+            projectId?: string | null;
+            milestoneId?: string | null;
             workItemId?: string | null;
-            tags: Array<string>;
             metadata?: Record<string, unknown> | null;
             createdBy: string;
             createdAt: string;
             updatedAt: string;
-            updatedBy?: string | null;
-            deletedAt?: string | null;
         }>;
         pageInfo: {
             __typename?: 'PlanmagnetPageInfo';
@@ -3383,8 +3870,132 @@ export type ListFeatureRequestsQuery = {
         };
     };
 };
-export type GetFeatureRequestQueryVariables = Types.Exact<{
-    id: Types.Scalars['ID']['input'];
+export type ListReleasesQueryVariables = Types.Exact<{
+    workspaceId: Types.Scalars['ID']['input'];
+    filter?: Types.InputMaybe<Types.PlanmagnetReleaseFilter>;
+    pagination?: Types.InputMaybe<Types.PlanmagnetPaginationInput>;
+}>;
+export type ListReleasesQuery = {
+    __typename?: 'Query';
+    planmagnetReleases: {
+        __typename?: 'PlanmagnetReleaseList';
+        totalCount: number;
+        items: Array<{
+            __typename?: 'Release';
+            id: string;
+            workspaceId: string;
+            projectId: string;
+            name: string;
+            description?: string | null;
+            version: string;
+            status: Types.ReleaseStatus;
+            plannedDate?: string | null;
+            releasedAt?: string | null;
+            releaseNotes?: string | null;
+            ownerId?: string | null;
+            tags: Array<string>;
+            metadata?: Record<string, unknown> | null;
+            createdBy: string;
+            createdAt: string;
+            updatedAt: string;
+            updatedBy?: string | null;
+            deletedAt?: string | null;
+        }>;
+        pageInfo: {
+            __typename?: 'PlanmagnetPageInfo';
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            startCursor?: string | null;
+            endCursor?: string | null;
+            totalCount: number;
+        };
+    };
+};
+export type GetReleaseQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetReleaseQuery = {
+    __typename?: 'Query';
+    planmagnetRelease?: {
+        __typename?: 'Release';
+        id: string;
+        workspaceId: string;
+        projectId: string;
+        name: string;
+        description?: string | null;
+        version: string;
+        status: Types.ReleaseStatus;
+        plannedDate?: string | null;
+        releasedAt?: string | null;
+        releaseNotes?: string | null;
+        ownerId?: string | null;
+        tags: Array<string>;
+        metadata?: Record<string, unknown> | null;
+        createdBy: string;
+        createdAt: string;
+        updatedAt: string;
+        updatedBy?: string | null;
+        deletedAt?: string | null;
+        workItems: Array<{
+            __typename?: 'WorkItem';
+            id: string;
+            key: string;
+            title: string;
+            type: Types.WorkItemType;
+            status: Types.WorkItemStatus;
+            priority: Types.WorkItemPriority;
+            assigneeId?: string | null;
+            sprintId?: string | null;
+            storyPoints?: number | null;
+            dueDate?: string | null;
+            labels: Array<string>;
+        }>;
+    } | null;
+};
+export type ListFeatureRequestsQueryVariables = Types.Exact<{
+    workspaceId: Types.Scalars['ID']['input'];
+    filter?: Types.InputMaybe<Types.PlanmagnetFeatureRequestFilter>;
+    pagination?: Types.InputMaybe<Types.PlanmagnetPaginationInput>;
+}>;
+export type ListFeatureRequestsQuery = {
+    __typename?: 'Query';
+    planmagnetFeatureRequests: {
+        __typename?: 'PlanmagnetFeatureRequestList';
+        totalCount: number;
+        items: Array<{
+            __typename?: 'FeatureRequest';
+            id: string;
+            workspaceId: string;
+            projectId?: string | null;
+            title: string;
+            description?: string | null;
+            status: Types.FeatureRequestStatus;
+            businessValue?: number | null;
+            effortEstimate?: string | null;
+            priorityScore?: number | null;
+            voteCount: number;
+            submittedBy: string;
+            workItemId?: string | null;
+            tags: Array<string>;
+            metadata?: Record<string, unknown> | null;
+            createdBy: string;
+            createdAt: string;
+            updatedAt: string;
+            updatedBy?: string | null;
+            deletedAt?: string | null;
+        }>;
+        pageInfo: {
+            __typename?: 'PlanmagnetPageInfo';
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+            startCursor?: string | null;
+            endCursor?: string | null;
+            totalCount: number;
+        };
+    };
+};
+export type GetFeatureRequestQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
 }>;
 export type GetFeatureRequestQuery = {
     __typename?: 'Query';
@@ -3733,7 +4344,7 @@ export type GetSprintQuery = {
         __typename?: 'Sprint';
         id: string;
         workspaceId: string;
-        projectId: string;
+        projectId?: string | null;
         name: string;
         goal?: string | null;
         status: Types.SprintStatus;
@@ -4293,6 +4904,8 @@ export declare const ReleaseFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const FeatureRequestFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const FeatureVoteFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const CompetitorFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const ProductLineFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const ProductFeatureFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const ProjectFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const ProjectSummaryFieldsFragmentDoc: Apollo.DocumentNode;
 export declare const SprintFieldsFragmentDoc: Apollo.DocumentNode;
@@ -4409,555 +5022,955 @@ export type ExecuteAutomationRuleMutationFn = Apollo.MutationFunction<Types.Exec
  * @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 [executeAutomationRuleMutation, { data, loading, error }] = useExecuteAutomationRuleMutation({
+ * const [executeAutomationRuleMutation, { data, loading, error }] = useExecuteAutomationRuleMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      triggerData: // value for 'triggerData'
+ *   },
+ * });
+ */
+export declare function useExecuteAutomationRuleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ExecuteAutomationRuleMutation, Types.ExecuteAutomationRuleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ExecuteAutomationRuleMutation, any, Apollo.ApolloCache>;
+export type ExecuteAutomationRuleMutationHookResult = ReturnType<typeof useExecuteAutomationRuleMutation>;
+export type ExecuteAutomationRuleMutationResult = Apollo.MutationResult<Types.ExecuteAutomationRuleMutation>;
+export type ExecuteAutomationRuleMutationOptions = Apollo.BaseMutationOptions<Types.ExecuteAutomationRuleMutation, Types.ExecuteAutomationRuleMutationVariables>;
+export declare const CreateBoardDocument: Apollo.DocumentNode;
+export type CreateBoardMutationFn = Apollo.MutationFunction<Types.CreateBoardMutation, Types.CreateBoardMutationVariables>;
+/**
+ * __useCreateBoardMutation__
+ *
+ * To run a mutation, you first call `useCreateBoardMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateBoardMutation` 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 [createBoardMutation, { data, loading, error }] = useCreateBoardMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateBoardMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateBoardMutation, Types.CreateBoardMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateBoardMutation, any, Apollo.ApolloCache>;
+export type CreateBoardMutationHookResult = ReturnType<typeof useCreateBoardMutation>;
+export type CreateBoardMutationResult = Apollo.MutationResult<Types.CreateBoardMutation>;
+export type CreateBoardMutationOptions = Apollo.BaseMutationOptions<Types.CreateBoardMutation, Types.CreateBoardMutationVariables>;
+export declare const UpdateBoardDocument: Apollo.DocumentNode;
+export type UpdateBoardMutationFn = Apollo.MutationFunction<Types.UpdateBoardMutation, Types.UpdateBoardMutationVariables>;
+/**
+ * __useUpdateBoardMutation__
+ *
+ * To run a mutation, you first call `useUpdateBoardMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateBoardMutation` 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 [updateBoardMutation, { data, loading, error }] = useUpdateBoardMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateBoardMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateBoardMutation, Types.UpdateBoardMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateBoardMutation, any, Apollo.ApolloCache>;
+export type UpdateBoardMutationHookResult = ReturnType<typeof useUpdateBoardMutation>;
+export type UpdateBoardMutationResult = Apollo.MutationResult<Types.UpdateBoardMutation>;
+export type UpdateBoardMutationOptions = Apollo.BaseMutationOptions<Types.UpdateBoardMutation, Types.UpdateBoardMutationVariables>;
+export declare const DeleteBoardDocument: Apollo.DocumentNode;
+export type DeleteBoardMutationFn = Apollo.MutationFunction<Types.DeleteBoardMutation, Types.DeleteBoardMutationVariables>;
+/**
+ * __useDeleteBoardMutation__
+ *
+ * To run a mutation, you first call `useDeleteBoardMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteBoardMutation` 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 [deleteBoardMutation, { data, loading, error }] = useDeleteBoardMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useDeleteBoardMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteBoardMutation, Types.DeleteBoardMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteBoardMutation, any, Apollo.ApolloCache>;
+export type DeleteBoardMutationHookResult = ReturnType<typeof useDeleteBoardMutation>;
+export type DeleteBoardMutationResult = Apollo.MutationResult<Types.DeleteBoardMutation>;
+export type DeleteBoardMutationOptions = Apollo.BaseMutationOptions<Types.DeleteBoardMutation, Types.DeleteBoardMutationVariables>;
+export declare const CreateBoardColumnDocument: Apollo.DocumentNode;
+export type CreateBoardColumnMutationFn = Apollo.MutationFunction<Types.CreateBoardColumnMutation, Types.CreateBoardColumnMutationVariables>;
+/**
+ * __useCreateBoardColumnMutation__
+ *
+ * To run a mutation, you first call `useCreateBoardColumnMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateBoardColumnMutation` 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 [createBoardColumnMutation, { data, loading, error }] = useCreateBoardColumnMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateBoardColumnMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateBoardColumnMutation, Types.CreateBoardColumnMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateBoardColumnMutation, any, Apollo.ApolloCache>;
+export type CreateBoardColumnMutationHookResult = ReturnType<typeof useCreateBoardColumnMutation>;
+export type CreateBoardColumnMutationResult = Apollo.MutationResult<Types.CreateBoardColumnMutation>;
+export type CreateBoardColumnMutationOptions = Apollo.BaseMutationOptions<Types.CreateBoardColumnMutation, Types.CreateBoardColumnMutationVariables>;
+export declare const UpdateBoardColumnDocument: Apollo.DocumentNode;
+export type UpdateBoardColumnMutationFn = Apollo.MutationFunction<Types.UpdateBoardColumnMutation, Types.UpdateBoardColumnMutationVariables>;
+/**
+ * __useUpdateBoardColumnMutation__
+ *
+ * To run a mutation, you first call `useUpdateBoardColumnMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateBoardColumnMutation` 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 [updateBoardColumnMutation, { data, loading, error }] = useUpdateBoardColumnMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateBoardColumnMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateBoardColumnMutation, Types.UpdateBoardColumnMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateBoardColumnMutation, any, Apollo.ApolloCache>;
+export type UpdateBoardColumnMutationHookResult = ReturnType<typeof useUpdateBoardColumnMutation>;
+export type UpdateBoardColumnMutationResult = Apollo.MutationResult<Types.UpdateBoardColumnMutation>;
+export type UpdateBoardColumnMutationOptions = Apollo.BaseMutationOptions<Types.UpdateBoardColumnMutation, Types.UpdateBoardColumnMutationVariables>;
+export declare const DeleteBoardColumnDocument: Apollo.DocumentNode;
+export type DeleteBoardColumnMutationFn = Apollo.MutationFunction<Types.DeleteBoardColumnMutation, Types.DeleteBoardColumnMutationVariables>;
+/**
+ * __useDeleteBoardColumnMutation__
+ *
+ * To run a mutation, you first call `useDeleteBoardColumnMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteBoardColumnMutation` 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 [deleteBoardColumnMutation, { data, loading, error }] = useDeleteBoardColumnMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useDeleteBoardColumnMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteBoardColumnMutation, Types.DeleteBoardColumnMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteBoardColumnMutation, any, Apollo.ApolloCache>;
+export type DeleteBoardColumnMutationHookResult = ReturnType<typeof useDeleteBoardColumnMutation>;
+export type DeleteBoardColumnMutationResult = Apollo.MutationResult<Types.DeleteBoardColumnMutation>;
+export type DeleteBoardColumnMutationOptions = Apollo.BaseMutationOptions<Types.DeleteBoardColumnMutation, Types.DeleteBoardColumnMutationVariables>;
+export declare const ReorderColumnsDocument: Apollo.DocumentNode;
+export type ReorderColumnsMutationFn = Apollo.MutationFunction<Types.ReorderColumnsMutation, Types.ReorderColumnsMutationVariables>;
+/**
+ * __useReorderColumnsMutation__
+ *
+ * To run a mutation, you first call `useReorderColumnsMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useReorderColumnsMutation` 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 [reorderColumnsMutation, { data, loading, error }] = useReorderColumnsMutation({
+ *   variables: {
+ *      boardId: // value for 'boardId'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useReorderColumnsMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ReorderColumnsMutation, Types.ReorderColumnsMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ReorderColumnsMutation, any, Apollo.ApolloCache>;
+export type ReorderColumnsMutationHookResult = ReturnType<typeof useReorderColumnsMutation>;
+export type ReorderColumnsMutationResult = Apollo.MutationResult<Types.ReorderColumnsMutation>;
+export type ReorderColumnsMutationOptions = Apollo.BaseMutationOptions<Types.ReorderColumnsMutation, Types.ReorderColumnsMutationVariables>;
+export declare const MoveCardDocument: Apollo.DocumentNode;
+export type MoveCardMutationFn = Apollo.MutationFunction<Types.MoveCardMutation, Types.MoveCardMutationVariables>;
+/**
+ * __useMoveCardMutation__
+ *
+ * To run a mutation, you first call `useMoveCardMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useMoveCardMutation` 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 [moveCardMutation, { data, loading, error }] = useMoveCardMutation({
+ *   variables: {
+ *      boardId: // value for 'boardId'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useMoveCardMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.MoveCardMutation, Types.MoveCardMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.MoveCardMutation, any, Apollo.ApolloCache>;
+export type MoveCardMutationHookResult = ReturnType<typeof useMoveCardMutation>;
+export type MoveCardMutationResult = Apollo.MutationResult<Types.MoveCardMutation>;
+export type MoveCardMutationOptions = Apollo.BaseMutationOptions<Types.MoveCardMutation, Types.MoveCardMutationVariables>;
+export declare const CreateBudgetDocument: Apollo.DocumentNode;
+export type CreateBudgetMutationFn = Apollo.MutationFunction<Types.CreateBudgetMutation, Types.CreateBudgetMutationVariables>;
+/**
+ * __useCreateBudgetMutation__
+ *
+ * To run a mutation, you first call `useCreateBudgetMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateBudgetMutation` 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 [createBudgetMutation, { data, loading, error }] = useCreateBudgetMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateBudgetMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateBudgetMutation, Types.CreateBudgetMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateBudgetMutation, any, Apollo.ApolloCache>;
+export type CreateBudgetMutationHookResult = ReturnType<typeof useCreateBudgetMutation>;
+export type CreateBudgetMutationResult = Apollo.MutationResult<Types.CreateBudgetMutation>;
+export type CreateBudgetMutationOptions = Apollo.BaseMutationOptions<Types.CreateBudgetMutation, Types.CreateBudgetMutationVariables>;
+export declare const UpdateBudgetDocument: Apollo.DocumentNode;
+export type UpdateBudgetMutationFn = Apollo.MutationFunction<Types.UpdateBudgetMutation, Types.UpdateBudgetMutationVariables>;
+/**
+ * __useUpdateBudgetMutation__
+ *
+ * To run a mutation, you first call `useUpdateBudgetMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateBudgetMutation` 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 [updateBudgetMutation, { data, loading, error }] = useUpdateBudgetMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateBudgetMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateBudgetMutation, Types.UpdateBudgetMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateBudgetMutation, any, Apollo.ApolloCache>;
+export type UpdateBudgetMutationHookResult = ReturnType<typeof useUpdateBudgetMutation>;
+export type UpdateBudgetMutationResult = Apollo.MutationResult<Types.UpdateBudgetMutation>;
+export type UpdateBudgetMutationOptions = Apollo.BaseMutationOptions<Types.UpdateBudgetMutation, Types.UpdateBudgetMutationVariables>;
+export declare const DeleteBudgetDocument: Apollo.DocumentNode;
+export type DeleteBudgetMutationFn = Apollo.MutationFunction<Types.DeleteBudgetMutation, Types.DeleteBudgetMutationVariables>;
+/**
+ * __useDeleteBudgetMutation__
+ *
+ * To run a mutation, you first call `useDeleteBudgetMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteBudgetMutation` 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 [deleteBudgetMutation, { data, loading, error }] = useDeleteBudgetMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useDeleteBudgetMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteBudgetMutation, Types.DeleteBudgetMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteBudgetMutation, any, Apollo.ApolloCache>;
+export type DeleteBudgetMutationHookResult = ReturnType<typeof useDeleteBudgetMutation>;
+export type DeleteBudgetMutationResult = Apollo.MutationResult<Types.DeleteBudgetMutation>;
+export type DeleteBudgetMutationOptions = Apollo.BaseMutationOptions<Types.DeleteBudgetMutation, Types.DeleteBudgetMutationVariables>;
+export declare const ApproveBudgetDocument: Apollo.DocumentNode;
+export type ApproveBudgetMutationFn = Apollo.MutationFunction<Types.ApproveBudgetMutation, Types.ApproveBudgetMutationVariables>;
+/**
+ * __useApproveBudgetMutation__
+ *
+ * To run a mutation, you first call `useApproveBudgetMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useApproveBudgetMutation` 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 [approveBudgetMutation, { data, loading, error }] = useApproveBudgetMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useApproveBudgetMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ApproveBudgetMutation, Types.ApproveBudgetMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ApproveBudgetMutation, any, Apollo.ApolloCache>;
+export type ApproveBudgetMutationHookResult = ReturnType<typeof useApproveBudgetMutation>;
+export type ApproveBudgetMutationResult = Apollo.MutationResult<Types.ApproveBudgetMutation>;
+export type ApproveBudgetMutationOptions = Apollo.BaseMutationOptions<Types.ApproveBudgetMutation, Types.ApproveBudgetMutationVariables>;
+export declare const LogExpenseDocument: Apollo.DocumentNode;
+export type LogExpenseMutationFn = Apollo.MutationFunction<Types.LogExpenseMutation, Types.LogExpenseMutationVariables>;
+/**
+ * __useLogExpenseMutation__
+ *
+ * To run a mutation, you first call `useLogExpenseMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useLogExpenseMutation` 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 [logExpenseMutation, { data, loading, error }] = useLogExpenseMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useLogExpenseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.LogExpenseMutation, Types.LogExpenseMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.LogExpenseMutation, any, Apollo.ApolloCache>;
+export type LogExpenseMutationHookResult = ReturnType<typeof useLogExpenseMutation>;
+export type LogExpenseMutationResult = Apollo.MutationResult<Types.LogExpenseMutation>;
+export type LogExpenseMutationOptions = Apollo.BaseMutationOptions<Types.LogExpenseMutation, Types.LogExpenseMutationVariables>;
+export declare const UpdateExpenseDocument: Apollo.DocumentNode;
+export type UpdateExpenseMutationFn = Apollo.MutationFunction<Types.UpdateExpenseMutation, Types.UpdateExpenseMutationVariables>;
+/**
+ * __useUpdateExpenseMutation__
+ *
+ * To run a mutation, you first call `useUpdateExpenseMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateExpenseMutation` 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 [updateExpenseMutation, { data, loading, error }] = useUpdateExpenseMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateExpenseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateExpenseMutation, Types.UpdateExpenseMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateExpenseMutation, any, Apollo.ApolloCache>;
+export type UpdateExpenseMutationHookResult = ReturnType<typeof useUpdateExpenseMutation>;
+export type UpdateExpenseMutationResult = Apollo.MutationResult<Types.UpdateExpenseMutation>;
+export type UpdateExpenseMutationOptions = Apollo.BaseMutationOptions<Types.UpdateExpenseMutation, Types.UpdateExpenseMutationVariables>;
+export declare const DeleteExpenseDocument: Apollo.DocumentNode;
+export type DeleteExpenseMutationFn = Apollo.MutationFunction<Types.DeleteExpenseMutation, Types.DeleteExpenseMutationVariables>;
+/**
+ * __useDeleteExpenseMutation__
+ *
+ * To run a mutation, you first call `useDeleteExpenseMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteExpenseMutation` 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 [deleteExpenseMutation, { data, loading, error }] = useDeleteExpenseMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useDeleteExpenseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteExpenseMutation, Types.DeleteExpenseMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteExpenseMutation, any, Apollo.ApolloCache>;
+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 CreateCustomFieldDefinitionDocument: Apollo.DocumentNode;
+export type CreateCustomFieldDefinitionMutationFn = Apollo.MutationFunction<Types.CreateCustomFieldDefinitionMutation, Types.CreateCustomFieldDefinitionMutationVariables>;
+/**
+ * __useCreateCustomFieldDefinitionMutation__
+ *
+ * To run a mutation, you first call `useCreateCustomFieldDefinitionMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateCustomFieldDefinitionMutation` 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 [createCustomFieldDefinitionMutation, { data, loading, error }] = useCreateCustomFieldDefinitionMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateCustomFieldDefinitionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateCustomFieldDefinitionMutation, Types.CreateCustomFieldDefinitionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateCustomFieldDefinitionMutation, any, Apollo.ApolloCache>;
+export type CreateCustomFieldDefinitionMutationHookResult = ReturnType<typeof useCreateCustomFieldDefinitionMutation>;
+export type CreateCustomFieldDefinitionMutationResult = Apollo.MutationResult<Types.CreateCustomFieldDefinitionMutation>;
+export type CreateCustomFieldDefinitionMutationOptions = Apollo.BaseMutationOptions<Types.CreateCustomFieldDefinitionMutation, Types.CreateCustomFieldDefinitionMutationVariables>;
+export declare const UpdateCustomFieldDefinitionDocument: Apollo.DocumentNode;
+export type UpdateCustomFieldDefinitionMutationFn = Apollo.MutationFunction<Types.UpdateCustomFieldDefinitionMutation, Types.UpdateCustomFieldDefinitionMutationVariables>;
+/**
+ * __useUpdateCustomFieldDefinitionMutation__
+ *
+ * To run a mutation, you first call `useUpdateCustomFieldDefinitionMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateCustomFieldDefinitionMutation` 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 [updateCustomFieldDefinitionMutation, { data, loading, error }] = useUpdateCustomFieldDefinitionMutation({
  *   variables: {
  *      id: // value for 'id'
- *      triggerData: // value for 'triggerData'
+ *      input: // value for 'input'
  *   },
  * });
  */
-export declare function useExecuteAutomationRuleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ExecuteAutomationRuleMutation, Types.ExecuteAutomationRuleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ExecuteAutomationRuleMutation, any, Apollo.ApolloCache>;
-export type ExecuteAutomationRuleMutationHookResult = ReturnType<typeof useExecuteAutomationRuleMutation>;
-export type ExecuteAutomationRuleMutationResult = Apollo.MutationResult<Types.ExecuteAutomationRuleMutation>;
-export type ExecuteAutomationRuleMutationOptions = Apollo.BaseMutationOptions<Types.ExecuteAutomationRuleMutation, Types.ExecuteAutomationRuleMutationVariables>;
-export declare const CreateBoardDocument: Apollo.DocumentNode;
-export type CreateBoardMutationFn = Apollo.MutationFunction<Types.CreateBoardMutation, Types.CreateBoardMutationVariables>;
+export declare function useUpdateCustomFieldDefinitionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateCustomFieldDefinitionMutation, Types.UpdateCustomFieldDefinitionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateCustomFieldDefinitionMutation, any, Apollo.ApolloCache>;
+export type UpdateCustomFieldDefinitionMutationHookResult = ReturnType<typeof useUpdateCustomFieldDefinitionMutation>;
+export type UpdateCustomFieldDefinitionMutationResult = Apollo.MutationResult<Types.UpdateCustomFieldDefinitionMutation>;
+export type UpdateCustomFieldDefinitionMutationOptions = Apollo.BaseMutationOptions<Types.UpdateCustomFieldDefinitionMutation, Types.UpdateCustomFieldDefinitionMutationVariables>;
+export declare const DeleteCustomFieldDefinitionDocument: Apollo.DocumentNode;
+export type DeleteCustomFieldDefinitionMutationFn = Apollo.MutationFunction<Types.DeleteCustomFieldDefinitionMutation, Types.DeleteCustomFieldDefinitionMutationVariables>;
 /**
- * __useCreateBoardMutation__
+ * __useDeleteCustomFieldDefinitionMutation__
  *
- * To run a mutation, you first call `useCreateBoardMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useCreateBoardMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useDeleteCustomFieldDefinitionMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteCustomFieldDefinitionMutation` 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 [createBoardMutation, { data, loading, error }] = useCreateBoardMutation({
+ * const [deleteCustomFieldDefinitionMutation, { data, loading, error }] = useDeleteCustomFieldDefinitionMutation({
  *   variables: {
- *      input: // value for 'input'
+ *      id: // value for 'id'
  *   },
  * });
  */
-export declare function useCreateBoardMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateBoardMutation, Types.CreateBoardMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateBoardMutation, any, Apollo.ApolloCache>;
-export type CreateBoardMutationHookResult = ReturnType<typeof useCreateBoardMutation>;
-export type CreateBoardMutationResult = Apollo.MutationResult<Types.CreateBoardMutation>;
-export type CreateBoardMutationOptions = Apollo.BaseMutationOptions<Types.CreateBoardMutation, Types.CreateBoardMutationVariables>;
-export declare const UpdateBoardDocument: Apollo.DocumentNode;
-export type UpdateBoardMutationFn = Apollo.MutationFunction<Types.UpdateBoardMutation, Types.UpdateBoardMutationVariables>;
+export declare function useDeleteCustomFieldDefinitionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteCustomFieldDefinitionMutation, Types.DeleteCustomFieldDefinitionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteCustomFieldDefinitionMutation, any, Apollo.ApolloCache>;
+export type DeleteCustomFieldDefinitionMutationHookResult = ReturnType<typeof useDeleteCustomFieldDefinitionMutation>;
+export type DeleteCustomFieldDefinitionMutationResult = Apollo.MutationResult<Types.DeleteCustomFieldDefinitionMutation>;
+export type DeleteCustomFieldDefinitionMutationOptions = Apollo.BaseMutationOptions<Types.DeleteCustomFieldDefinitionMutation, Types.DeleteCustomFieldDefinitionMutationVariables>;
+export declare const SetCustomFieldValueDocument: Apollo.DocumentNode;
+export type SetCustomFieldValueMutationFn = Apollo.MutationFunction<Types.SetCustomFieldValueMutation, Types.SetCustomFieldValueMutationVariables>;
 /**
- * __useUpdateBoardMutation__
+ * __useSetCustomFieldValueMutation__
  *
- * To run a mutation, you first call `useUpdateBoardMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useUpdateBoardMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useSetCustomFieldValueMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSetCustomFieldValueMutation` 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 [updateBoardMutation, { data, loading, error }] = useUpdateBoardMutation({
+ * const [setCustomFieldValueMutation, { data, loading, error }] = useSetCustomFieldValueMutation({
  *   variables: {
- *      id: // value for 'id'
  *      input: // value for 'input'
  *   },
  * });
  */
-export declare function useUpdateBoardMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateBoardMutation, Types.UpdateBoardMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateBoardMutation, any, Apollo.ApolloCache>;
-export type UpdateBoardMutationHookResult = ReturnType<typeof useUpdateBoardMutation>;
-export type UpdateBoardMutationResult = Apollo.MutationResult<Types.UpdateBoardMutation>;
-export type UpdateBoardMutationOptions = Apollo.BaseMutationOptions<Types.UpdateBoardMutation, Types.UpdateBoardMutationVariables>;
-export declare const DeleteBoardDocument: Apollo.DocumentNode;
-export type DeleteBoardMutationFn = Apollo.MutationFunction<Types.DeleteBoardMutation, Types.DeleteBoardMutationVariables>;
+export declare function useSetCustomFieldValueMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SetCustomFieldValueMutation, Types.SetCustomFieldValueMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.SetCustomFieldValueMutation, any, Apollo.ApolloCache>;
+export type SetCustomFieldValueMutationHookResult = ReturnType<typeof useSetCustomFieldValueMutation>;
+export type SetCustomFieldValueMutationResult = Apollo.MutationResult<Types.SetCustomFieldValueMutation>;
+export type SetCustomFieldValueMutationOptions = Apollo.BaseMutationOptions<Types.SetCustomFieldValueMutation, Types.SetCustomFieldValueMutationVariables>;
+export declare const RemoveCustomFieldValueDocument: Apollo.DocumentNode;
+export type RemoveCustomFieldValueMutationFn = Apollo.MutationFunction<Types.RemoveCustomFieldValueMutation, Types.RemoveCustomFieldValueMutationVariables>;
 /**
- * __useDeleteBoardMutation__
+ * __useRemoveCustomFieldValueMutation__
  *
- * To run a mutation, you first call `useDeleteBoardMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useDeleteBoardMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useRemoveCustomFieldValueMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRemoveCustomFieldValueMutation` 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 [deleteBoardMutation, { data, loading, error }] = useDeleteBoardMutation({
+ * const [removeCustomFieldValueMutation, { data, loading, error }] = useRemoveCustomFieldValueMutation({
  *   variables: {
- *      id: // value for 'id'
+ *      definitionId: // value for 'definitionId'
+ *      workItemId: // value for 'workItemId'
  *   },
  * });
  */
-export declare function useDeleteBoardMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteBoardMutation, Types.DeleteBoardMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteBoardMutation, any, Apollo.ApolloCache>;
-export type DeleteBoardMutationHookResult = ReturnType<typeof useDeleteBoardMutation>;
-export type DeleteBoardMutationResult = Apollo.MutationResult<Types.DeleteBoardMutation>;
-export type DeleteBoardMutationOptions = Apollo.BaseMutationOptions<Types.DeleteBoardMutation, Types.DeleteBoardMutationVariables>;
-export declare const CreateBoardColumnDocument: Apollo.DocumentNode;
-export type CreateBoardColumnMutationFn = Apollo.MutationFunction<Types.CreateBoardColumnMutation, Types.CreateBoardColumnMutationVariables>;
+export declare function useRemoveCustomFieldValueMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RemoveCustomFieldValueMutation, Types.RemoveCustomFieldValueMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RemoveCustomFieldValueMutation, any, Apollo.ApolloCache>;
+export type RemoveCustomFieldValueMutationHookResult = ReturnType<typeof useRemoveCustomFieldValueMutation>;
+export type RemoveCustomFieldValueMutationResult = Apollo.MutationResult<Types.RemoveCustomFieldValueMutation>;
+export type RemoveCustomFieldValueMutationOptions = Apollo.BaseMutationOptions<Types.RemoveCustomFieldValueMutation, Types.RemoveCustomFieldValueMutationVariables>;
+export declare const CreateMilestoneDocument: Apollo.DocumentNode;
+export type CreateMilestoneMutationFn = Apollo.MutationFunction<Types.CreateMilestoneMutation, Types.CreateMilestoneMutationVariables>;
 /**
- * __useCreateBoardColumnMutation__
+ * __useCreateMilestoneMutation__
  *
- * To run a mutation, you first call `useCreateBoardColumnMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useCreateBoardColumnMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useCreateMilestoneMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateMilestoneMutation` 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 [createBoardColumnMutation, { data, loading, error }] = useCreateBoardColumnMutation({
+ * const [createMilestoneMutation, { data, loading, error }] = useCreateMilestoneMutation({
  *   variables: {
  *      input: // value for 'input'
  *   },
  * });
  */
-export declare function useCreateBoardColumnMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateBoardColumnMutation, Types.CreateBoardColumnMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateBoardColumnMutation, any, Apollo.ApolloCache>;
-export type CreateBoardColumnMutationHookResult = ReturnType<typeof useCreateBoardColumnMutation>;
-export type CreateBoardColumnMutationResult = Apollo.MutationResult<Types.CreateBoardColumnMutation>;
-export type CreateBoardColumnMutationOptions = Apollo.BaseMutationOptions<Types.CreateBoardColumnMutation, Types.CreateBoardColumnMutationVariables>;
-export declare const UpdateBoardColumnDocument: Apollo.DocumentNode;
-export type UpdateBoardColumnMutationFn = Apollo.MutationFunction<Types.UpdateBoardColumnMutation, Types.UpdateBoardColumnMutationVariables>;
+export declare function useCreateMilestoneMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateMilestoneMutation, Types.CreateMilestoneMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateMilestoneMutation, any, Apollo.ApolloCache>;
+export type CreateMilestoneMutationHookResult = ReturnType<typeof useCreateMilestoneMutation>;
+export type CreateMilestoneMutationResult = Apollo.MutationResult<Types.CreateMilestoneMutation>;
+export type CreateMilestoneMutationOptions = Apollo.BaseMutationOptions<Types.CreateMilestoneMutation, Types.CreateMilestoneMutationVariables>;
+export declare const UpdateMilestoneDocument: Apollo.DocumentNode;
+export type UpdateMilestoneMutationFn = Apollo.MutationFunction<Types.UpdateMilestoneMutation, Types.UpdateMilestoneMutationVariables>;
 /**
- * __useUpdateBoardColumnMutation__
+ * __useUpdateMilestoneMutation__
  *
- * To run a mutation, you first call `useUpdateBoardColumnMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useUpdateBoardColumnMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useUpdateMilestoneMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateMilestoneMutation` 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 [updateBoardColumnMutation, { data, loading, error }] = useUpdateBoardColumnMutation({
+ * const [updateMilestoneMutation, { data, loading, error }] = useUpdateMilestoneMutation({
  *   variables: {
  *      id: // value for 'id'
  *      input: // value for 'input'
  *   },
  * });
  */
-export declare function useUpdateBoardColumnMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateBoardColumnMutation, Types.UpdateBoardColumnMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateBoardColumnMutation, any, Apollo.ApolloCache>;
-export type UpdateBoardColumnMutationHookResult = ReturnType<typeof useUpdateBoardColumnMutation>;
-export type UpdateBoardColumnMutationResult = Apollo.MutationResult<Types.UpdateBoardColumnMutation>;
-export type UpdateBoardColumnMutationOptions = Apollo.BaseMutationOptions<Types.UpdateBoardColumnMutation, Types.UpdateBoardColumnMutationVariables>;
-export declare const DeleteBoardColumnDocument: Apollo.DocumentNode;
-export type DeleteBoardColumnMutationFn = Apollo.MutationFunction<Types.DeleteBoardColumnMutation, Types.DeleteBoardColumnMutationVariables>;
+export declare function useUpdateMilestoneMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateMilestoneMutation, Types.UpdateMilestoneMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateMilestoneMutation, any, Apollo.ApolloCache>;
+export type UpdateMilestoneMutationHookResult = ReturnType<typeof useUpdateMilestoneMutation>;
+export type UpdateMilestoneMutationResult = Apollo.MutationResult<Types.UpdateMilestoneMutation>;
+export type UpdateMilestoneMutationOptions = Apollo.BaseMutationOptions<Types.UpdateMilestoneMutation, Types.UpdateMilestoneMutationVariables>;
+export declare const DeleteMilestoneDocument: Apollo.DocumentNode;
+export type DeleteMilestoneMutationFn = Apollo.MutationFunction<Types.DeleteMilestoneMutation, Types.DeleteMilestoneMutationVariables>;
 /**
- * __useDeleteBoardColumnMutation__
+ * __useDeleteMilestoneMutation__
  *
- * To run a mutation, you first call `useDeleteBoardColumnMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useDeleteBoardColumnMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useDeleteMilestoneMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteMilestoneMutation` 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 [deleteBoardColumnMutation, { data, loading, error }] = useDeleteBoardColumnMutation({
+ * const [deleteMilestoneMutation, { data, loading, error }] = useDeleteMilestoneMutation({
  *   variables: {
  *      id: // value for 'id'
  *   },
  * });
  */
-export declare function useDeleteBoardColumnMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteBoardColumnMutation, Types.DeleteBoardColumnMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteBoardColumnMutation, any, Apollo.ApolloCache>;
-export type DeleteBoardColumnMutationHookResult = ReturnType<typeof useDeleteBoardColumnMutation>;
-export type DeleteBoardColumnMutationResult = Apollo.MutationResult<Types.DeleteBoardColumnMutation>;
-export type DeleteBoardColumnMutationOptions = Apollo.BaseMutationOptions<Types.DeleteBoardColumnMutation, Types.DeleteBoardColumnMutationVariables>;
-export declare const ReorderColumnsDocument: Apollo.DocumentNode;
-export type ReorderColumnsMutationFn = Apollo.MutationFunction<Types.ReorderColumnsMutation, Types.ReorderColumnsMutationVariables>;
+export declare function useDeleteMilestoneMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteMilestoneMutation, Types.DeleteMilestoneMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteMilestoneMutation, any, Apollo.ApolloCache>;
+export type DeleteMilestoneMutationHookResult = ReturnType<typeof useDeleteMilestoneMutation>;
+export type DeleteMilestoneMutationResult = Apollo.MutationResult<Types.DeleteMilestoneMutation>;
+export type DeleteMilestoneMutationOptions = Apollo.BaseMutationOptions<Types.DeleteMilestoneMutation, Types.DeleteMilestoneMutationVariables>;
+export declare const CreateProductLineDocument: Apollo.DocumentNode;
+export type CreateProductLineMutationFn = Apollo.MutationFunction<Types.CreateProductLineMutation, Types.CreateProductLineMutationVariables>;
 /**
- * __useReorderColumnsMutation__
+ * __useCreateProductLineMutation__
  *
- * To run a mutation, you first call `useReorderColumnsMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useReorderColumnsMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useCreateProductLineMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateProductLineMutation` 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 [reorderColumnsMutation, { data, loading, error }] = useReorderColumnsMutation({
+ * const [createProductLineMutation, { data, loading, error }] = useCreateProductLineMutation({
  *   variables: {
- *      boardId: // value for 'boardId'
  *      input: // value for 'input'
  *   },
  * });
  */
-export declare function useReorderColumnsMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ReorderColumnsMutation, Types.ReorderColumnsMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ReorderColumnsMutation, any, Apollo.ApolloCache>;
-export type ReorderColumnsMutationHookResult = ReturnType<typeof useReorderColumnsMutation>;
-export type ReorderColumnsMutationResult = Apollo.MutationResult<Types.ReorderColumnsMutation>;
-export type ReorderColumnsMutationOptions = Apollo.BaseMutationOptions<Types.ReorderColumnsMutation, Types.ReorderColumnsMutationVariables>;
-export declare const MoveCardDocument: Apollo.DocumentNode;
-export type MoveCardMutationFn = Apollo.MutationFunction<Types.MoveCardMutation, Types.MoveCardMutationVariables>;
+export declare function useCreateProductLineMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateProductLineMutation, Types.CreateProductLineMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateProductLineMutation, any, Apollo.ApolloCache>;
+export type CreateProductLineMutationHookResult = ReturnType<typeof useCreateProductLineMutation>;
+export type CreateProductLineMutationResult = Apollo.MutationResult<Types.CreateProductLineMutation>;
+export type CreateProductLineMutationOptions = Apollo.BaseMutationOptions<Types.CreateProductLineMutation, Types.CreateProductLineMutationVariables>;
+export declare const UpdateProductLineDocument: Apollo.DocumentNode;
+export type UpdateProductLineMutationFn = Apollo.MutationFunction<Types.UpdateProductLineMutation, Types.UpdateProductLineMutationVariables>;
 /**
- * __useMoveCardMutation__
+ * __useUpdateProductLineMutation__
  *
- * To run a mutation, you first call `useMoveCardMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useMoveCardMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useUpdateProductLineMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateProductLineMutation` 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 [moveCardMutation, { data, loading, error }] = useMoveCardMutation({
+ * const [updateProductLineMutation, { data, loading, error }] = useUpdateProductLineMutation({
  *   variables: {
- *      boardId: // value for 'boardId'
+ *      id: // value for 'id'
  *      input: // value for 'input'
  *   },
  * });
  */
-export declare function useMoveCardMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.MoveCardMutation, Types.MoveCardMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.MoveCardMutation, any, Apollo.ApolloCache>;
-export type MoveCardMutationHookResult = ReturnType<typeof useMoveCardMutation>;
-export type MoveCardMutationResult = Apollo.MutationResult<Types.MoveCardMutation>;
-export type MoveCardMutationOptions = Apollo.BaseMutationOptions<Types.MoveCardMutation, Types.MoveCardMutationVariables>;
-export declare const CreateBudgetDocument: Apollo.DocumentNode;
-export type CreateBudgetMutationFn = Apollo.MutationFunction<Types.CreateBudgetMutation, Types.CreateBudgetMutationVariables>;
+export declare function useUpdateProductLineMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateProductLineMutation, Types.UpdateProductLineMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateProductLineMutation, any, Apollo.ApolloCache>;
+export type UpdateProductLineMutationHookResult = ReturnType<typeof useUpdateProductLineMutation>;
+export type UpdateProductLineMutationResult = Apollo.MutationResult<Types.UpdateProductLineMutation>;
+export type UpdateProductLineMutationOptions = Apollo.BaseMutationOptions<Types.UpdateProductLineMutation, Types.UpdateProductLineMutationVariables>;
+export declare const ArchiveProductLineDocument: Apollo.DocumentNode;
+export type ArchiveProductLineMutationFn = Apollo.MutationFunction<Types.ArchiveProductLineMutation, Types.ArchiveProductLineMutationVariables>;
 /**
- * __useCreateBudgetMutation__
+ * __useArchiveProductLineMutation__
  *
- * To run a mutation, you first call `useCreateBudgetMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useCreateBudgetMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useArchiveProductLineMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useArchiveProductLineMutation` 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 [createBudgetMutation, { data, loading, error }] = useCreateBudgetMutation({
+ * const [archiveProductLineMutation, { data, loading, error }] = useArchiveProductLineMutation({
  *   variables: {
- *      input: // value for 'input'
+ *      id: // value for 'id'
  *   },
  * });
  */
-export declare function useCreateBudgetMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateBudgetMutation, Types.CreateBudgetMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateBudgetMutation, any, Apollo.ApolloCache>;
-export type CreateBudgetMutationHookResult = ReturnType<typeof useCreateBudgetMutation>;
-export type CreateBudgetMutationResult = Apollo.MutationResult<Types.CreateBudgetMutation>;
-export type CreateBudgetMutationOptions = Apollo.BaseMutationOptions<Types.CreateBudgetMutation, Types.CreateBudgetMutationVariables>;
-export declare const UpdateBudgetDocument: Apollo.DocumentNode;
-export type UpdateBudgetMutationFn = Apollo.MutationFunction<Types.UpdateBudgetMutation, Types.UpdateBudgetMutationVariables>;
+export declare function useArchiveProductLineMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ArchiveProductLineMutation, Types.ArchiveProductLineMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ArchiveProductLineMutation, any, Apollo.ApolloCache>;
+export type ArchiveProductLineMutationHookResult = ReturnType<typeof useArchiveProductLineMutation>;
+export type ArchiveProductLineMutationResult = Apollo.MutationResult<Types.ArchiveProductLineMutation>;
+export type ArchiveProductLineMutationOptions = Apollo.BaseMutationOptions<Types.ArchiveProductLineMutation, Types.ArchiveProductLineMutationVariables>;
+export declare const UnarchiveProductLineDocument: Apollo.DocumentNode;
+export type UnarchiveProductLineMutationFn = Apollo.MutationFunction<Types.UnarchiveProductLineMutation, Types.UnarchiveProductLineMutationVariables>;
 /**
- * __useUpdateBudgetMutation__
+ * __useUnarchiveProductLineMutation__
  *
- * To run a mutation, you first call `useUpdateBudgetMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useUpdateBudgetMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useUnarchiveProductLineMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUnarchiveProductLineMutation` 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 [updateBudgetMutation, { data, loading, error }] = useUpdateBudgetMutation({
+ * const [unarchiveProductLineMutation, { data, loading, error }] = useUnarchiveProductLineMutation({
  *   variables: {
  *      id: // value for 'id'
- *      input: // value for 'input'
  *   },
  * });
  */
-export declare function useUpdateBudgetMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateBudgetMutation, Types.UpdateBudgetMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateBudgetMutation, any, Apollo.ApolloCache>;
-export type UpdateBudgetMutationHookResult = ReturnType<typeof useUpdateBudgetMutation>;
-export type UpdateBudgetMutationResult = Apollo.MutationResult<Types.UpdateBudgetMutation>;
-export type UpdateBudgetMutationOptions = Apollo.BaseMutationOptions<Types.UpdateBudgetMutation, Types.UpdateBudgetMutationVariables>;
-export declare const DeleteBudgetDocument: Apollo.DocumentNode;
-export type DeleteBudgetMutationFn = Apollo.MutationFunction<Types.DeleteBudgetMutation, Types.DeleteBudgetMutationVariables>;
+export declare function useUnarchiveProductLineMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UnarchiveProductLineMutation, Types.UnarchiveProductLineMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UnarchiveProductLineMutation, any, Apollo.ApolloCache>;
+export type UnarchiveProductLineMutationHookResult = ReturnType<typeof useUnarchiveProductLineMutation>;
+export type UnarchiveProductLineMutationResult = Apollo.MutationResult<Types.UnarchiveProductLineMutation>;
+export type UnarchiveProductLineMutationOptions = Apollo.BaseMutationOptions<Types.UnarchiveProductLineMutation, Types.UnarchiveProductLineMutationVariables>;
+export declare const DeleteProductLineDocument: Apollo.DocumentNode;
+export type DeleteProductLineMutationFn = Apollo.MutationFunction<Types.DeleteProductLineMutation, Types.DeleteProductLineMutationVariables>;
 /**
- * __useDeleteBudgetMutation__
+ * __useDeleteProductLineMutation__
  *
- * To run a mutation, you first call `useDeleteBudgetMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useDeleteBudgetMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useDeleteProductLineMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteProductLineMutation` 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 [deleteBudgetMutation, { data, loading, error }] = useDeleteBudgetMutation({
+ * const [deleteProductLineMutation, { data, loading, error }] = useDeleteProductLineMutation({
  *   variables: {
  *      id: // value for 'id'
  *   },
  * });
  */
-export declare function useDeleteBudgetMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteBudgetMutation, Types.DeleteBudgetMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteBudgetMutation, any, Apollo.ApolloCache>;
-export type DeleteBudgetMutationHookResult = ReturnType<typeof useDeleteBudgetMutation>;
-export type DeleteBudgetMutationResult = Apollo.MutationResult<Types.DeleteBudgetMutation>;
-export type DeleteBudgetMutationOptions = Apollo.BaseMutationOptions<Types.DeleteBudgetMutation, Types.DeleteBudgetMutationVariables>;
-export declare const ApproveBudgetDocument: Apollo.DocumentNode;
-export type ApproveBudgetMutationFn = Apollo.MutationFunction<Types.ApproveBudgetMutation, Types.ApproveBudgetMutationVariables>;
+export declare function useDeleteProductLineMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteProductLineMutation, Types.DeleteProductLineMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteProductLineMutation, any, Apollo.ApolloCache>;
+export type DeleteProductLineMutationHookResult = ReturnType<typeof useDeleteProductLineMutation>;
+export type DeleteProductLineMutationResult = Apollo.MutationResult<Types.DeleteProductLineMutation>;
+export type DeleteProductLineMutationOptions = Apollo.BaseMutationOptions<Types.DeleteProductLineMutation, Types.DeleteProductLineMutationVariables>;
+export declare const AssignProductLineDocument: Apollo.DocumentNode;
+export type AssignProductLineMutationFn = Apollo.MutationFunction<Types.AssignProductLineMutation, Types.AssignProductLineMutationVariables>;
 /**
- * __useApproveBudgetMutation__
+ * __useAssignProductLineMutation__
  *
- * To run a mutation, you first call `useApproveBudgetMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useApproveBudgetMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useAssignProductLineMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAssignProductLineMutation` 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 [approveBudgetMutation, { data, loading, error }] = useApproveBudgetMutation({
+ * const [assignProductLineMutation, { data, loading, error }] = useAssignProductLineMutation({
  *   variables: {
- *      id: // value for 'id'
+ *      productId: // value for 'productId'
+ *      productLineId: // value for 'productLineId'
  *   },
  * });
  */
-export declare function useApproveBudgetMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ApproveBudgetMutation, Types.ApproveBudgetMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ApproveBudgetMutation, any, Apollo.ApolloCache>;
-export type ApproveBudgetMutationHookResult = ReturnType<typeof useApproveBudgetMutation>;
-export type ApproveBudgetMutationResult = Apollo.MutationResult<Types.ApproveBudgetMutation>;
-export type ApproveBudgetMutationOptions = Apollo.BaseMutationOptions<Types.ApproveBudgetMutation, Types.ApproveBudgetMutationVariables>;
-export declare const LogExpenseDocument: Apollo.DocumentNode;
-export type LogExpenseMutationFn = Apollo.MutationFunction<Types.LogExpenseMutation, Types.LogExpenseMutationVariables>;
+export declare function useAssignProductLineMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AssignProductLineMutation, Types.AssignProductLineMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AssignProductLineMutation, any, Apollo.ApolloCache>;
+export type AssignProductLineMutationHookResult = ReturnType<typeof useAssignProductLineMutation>;
+export type AssignProductLineMutationResult = Apollo.MutationResult<Types.AssignProductLineMutation>;
+export type AssignProductLineMutationOptions = Apollo.BaseMutationOptions<Types.AssignProductLineMutation, Types.AssignProductLineMutationVariables>;
+export declare const LinkProductTeamDocument: Apollo.DocumentNode;
+export type LinkProductTeamMutationFn = Apollo.MutationFunction<Types.LinkProductTeamMutation, Types.LinkProductTeamMutationVariables>;
 /**
- * __useLogExpenseMutation__
+ * __useLinkProductTeamMutation__
  *
- * To run a mutation, you first call `useLogExpenseMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useLogExpenseMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useLinkProductTeamMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useLinkProductTeamMutation` 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 [logExpenseMutation, { data, loading, error }] = useLogExpenseMutation({
+ * const [linkProductTeamMutation, { data, loading, error }] = useLinkProductTeamMutation({
  *   variables: {
- *      input: // value for 'input'
+ *      productId: // value for 'productId'
+ *      teamId: // value for 'teamId'
  *   },
  * });
  */
-export declare function useLogExpenseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.LogExpenseMutation, Types.LogExpenseMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.LogExpenseMutation, any, Apollo.ApolloCache>;
-export type LogExpenseMutationHookResult = ReturnType<typeof useLogExpenseMutation>;
-export type LogExpenseMutationResult = Apollo.MutationResult<Types.LogExpenseMutation>;
-export type LogExpenseMutationOptions = Apollo.BaseMutationOptions<Types.LogExpenseMutation, Types.LogExpenseMutationVariables>;
-export declare const UpdateExpenseDocument: Apollo.DocumentNode;
-export type UpdateExpenseMutationFn = Apollo.MutationFunction<Types.UpdateExpenseMutation, Types.UpdateExpenseMutationVariables>;
+export declare function useLinkProductTeamMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.LinkProductTeamMutation, Types.LinkProductTeamMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.LinkProductTeamMutation, any, Apollo.ApolloCache>;
+export type LinkProductTeamMutationHookResult = ReturnType<typeof useLinkProductTeamMutation>;
+export type LinkProductTeamMutationResult = Apollo.MutationResult<Types.LinkProductTeamMutation>;
+export type LinkProductTeamMutationOptions = Apollo.BaseMutationOptions<Types.LinkProductTeamMutation, Types.LinkProductTeamMutationVariables>;
+export declare const UnlinkProductTeamDocument: Apollo.DocumentNode;
+export type UnlinkProductTeamMutationFn = Apollo.MutationFunction<Types.UnlinkProductTeamMutation, Types.UnlinkProductTeamMutationVariables>;
 /**
- * __useUpdateExpenseMutation__
+ * __useUnlinkProductTeamMutation__
  *
- * To run a mutation, you first call `useUpdateExpenseMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useUpdateExpenseMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useUnlinkProductTeamMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUnlinkProductTeamMutation` 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 [updateExpenseMutation, { data, loading, error }] = useUpdateExpenseMutation({
+ * const [unlinkProductTeamMutation, { data, loading, error }] = useUnlinkProductTeamMutation({
  *   variables: {
- *      id: // value for 'id'
- *      input: // value for 'input'
+ *      productId: // value for 'productId'
+ *      teamId: // value for 'teamId'
  *   },
  * });
  */
-export declare function useUpdateExpenseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateExpenseMutation, Types.UpdateExpenseMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateExpenseMutation, any, Apollo.ApolloCache>;
-export type UpdateExpenseMutationHookResult = ReturnType<typeof useUpdateExpenseMutation>;
-export type UpdateExpenseMutationResult = Apollo.MutationResult<Types.UpdateExpenseMutation>;
-export type UpdateExpenseMutationOptions = Apollo.BaseMutationOptions<Types.UpdateExpenseMutation, Types.UpdateExpenseMutationVariables>;
-export declare const DeleteExpenseDocument: Apollo.DocumentNode;
-export type DeleteExpenseMutationFn = Apollo.MutationFunction<Types.DeleteExpenseMutation, Types.DeleteExpenseMutationVariables>;
+export declare function useUnlinkProductTeamMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UnlinkProductTeamMutation, Types.UnlinkProductTeamMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UnlinkProductTeamMutation, any, Apollo.ApolloCache>;
+export type UnlinkProductTeamMutationHookResult = ReturnType<typeof useUnlinkProductTeamMutation>;
+export type UnlinkProductTeamMutationResult = Apollo.MutationResult<Types.UnlinkProductTeamMutation>;
+export type UnlinkProductTeamMutationOptions = Apollo.BaseMutationOptions<Types.UnlinkProductTeamMutation, Types.UnlinkProductTeamMutationVariables>;
+export declare const CreateProductFeatureDocument: Apollo.DocumentNode;
+export type CreateProductFeatureMutationFn = Apollo.MutationFunction<Types.CreateProductFeatureMutation, Types.CreateProductFeatureMutationVariables>;
 /**
- * __useDeleteExpenseMutation__
+ * __useCreateProductFeatureMutation__
  *
- * To run a mutation, you first call `useDeleteExpenseMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useDeleteExpenseMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useCreateProductFeatureMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateProductFeatureMutation` 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 [deleteExpenseMutation, { data, loading, error }] = useDeleteExpenseMutation({
+ * const [createProductFeatureMutation, { data, loading, error }] = useCreateProductFeatureMutation({
  *   variables: {
- *      id: // value for 'id'
+ *      input: // value for 'input'
  *   },
  * });
  */
-export declare function useDeleteExpenseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteExpenseMutation, Types.DeleteExpenseMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteExpenseMutation, any, Apollo.ApolloCache>;
-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 CreateCustomFieldDefinitionDocument: Apollo.DocumentNode;
-export type CreateCustomFieldDefinitionMutationFn = Apollo.MutationFunction<Types.CreateCustomFieldDefinitionMutation, Types.CreateCustomFieldDefinitionMutationVariables>;
+export declare function useCreateProductFeatureMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateProductFeatureMutation, Types.CreateProductFeatureMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateProductFeatureMutation, any, Apollo.ApolloCache>;
+export type CreateProductFeatureMutationHookResult = ReturnType<typeof useCreateProductFeatureMutation>;
+export type CreateProductFeatureMutationResult = Apollo.MutationResult<Types.CreateProductFeatureMutation>;
+export type CreateProductFeatureMutationOptions = Apollo.BaseMutationOptions<Types.CreateProductFeatureMutation, Types.CreateProductFeatureMutationVariables>;
+export declare const UpdateProductFeatureDocument: Apollo.DocumentNode;
+export type UpdateProductFeatureMutationFn = Apollo.MutationFunction<Types.UpdateProductFeatureMutation, Types.UpdateProductFeatureMutationVariables>;
 /**
- * __useCreateCustomFieldDefinitionMutation__
+ * __useUpdateProductFeatureMutation__
  *
- * To run a mutation, you first call `useCreateCustomFieldDefinitionMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useCreateCustomFieldDefinitionMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useUpdateProductFeatureMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateProductFeatureMutation` 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 [createCustomFieldDefinitionMutation, { data, loading, error }] = useCreateCustomFieldDefinitionMutation({
+ * const [updateProductFeatureMutation, { data, loading, error }] = useUpdateProductFeatureMutation({
  *   variables: {
+ *      id: // value for 'id'
  *      input: // value for 'input'
- *   },
- * });
- */
-export declare function useCreateCustomFieldDefinitionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateCustomFieldDefinitionMutation, Types.CreateCustomFieldDefinitionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateCustomFieldDefinitionMutation, any, Apollo.ApolloCache>;
-export type CreateCustomFieldDefinitionMutationHookResult = ReturnType<typeof useCreateCustomFieldDefinitionMutation>;
-export type CreateCustomFieldDefinitionMutationResult = Apollo.MutationResult<Types.CreateCustomFieldDefinitionMutation>;
-export type CreateCustomFieldDefinitionMutationOptions = Apollo.BaseMutationOptions<Types.CreateCustomFieldDefinitionMutation, Types.CreateCustomFieldDefinitionMutationVariables>;
-export declare const UpdateCustomFieldDefinitionDocument: Apollo.DocumentNode;
-export type UpdateCustomFieldDefinitionMutationFn = Apollo.MutationFunction<Types.UpdateCustomFieldDefinitionMutation, Types.UpdateCustomFieldDefinitionMutationVariables>;
+ *   },
+ * });
+ */
+export declare function useUpdateProductFeatureMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateProductFeatureMutation, Types.UpdateProductFeatureMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateProductFeatureMutation, any, Apollo.ApolloCache>;
+export type UpdateProductFeatureMutationHookResult = ReturnType<typeof useUpdateProductFeatureMutation>;
+export type UpdateProductFeatureMutationResult = Apollo.MutationResult<Types.UpdateProductFeatureMutation>;
+export type UpdateProductFeatureMutationOptions = Apollo.BaseMutationOptions<Types.UpdateProductFeatureMutation, Types.UpdateProductFeatureMutationVariables>;
+export declare const ArchiveProductFeatureDocument: Apollo.DocumentNode;
+export type ArchiveProductFeatureMutationFn = Apollo.MutationFunction<Types.ArchiveProductFeatureMutation, Types.ArchiveProductFeatureMutationVariables>;
 /**
- * __useUpdateCustomFieldDefinitionMutation__
+ * __useArchiveProductFeatureMutation__
  *
- * To run a mutation, you first call `useUpdateCustomFieldDefinitionMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useUpdateCustomFieldDefinitionMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useArchiveProductFeatureMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useArchiveProductFeatureMutation` 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 [updateCustomFieldDefinitionMutation, { data, loading, error }] = useUpdateCustomFieldDefinitionMutation({
+ * const [archiveProductFeatureMutation, { data, loading, error }] = useArchiveProductFeatureMutation({
  *   variables: {
  *      id: // value for 'id'
- *      input: // value for 'input'
  *   },
  * });
  */
-export declare function useUpdateCustomFieldDefinitionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateCustomFieldDefinitionMutation, Types.UpdateCustomFieldDefinitionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateCustomFieldDefinitionMutation, any, Apollo.ApolloCache>;
-export type UpdateCustomFieldDefinitionMutationHookResult = ReturnType<typeof useUpdateCustomFieldDefinitionMutation>;
-export type UpdateCustomFieldDefinitionMutationResult = Apollo.MutationResult<Types.UpdateCustomFieldDefinitionMutation>;
-export type UpdateCustomFieldDefinitionMutationOptions = Apollo.BaseMutationOptions<Types.UpdateCustomFieldDefinitionMutation, Types.UpdateCustomFieldDefinitionMutationVariables>;
-export declare const DeleteCustomFieldDefinitionDocument: Apollo.DocumentNode;
-export type DeleteCustomFieldDefinitionMutationFn = Apollo.MutationFunction<Types.DeleteCustomFieldDefinitionMutation, Types.DeleteCustomFieldDefinitionMutationVariables>;
+export declare function useArchiveProductFeatureMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ArchiveProductFeatureMutation, Types.ArchiveProductFeatureMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ArchiveProductFeatureMutation, any, Apollo.ApolloCache>;
+export type ArchiveProductFeatureMutationHookResult = ReturnType<typeof useArchiveProductFeatureMutation>;
+export type ArchiveProductFeatureMutationResult = Apollo.MutationResult<Types.ArchiveProductFeatureMutation>;
+export type ArchiveProductFeatureMutationOptions = Apollo.BaseMutationOptions<Types.ArchiveProductFeatureMutation, Types.ArchiveProductFeatureMutationVariables>;
+export declare const UnarchiveProductFeatureDocument: Apollo.DocumentNode;
+export type UnarchiveProductFeatureMutationFn = Apollo.MutationFunction<Types.UnarchiveProductFeatureMutation, Types.UnarchiveProductFeatureMutationVariables>;
 /**
- * __useDeleteCustomFieldDefinitionMutation__
+ * __useUnarchiveProductFeatureMutation__
  *
- * To run a mutation, you first call `useDeleteCustomFieldDefinitionMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useDeleteCustomFieldDefinitionMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useUnarchiveProductFeatureMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUnarchiveProductFeatureMutation` 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 [deleteCustomFieldDefinitionMutation, { data, loading, error }] = useDeleteCustomFieldDefinitionMutation({
+ * const [unarchiveProductFeatureMutation, { data, loading, error }] = useUnarchiveProductFeatureMutation({
  *   variables: {
  *      id: // value for 'id'
  *   },
  * });
  */
-export declare function useDeleteCustomFieldDefinitionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteCustomFieldDefinitionMutation, Types.DeleteCustomFieldDefinitionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteCustomFieldDefinitionMutation, any, Apollo.ApolloCache>;
-export type DeleteCustomFieldDefinitionMutationHookResult = ReturnType<typeof useDeleteCustomFieldDefinitionMutation>;
-export type DeleteCustomFieldDefinitionMutationResult = Apollo.MutationResult<Types.DeleteCustomFieldDefinitionMutation>;
-export type DeleteCustomFieldDefinitionMutationOptions = Apollo.BaseMutationOptions<Types.DeleteCustomFieldDefinitionMutation, Types.DeleteCustomFieldDefinitionMutationVariables>;
-export declare const SetCustomFieldValueDocument: Apollo.DocumentNode;
-export type SetCustomFieldValueMutationFn = Apollo.MutationFunction<Types.SetCustomFieldValueMutation, Types.SetCustomFieldValueMutationVariables>;
+export declare function useUnarchiveProductFeatureMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UnarchiveProductFeatureMutation, Types.UnarchiveProductFeatureMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UnarchiveProductFeatureMutation, any, Apollo.ApolloCache>;
+export type UnarchiveProductFeatureMutationHookResult = ReturnType<typeof useUnarchiveProductFeatureMutation>;
+export type UnarchiveProductFeatureMutationResult = Apollo.MutationResult<Types.UnarchiveProductFeatureMutation>;
+export type UnarchiveProductFeatureMutationOptions = Apollo.BaseMutationOptions<Types.UnarchiveProductFeatureMutation, Types.UnarchiveProductFeatureMutationVariables>;
+export declare const DeleteProductFeatureDocument: Apollo.DocumentNode;
+export type DeleteProductFeatureMutationFn = Apollo.MutationFunction<Types.DeleteProductFeatureMutation, Types.DeleteProductFeatureMutationVariables>;
 /**
- * __useSetCustomFieldValueMutation__
+ * __useDeleteProductFeatureMutation__
  *
- * To run a mutation, you first call `useSetCustomFieldValueMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useSetCustomFieldValueMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useDeleteProductFeatureMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteProductFeatureMutation` 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 [setCustomFieldValueMutation, { data, loading, error }] = useSetCustomFieldValueMutation({
+ * const [deleteProductFeatureMutation, { data, loading, error }] = useDeleteProductFeatureMutation({
  *   variables: {
- *      input: // value for 'input'
+ *      id: // value for 'id'
  *   },
  * });
  */
-export declare function useSetCustomFieldValueMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SetCustomFieldValueMutation, Types.SetCustomFieldValueMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.SetCustomFieldValueMutation, any, Apollo.ApolloCache>;
-export type SetCustomFieldValueMutationHookResult = ReturnType<typeof useSetCustomFieldValueMutation>;
-export type SetCustomFieldValueMutationResult = Apollo.MutationResult<Types.SetCustomFieldValueMutation>;
-export type SetCustomFieldValueMutationOptions = Apollo.BaseMutationOptions<Types.SetCustomFieldValueMutation, Types.SetCustomFieldValueMutationVariables>;
-export declare const RemoveCustomFieldValueDocument: Apollo.DocumentNode;
-export type RemoveCustomFieldValueMutationFn = Apollo.MutationFunction<Types.RemoveCustomFieldValueMutation, Types.RemoveCustomFieldValueMutationVariables>;
+export declare function useDeleteProductFeatureMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteProductFeatureMutation, Types.DeleteProductFeatureMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteProductFeatureMutation, any, Apollo.ApolloCache>;
+export type DeleteProductFeatureMutationHookResult = ReturnType<typeof useDeleteProductFeatureMutation>;
+export type DeleteProductFeatureMutationResult = Apollo.MutationResult<Types.DeleteProductFeatureMutation>;
+export type DeleteProductFeatureMutationOptions = Apollo.BaseMutationOptions<Types.DeleteProductFeatureMutation, Types.DeleteProductFeatureMutationVariables>;
+export declare const LinkFeatureRequestToProductFeatureDocument: Apollo.DocumentNode;
+export type LinkFeatureRequestToProductFeatureMutationFn = Apollo.MutationFunction<Types.LinkFeatureRequestToProductFeatureMutation, Types.LinkFeatureRequestToProductFeatureMutationVariables>;
 /**
- * __useRemoveCustomFieldValueMutation__
+ * __useLinkFeatureRequestToProductFeatureMutation__
  *
- * To run a mutation, you first call `useRemoveCustomFieldValueMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useRemoveCustomFieldValueMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useLinkFeatureRequestToProductFeatureMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useLinkFeatureRequestToProductFeatureMutation` 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 [removeCustomFieldValueMutation, { data, loading, error }] = useRemoveCustomFieldValueMutation({
+ * const [linkFeatureRequestToProductFeatureMutation, { data, loading, error }] = useLinkFeatureRequestToProductFeatureMutation({
  *   variables: {
- *      definitionId: // value for 'definitionId'
- *      workItemId: // value for 'workItemId'
+ *      featureRequestId: // value for 'featureRequestId'
+ *      productFeatureId: // value for 'productFeatureId'
  *   },
  * });
  */
-export declare function useRemoveCustomFieldValueMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RemoveCustomFieldValueMutation, Types.RemoveCustomFieldValueMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RemoveCustomFieldValueMutation, any, Apollo.ApolloCache>;
-export type RemoveCustomFieldValueMutationHookResult = ReturnType<typeof useRemoveCustomFieldValueMutation>;
-export type RemoveCustomFieldValueMutationResult = Apollo.MutationResult<Types.RemoveCustomFieldValueMutation>;
-export type RemoveCustomFieldValueMutationOptions = Apollo.BaseMutationOptions<Types.RemoveCustomFieldValueMutation, Types.RemoveCustomFieldValueMutationVariables>;
-export declare const CreateMilestoneDocument: Apollo.DocumentNode;
-export type CreateMilestoneMutationFn = Apollo.MutationFunction<Types.CreateMilestoneMutation, Types.CreateMilestoneMutationVariables>;
+export declare function useLinkFeatureRequestToProductFeatureMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.LinkFeatureRequestToProductFeatureMutation, Types.LinkFeatureRequestToProductFeatureMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.LinkFeatureRequestToProductFeatureMutation, any, Apollo.ApolloCache>;
+export type LinkFeatureRequestToProductFeatureMutationHookResult = ReturnType<typeof useLinkFeatureRequestToProductFeatureMutation>;
+export type LinkFeatureRequestToProductFeatureMutationResult = Apollo.MutationResult<Types.LinkFeatureRequestToProductFeatureMutation>;
+export type LinkFeatureRequestToProductFeatureMutationOptions = Apollo.BaseMutationOptions<Types.LinkFeatureRequestToProductFeatureMutation, Types.LinkFeatureRequestToProductFeatureMutationVariables>;
+export declare const UnlinkFeatureRequestFromProductFeatureDocument: Apollo.DocumentNode;
+export type UnlinkFeatureRequestFromProductFeatureMutationFn = Apollo.MutationFunction<Types.UnlinkFeatureRequestFromProductFeatureMutation, Types.UnlinkFeatureRequestFromProductFeatureMutationVariables>;
 /**
- * __useCreateMilestoneMutation__
+ * __useUnlinkFeatureRequestFromProductFeatureMutation__
  *
- * To run a mutation, you first call `useCreateMilestoneMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useCreateMilestoneMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useUnlinkFeatureRequestFromProductFeatureMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUnlinkFeatureRequestFromProductFeatureMutation` 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 [createMilestoneMutation, { data, loading, error }] = useCreateMilestoneMutation({
+ * const [unlinkFeatureRequestFromProductFeatureMutation, { data, loading, error }] = useUnlinkFeatureRequestFromProductFeatureMutation({
  *   variables: {
- *      input: // value for 'input'
+ *      featureRequestId: // value for 'featureRequestId'
+ *      productFeatureId: // value for 'productFeatureId'
  *   },
  * });
  */
-export declare function useCreateMilestoneMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateMilestoneMutation, Types.CreateMilestoneMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateMilestoneMutation, any, Apollo.ApolloCache>;
-export type CreateMilestoneMutationHookResult = ReturnType<typeof useCreateMilestoneMutation>;
-export type CreateMilestoneMutationResult = Apollo.MutationResult<Types.CreateMilestoneMutation>;
-export type CreateMilestoneMutationOptions = Apollo.BaseMutationOptions<Types.CreateMilestoneMutation, Types.CreateMilestoneMutationVariables>;
-export declare const UpdateMilestoneDocument: Apollo.DocumentNode;
-export type UpdateMilestoneMutationFn = Apollo.MutationFunction<Types.UpdateMilestoneMutation, Types.UpdateMilestoneMutationVariables>;
+export declare function useUnlinkFeatureRequestFromProductFeatureMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UnlinkFeatureRequestFromProductFeatureMutation, Types.UnlinkFeatureRequestFromProductFeatureMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UnlinkFeatureRequestFromProductFeatureMutation, any, Apollo.ApolloCache>;
+export type UnlinkFeatureRequestFromProductFeatureMutationHookResult = ReturnType<typeof useUnlinkFeatureRequestFromProductFeatureMutation>;
+export type UnlinkFeatureRequestFromProductFeatureMutationResult = Apollo.MutationResult<Types.UnlinkFeatureRequestFromProductFeatureMutation>;
+export type UnlinkFeatureRequestFromProductFeatureMutationOptions = Apollo.BaseMutationOptions<Types.UnlinkFeatureRequestFromProductFeatureMutation, Types.UnlinkFeatureRequestFromProductFeatureMutationVariables>;
+export declare const LinkEpicToProductFeatureDocument: Apollo.DocumentNode;
+export type LinkEpicToProductFeatureMutationFn = Apollo.MutationFunction<Types.LinkEpicToProductFeatureMutation, Types.LinkEpicToProductFeatureMutationVariables>;
 /**
- * __useUpdateMilestoneMutation__
+ * __useLinkEpicToProductFeatureMutation__
  *
- * To run a mutation, you first call `useUpdateMilestoneMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useUpdateMilestoneMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useLinkEpicToProductFeatureMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useLinkEpicToProductFeatureMutation` 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 [updateMilestoneMutation, { data, loading, error }] = useUpdateMilestoneMutation({
+ * const [linkEpicToProductFeatureMutation, { data, loading, error }] = useLinkEpicToProductFeatureMutation({
  *   variables: {
- *      id: // value for 'id'
- *      input: // value for 'input'
+ *      productFeatureId: // value for 'productFeatureId'
+ *      workItemId: // value for 'workItemId'
  *   },
  * });
  */
-export declare function useUpdateMilestoneMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateMilestoneMutation, Types.UpdateMilestoneMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateMilestoneMutation, any, Apollo.ApolloCache>;
-export type UpdateMilestoneMutationHookResult = ReturnType<typeof useUpdateMilestoneMutation>;
-export type UpdateMilestoneMutationResult = Apollo.MutationResult<Types.UpdateMilestoneMutation>;
-export type UpdateMilestoneMutationOptions = Apollo.BaseMutationOptions<Types.UpdateMilestoneMutation, Types.UpdateMilestoneMutationVariables>;
-export declare const DeleteMilestoneDocument: Apollo.DocumentNode;
-export type DeleteMilestoneMutationFn = Apollo.MutationFunction<Types.DeleteMilestoneMutation, Types.DeleteMilestoneMutationVariables>;
+export declare function useLinkEpicToProductFeatureMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.LinkEpicToProductFeatureMutation, Types.LinkEpicToProductFeatureMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.LinkEpicToProductFeatureMutation, any, Apollo.ApolloCache>;
+export type LinkEpicToProductFeatureMutationHookResult = ReturnType<typeof useLinkEpicToProductFeatureMutation>;
+export type LinkEpicToProductFeatureMutationResult = Apollo.MutationResult<Types.LinkEpicToProductFeatureMutation>;
+export type LinkEpicToProductFeatureMutationOptions = Apollo.BaseMutationOptions<Types.LinkEpicToProductFeatureMutation, Types.LinkEpicToProductFeatureMutationVariables>;
+export declare const UnlinkEpicFromProductFeatureDocument: Apollo.DocumentNode;
+export type UnlinkEpicFromProductFeatureMutationFn = Apollo.MutationFunction<Types.UnlinkEpicFromProductFeatureMutation, Types.UnlinkEpicFromProductFeatureMutationVariables>;
 /**
- * __useDeleteMilestoneMutation__
+ * __useUnlinkEpicFromProductFeatureMutation__
  *
- * To run a mutation, you first call `useDeleteMilestoneMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useDeleteMilestoneMutation` returns a tuple that includes:
+ * To run a mutation, you first call `useUnlinkEpicFromProductFeatureMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUnlinkEpicFromProductFeatureMutation` 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 [deleteMilestoneMutation, { data, loading, error }] = useDeleteMilestoneMutation({
+ * const [unlinkEpicFromProductFeatureMutation, { data, loading, error }] = useUnlinkEpicFromProductFeatureMutation({
  *   variables: {
- *      id: // value for 'id'
+ *      productFeatureId: // value for 'productFeatureId'
+ *      workItemId: // value for 'workItemId'
  *   },
  * });
  */
-export declare function useDeleteMilestoneMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteMilestoneMutation, Types.DeleteMilestoneMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteMilestoneMutation, any, Apollo.ApolloCache>;
-export type DeleteMilestoneMutationHookResult = ReturnType<typeof useDeleteMilestoneMutation>;
-export type DeleteMilestoneMutationResult = Apollo.MutationResult<Types.DeleteMilestoneMutation>;
-export type DeleteMilestoneMutationOptions = Apollo.BaseMutationOptions<Types.DeleteMilestoneMutation, Types.DeleteMilestoneMutationVariables>;
+export declare function useUnlinkEpicFromProductFeatureMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UnlinkEpicFromProductFeatureMutation, Types.UnlinkEpicFromProductFeatureMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UnlinkEpicFromProductFeatureMutation, any, Apollo.ApolloCache>;
+export type UnlinkEpicFromProductFeatureMutationHookResult = ReturnType<typeof useUnlinkEpicFromProductFeatureMutation>;
+export type UnlinkEpicFromProductFeatureMutationResult = Apollo.MutationResult<Types.UnlinkEpicFromProductFeatureMutation>;
+export type UnlinkEpicFromProductFeatureMutationOptions = Apollo.BaseMutationOptions<Types.UnlinkEpicFromProductFeatureMutation, Types.UnlinkEpicFromProductFeatureMutationVariables>;
 export declare const CreateRoadmapDocument: Apollo.DocumentNode;
 export type CreateRoadmapMutationFn = Apollo.MutationFunction<Types.CreateRoadmapMutation, Types.CreateRoadmapMutationVariables>;
 /**
@@ -7250,6 +8263,406 @@ export type GetPortfolioOverviewQueryHookResult = ReturnType<typeof useGetPortfo
 export type GetPortfolioOverviewLazyQueryHookResult = ReturnType<typeof useGetPortfolioOverviewLazyQuery>;
 export type GetPortfolioOverviewSuspenseQueryHookResult = ReturnType<typeof useGetPortfolioOverviewSuspenseQuery>;
 export type GetPortfolioOverviewQueryResult = Apollo.QueryResult<Types.GetPortfolioOverviewQuery, Types.GetPortfolioOverviewQueryVariables>;
+export declare const ProductLinesPageDocument: Apollo.DocumentNode;
+/**
+ * __useProductLinesPageQuery__
+ *
+ * To run a query within a React component, call `useProductLinesPageQuery` and pass it any options that fit your needs.
+ * When your component renders, `useProductLinesPageQuery` 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 } = useProductLinesPageQuery({
+ *   variables: {
+ *      workspaceId: // value for 'workspaceId'
+ *      filter: // value for 'filter'
+ *   },
+ * });
+ */
+export declare function useProductLinesPageQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ProductLinesPageQuery, Types.ProductLinesPageQueryVariables> & ({
+    variables: Types.ProductLinesPageQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.ProductLinesPageQuery, Types.ProductLinesPageQueryVariables, "empty" | "complete" | "streaming", Types.ProductLinesPageQueryVariables>;
+export declare function useProductLinesPageLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ProductLinesPageQuery, Types.ProductLinesPageQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ProductLinesPageQuery, Types.ProductLinesPageQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useProductLinesPageSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductLinesPageQuery, Types.ProductLinesPageQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductLinesPageQuery, Types.ProductLinesPageQueryVariables>;
+export declare function useProductLinesPageSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductLinesPageQuery, Types.ProductLinesPageQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductLinesPageQuery | undefined, Types.ProductLinesPageQueryVariables>;
+export type ProductLinesPageQueryHookResult = ReturnType<typeof useProductLinesPageQuery>;
+export type ProductLinesPageLazyQueryHookResult = ReturnType<typeof useProductLinesPageLazyQuery>;
+export type ProductLinesPageSuspenseQueryHookResult = ReturnType<typeof useProductLinesPageSuspenseQuery>;
+export type ProductLinesPageQueryResult = Apollo.QueryResult<Types.ProductLinesPageQuery, Types.ProductLinesPageQueryVariables>;
+export declare const ProductLineOptionsDocument: Apollo.DocumentNode;
+/**
+ * __useProductLineOptionsQuery__
+ *
+ * To run a query within a React component, call `useProductLineOptionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useProductLineOptionsQuery` 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 } = useProductLineOptionsQuery({
+ *   variables: {
+ *      workspaceId: // value for 'workspaceId'
+ *   },
+ * });
+ */
+export declare function useProductLineOptionsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ProductLineOptionsQuery, Types.ProductLineOptionsQueryVariables> & ({
+    variables: Types.ProductLineOptionsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.ProductLineOptionsQuery, Types.ProductLineOptionsQueryVariables, "empty" | "complete" | "streaming", Types.ProductLineOptionsQueryVariables>;
+export declare function useProductLineOptionsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ProductLineOptionsQuery, Types.ProductLineOptionsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ProductLineOptionsQuery, Types.ProductLineOptionsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useProductLineOptionsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductLineOptionsQuery, Types.ProductLineOptionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductLineOptionsQuery, Types.ProductLineOptionsQueryVariables>;
+export declare function useProductLineOptionsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductLineOptionsQuery, Types.ProductLineOptionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductLineOptionsQuery | undefined, Types.ProductLineOptionsQueryVariables>;
+export type ProductLineOptionsQueryHookResult = ReturnType<typeof useProductLineOptionsQuery>;
+export type ProductLineOptionsLazyQueryHookResult = ReturnType<typeof useProductLineOptionsLazyQuery>;
+export type ProductLineOptionsSuspenseQueryHookResult = ReturnType<typeof useProductLineOptionsSuspenseQuery>;
+export type ProductLineOptionsQueryResult = Apollo.QueryResult<Types.ProductLineOptionsQuery, Types.ProductLineOptionsQueryVariables>;
+export declare const ProductLineAssignmentDocument: Apollo.DocumentNode;
+/**
+ * __useProductLineAssignmentQuery__
+ *
+ * To run a query within a React component, call `useProductLineAssignmentQuery` and pass it any options that fit your needs.
+ * When your component renders, `useProductLineAssignmentQuery` 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 } = useProductLineAssignmentQuery({
+ *   variables: {
+ *      productId: // value for 'productId'
+ *   },
+ * });
+ */
+export declare function useProductLineAssignmentQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ProductLineAssignmentQuery, Types.ProductLineAssignmentQueryVariables> & ({
+    variables: Types.ProductLineAssignmentQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.ProductLineAssignmentQuery, Types.ProductLineAssignmentQueryVariables, "empty" | "complete" | "streaming", Types.ProductLineAssignmentQueryVariables>;
+export declare function useProductLineAssignmentLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ProductLineAssignmentQuery, Types.ProductLineAssignmentQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ProductLineAssignmentQuery, Types.ProductLineAssignmentQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useProductLineAssignmentSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductLineAssignmentQuery, Types.ProductLineAssignmentQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductLineAssignmentQuery, Types.ProductLineAssignmentQueryVariables>;
+export declare function useProductLineAssignmentSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductLineAssignmentQuery, Types.ProductLineAssignmentQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductLineAssignmentQuery | undefined, Types.ProductLineAssignmentQueryVariables>;
+export type ProductLineAssignmentQueryHookResult = ReturnType<typeof useProductLineAssignmentQuery>;
+export type ProductLineAssignmentLazyQueryHookResult = ReturnType<typeof useProductLineAssignmentLazyQuery>;
+export type ProductLineAssignmentSuspenseQueryHookResult = ReturnType<typeof useProductLineAssignmentSuspenseQuery>;
+export type ProductLineAssignmentQueryResult = Apollo.QueryResult<Types.ProductLineAssignmentQuery, Types.ProductLineAssignmentQueryVariables>;
+export declare const ProductLineCandidateProductsDocument: Apollo.DocumentNode;
+/**
+ * __useProductLineCandidateProductsQuery__
+ *
+ * To run a query within a React component, call `useProductLineCandidateProductsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useProductLineCandidateProductsQuery` 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 } = useProductLineCandidateProductsQuery({
+ *   variables: {
+ *      workspaceId: // value for 'workspaceId'
+ *   },
+ * });
+ */
+export declare function useProductLineCandidateProductsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ProductLineCandidateProductsQuery, Types.ProductLineCandidateProductsQueryVariables> & ({
+    variables: Types.ProductLineCandidateProductsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.ProductLineCandidateProductsQuery, Types.ProductLineCandidateProductsQueryVariables, "empty" | "complete" | "streaming", Types.ProductLineCandidateProductsQueryVariables>;
+export declare function useProductLineCandidateProductsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ProductLineCandidateProductsQuery, Types.ProductLineCandidateProductsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ProductLineCandidateProductsQuery, Types.ProductLineCandidateProductsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useProductLineCandidateProductsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductLineCandidateProductsQuery, Types.ProductLineCandidateProductsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductLineCandidateProductsQuery, Types.ProductLineCandidateProductsQueryVariables>;
+export declare function useProductLineCandidateProductsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductLineCandidateProductsQuery, Types.ProductLineCandidateProductsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductLineCandidateProductsQuery | undefined, Types.ProductLineCandidateProductsQueryVariables>;
+export type ProductLineCandidateProductsQueryHookResult = ReturnType<typeof useProductLineCandidateProductsQuery>;
+export type ProductLineCandidateProductsLazyQueryHookResult = ReturnType<typeof useProductLineCandidateProductsLazyQuery>;
+export type ProductLineCandidateProductsSuspenseQueryHookResult = ReturnType<typeof useProductLineCandidateProductsSuspenseQuery>;
+export type ProductLineCandidateProductsQueryResult = Apollo.QueryResult<Types.ProductLineCandidateProductsQuery, Types.ProductLineCandidateProductsQueryVariables>;
+export declare const ProductTeamsDocument: Apollo.DocumentNode;
+/**
+ * __useProductTeamsQuery__
+ *
+ * To run a query within a React component, call `useProductTeamsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useProductTeamsQuery` 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 } = useProductTeamsQuery({
+ *   variables: {
+ *      productId: // value for 'productId'
+ *   },
+ * });
+ */
+export declare function useProductTeamsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ProductTeamsQuery, Types.ProductTeamsQueryVariables> & ({
+    variables: Types.ProductTeamsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.ProductTeamsQuery, Types.ProductTeamsQueryVariables, "empty" | "complete" | "streaming", Types.ProductTeamsQueryVariables>;
+export declare function useProductTeamsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ProductTeamsQuery, Types.ProductTeamsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ProductTeamsQuery, Types.ProductTeamsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useProductTeamsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductTeamsQuery, Types.ProductTeamsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductTeamsQuery, Types.ProductTeamsQueryVariables>;
+export declare function useProductTeamsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductTeamsQuery, Types.ProductTeamsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductTeamsQuery | undefined, Types.ProductTeamsQueryVariables>;
+export type ProductTeamsQueryHookResult = ReturnType<typeof useProductTeamsQuery>;
+export type ProductTeamsLazyQueryHookResult = ReturnType<typeof useProductTeamsLazyQuery>;
+export type ProductTeamsSuspenseQueryHookResult = ReturnType<typeof useProductTeamsSuspenseQuery>;
+export type ProductTeamsQueryResult = Apollo.QueryResult<Types.ProductTeamsQuery, Types.ProductTeamsQueryVariables>;
+export declare const ProductFeaturesListDocument: Apollo.DocumentNode;
+/**
+ * __useProductFeaturesListQuery__
+ *
+ * To run a query within a React component, call `useProductFeaturesListQuery` and pass it any options that fit your needs.
+ * When your component renders, `useProductFeaturesListQuery` 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 } = useProductFeaturesListQuery({
+ *   variables: {
+ *      workspaceId: // value for 'workspaceId'
+ *      productId: // value for 'productId'
+ *      filter: // value for 'filter'
+ *   },
+ * });
+ */
+export declare function useProductFeaturesListQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ProductFeaturesListQuery, Types.ProductFeaturesListQueryVariables> & ({
+    variables: Types.ProductFeaturesListQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.ProductFeaturesListQuery, Types.ProductFeaturesListQueryVariables, "empty" | "complete" | "streaming", Types.ProductFeaturesListQueryVariables>;
+export declare function useProductFeaturesListLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ProductFeaturesListQuery, Types.ProductFeaturesListQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ProductFeaturesListQuery, Types.ProductFeaturesListQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useProductFeaturesListSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductFeaturesListQuery, Types.ProductFeaturesListQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductFeaturesListQuery, Types.ProductFeaturesListQueryVariables>;
+export declare function useProductFeaturesListSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductFeaturesListQuery, Types.ProductFeaturesListQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductFeaturesListQuery | undefined, Types.ProductFeaturesListQueryVariables>;
+export type ProductFeaturesListQueryHookResult = ReturnType<typeof useProductFeaturesListQuery>;
+export type ProductFeaturesListLazyQueryHookResult = ReturnType<typeof useProductFeaturesListLazyQuery>;
+export type ProductFeaturesListSuspenseQueryHookResult = ReturnType<typeof useProductFeaturesListSuspenseQuery>;
+export type ProductFeaturesListQueryResult = Apollo.QueryResult<Types.ProductFeaturesListQuery, Types.ProductFeaturesListQueryVariables>;
+export declare const ProductFeatureDetailDocument: Apollo.DocumentNode;
+/**
+ * __useProductFeatureDetailQuery__
+ *
+ * To run a query within a React component, call `useProductFeatureDetailQuery` and pass it any options that fit your needs.
+ * When your component renders, `useProductFeatureDetailQuery` 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 } = useProductFeatureDetailQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useProductFeatureDetailQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ProductFeatureDetailQuery, Types.ProductFeatureDetailQueryVariables> & ({
+    variables: Types.ProductFeatureDetailQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.ProductFeatureDetailQuery, Types.ProductFeatureDetailQueryVariables, "empty" | "complete" | "streaming", Types.ProductFeatureDetailQueryVariables>;
+export declare function useProductFeatureDetailLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ProductFeatureDetailQuery, Types.ProductFeatureDetailQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ProductFeatureDetailQuery, Types.ProductFeatureDetailQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useProductFeatureDetailSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductFeatureDetailQuery, Types.ProductFeatureDetailQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductFeatureDetailQuery, Types.ProductFeatureDetailQueryVariables>;
+export declare function useProductFeatureDetailSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductFeatureDetailQuery, Types.ProductFeatureDetailQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductFeatureDetailQuery | undefined, Types.ProductFeatureDetailQueryVariables>;
+export type ProductFeatureDetailQueryHookResult = ReturnType<typeof useProductFeatureDetailQuery>;
+export type ProductFeatureDetailLazyQueryHookResult = ReturnType<typeof useProductFeatureDetailLazyQuery>;
+export type ProductFeatureDetailSuspenseQueryHookResult = ReturnType<typeof useProductFeatureDetailSuspenseQuery>;
+export type ProductFeatureDetailQueryResult = Apollo.QueryResult<Types.ProductFeatureDetailQuery, Types.ProductFeatureDetailQueryVariables>;
+export declare const ProductFeatureEpicCandidatesDocument: Apollo.DocumentNode;
+/**
+ * __useProductFeatureEpicCandidatesQuery__
+ *
+ * To run a query within a React component, call `useProductFeatureEpicCandidatesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useProductFeatureEpicCandidatesQuery` 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 } = useProductFeatureEpicCandidatesQuery({
+ *   variables: {
+ *      workspaceId: // value for 'workspaceId'
+ *      filter: // value for 'filter'
+ *   },
+ * });
+ */
+export declare function useProductFeatureEpicCandidatesQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ProductFeatureEpicCandidatesQuery, Types.ProductFeatureEpicCandidatesQueryVariables> & ({
+    variables: Types.ProductFeatureEpicCandidatesQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.ProductFeatureEpicCandidatesQuery, Types.ProductFeatureEpicCandidatesQueryVariables, "empty" | "complete" | "streaming", Types.ProductFeatureEpicCandidatesQueryVariables>;
+export declare function useProductFeatureEpicCandidatesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ProductFeatureEpicCandidatesQuery, Types.ProductFeatureEpicCandidatesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ProductFeatureEpicCandidatesQuery, Types.ProductFeatureEpicCandidatesQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useProductFeatureEpicCandidatesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductFeatureEpicCandidatesQuery, Types.ProductFeatureEpicCandidatesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductFeatureEpicCandidatesQuery, Types.ProductFeatureEpicCandidatesQueryVariables>;
+export declare function useProductFeatureEpicCandidatesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductFeatureEpicCandidatesQuery, Types.ProductFeatureEpicCandidatesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductFeatureEpicCandidatesQuery | undefined, Types.ProductFeatureEpicCandidatesQueryVariables>;
+export type ProductFeatureEpicCandidatesQueryHookResult = ReturnType<typeof useProductFeatureEpicCandidatesQuery>;
+export type ProductFeatureEpicCandidatesLazyQueryHookResult = ReturnType<typeof useProductFeatureEpicCandidatesLazyQuery>;
+export type ProductFeatureEpicCandidatesSuspenseQueryHookResult = ReturnType<typeof useProductFeatureEpicCandidatesSuspenseQuery>;
+export type ProductFeatureEpicCandidatesQueryResult = Apollo.QueryResult<Types.ProductFeatureEpicCandidatesQuery, Types.ProductFeatureEpicCandidatesQueryVariables>;
+export declare const ProductFeatureRequestCandidatesDocument: Apollo.DocumentNode;
+/**
+ * __useProductFeatureRequestCandidatesQuery__
+ *
+ * To run a query within a React component, call `useProductFeatureRequestCandidatesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useProductFeatureRequestCandidatesQuery` 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 } = useProductFeatureRequestCandidatesQuery({
+ *   variables: {
+ *      workspaceId: // value for 'workspaceId'
+ *      sameProduct: // value for 'sameProduct'
+ *      anyProduct: // value for 'anyProduct'
+ *   },
+ * });
+ */
+export declare function useProductFeatureRequestCandidatesQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ProductFeatureRequestCandidatesQuery, Types.ProductFeatureRequestCandidatesQueryVariables> & ({
+    variables: Types.ProductFeatureRequestCandidatesQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.ProductFeatureRequestCandidatesQuery, Types.ProductFeatureRequestCandidatesQueryVariables, "empty" | "complete" | "streaming", Types.ProductFeatureRequestCandidatesQueryVariables>;
+export declare function useProductFeatureRequestCandidatesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ProductFeatureRequestCandidatesQuery, Types.ProductFeatureRequestCandidatesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ProductFeatureRequestCandidatesQuery, Types.ProductFeatureRequestCandidatesQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useProductFeatureRequestCandidatesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductFeatureRequestCandidatesQuery, Types.ProductFeatureRequestCandidatesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductFeatureRequestCandidatesQuery, Types.ProductFeatureRequestCandidatesQueryVariables>;
+export declare function useProductFeatureRequestCandidatesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductFeatureRequestCandidatesQuery, Types.ProductFeatureRequestCandidatesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductFeatureRequestCandidatesQuery | undefined, Types.ProductFeatureRequestCandidatesQueryVariables>;
+export type ProductFeatureRequestCandidatesQueryHookResult = ReturnType<typeof useProductFeatureRequestCandidatesQuery>;
+export type ProductFeatureRequestCandidatesLazyQueryHookResult = ReturnType<typeof useProductFeatureRequestCandidatesLazyQuery>;
+export type ProductFeatureRequestCandidatesSuspenseQueryHookResult = ReturnType<typeof useProductFeatureRequestCandidatesSuspenseQuery>;
+export type ProductFeatureRequestCandidatesQueryResult = Apollo.QueryResult<Types.ProductFeatureRequestCandidatesQuery, Types.ProductFeatureRequestCandidatesQueryVariables>;
+export declare const ProductHierarchyDocument: Apollo.DocumentNode;
+/**
+ * __useProductHierarchyQuery__
+ *
+ * To run a query within a React component, call `useProductHierarchyQuery` and pass it any options that fit your needs.
+ * When your component renders, `useProductHierarchyQuery` 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 } = useProductHierarchyQuery({
+ *   variables: {
+ *      workspaceId: // value for 'workspaceId'
+ *      lineFilter: // value for 'lineFilter'
+ *      productFilter: // value for 'productFilter'
+ *      includeArchivedFeatures: // value for 'includeArchivedFeatures'
+ *   },
+ * });
+ */
+export declare function useProductHierarchyQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ProductHierarchyQuery, Types.ProductHierarchyQueryVariables> & ({
+    variables: Types.ProductHierarchyQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.ProductHierarchyQuery, Types.ProductHierarchyQueryVariables, "empty" | "complete" | "streaming", Types.ProductHierarchyQueryVariables>;
+export declare function useProductHierarchyLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ProductHierarchyQuery, Types.ProductHierarchyQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ProductHierarchyQuery, Types.ProductHierarchyQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useProductHierarchySuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductHierarchyQuery, Types.ProductHierarchyQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductHierarchyQuery, Types.ProductHierarchyQueryVariables>;
+export declare function useProductHierarchySuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ProductHierarchyQuery, Types.ProductHierarchyQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ProductHierarchyQuery | undefined, Types.ProductHierarchyQueryVariables>;
+export type ProductHierarchyQueryHookResult = ReturnType<typeof useProductHierarchyQuery>;
+export type ProductHierarchyLazyQueryHookResult = ReturnType<typeof useProductHierarchyLazyQuery>;
+export type ProductHierarchySuspenseQueryHookResult = ReturnType<typeof useProductHierarchySuspenseQuery>;
+export type ProductHierarchyQueryResult = Apollo.QueryResult<Types.ProductHierarchyQuery, Types.ProductHierarchyQueryVariables>;
+export declare const FeatureRequestProductFeatureDocument: Apollo.DocumentNode;
+/**
+ * __useFeatureRequestProductFeatureQuery__
+ *
+ * To run a query within a React component, call `useFeatureRequestProductFeatureQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFeatureRequestProductFeatureQuery` 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 } = useFeatureRequestProductFeatureQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useFeatureRequestProductFeatureQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.FeatureRequestProductFeatureQuery, Types.FeatureRequestProductFeatureQueryVariables> & ({
+    variables: Types.FeatureRequestProductFeatureQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.FeatureRequestProductFeatureQuery, Types.FeatureRequestProductFeatureQueryVariables, "empty" | "complete" | "streaming", Types.FeatureRequestProductFeatureQueryVariables>;
+export declare function useFeatureRequestProductFeatureLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.FeatureRequestProductFeatureQuery, Types.FeatureRequestProductFeatureQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.FeatureRequestProductFeatureQuery, Types.FeatureRequestProductFeatureQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useFeatureRequestProductFeatureSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.FeatureRequestProductFeatureQuery, Types.FeatureRequestProductFeatureQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.FeatureRequestProductFeatureQuery, Types.FeatureRequestProductFeatureQueryVariables>;
+export declare function useFeatureRequestProductFeatureSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.FeatureRequestProductFeatureQuery, Types.FeatureRequestProductFeatureQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.FeatureRequestProductFeatureQuery | undefined, Types.FeatureRequestProductFeatureQueryVariables>;
+export type FeatureRequestProductFeatureQueryHookResult = ReturnType<typeof useFeatureRequestProductFeatureQuery>;
+export type FeatureRequestProductFeatureLazyQueryHookResult = ReturnType<typeof useFeatureRequestProductFeatureLazyQuery>;
+export type FeatureRequestProductFeatureSuspenseQueryHookResult = ReturnType<typeof useFeatureRequestProductFeatureSuspenseQuery>;
+export type FeatureRequestProductFeatureQueryResult = Apollo.QueryResult<Types.FeatureRequestProductFeatureQuery, Types.FeatureRequestProductFeatureQueryVariables>;
+export declare const FeatureRequestFeatureOptionsDocument: Apollo.DocumentNode;
+/**
+ * __useFeatureRequestFeatureOptionsQuery__
+ *
+ * To run a query within a React component, call `useFeatureRequestFeatureOptionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFeatureRequestFeatureOptionsQuery` 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 } = useFeatureRequestFeatureOptionsQuery({
+ *   variables: {
+ *      workspaceId: // value for 'workspaceId'
+ *      productId: // value for 'productId'
+ *   },
+ * });
+ */
+export declare function useFeatureRequestFeatureOptionsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.FeatureRequestFeatureOptionsQuery, Types.FeatureRequestFeatureOptionsQueryVariables> & ({
+    variables: Types.FeatureRequestFeatureOptionsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.FeatureRequestFeatureOptionsQuery, Types.FeatureRequestFeatureOptionsQueryVariables, "empty" | "complete" | "streaming", Types.FeatureRequestFeatureOptionsQueryVariables>;
+export declare function useFeatureRequestFeatureOptionsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.FeatureRequestFeatureOptionsQuery, Types.FeatureRequestFeatureOptionsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.FeatureRequestFeatureOptionsQuery, Types.FeatureRequestFeatureOptionsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useFeatureRequestFeatureOptionsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.FeatureRequestFeatureOptionsQuery, Types.FeatureRequestFeatureOptionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.FeatureRequestFeatureOptionsQuery, Types.FeatureRequestFeatureOptionsQueryVariables>;
+export declare function useFeatureRequestFeatureOptionsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.FeatureRequestFeatureOptionsQuery, Types.FeatureRequestFeatureOptionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.FeatureRequestFeatureOptionsQuery | undefined, Types.FeatureRequestFeatureOptionsQueryVariables>;
+export type FeatureRequestFeatureOptionsQueryHookResult = ReturnType<typeof useFeatureRequestFeatureOptionsQuery>;
+export type FeatureRequestFeatureOptionsLazyQueryHookResult = ReturnType<typeof useFeatureRequestFeatureOptionsLazyQuery>;
+export type FeatureRequestFeatureOptionsSuspenseQueryHookResult = ReturnType<typeof useFeatureRequestFeatureOptionsSuspenseQuery>;
+export type FeatureRequestFeatureOptionsQueryResult = Apollo.QueryResult<Types.FeatureRequestFeatureOptionsQuery, Types.FeatureRequestFeatureOptionsQueryVariables>;
+export declare const WorkItemProductFeatureDocument: Apollo.DocumentNode;
+/**
+ * __useWorkItemProductFeatureQuery__
+ *
+ * To run a query within a React component, call `useWorkItemProductFeatureQuery` and pass it any options that fit your needs.
+ * When your component renders, `useWorkItemProductFeatureQuery` 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 } = useWorkItemProductFeatureQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useWorkItemProductFeatureQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.WorkItemProductFeatureQuery, Types.WorkItemProductFeatureQueryVariables> & ({
+    variables: Types.WorkItemProductFeatureQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.WorkItemProductFeatureQuery, Types.WorkItemProductFeatureQueryVariables, "empty" | "complete" | "streaming", Types.WorkItemProductFeatureQueryVariables>;
+export declare function useWorkItemProductFeatureLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.WorkItemProductFeatureQuery, Types.WorkItemProductFeatureQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.WorkItemProductFeatureQuery, Types.WorkItemProductFeatureQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useWorkItemProductFeatureSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.WorkItemProductFeatureQuery, Types.WorkItemProductFeatureQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.WorkItemProductFeatureQuery, Types.WorkItemProductFeatureQueryVariables>;
+export declare function useWorkItemProductFeatureSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.WorkItemProductFeatureQuery, Types.WorkItemProductFeatureQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.WorkItemProductFeatureQuery | undefined, Types.WorkItemProductFeatureQueryVariables>;
+export type WorkItemProductFeatureQueryHookResult = ReturnType<typeof useWorkItemProductFeatureQuery>;
+export type WorkItemProductFeatureLazyQueryHookResult = ReturnType<typeof useWorkItemProductFeatureLazyQuery>;
+export type WorkItemProductFeatureSuspenseQueryHookResult = ReturnType<typeof useWorkItemProductFeatureSuspenseQuery>;
+export type WorkItemProductFeatureQueryResult = Apollo.QueryResult<Types.WorkItemProductFeatureQuery, Types.WorkItemProductFeatureQueryVariables>;
 export declare const ListRoadmapsDocument: Apollo.DocumentNode;
 /**
  * __useListRoadmapsQuery__