import * as Types from './wspace-types';
import * as Apollo from '@apollo/client';
import * as ApolloReactHooks from '@apollo/client/react';
export type BoardFieldsFragment = {
    __typename?: 'Board';
    id: string;
    workspaceId: string;
    projectId: string;
    name: string;
    description?: string | null;
    type: Types.BoardType;
    isDefault: boolean;
    metadata?: Record<string, unknown> | null;
    createdBy: string;
    createdAt: string;
    updatedAt: string;
    updatedBy?: string | null;
    deletedAt?: string | null;
    columns: Array<{
        __typename?: 'BoardColumn';
        id: string;
        boardId: string;
        name: string;
        type: Types.BoardColumnType;
        mappedStatus?: Types.WorkItemStatus | null;
        wipLimit?: number | null;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
    }>;
};
export type BoardColumnFieldsFragment = {
    __typename?: 'BoardColumn';
    id: string;
    boardId: string;
    name: string;
    type: Types.BoardColumnType;
    mappedStatus?: Types.WorkItemStatus | null;
    wipLimit?: number | null;
    sortOrder: number;
    metadata?: Record<string, unknown> | null;
    createdAt: string;
    updatedAt: string;
};
export type BoardSummaryFieldsFragment = {
    __typename?: 'Board';
    id: string;
    name: string;
    type: Types.BoardType;
    isDefault: boolean;
    projectId: string;
};
export type MilestoneFieldsFragment = {
    __typename?: 'Milestone';
    id: string;
    workspaceId: string;
    projectId: string;
    name: string;
    description?: string | null;
    status: Types.MilestoneStatus;
    dueDate?: string | null;
    completedAt?: string | null;
    ownerId?: string | null;
    sortOrder: number;
    metadata?: Record<string, unknown> | null;
    createdBy: string;
    createdAt: string;
    updatedAt: string;
    updatedBy?: string | null;
    deletedAt?: string | null;
};
export type MilestoneSummaryFieldsFragment = {
    __typename?: 'Milestone';
    id: string;
    name: string;
    status: Types.MilestoneStatus;
    dueDate?: string | null;
    completedAt?: string | null;
    ownerId?: string | null;
};
export type PortfolioFieldsFragment = {
    __typename?: 'Portfolio';
    id: string;
    workspaceId: string;
    name: string;
    description?: string | null;
    status: Types.PortfolioStatus;
    ownerId: string;
    alignment?: Types.StrategicAlignment | null;
    alignmentLabel?: string | null;
    budgetTotal?: number | null;
    currency?: string | null;
    fiscalPeriod?: string | null;
    tags: Array<string>;
    metadata?: Record<string, unknown> | null;
    createdBy: string;
    createdAt: string;
    updatedAt: string;
    updatedBy?: string | null;
    deletedAt?: string | null;
};
export type PortfolioSummaryFieldsFragment = {
    __typename?: 'Portfolio';
    id: string;
    name: string;
    status: Types.PortfolioStatus;
    ownerId: string;
    alignment?: Types.StrategicAlignment | null;
    budgetTotal?: number | null;
    currency?: string | null;
};
export type PortfolioOverviewFieldsFragment = {
    __typename?: 'PortfolioOverview';
    portfolioId: string;
    totalProjects: number;
    totalPrograms: number;
    atRiskCount: number;
    overdueMilestones: number;
    healthScore?: number | null;
    budgetUtilization?: number | null;
    totalBudget?: number | null;
    totalSpent?: number | null;
    projectsByStatus: Record<string, unknown>;
};
export type ProgramFieldsFragment = {
    __typename?: 'Program';
    id: string;
    workspaceId: string;
    name: string;
    description?: string | null;
    status: Types.ProjectStatus;
    ownerId: string;
    startDate?: string | null;
    endDate?: string | null;
    budgetTotal?: number | null;
    currency?: string | null;
    tags: Array<string>;
    metadata?: Record<string, unknown> | null;
    createdBy: string;
    createdAt: string;
    updatedAt: string;
    updatedBy?: string | null;
    deletedAt?: string | null;
};
export type ProgramSummaryFieldsFragment = {
    __typename?: 'Program';
    id: string;
    name: string;
    status: Types.ProjectStatus;
    ownerId: string;
    startDate?: string | null;
    endDate?: string | null;
};
export type RoadmapFieldsFragment = {
    __typename?: 'Roadmap';
    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;
};
export type RoadmapItemFieldsFragment = {
    __typename?: 'RoadmapItem';
    id: string;
    roadmapId: string;
    title: 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;
};
export type ReleaseFieldsFragment = {
    __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;
};
export type FeatureRequestFieldsFragment = {
    __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;
};
export type FeatureVoteFieldsFragment = {
    __typename?: 'FeatureVote';
    id: string;
    featureRequestId: string;
    voterId: string;
    weight: number;
    comment?: string | null;
    createdAt: string;
};
export type CompetitorFieldsFragment = {
    __typename?: 'Competitor';
    id: string;
    workspaceId: string;
    name: string;
    description?: string | null;
    website?: string | null;
    tags: Array<string>;
    metadata?: Record<string, unknown> | null;
    createdBy: string;
    createdAt: string;
    updatedAt: string;
    deletedAt?: string | null;
};
export type ProjectFieldsFragment = {
    __typename?: 'Project';
    id: string;
    workspaceId: string;
    name: string;
    description?: string | null;
    key: string;
    status: Types.ProjectStatus;
    methodology: Types.ProjectMethodology;
    startDate?: string | null;
    endDate?: string | null;
    defaultAssigneeId?: string | null;
    ownerId: string;
    programId?: string | null;
    tags: Array<string>;
    metadata?: Record<string, unknown> | null;
    createdBy: string;
    createdAt: string;
    updatedAt: string;
    updatedBy?: string | null;
    deletedAt?: string | null;
};
export type ProjectSummaryFieldsFragment = {
    __typename?: 'Project';
    id: string;
    name: string;
    key: string;
    status: Types.ProjectStatus;
    methodology: Types.ProjectMethodology;
    ownerId: string;
    startDate?: string | null;
    endDate?: string | null;
    tags: Array<string>;
};
export type SprintFieldsFragment = {
    __typename?: 'Sprint';
    id: string;
    workspaceId: string;
    projectId: string;
    name: string;
    goal?: string | null;
    status: Types.SprintStatus;
    startDate?: string | null;
    endDate?: string | null;
    capacity?: number | null;
    velocity?: number | null;
    sortOrder: number;
    metadata?: Record<string, unknown> | null;
    createdBy: string;
    createdAt: string;
    updatedAt: string;
    updatedBy?: string | null;
    deletedAt?: string | null;
};
export type SprintSummaryFieldsFragment = {
    __typename?: 'Sprint';
    id: string;
    name: string;
    status: Types.SprintStatus;
    startDate?: string | null;
    endDate?: string | null;
    capacity?: number | null;
    velocity?: number | null;
};
export type TimeEntryFieldsFragment = {
    __typename?: 'TimeEntry';
    id: string;
    workspaceId: string;
    projectId: string;
    workItemId: string;
    userId: string;
    date: string;
    durationMinutes: number;
    startTime?: string | null;
    endTime?: string | null;
    description?: string | null;
    billingType: Types.BillingType;
    billingRate?: number | null;
    status: Types.TimeEntryStatus;
    timesheetId?: string | null;
    metadata?: Record<string, unknown> | null;
    createdBy: string;
    createdAt: string;
    updatedAt: string;
};
export type TimesheetFieldsFragment = {
    __typename?: 'Timesheet';
    id: string;
    workspaceId: string;
    userId: string;
    periodStart: string;
    periodEnd: string;
    status: Types.TimeEntryStatus;
    totalMinutes: number;
    billableMinutes: number;
    approverId?: string | null;
    approvedAt?: string | null;
    rejectionReason?: string | null;
    metadata?: Record<string, unknown> | null;
    createdBy: string;
    createdAt: string;
    updatedAt: string;
};
export type WorkItemFieldsFragment = {
    __typename?: 'WorkItem';
    id: string;
    workspaceId: string;
    projectId: string;
    key: string;
    title: string;
    description?: string | null;
    type: Types.WorkItemType;
    status: Types.WorkItemStatus;
    priority: Types.WorkItemPriority;
    assigneeId?: string | null;
    reporterId?: string | null;
    parentId?: string | null;
    sprintId?: string | null;
    storyPoints?: number | null;
    estimateMinutes?: number | null;
    timeSpentMinutes?: number | null;
    dueDate?: string | null;
    labels: Array<string>;
    tags: Array<string>;
    sortOrder: number;
    metadata?: Record<string, unknown> | null;
    createdBy: string;
    createdAt: string;
    updatedAt: string;
    updatedBy?: string | null;
    deletedAt?: string | null;
};
export type WorkItemSummaryFieldsFragment = {
    __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>;
};
export type WorkItemDependencyFieldsFragment = {
    __typename?: 'WorkItemDependency';
    id: string;
    workspaceId: string;
    sourceWorkItemId: string;
    targetWorkItemId: string;
    type: Types.DependencyType;
    status: Types.DependencyStatus;
    description?: string | null;
    metadata?: Record<string, unknown> | null;
    createdBy: string;
    createdAt: string;
    updatedAt: string;
};
export type CreateAutomationRuleMutationVariables = Types.Exact<{
    input: Types.CreateAutomationRuleInput;
}>;
export type CreateAutomationRuleMutation = {
    __typename?: 'Mutation';
    planmagnetCreateAutomationRule: {
        __typename?: 'AutomationRule';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        description?: string | null;
        status: Types.AutomationStatus;
        triggerType: Types.AutomationTriggerType;
        triggerConfig: Record<string, unknown>;
        conditions?: Record<string, unknown> | null;
        actions: Record<string, unknown>;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type UpdateAutomationRuleMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateAutomationRuleInput;
}>;
export type UpdateAutomationRuleMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateAutomationRule: {
        __typename?: 'AutomationRule';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        description?: string | null;
        status: Types.AutomationStatus;
        triggerType: Types.AutomationTriggerType;
        triggerConfig: Record<string, unknown>;
        conditions?: Record<string, unknown> | null;
        actions: Record<string, unknown>;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
    };
};
export type DeleteAutomationRuleMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteAutomationRuleMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteAutomationRule: boolean;
};
export type ToggleAutomationRuleMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    status: Types.AutomationStatus;
}>;
export type ToggleAutomationRuleMutation = {
    __typename?: 'Mutation';
    planmagnetToggleAutomationRule: {
        __typename?: 'AutomationRule';
        id: string;
        name: string;
        status: Types.AutomationStatus;
        updatedAt: string;
        updatedBy?: string | null;
    };
};
export type ExecuteAutomationRuleMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    triggerData?: Types.InputMaybe<Types.Scalars['JSON']['input']>;
}>;
export type ExecuteAutomationRuleMutation = {
    __typename?: 'Mutation';
    planmagnetExecuteAutomationRule: {
        __typename?: 'AutomationExecution';
        id: string;
        ruleId: string;
        status: Types.AutomationExecutionStatus;
        executedAt: string;
        completedAt?: string | null;
        durationMs?: number | null;
        triggerData?: Record<string, unknown> | null;
        result?: Record<string, unknown> | null;
        errorMessage?: string | null;
    };
};
export type CreateBoardMutationVariables = Types.Exact<{
    input: Types.CreateBoardInput;
}>;
export type CreateBoardMutation = {
    __typename?: 'Mutation';
    planmagnetCreateBoard: {
        __typename?: 'Board';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        description?: string | null;
        type: Types.BoardType;
        isDefault: boolean;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
        columns: Array<{
            __typename?: 'BoardColumn';
            id: string;
            boardId: string;
            name: string;
            type: Types.BoardColumnType;
            mappedStatus?: Types.WorkItemStatus | null;
            wipLimit?: number | null;
            sortOrder: number;
            metadata?: Record<string, unknown> | null;
            createdAt: string;
            updatedAt: string;
        }>;
    };
};
export type UpdateBoardMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateBoardInput;
}>;
export type UpdateBoardMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateBoard: {
        __typename?: 'Board';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        description?: string | null;
        type: Types.BoardType;
        isDefault: boolean;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
        columns: Array<{
            __typename?: 'BoardColumn';
            id: string;
            boardId: string;
            name: string;
            type: Types.BoardColumnType;
            mappedStatus?: Types.WorkItemStatus | null;
            wipLimit?: number | null;
            sortOrder: number;
            metadata?: Record<string, unknown> | null;
            createdAt: string;
            updatedAt: string;
        }>;
    };
};
export type DeleteBoardMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteBoardMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteBoard: boolean;
};
export type CreateBoardColumnMutationVariables = Types.Exact<{
    input: Types.CreateBoardColumnInput;
}>;
export type CreateBoardColumnMutation = {
    __typename?: 'Mutation';
    planmagnetCreateBoardColumn: {
        __typename?: 'BoardColumn';
        id: string;
        boardId: string;
        name: string;
        type: Types.BoardColumnType;
        mappedStatus?: Types.WorkItemStatus | null;
        wipLimit?: number | null;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
    };
};
export type UpdateBoardColumnMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateBoardColumnInput;
}>;
export type UpdateBoardColumnMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateBoardColumn: {
        __typename?: 'BoardColumn';
        id: string;
        boardId: string;
        name: string;
        type: Types.BoardColumnType;
        mappedStatus?: Types.WorkItemStatus | null;
        wipLimit?: number | null;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
    };
};
export type DeleteBoardColumnMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteBoardColumnMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteBoardColumn: boolean;
};
export type ReorderColumnsMutationVariables = Types.Exact<{
    boardId: Types.Scalars['ID']['input'];
    input: Types.ReorderColumnsInput;
}>;
export type ReorderColumnsMutation = {
    __typename?: 'Mutation';
    planmagnetReorderColumns: {
        __typename?: 'Board';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        description?: string | null;
        type: Types.BoardType;
        isDefault: boolean;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
        columns: Array<{
            __typename?: 'BoardColumn';
            id: string;
            boardId: string;
            name: string;
            type: Types.BoardColumnType;
            mappedStatus?: Types.WorkItemStatus | null;
            wipLimit?: number | null;
            sortOrder: number;
            metadata?: Record<string, unknown> | null;
            createdAt: string;
            updatedAt: string;
        }>;
    };
};
export type MoveCardMutationVariables = Types.Exact<{
    boardId: Types.Scalars['ID']['input'];
    input: Types.MoveCardInput;
}>;
export type MoveCardMutation = {
    __typename?: 'Mutation';
    planmagnetMoveCard: {
        __typename?: 'Board';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        description?: string | null;
        type: Types.BoardType;
        isDefault: boolean;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
        columns: Array<{
            __typename?: 'BoardColumn';
            id: string;
            boardId: string;
            name: string;
            type: Types.BoardColumnType;
            mappedStatus?: Types.WorkItemStatus | null;
            wipLimit?: number | null;
            sortOrder: number;
            metadata?: Record<string, unknown> | null;
            createdAt: string;
            updatedAt: string;
        }>;
    };
};
export type CreateBudgetMutationVariables = Types.Exact<{
    input: Types.CreateBudgetInput;
}>;
export type CreateBudgetMutation = {
    __typename?: 'Mutation';
    planmagnetCreateBudget: {
        __typename?: 'Budget';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        description?: string | null;
        status: Types.BudgetStatus;
        currency: string;
        plannedAmount: number;
        spentAmount: number;
        remainingAmount: number;
        periodStart?: string | null;
        periodEnd?: string | null;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type UpdateBudgetMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateBudgetInput;
}>;
export type UpdateBudgetMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateBudget: {
        __typename?: 'Budget';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        description?: string | null;
        status: Types.BudgetStatus;
        currency: string;
        plannedAmount: number;
        spentAmount: number;
        remainingAmount: number;
        periodStart?: string | null;
        periodEnd?: string | null;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
    };
};
export type DeleteBudgetMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteBudgetMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteBudget: boolean;
};
export type ApproveBudgetMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type ApproveBudgetMutation = {
    __typename?: 'Mutation';
    planmagnetApproveBudget: {
        __typename?: 'Budget';
        id: string;
        status: Types.BudgetStatus;
        approverId?: string | null;
        approvedAt?: string | null;
        updatedAt: string;
    };
};
export type LogExpenseMutationVariables = Types.Exact<{
    input: Types.LogExpenseInput;
}>;
export type LogExpenseMutation = {
    __typename?: 'Mutation';
    planmagnetLogExpense: {
        __typename?: 'BudgetExpense';
        id: string;
        budgetId: string;
        amount: number;
        description: string;
        category?: string | null;
        date: string;
        referenceUrl?: string | null;
        workItemId?: string | null;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type UpdateExpenseMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateExpenseInput;
}>;
export type UpdateExpenseMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateExpense: {
        __typename?: 'BudgetExpense';
        id: string;
        budgetId: string;
        amount: number;
        description: string;
        category?: string | null;
        date: string;
        referenceUrl?: string | null;
        workItemId?: string | null;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type DeleteExpenseMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteExpenseMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteExpense: boolean;
};
export type CreateCustomFieldDefinitionMutationVariables = Types.Exact<{
    input: Types.CreateCustomFieldDefinitionInput;
}>;
export type CreateCustomFieldDefinitionMutation = {
    __typename?: 'Mutation';
    planmagnetCreateCustomFieldDefinition: {
        __typename?: 'CustomFieldDefinition';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        description?: string | null;
        fieldType: Types.CustomFieldType;
        isRequired: boolean;
        defaultValue?: Record<string, unknown> | null;
        options?: Record<string, unknown> | null;
        validationRules?: Record<string, unknown> | null;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type UpdateCustomFieldDefinitionMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateCustomFieldDefinitionInput;
}>;
export type UpdateCustomFieldDefinitionMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateCustomFieldDefinition: {
        __typename?: 'CustomFieldDefinition';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        description?: string | null;
        fieldType: Types.CustomFieldType;
        isRequired: boolean;
        defaultValue?: Record<string, unknown> | null;
        options?: Record<string, unknown> | null;
        validationRules?: Record<string, unknown> | null;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type DeleteCustomFieldDefinitionMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteCustomFieldDefinitionMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteCustomFieldDefinition: boolean;
};
export type SetCustomFieldValueMutationVariables = Types.Exact<{
    input: Types.SetCustomFieldValueInput;
}>;
export type SetCustomFieldValueMutation = {
    __typename?: 'Mutation';
    planmagnetSetCustomFieldValue: {
        __typename?: 'CustomFieldValue';
        id: string;
        workItemId: string;
        definitionId: string;
        value: Record<string, unknown>;
        setBy: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type RemoveCustomFieldValueMutationVariables = Types.Exact<{
    definitionId: Types.Scalars['ID']['input'];
    workItemId: Types.Scalars['ID']['input'];
}>;
export type RemoveCustomFieldValueMutation = {
    __typename?: 'Mutation';
    planmagnetRemoveCustomFieldValue: boolean;
};
export type CreateMilestoneMutationVariables = Types.Exact<{
    input: Types.CreateMilestoneInput;
}>;
export type CreateMilestoneMutation = {
    __typename?: 'Mutation';
    planmagnetCreateMilestone: {
        __typename?: 'Milestone';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        description?: string | null;
        status: Types.MilestoneStatus;
        dueDate?: string | null;
        completedAt?: string | null;
        ownerId?: string | null;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
    };
};
export type UpdateMilestoneMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateMilestoneInput;
}>;
export type UpdateMilestoneMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateMilestone: {
        __typename?: 'Milestone';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        description?: string | null;
        status: Types.MilestoneStatus;
        dueDate?: string | null;
        completedAt?: string | null;
        ownerId?: string | null;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
    };
};
export type DeleteMilestoneMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteMilestoneMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteMilestone: boolean;
};
export type CreateRoadmapMutationVariables = Types.Exact<{
    input: Types.CreateRoadmapInput;
}>;
export type CreateRoadmapMutation = {
    __typename?: 'Mutation';
    planmagnetCreateRoadmap: {
        __typename?: 'Roadmap';
        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;
    };
};
export type UpdateRoadmapMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateRoadmapInput;
}>;
export type UpdateRoadmapMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateRoadmap: {
        __typename?: 'Roadmap';
        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;
    };
};
export type DeleteRoadmapMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteRoadmapMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteRoadmap: boolean;
};
export type CreateRoadmapItemMutationVariables = Types.Exact<{
    input: Types.CreateRoadmapItemInput;
}>;
export type CreateRoadmapItemMutation = {
    __typename?: 'Mutation';
    planmagnetCreateRoadmapItem: {
        __typename?: 'RoadmapItem';
        id: string;
        roadmapId: string;
        title: 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;
    };
};
export type UpdateRoadmapItemMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateRoadmapItemInput;
}>;
export type UpdateRoadmapItemMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateRoadmapItem: {
        __typename?: 'RoadmapItem';
        id: string;
        roadmapId: string;
        title: 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;
    };
};
export type DeleteRoadmapItemMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteRoadmapItemMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteRoadmapItem: boolean;
};
export type CreateReleaseMutationVariables = Types.Exact<{
    input: Types.CreateReleaseInput;
}>;
export type CreateReleaseMutation = {
    __typename?: 'Mutation';
    planmagnetCreateRelease: {
        __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;
    };
};
export type UpdateReleaseMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateReleaseInput;
}>;
export type UpdateReleaseMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateRelease: {
        __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;
    };
};
export type DeleteReleaseMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteReleaseMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteRelease: boolean;
};
export type CreateFeatureRequestMutationVariables = Types.Exact<{
    input: Types.CreateFeatureRequestInput;
}>;
export type CreateFeatureRequestMutation = {
    __typename?: 'Mutation';
    planmagnetCreateFeatureRequest: {
        __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;
    };
};
export type UpdateFeatureRequestMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateFeatureRequestInput;
}>;
export type UpdateFeatureRequestMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateFeatureRequest: {
        __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;
    };
};
export type DeleteFeatureRequestMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteFeatureRequestMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteFeatureRequest: boolean;
};
export type VoteOnFeatureMutationVariables = Types.Exact<{
    featureRequestId: Types.Scalars['ID']['input'];
    input?: Types.InputMaybe<Types.VoteOnFeatureInput>;
}>;
export type VoteOnFeatureMutation = {
    __typename?: 'Mutation';
    planmagnetVoteOnFeature: {
        __typename?: 'FeatureVote';
        id: string;
        featureRequestId: string;
        voterId: string;
        weight: number;
        comment?: string | null;
        createdAt: string;
    };
};
export type RemoveFeatureVoteMutationVariables = Types.Exact<{
    featureRequestId: Types.Scalars['ID']['input'];
}>;
export type RemoveFeatureVoteMutation = {
    __typename?: 'Mutation';
    planmagnetRemoveFeatureVote: boolean;
};
export type CreateCompetitorMutationVariables = Types.Exact<{
    input: Types.CreateCompetitorInput;
}>;
export type CreateCompetitorMutation = {
    __typename?: 'Mutation';
    planmagnetCreateCompetitor: {
        __typename?: 'Competitor';
        id: string;
        workspaceId: string;
        name: string;
        description?: string | null;
        website?: string | null;
        tags: Array<string>;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        deletedAt?: string | null;
    };
};
export type UpdateCompetitorMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateCompetitorInput;
}>;
export type UpdateCompetitorMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateCompetitor: {
        __typename?: 'Competitor';
        id: string;
        workspaceId: string;
        name: string;
        description?: string | null;
        website?: string | null;
        tags: Array<string>;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        deletedAt?: string | null;
    };
};
export type DeleteCompetitorMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteCompetitorMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteCompetitor: boolean;
};
export type LinkCompetitorToFeatureMutationVariables = Types.Exact<{
    input: Types.LinkCompetitorInput;
}>;
export type LinkCompetitorToFeatureMutation = {
    __typename?: 'Mutation';
    planmagnetLinkCompetitorToFeature: {
        __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;
    };
};
export type UnlinkCompetitorFromFeatureMutationVariables = Types.Exact<{
    input: Types.LinkCompetitorInput;
}>;
export type UnlinkCompetitorFromFeatureMutation = {
    __typename?: 'Mutation';
    planmagnetUnlinkCompetitorFromFeature: {
        __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;
    };
};
export type CreateProgramMutationVariables = Types.Exact<{
    input: Types.CreateProgramInput;
}>;
export type CreateProgramMutation = {
    __typename?: 'Mutation';
    planmagnetCreateProgram: {
        __typename?: 'Program';
        id: string;
        workspaceId: string;
        name: string;
        description?: string | null;
        status: Types.ProjectStatus;
        ownerId: string;
        startDate?: string | null;
        endDate?: string | null;
        budgetTotal?: number | null;
        currency?: string | null;
        tags: Array<string>;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
    };
};
export type UpdateProgramMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateProgramInput;
}>;
export type UpdateProgramMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateProgram: {
        __typename?: 'Program';
        id: string;
        workspaceId: string;
        name: string;
        description?: string | null;
        status: Types.ProjectStatus;
        ownerId: string;
        startDate?: string | null;
        endDate?: string | null;
        budgetTotal?: number | null;
        currency?: string | null;
        tags: Array<string>;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
    };
};
export type DeleteProgramMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteProgramMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteProgram: boolean;
};
export type CreateProjectMutationVariables = Types.Exact<{
    input: Types.CreateProjectInput;
}>;
export type CreateProjectMutation = {
    __typename?: 'Mutation';
    planmagnetCreateProject: {
        __typename?: 'Project';
        id: string;
        workspaceId: string;
        name: string;
        description?: string | null;
        key: string;
        status: Types.ProjectStatus;
        methodology: Types.ProjectMethodology;
        startDate?: string | null;
        endDate?: string | null;
        defaultAssigneeId?: string | null;
        ownerId: string;
        programId?: string | null;
        tags: Array<string>;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
    };
};
export type UpdateProjectMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateProjectInput;
}>;
export type UpdateProjectMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateProject: {
        __typename?: 'Project';
        id: string;
        workspaceId: string;
        name: string;
        description?: string | null;
        key: string;
        status: Types.ProjectStatus;
        methodology: Types.ProjectMethodology;
        startDate?: string | null;
        endDate?: string | null;
        defaultAssigneeId?: string | null;
        ownerId: string;
        programId?: string | null;
        tags: Array<string>;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
    };
};
export type DeleteProjectMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteProjectMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteProject: boolean;
};
export type CreateQualityGateMutationVariables = Types.Exact<{
    input: Types.CreateQualityGateInput;
}>;
export type CreateQualityGateMutation = {
    __typename?: 'Mutation';
    planmagnetCreateQualityGate: {
        __typename?: 'QualityGate';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        description?: string | null;
        status: Types.QualityGateStatus;
        phase?: string | null;
        criteria: Record<string, unknown>;
        milestoneId?: string | null;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type UpdateQualityGateMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateQualityGateInput;
}>;
export type UpdateQualityGateMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateQualityGate: {
        __typename?: 'QualityGate';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        description?: string | null;
        status: Types.QualityGateStatus;
        phase?: string | null;
        criteria: Record<string, unknown>;
        milestoneId?: string | null;
        sortOrder: number;
        reviewerId?: string | null;
        reviewedAt?: string | null;
        reviewNotes?: string | null;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
    };
};
export type DeleteQualityGateMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteQualityGateMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteQualityGate: boolean;
};
export type ReviewQualityGateMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.ReviewQualityGateInput;
}>;
export type ReviewQualityGateMutation = {
    __typename?: 'Mutation';
    planmagnetReviewQualityGate: {
        __typename?: 'QualityGate';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        status: Types.QualityGateStatus;
        reviewerId?: string | null;
        reviewedAt?: string | null;
        reviewNotes?: string | null;
        updatedAt: string;
        updatedBy?: string | null;
    };
};
export type CreateRiskMutationVariables = Types.Exact<{
    input: Types.CreateRiskInput;
}>;
export type CreateRiskMutation = {
    __typename?: 'Mutation';
    planmagnetCreateRisk: {
        __typename?: 'Risk';
        id: string;
        workspaceId: string;
        projectId: string;
        title: string;
        description?: string | null;
        severity: Types.RiskSeverity;
        status: Types.RiskStatus;
        likelihood: number;
        impact: number;
        riskScore: number;
        category?: string | null;
        ownerId?: string | null;
        mitigationPlan?: string | null;
        contingencyPlan?: string | null;
        dueDate?: string | null;
        tags: Array<string>;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type UpdateRiskMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateRiskInput;
}>;
export type UpdateRiskMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateRisk: {
        __typename?: 'Risk';
        id: string;
        workspaceId: string;
        projectId: string;
        title: string;
        description?: string | null;
        severity: Types.RiskSeverity;
        status: Types.RiskStatus;
        likelihood: number;
        impact: number;
        riskScore: number;
        category?: string | null;
        ownerId?: string | null;
        mitigationPlan?: string | null;
        contingencyPlan?: string | null;
        dueDate?: string | null;
        resolvedAt?: string | null;
        tags: Array<string>;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
    };
};
export type DeleteRiskMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteRiskMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteRisk: boolean;
};
export type CreateSprintMutationVariables = Types.Exact<{
    input: Types.CreateSprintInput;
}>;
export type CreateSprintMutation = {
    __typename?: 'Mutation';
    planmagnetCreateSprint: {
        __typename?: 'Sprint';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        goal?: string | null;
        status: Types.SprintStatus;
        startDate?: string | null;
        endDate?: string | null;
        capacity?: number | null;
        velocity?: number | null;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
    };
};
export type UpdateSprintMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateSprintInput;
}>;
export type UpdateSprintMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateSprint: {
        __typename?: 'Sprint';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        goal?: string | null;
        status: Types.SprintStatus;
        startDate?: string | null;
        endDate?: string | null;
        capacity?: number | null;
        velocity?: number | null;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
    };
};
export type DeleteSprintMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteSprintMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteSprint: boolean;
};
export type StartSprintMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type StartSprintMutation = {
    __typename?: 'Mutation';
    planmagnetStartSprint: {
        __typename?: 'Sprint';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        goal?: string | null;
        status: Types.SprintStatus;
        startDate?: string | null;
        endDate?: string | null;
        capacity?: number | null;
        velocity?: number | null;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
    };
};
export type CompleteSprintMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type CompleteSprintMutation = {
    __typename?: 'Mutation';
    planmagnetCompleteSprint: {
        __typename?: 'Sprint';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        goal?: string | null;
        status: Types.SprintStatus;
        startDate?: string | null;
        endDate?: string | null;
        capacity?: number | null;
        velocity?: number | null;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
    };
};
export type CancelSprintMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type CancelSprintMutation = {
    __typename?: 'Mutation';
    planmagnetCancelSprint: {
        __typename?: 'Sprint';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        goal?: string | null;
        status: Types.SprintStatus;
        startDate?: string | null;
        endDate?: string | null;
        capacity?: number | null;
        velocity?: number | null;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
    };
};
export type AddWorkItemsToSprintMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.SprintWorkItemsInput;
}>;
export type AddWorkItemsToSprintMutation = {
    __typename?: 'Mutation';
    planmagnetAddWorkItemsToSprint: {
        __typename?: 'Sprint';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        goal?: string | null;
        status: Types.SprintStatus;
        startDate?: string | null;
        endDate?: string | null;
        capacity?: number | null;
        velocity?: number | null;
        sortOrder: number;
        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>;
        }>;
    };
};
export type RemoveWorkItemsFromSprintMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.SprintWorkItemsInput;
}>;
export type RemoveWorkItemsFromSprintMutation = {
    __typename?: 'Mutation';
    planmagnetRemoveWorkItemsFromSprint: {
        __typename?: 'Sprint';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        goal?: string | null;
        status: Types.SprintStatus;
        startDate?: string | null;
        endDate?: string | null;
        capacity?: number | null;
        velocity?: number | null;
        sortOrder: number;
        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>;
        }>;
    };
};
export type CreateExternalSyncMutationVariables = Types.Exact<{
    input: Types.CreateExternalSyncInput;
}>;
export type CreateExternalSyncMutation = {
    __typename?: 'Mutation';
    planmagnetCreateExternalSync: {
        __typename?: 'ExternalSync';
        id: string;
        workspaceId: string;
        projectId: string;
        provider: Types.SyncProvider;
        direction: Types.SyncDirection;
        status: Types.SyncStatus;
        externalProjectId: string;
        externalProjectUrl?: string | null;
        connectionConfig: Record<string, unknown>;
        fieldMapping?: Record<string, unknown> | null;
        syncFilters?: Record<string, unknown> | null;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type UpdateExternalSyncMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateExternalSyncInput;
}>;
export type UpdateExternalSyncMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateExternalSync: {
        __typename?: 'ExternalSync';
        id: string;
        workspaceId: string;
        projectId: string;
        provider: Types.SyncProvider;
        direction: Types.SyncDirection;
        status: Types.SyncStatus;
        externalProjectId: string;
        externalProjectUrl?: string | null;
        connectionConfig: Record<string, unknown>;
        fieldMapping?: Record<string, unknown> | null;
        syncFilters?: Record<string, unknown> | null;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
    };
};
export type DeleteExternalSyncMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteExternalSyncMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteExternalSync: boolean;
};
export type PauseExternalSyncMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type PauseExternalSyncMutation = {
    __typename?: 'Mutation';
    planmagnetPauseExternalSync: {
        __typename?: 'ExternalSync';
        id: string;
        status: Types.SyncStatus;
        updatedAt: string;
    };
};
export type ResumeExternalSyncMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type ResumeExternalSyncMutation = {
    __typename?: 'Mutation';
    planmagnetResumeExternalSync: {
        __typename?: 'ExternalSync';
        id: string;
        status: Types.SyncStatus;
        updatedAt: string;
    };
};
export type StartSyncMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type StartSyncMutation = {
    __typename?: 'Mutation';
    planmagnetStartSync: {
        __typename?: 'SyncResult';
        syncId: string;
        success: boolean;
        itemsCreated: number;
        itemsUpdated: number;
        itemsSkipped: number;
        errorCount: number;
        errors?: Array<string> | null;
        durationMs?: number | null;
        syncedAt: string;
    };
};
export type ImportFromExternalMutationVariables = Types.Exact<{
    input: Types.ImportFromExternalInput;
}>;
export type ImportFromExternalMutation = {
    __typename?: 'Mutation';
    planmagnetImportFromExternal: {
        __typename?: 'SyncResult';
        syncId: string;
        success: boolean;
        itemsCreated: number;
        itemsUpdated: number;
        itemsSkipped: number;
        errorCount: number;
        errors?: Array<string> | null;
        durationMs?: number | null;
        syncedAt: string;
    };
};
export type ExportToExternalMutationVariables = Types.Exact<{
    input: Types.ExportToExternalInput;
}>;
export type ExportToExternalMutation = {
    __typename?: 'Mutation';
    planmagnetExportToExternal: {
        __typename?: 'SyncResult';
        syncId: string;
        success: boolean;
        itemsCreated: number;
        itemsUpdated: number;
        itemsSkipped: number;
        errorCount: number;
        errors?: Array<string> | null;
        durationMs?: number | null;
        syncedAt: string;
    };
};
export type CreateProjectTemplateMutationVariables = Types.Exact<{
    input: Types.CreateProjectTemplateInput;
}>;
export type CreateProjectTemplateMutation = {
    __typename?: 'Mutation';
    planmagnetCreateProjectTemplate: {
        __typename?: 'ProjectTemplate';
        id: string;
        workspaceId: string;
        name: string;
        description?: string | null;
        category?: string | null;
        isBuiltIn: boolean;
        isPublished: boolean;
        usageCount: number;
        configuration: Record<string, unknown>;
        boardConfig?: Record<string, unknown> | null;
        sprintConfig?: Record<string, unknown> | null;
        customFieldsConfig?: Record<string, unknown> | null;
        tags: Array<string>;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type UpdateProjectTemplateMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateProjectTemplateInput;
}>;
export type UpdateProjectTemplateMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateProjectTemplate: {
        __typename?: 'ProjectTemplate';
        id: string;
        workspaceId: string;
        name: string;
        description?: string | null;
        category?: string | null;
        isBuiltIn: boolean;
        isPublished: boolean;
        usageCount: number;
        configuration: Record<string, unknown>;
        boardConfig?: Record<string, unknown> | null;
        sprintConfig?: Record<string, unknown> | null;
        customFieldsConfig?: Record<string, unknown> | null;
        tags: Array<string>;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
    };
};
export type DeleteProjectTemplateMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteProjectTemplateMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteProjectTemplate: boolean;
};
export type ApplyTemplateMutationVariables = Types.Exact<{
    input: Types.ApplyTemplateInput;
}>;
export type ApplyTemplateMutation = {
    __typename?: 'Mutation';
    planmagnetApplyTemplate: {
        __typename?: 'Project';
        id: string;
        workspaceId: string;
        name: string;
        description?: string | null;
        key: string;
        status: Types.ProjectStatus;
        methodology: Types.ProjectMethodology;
        startDate?: string | null;
        endDate?: string | null;
        defaultAssigneeId?: string | null;
        ownerId: string;
        programId?: string | null;
        tags: Array<string>;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
    };
};
export type CreateTemplateFromProjectMutationVariables = Types.Exact<{
    projectId: Types.Scalars['ID']['input'];
    name: Types.Scalars['String']['input'];
    description?: Types.InputMaybe<Types.Scalars['String']['input']>;
}>;
export type CreateTemplateFromProjectMutation = {
    __typename?: 'Mutation';
    planmagnetCreateTemplateFromProject: {
        __typename?: 'ProjectTemplate';
        id: string;
        workspaceId: string;
        name: string;
        description?: string | null;
        category?: string | null;
        isBuiltIn: boolean;
        isPublished: boolean;
        configuration: Record<string, unknown>;
        boardConfig?: Record<string, unknown> | null;
        sprintConfig?: Record<string, unknown> | null;
        customFieldsConfig?: Record<string, unknown> | null;
        tags: Array<string>;
        createdBy: string;
        createdAt: string;
    };
};
export type CreateTimeEntryMutationVariables = Types.Exact<{
    input: Types.CreateTimeEntryInput;
}>;
export type CreateTimeEntryMutation = {
    __typename?: 'Mutation';
    planmagnetCreateTimeEntry: {
        __typename?: 'TimeEntry';
        id: string;
        workspaceId: string;
        projectId: string;
        workItemId: string;
        userId: string;
        date: string;
        durationMinutes: number;
        startTime?: string | null;
        endTime?: string | null;
        description?: string | null;
        billingType: Types.BillingType;
        billingRate?: number | null;
        status: Types.TimeEntryStatus;
        timesheetId?: string | null;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type UpdateTimeEntryMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateTimeEntryInput;
}>;
export type UpdateTimeEntryMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateTimeEntry: {
        __typename?: 'TimeEntry';
        id: string;
        workspaceId: string;
        projectId: string;
        workItemId: string;
        userId: string;
        date: string;
        durationMinutes: number;
        startTime?: string | null;
        endTime?: string | null;
        description?: string | null;
        billingType: Types.BillingType;
        billingRate?: number | null;
        status: Types.TimeEntryStatus;
        timesheetId?: string | null;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type DeleteTimeEntryMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteTimeEntryMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteTimeEntry: boolean;
};
export type LogTimeMutationVariables = Types.Exact<{
    input: Types.LogTimeInput;
}>;
export type LogTimeMutation = {
    __typename?: 'Mutation';
    planmagnetLogTime: {
        __typename?: 'TimeEntry';
        id: string;
        workspaceId: string;
        projectId: string;
        workItemId: string;
        userId: string;
        date: string;
        durationMinutes: number;
        startTime?: string | null;
        endTime?: string | null;
        description?: string | null;
        billingType: Types.BillingType;
        billingRate?: number | null;
        status: Types.TimeEntryStatus;
        timesheetId?: string | null;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type CreateTimesheetMutationVariables = Types.Exact<{
    input: Types.CreateTimesheetInput;
}>;
export type CreateTimesheetMutation = {
    __typename?: 'Mutation';
    planmagnetCreateTimesheet: {
        __typename?: 'Timesheet';
        id: string;
        workspaceId: string;
        userId: string;
        periodStart: string;
        periodEnd: string;
        status: Types.TimeEntryStatus;
        totalMinutes: number;
        billableMinutes: number;
        approverId?: string | null;
        approvedAt?: string | null;
        rejectionReason?: string | null;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type SubmitTimesheetMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type SubmitTimesheetMutation = {
    __typename?: 'Mutation';
    planmagnetSubmitTimesheet: {
        __typename?: 'Timesheet';
        id: string;
        workspaceId: string;
        userId: string;
        periodStart: string;
        periodEnd: string;
        status: Types.TimeEntryStatus;
        totalMinutes: number;
        billableMinutes: number;
        approverId?: string | null;
        approvedAt?: string | null;
        rejectionReason?: string | null;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type ApproveTimesheetMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type ApproveTimesheetMutation = {
    __typename?: 'Mutation';
    planmagnetApproveTimesheet: {
        __typename?: 'Timesheet';
        id: string;
        workspaceId: string;
        userId: string;
        periodStart: string;
        periodEnd: string;
        status: Types.TimeEntryStatus;
        totalMinutes: number;
        billableMinutes: number;
        approverId?: string | null;
        approvedAt?: string | null;
        rejectionReason?: string | null;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type RejectTimesheetMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    reason?: Types.InputMaybe<Types.Scalars['String']['input']>;
}>;
export type RejectTimesheetMutation = {
    __typename?: 'Mutation';
    planmagnetRejectTimesheet: {
        __typename?: 'Timesheet';
        id: string;
        workspaceId: string;
        userId: string;
        periodStart: string;
        periodEnd: string;
        status: Types.TimeEntryStatus;
        totalMinutes: number;
        billableMinutes: number;
        approverId?: string | null;
        approvedAt?: string | null;
        rejectionReason?: string | null;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type UpdateUiSessionMutationVariables = Types.Exact<{
    input: Types.UiSessionViewStateInput;
}>;
export type UpdateUiSessionMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateUISession: {
        __typename?: 'UISession';
        id: string;
        workspaceId: string;
        userId: string;
        state: Record<string, unknown>;
        metadata?: Record<string, unknown> | null;
        createdAt: string;
        updatedAt: string;
    };
};
export type CreateWorkItemMutationVariables = Types.Exact<{
    input: Types.CreateWorkItemInput;
}>;
export type CreateWorkItemMutation = {
    __typename?: 'Mutation';
    planmagnetCreateWorkItem: {
        __typename?: 'WorkItem';
        id: string;
        workspaceId: string;
        projectId: string;
        key: string;
        title: string;
        description?: string | null;
        type: Types.WorkItemType;
        status: Types.WorkItemStatus;
        priority: Types.WorkItemPriority;
        assigneeId?: string | null;
        reporterId?: string | null;
        parentId?: string | null;
        sprintId?: string | null;
        storyPoints?: number | null;
        estimateMinutes?: number | null;
        timeSpentMinutes?: number | null;
        dueDate?: string | null;
        labels: Array<string>;
        tags: Array<string>;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
    };
};
export type UpdateWorkItemMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateWorkItemInput;
}>;
export type UpdateWorkItemMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateWorkItem: {
        __typename?: 'WorkItem';
        id: string;
        workspaceId: string;
        projectId: string;
        key: string;
        title: string;
        description?: string | null;
        type: Types.WorkItemType;
        status: Types.WorkItemStatus;
        priority: Types.WorkItemPriority;
        assigneeId?: string | null;
        reporterId?: string | null;
        parentId?: string | null;
        sprintId?: string | null;
        storyPoints?: number | null;
        estimateMinutes?: number | null;
        timeSpentMinutes?: number | null;
        dueDate?: string | null;
        labels: Array<string>;
        tags: Array<string>;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
    };
};
export type DeleteWorkItemMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteWorkItemMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteWorkItem: boolean;
};
export type MoveWorkItemMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.MoveWorkItemInput;
}>;
export type MoveWorkItemMutation = {
    __typename?: 'Mutation';
    planmagnetMoveWorkItem: {
        __typename?: 'WorkItem';
        id: string;
        workspaceId: string;
        projectId: string;
        key: string;
        title: string;
        description?: string | null;
        type: Types.WorkItemType;
        status: Types.WorkItemStatus;
        priority: Types.WorkItemPriority;
        assigneeId?: string | null;
        reporterId?: string | null;
        parentId?: string | null;
        sprintId?: string | null;
        storyPoints?: number | null;
        estimateMinutes?: number | null;
        timeSpentMinutes?: number | null;
        dueDate?: string | null;
        labels: Array<string>;
        tags: Array<string>;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
    };
};
export type BulkUpdateWorkItemsMutationVariables = Types.Exact<{
    input: Types.BulkUpdateWorkItemsInput;
}>;
export type BulkUpdateWorkItemsMutation = {
    __typename?: 'Mutation';
    planmagnetBulkUpdateWorkItems: 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>;
    }>;
};
export type AssignWorkItemMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.AssignWorkItemInput;
}>;
export type AssignWorkItemMutation = {
    __typename?: 'Mutation';
    planmagnetAssignWorkItem: {
        __typename?: 'WorkItem';
        id: string;
        workspaceId: string;
        projectId: string;
        key: string;
        title: string;
        description?: string | null;
        type: Types.WorkItemType;
        status: Types.WorkItemStatus;
        priority: Types.WorkItemPriority;
        assigneeId?: string | null;
        reporterId?: string | null;
        parentId?: string | null;
        sprintId?: string | null;
        storyPoints?: number | null;
        estimateMinutes?: number | null;
        timeSpentMinutes?: number | null;
        dueDate?: string | null;
        labels: Array<string>;
        tags: Array<string>;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
    };
};
export type CreateDependencyMutationVariables = Types.Exact<{
    input: Types.CreateDependencyInput;
}>;
export type CreateDependencyMutation = {
    __typename?: 'Mutation';
    planmagnetCreateDependency: {
        __typename?: 'WorkItemDependency';
        id: string;
        workspaceId: string;
        sourceWorkItemId: string;
        targetWorkItemId: string;
        type: Types.DependencyType;
        status: Types.DependencyStatus;
        description?: string | null;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type UpdateDependencyMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
    input: Types.UpdateDependencyInput;
}>;
export type UpdateDependencyMutation = {
    __typename?: 'Mutation';
    planmagnetUpdateDependency: {
        __typename?: 'WorkItemDependency';
        id: string;
        workspaceId: string;
        sourceWorkItemId: string;
        targetWorkItemId: string;
        type: Types.DependencyType;
        status: Types.DependencyStatus;
        description?: string | null;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
    };
};
export type DeleteDependencyMutationVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type DeleteDependencyMutation = {
    __typename?: 'Mutation';
    planmagnetDeleteDependency: boolean;
};
export type ListAutomationRulesQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.AutomationRuleFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListAutomationRulesQuery = {
    __typename?: 'Query';
    planmagnetAutomationRules: {
        __typename?: 'AutomationRuleList';
        totalCount: number;
        items: Array<{
            __typename?: 'AutomationRule';
            id: string;
            name: string;
            description?: string | null;
            status: Types.AutomationStatus;
            triggerType: Types.AutomationTriggerType;
            triggerConfig: Record<string, unknown>;
            conditions?: Record<string, unknown> | null;
            actions: Record<string, unknown>;
            executionCount: number;
            lastExecutedAt?: string | null;
            sortOrder: number;
            projectId: string;
            createdBy: string;
            createdAt: string;
            updatedAt: string;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type GetAutomationRuleQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetAutomationRuleQuery = {
    __typename?: 'Query';
    planmagnetAutomationRule?: {
        __typename?: 'AutomationRule';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        description?: string | null;
        status: Types.AutomationStatus;
        triggerType: Types.AutomationTriggerType;
        triggerConfig: Record<string, unknown>;
        conditions?: Record<string, unknown> | null;
        actions: Record<string, unknown>;
        executionCount: number;
        lastExecutedAt?: string | null;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
        project?: {
            __typename?: 'Project';
            id: string;
            name: string;
            key: string;
        } | null;
    } | null;
};
export type ListAutomationExecutionsQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.AutomationExecutionFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListAutomationExecutionsQuery = {
    __typename?: 'Query';
    planmagnetAutomationExecutions: {
        __typename?: 'AutomationExecutionList';
        totalCount: number;
        items: Array<{
            __typename?: 'AutomationExecution';
            id: string;
            ruleId: string;
            status: Types.AutomationExecutionStatus;
            executedAt: string;
            completedAt?: string | null;
            durationMs?: number | null;
            triggerData?: Record<string, unknown> | null;
            result?: Record<string, unknown> | null;
            errorMessage?: string | null;
            rule?: {
                __typename?: 'AutomationRule';
                id: string;
                name: string;
            } | null;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type ListBoardsQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.BoardFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListBoardsQuery = {
    __typename?: 'Query';
    planmagnetBoards: {
        __typename?: 'BoardList';
        totalCount: number;
        items: Array<{
            __typename?: 'Board';
            id: string;
            name: string;
            type: Types.BoardType;
            isDefault: boolean;
            projectId: string;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type GetBoardQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetBoardQuery = {
    __typename?: 'Query';
    planmagnetBoard?: {
        __typename?: 'Board';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        description?: string | null;
        type: Types.BoardType;
        isDefault: boolean;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
        columns: Array<{
            __typename?: 'BoardColumn';
            id: string;
            boardId: string;
            name: string;
            type: Types.BoardColumnType;
            mappedStatus?: Types.WorkItemStatus | null;
            wipLimit?: number | null;
            sortOrder: number;
            metadata?: Record<string, unknown> | null;
            createdAt: string;
            updatedAt: string;
        }>;
    } | null;
};
export type ListBudgetsQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.BudgetFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListBudgetsQuery = {
    __typename?: 'Query';
    planmagnetBudgets: {
        __typename?: 'BudgetList';
        totalCount: number;
        items: Array<{
            __typename?: 'Budget';
            id: string;
            workspaceId: string;
            projectId: string;
            name: string;
            description?: string | null;
            status: Types.BudgetStatus;
            currency: string;
            plannedAmount: number;
            spentAmount: number;
            remainingAmount: number;
            periodStart?: string | null;
            periodEnd?: string | null;
            approverId?: string | null;
            approvedAt?: string | null;
            metadata?: Record<string, unknown> | null;
            createdBy: string;
            createdAt: string;
            updatedAt: string;
            updatedBy?: string | null;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type GetBudgetQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetBudgetQuery = {
    __typename?: 'Query';
    planmagnetBudget?: {
        __typename?: 'Budget';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        description?: string | null;
        status: Types.BudgetStatus;
        currency: string;
        plannedAmount: number;
        spentAmount: number;
        remainingAmount: number;
        periodStart?: string | null;
        periodEnd?: string | null;
        approverId?: string | null;
        approvedAt?: string | null;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
        project?: {
            __typename?: 'Project';
            id: string;
            name: string;
            key: string;
        } | null;
        expenses: Array<{
            __typename?: 'BudgetExpense';
            id: string;
            budgetId: string;
            amount: number;
            description: string;
            category?: string | null;
            date: string;
            referenceUrl?: string | null;
            workItemId?: string | null;
            createdBy: string;
            createdAt: string;
        }>;
    } | null;
};
export type ListBudgetExpensesQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.BudgetExpenseFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListBudgetExpensesQuery = {
    __typename?: 'Query';
    planmagnetBudgetExpenses: {
        __typename?: 'BudgetExpenseList';
        totalCount: number;
        items: Array<{
            __typename?: 'BudgetExpense';
            id: string;
            budgetId: string;
            amount: number;
            description: string;
            category?: string | null;
            date: string;
            referenceUrl?: string | null;
            workItemId?: string | null;
            metadata?: Record<string, unknown> | null;
            createdBy: string;
            createdAt: string;
            updatedAt: string;
            budget?: {
                __typename?: 'Budget';
                id: string;
                name: string;
                currency: string;
            } | null;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type ListCustomFieldDefinitionsQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.CustomFieldDefinitionFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListCustomFieldDefinitionsQuery = {
    __typename?: 'Query';
    planmagnetCustomFieldDefinitions: {
        __typename?: 'CustomFieldDefinitionList';
        totalCount: number;
        items: Array<{
            __typename?: 'CustomFieldDefinition';
            id: string;
            workspaceId: string;
            projectId: string;
            name: string;
            description?: string | null;
            fieldType: Types.CustomFieldType;
            isRequired: boolean;
            defaultValue?: Record<string, unknown> | null;
            options?: Record<string, unknown> | null;
            validationRules?: Record<string, unknown> | null;
            sortOrder: number;
            metadata?: Record<string, unknown> | null;
            createdBy: string;
            createdAt: string;
            updatedAt: string;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type ListCustomFieldValuesQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.CustomFieldValueFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListCustomFieldValuesQuery = {
    __typename?: 'Query';
    planmagnetCustomFieldValues: {
        __typename?: 'CustomFieldValueList';
        totalCount: number;
        items: Array<{
            __typename?: 'CustomFieldValue';
            id: string;
            workItemId: string;
            definitionId: string;
            value: Record<string, unknown>;
            setBy: string;
            createdAt: string;
            updatedAt: string;
            definition?: {
                __typename?: 'CustomFieldDefinition';
                id: string;
                name: string;
                fieldType: Types.CustomFieldType;
            } | null;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type DashboardProjectsQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.ProjectFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type DashboardProjectsQuery = {
    __typename?: 'Query';
    planmagnetProjects: {
        __typename?: 'ProjectList';
        totalCount: number;
        items: Array<{
            __typename?: 'Project';
            id: string;
            name: string;
            key: string;
            status: Types.ProjectStatus;
            methodology: Types.ProjectMethodology;
            ownerId: string;
            startDate?: string | null;
            endDate?: string | null;
            tags: Array<string>;
        }>;
    };
};
export type DashboardWorkItemsQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.WorkItemFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type DashboardWorkItemsQuery = {
    __typename?: 'Query';
    planmagnetWorkItems: {
        __typename?: 'WorkItemList';
        totalCount: number;
        items: 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>;
            project?: {
                __typename?: 'Project';
                id: string;
                name: string;
                key: string;
            } | null;
        }>;
    };
};
export type DashboardSprintsQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.SprintFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type DashboardSprintsQuery = {
    __typename?: 'Query';
    planmagnetSprints: {
        __typename?: 'SprintList';
        totalCount: number;
        items: Array<{
            __typename?: 'Sprint';
            projectId: string;
            id: string;
            name: string;
            status: Types.SprintStatus;
            startDate?: string | null;
            endDate?: string | null;
            capacity?: number | null;
            velocity?: number | null;
        }>;
    };
};
export type DashboardMilestonesQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.MilestoneFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type DashboardMilestonesQuery = {
    __typename?: 'Query';
    planmagnetMilestones: {
        __typename?: 'MilestoneList';
        totalCount: number;
        items: Array<{
            __typename?: 'Milestone';
            projectId: string;
            id: string;
            name: string;
            status: Types.MilestoneStatus;
            dueDate?: string | null;
            completedAt?: string | null;
            ownerId?: string | null;
        }>;
    };
};
export type DashboardRisksQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.RiskFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type DashboardRisksQuery = {
    __typename?: 'Query';
    planmagnetRisks: {
        __typename?: 'RiskList';
        totalCount: number;
        items: Array<{
            __typename?: 'Risk';
            id: string;
            title: string;
            severity: Types.RiskSeverity;
            status: Types.RiskStatus;
            riskScore: number;
            projectId: string;
            ownerId?: string | null;
        }>;
    };
};
export type DashboardPortfolioOverviewQueryVariables = Types.Exact<{
    portfolioId: Types.Scalars['ID']['input'];
}>;
export type DashboardPortfolioOverviewQuery = {
    __typename?: 'Query';
    planmagnetPortfolioOverview: {
        __typename?: 'PortfolioOverview';
        portfolioId: string;
        totalProjects: number;
        totalPrograms: number;
        atRiskCount: number;
        overdueMilestones: number;
        healthScore?: number | null;
        budgetUtilization?: number | null;
        totalBudget?: number | null;
        totalSpent?: number | null;
        projectsByStatus: Record<string, unknown>;
    };
};
export type ListMilestonesQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.MilestoneFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListMilestonesQuery = {
    __typename?: 'Query';
    planmagnetMilestones: {
        __typename?: 'MilestoneList';
        totalCount: number;
        items: Array<{
            __typename?: 'Milestone';
            id: string;
            name: string;
            status: Types.MilestoneStatus;
            dueDate?: string | null;
            completedAt?: string | null;
            ownerId?: string | null;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type GetMilestoneQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetMilestoneQuery = {
    __typename?: 'Query';
    planmagnetMilestone?: {
        __typename?: 'Milestone';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        description?: string | null;
        status: Types.MilestoneStatus;
        dueDate?: string | null;
        completedAt?: string | null;
        ownerId?: string | null;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
        project?: {
            __typename?: 'Project';
            id: string;
            name: string;
            key: string;
        } | null;
    } | null;
};
export type ListPortfoliosQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.PortfolioFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListPortfoliosQuery = {
    __typename?: 'Query';
    planmagnetPortfolios: {
        __typename?: 'PortfolioList';
        totalCount: number;
        items: Array<{
            __typename?: 'Portfolio';
            id: string;
            name: string;
            status: Types.PortfolioStatus;
            ownerId: string;
            alignment?: Types.StrategicAlignment | null;
            budgetTotal?: number | null;
            currency?: string | null;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type GetPortfolioQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetPortfolioQuery = {
    __typename?: 'Query';
    planmagnetPortfolio?: {
        __typename?: 'Portfolio';
        id: string;
        workspaceId: string;
        name: string;
        description?: string | null;
        status: Types.PortfolioStatus;
        ownerId: string;
        alignment?: Types.StrategicAlignment | null;
        alignmentLabel?: string | null;
        budgetTotal?: number | null;
        currency?: string | null;
        fiscalPeriod?: string | null;
        tags: Array<string>;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
        programs: Array<{
            __typename?: 'Program';
            id: string;
            name: string;
            status: Types.ProjectStatus;
            ownerId: string;
            startDate?: string | null;
            endDate?: string | null;
        }>;
        projects: Array<{
            __typename?: 'Project';
            id: string;
            name: string;
            key: string;
            status: Types.ProjectStatus;
            methodology: Types.ProjectMethodology;
            ownerId: string;
            startDate?: string | null;
            endDate?: string | null;
            tags: Array<string>;
        }>;
    } | null;
};
export type GetPortfolioOverviewQueryVariables = Types.Exact<{
    portfolioId: Types.Scalars['ID']['input'];
}>;
export type GetPortfolioOverviewQuery = {
    __typename?: 'Query';
    planmagnetPortfolioOverview: {
        __typename?: 'PortfolioOverview';
        portfolioId: string;
        totalProjects: number;
        totalPrograms: number;
        atRiskCount: number;
        overdueMilestones: number;
        healthScore?: number | null;
        budgetUtilization?: number | null;
        totalBudget?: number | null;
        totalSpent?: number | null;
        projectsByStatus: Record<string, unknown>;
    };
};
export type ListRoadmapsQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.RoadmapFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListRoadmapsQuery = {
    __typename?: 'Query';
    planmagnetRoadmaps: {
        __typename?: 'RoadmapList';
        totalCount: number;
        items: Array<{
            __typename?: 'Roadmap';
            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;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type GetRoadmapQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetRoadmapQuery = {
    __typename?: 'Query';
    planmagnetRoadmap?: {
        __typename?: 'Roadmap';
        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;
        items: Array<{
            __typename?: 'RoadmapItem';
            id: string;
            roadmapId: string;
            title: 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 ListRoadmapItemsQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.RoadmapItemFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListRoadmapItemsQuery = {
    __typename?: 'Query';
    planmagnetRoadmapItems: {
        __typename?: 'RoadmapItemList';
        totalCount: number;
        items: Array<{
            __typename?: 'RoadmapItem';
            id: string;
            roadmapId: string;
            title: 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;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type ListReleasesQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.ReleaseFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListReleasesQuery = {
    __typename?: 'Query';
    planmagnetReleases: {
        __typename?: 'ReleaseList';
        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?: 'PageInfo';
            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.FeatureRequestFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListFeatureRequestsQuery = {
    __typename?: 'Query';
    planmagnetFeatureRequests: {
        __typename?: 'FeatureRequestList';
        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?: 'PageInfo';
            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';
    planmagnetFeatureRequest?: {
        __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;
        votes: Array<{
            __typename?: 'FeatureVote';
            id: string;
            featureRequestId: string;
            voterId: string;
            weight: number;
            comment?: string | null;
            createdAt: string;
        }>;
        competitors: Array<{
            __typename?: 'Competitor';
            id: string;
            workspaceId: string;
            name: string;
            description?: string | null;
            website?: string | null;
            tags: Array<string>;
            metadata?: Record<string, unknown> | null;
            createdBy: string;
            createdAt: string;
            updatedAt: string;
            deletedAt?: string | null;
        }>;
    } | null;
};
export type ListCompetitorsQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.CompetitorFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListCompetitorsQuery = {
    __typename?: 'Query';
    planmagnetCompetitors: {
        __typename?: 'CompetitorList';
        totalCount: number;
        items: Array<{
            __typename?: 'Competitor';
            id: string;
            workspaceId: string;
            name: string;
            description?: string | null;
            website?: string | null;
            tags: Array<string>;
            metadata?: Record<string, unknown> | null;
            createdBy: string;
            createdAt: string;
            updatedAt: string;
            deletedAt?: string | null;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type ListProgramsQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.ProgramFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListProgramsQuery = {
    __typename?: 'Query';
    planmagnetPrograms: {
        __typename?: 'ProgramList';
        totalCount: number;
        items: Array<{
            __typename?: 'Program';
            id: string;
            name: string;
            status: Types.ProjectStatus;
            ownerId: string;
            startDate?: string | null;
            endDate?: string | null;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type GetProgramQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetProgramQuery = {
    __typename?: 'Query';
    planmagnetProgram?: {
        __typename?: 'Program';
        id: string;
        workspaceId: string;
        name: string;
        description?: string | null;
        status: Types.ProjectStatus;
        ownerId: string;
        startDate?: string | null;
        endDate?: string | null;
        budgetTotal?: number | null;
        currency?: string | null;
        tags: Array<string>;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
        projects: Array<{
            __typename?: 'Project';
            id: string;
            name: string;
            key: string;
            status: Types.ProjectStatus;
            methodology: Types.ProjectMethodology;
            ownerId: string;
            startDate?: string | null;
            endDate?: string | null;
            tags: Array<string>;
        }>;
    } | null;
};
export type GetProjectsQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.ProjectFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type GetProjectsQuery = {
    __typename?: 'Query';
    planmagnetProjects: {
        __typename?: 'ProjectList';
        totalCount: number;
        items: Array<{
            __typename?: 'Project';
            id: string;
            name: string;
            key: string;
            status: Types.ProjectStatus;
            methodology: Types.ProjectMethodology;
            ownerId: string;
            startDate?: string | null;
            endDate?: string | null;
            tags: Array<string>;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type GetProjectQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetProjectQuery = {
    __typename?: 'Query';
    planmagnetProject?: {
        __typename?: 'Project';
        id: string;
        workspaceId: string;
        name: string;
        description?: string | null;
        key: string;
        status: Types.ProjectStatus;
        methodology: Types.ProjectMethodology;
        startDate?: string | null;
        endDate?: string | null;
        defaultAssigneeId?: string | null;
        ownerId: string;
        programId?: string | null;
        tags: Array<string>;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
    } | null;
};
export type ListRisksQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.RiskFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListRisksQuery = {
    __typename?: 'Query';
    planmagnetRisks: {
        __typename?: 'RiskList';
        totalCount: number;
        items: Array<{
            __typename?: 'Risk';
            id: string;
            workspaceId: string;
            projectId: string;
            title: string;
            description?: string | null;
            severity: Types.RiskSeverity;
            status: Types.RiskStatus;
            likelihood: number;
            impact: number;
            riskScore: number;
            category?: string | null;
            ownerId?: string | null;
            mitigationPlan?: string | null;
            contingencyPlan?: string | null;
            dueDate?: string | null;
            resolvedAt?: string | null;
            tags: Array<string>;
            metadata?: Record<string, unknown> | null;
            createdBy: string;
            createdAt: string;
            updatedAt: string;
            updatedBy?: string | null;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type GetRiskQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetRiskQuery = {
    __typename?: 'Query';
    planmagnetRisk?: {
        __typename?: 'Risk';
        id: string;
        workspaceId: string;
        projectId: string;
        title: string;
        description?: string | null;
        severity: Types.RiskSeverity;
        status: Types.RiskStatus;
        likelihood: number;
        impact: number;
        riskScore: number;
        category?: string | null;
        ownerId?: string | null;
        mitigationPlan?: string | null;
        contingencyPlan?: string | null;
        dueDate?: string | null;
        resolvedAt?: string | null;
        tags: Array<string>;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
        project?: {
            __typename?: 'Project';
            id: string;
            name: string;
            key: string;
        } | null;
    } | null;
};
export type GetRiskMatrixQueryVariables = Types.Exact<{
    projectId: Types.Scalars['ID']['input'];
}>;
export type GetRiskMatrixQuery = {
    __typename?: 'Query';
    planmagnetRiskMatrix: {
        __typename?: 'RiskMatrix';
        projectId: string;
        totalRisks: number;
        averageRiskScore?: number | null;
        matrix: Record<string, unknown>;
        bySeverity: Record<string, unknown>;
        byStatus: Record<string, unknown>;
    };
};
export type ListSprintsQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.SprintFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListSprintsQuery = {
    __typename?: 'Query';
    planmagnetSprints: {
        __typename?: 'SprintList';
        totalCount: number;
        items: Array<{
            __typename?: 'Sprint';
            id: string;
            name: string;
            status: Types.SprintStatus;
            startDate?: string | null;
            endDate?: string | null;
            capacity?: number | null;
            velocity?: number | null;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type GetSprintQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetSprintQuery = {
    __typename?: 'Query';
    planmagnetSprint?: {
        __typename?: 'Sprint';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        goal?: string | null;
        status: Types.SprintStatus;
        startDate?: string | null;
        endDate?: string | null;
        capacity?: number | null;
        velocity?: number | null;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
        project?: {
            __typename?: 'Project';
            id: string;
            name: string;
            key: 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 ListExternalSyncsQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.ExternalSyncFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListExternalSyncsQuery = {
    __typename?: 'Query';
    planmagnetExternalSyncs: {
        __typename?: 'ExternalSyncList';
        totalCount: number;
        items: Array<{
            __typename?: 'ExternalSync';
            id: string;
            workspaceId: string;
            projectId: string;
            provider: Types.SyncProvider;
            direction: Types.SyncDirection;
            status: Types.SyncStatus;
            externalProjectId: string;
            externalProjectUrl?: string | null;
            connectionConfig: Record<string, unknown>;
            fieldMapping?: Record<string, unknown> | null;
            syncFilters?: Record<string, unknown> | null;
            lastSyncedAt?: string | null;
            lastSyncError?: string | null;
            totalItemsSynced: number;
            metadata?: Record<string, unknown> | null;
            createdBy: string;
            createdAt: string;
            updatedAt: string;
            updatedBy?: string | null;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type GetExternalSyncQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetExternalSyncQuery = {
    __typename?: 'Query';
    planmagnetExternalSync?: {
        __typename?: 'ExternalSync';
        id: string;
        workspaceId: string;
        projectId: string;
        provider: Types.SyncProvider;
        direction: Types.SyncDirection;
        status: Types.SyncStatus;
        externalProjectId: string;
        externalProjectUrl?: string | null;
        connectionConfig: Record<string, unknown>;
        fieldMapping?: Record<string, unknown> | null;
        syncFilters?: Record<string, unknown> | null;
        lastSyncedAt?: string | null;
        lastSyncError?: string | null;
        totalItemsSynced: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
        project?: {
            __typename?: 'Project';
            id: string;
            name: string;
            key: string;
        } | null;
    } | null;
};
export type ListExternalMappingsQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.ExternalMappingFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListExternalMappingsQuery = {
    __typename?: 'Query';
    planmagnetExternalMappings: {
        __typename?: 'ExternalMappingList';
        totalCount: number;
        items: Array<{
            __typename?: 'ExternalMapping';
            id: string;
            syncId: string;
            internalId: string;
            internalType: string;
            externalId: string;
            externalType: string;
            externalUrl?: string | null;
            lastSyncedAt?: string | null;
            lastSyncDirection?: Types.SyncDirection | null;
            metadata?: Record<string, unknown> | null;
            createdAt: string;
            updatedAt: string;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type ListProjectTemplatesQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.ProjectTemplateFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListProjectTemplatesQuery = {
    __typename?: 'Query';
    planmagnetProjectTemplates: {
        __typename?: 'ProjectTemplateList';
        totalCount: number;
        items: Array<{
            __typename?: 'ProjectTemplate';
            id: string;
            workspaceId: string;
            name: string;
            description?: string | null;
            category?: string | null;
            isBuiltIn: boolean;
            isPublished: boolean;
            usageCount: number;
            configuration: Record<string, unknown>;
            boardConfig?: Record<string, unknown> | null;
            sprintConfig?: Record<string, unknown> | null;
            customFieldsConfig?: Record<string, unknown> | null;
            tags: Array<string>;
            metadata?: Record<string, unknown> | null;
            createdBy: string;
            createdAt: string;
            updatedAt: string;
            updatedBy?: string | null;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type GetProjectTemplateQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetProjectTemplateQuery = {
    __typename?: 'Query';
    planmagnetProjectTemplate?: {
        __typename?: 'ProjectTemplate';
        id: string;
        workspaceId: string;
        name: string;
        description?: string | null;
        category?: string | null;
        isBuiltIn: boolean;
        isPublished: boolean;
        usageCount: number;
        configuration: Record<string, unknown>;
        boardConfig?: Record<string, unknown> | null;
        sprintConfig?: Record<string, unknown> | null;
        customFieldsConfig?: Record<string, unknown> | null;
        tags: Array<string>;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
    } | null;
};
export type ListTimeEntriesQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.TimeEntryFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListTimeEntriesQuery = {
    __typename?: 'Query';
    planmagnetTimeEntries: {
        __typename?: 'TimeEntryList';
        totalCount: number;
        items: Array<{
            __typename?: 'TimeEntry';
            id: string;
            workspaceId: string;
            projectId: string;
            workItemId: string;
            userId: string;
            date: string;
            durationMinutes: number;
            startTime?: string | null;
            endTime?: string | null;
            description?: string | null;
            billingType: Types.BillingType;
            billingRate?: number | null;
            status: Types.TimeEntryStatus;
            timesheetId?: string | null;
            metadata?: Record<string, unknown> | null;
            createdBy: string;
            createdAt: string;
            updatedAt: string;
            workItem?: {
                __typename?: 'WorkItem';
                id: string;
                key: string;
                title: string;
            } | null;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type ListTimesheetsQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.TimesheetFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListTimesheetsQuery = {
    __typename?: 'Query';
    planmagnetTimesheets: {
        __typename?: 'TimesheetList';
        totalCount: number;
        items: Array<{
            __typename?: 'Timesheet';
            id: string;
            workspaceId: string;
            userId: string;
            periodStart: string;
            periodEnd: string;
            status: Types.TimeEntryStatus;
            totalMinutes: number;
            billableMinutes: number;
            approverId?: string | null;
            approvedAt?: string | null;
            rejectionReason?: string | null;
            metadata?: Record<string, unknown> | null;
            createdBy: string;
            createdAt: string;
            updatedAt: string;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type GetTimesheetQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetTimesheetQuery = {
    __typename?: 'Query';
    planmagnetTimesheet?: {
        __typename?: 'Timesheet';
        id: string;
        workspaceId: string;
        userId: string;
        periodStart: string;
        periodEnd: string;
        status: Types.TimeEntryStatus;
        totalMinutes: number;
        billableMinutes: number;
        approverId?: string | null;
        approvedAt?: string | null;
        rejectionReason?: string | null;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        entries: Array<{
            __typename?: 'TimeEntry';
            id: string;
            workspaceId: string;
            projectId: string;
            workItemId: string;
            userId: string;
            date: string;
            durationMinutes: number;
            startTime?: string | null;
            endTime?: string | null;
            description?: string | null;
            billingType: Types.BillingType;
            billingRate?: number | null;
            status: Types.TimeEntryStatus;
            timesheetId?: string | null;
            metadata?: Record<string, unknown> | null;
            createdBy: string;
            createdAt: string;
            updatedAt: string;
        }>;
    } | null;
};
export type ListWorkItemsQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.WorkItemFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListWorkItemsQuery = {
    __typename?: 'Query';
    planmagnetWorkItems: {
        __typename?: 'WorkItemList';
        totalCount: number;
        items: 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>;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type GetWorkItemQueryVariables = Types.Exact<{
    id: Types.Scalars['ID']['input'];
}>;
export type GetWorkItemQuery = {
    __typename?: 'Query';
    planmagnetWorkItem?: {
        __typename?: 'WorkItem';
        id: string;
        workspaceId: string;
        projectId: string;
        key: string;
        title: string;
        description?: string | null;
        type: Types.WorkItemType;
        status: Types.WorkItemStatus;
        priority: Types.WorkItemPriority;
        assigneeId?: string | null;
        reporterId?: string | null;
        parentId?: string | null;
        sprintId?: string | null;
        storyPoints?: number | null;
        estimateMinutes?: number | null;
        timeSpentMinutes?: number | null;
        dueDate?: string | null;
        labels: Array<string>;
        tags: Array<string>;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
        children: 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>;
        }>;
        parent?: {
            __typename?: 'WorkItem';
            id: string;
            key: string;
            title: string;
        } | null;
        sprint?: {
            __typename?: 'Sprint';
            id: string;
            name: string;
            status: Types.SprintStatus;
            startDate?: string | null;
            endDate?: string | null;
            capacity?: number | null;
            velocity?: number | null;
        } | null;
        project?: {
            __typename?: 'Project';
            id: string;
            name: string;
            key: string;
        } | null;
        dependencies: Array<{
            __typename?: 'WorkItemDependency';
            id: string;
            workspaceId: string;
            sourceWorkItemId: string;
            targetWorkItemId: string;
            type: Types.DependencyType;
            status: Types.DependencyStatus;
            description?: string | null;
            metadata?: Record<string, unknown> | null;
            createdBy: string;
            createdAt: string;
            updatedAt: string;
        }>;
        customFieldValues: Array<{
            __typename?: 'CustomFieldValue';
            id: string;
            definitionId: string;
            value: Record<string, unknown>;
            setBy: string;
        }>;
    } | null;
};
export type ListDependenciesQueryVariables = Types.Exact<{
    workspaceId: Types.Scalars['ID']['input'];
    filter?: Types.InputMaybe<Types.DependencyFilter>;
    pagination?: Types.InputMaybe<Types.PaginationInput>;
}>;
export type ListDependenciesQuery = {
    __typename?: 'Query';
    planmagnetDependencies: {
        __typename?: 'WorkItemDependencyList';
        totalCount: number;
        items: Array<{
            __typename?: 'WorkItemDependency';
            id: string;
            workspaceId: string;
            sourceWorkItemId: string;
            targetWorkItemId: string;
            type: Types.DependencyType;
            status: Types.DependencyStatus;
            description?: string | null;
            metadata?: Record<string, unknown> | null;
            createdBy: string;
            createdAt: string;
            updatedAt: string;
            sourceWorkItem?: {
                __typename?: 'WorkItem';
                id: string;
                key: string;
                title: string;
                status: Types.WorkItemStatus;
            } | null;
            targetWorkItem?: {
                __typename?: 'WorkItem';
                id: string;
                key: string;
                title: string;
                status: Types.WorkItemStatus;
            } | null;
        }>;
        pageInfo: {
            __typename?: 'PageInfo';
            hasNextPage: boolean;
            hasPreviousPage: boolean;
            startCursor?: string | null;
            endCursor?: string | null;
            totalCount: number;
        };
    };
};
export type OnProjectUpdatedSubscriptionVariables = Types.Exact<{
    projectId: Types.Scalars['ID']['input'];
}>;
export type OnProjectUpdatedSubscription = {
    __typename?: 'Subscription';
    planmagnetOnProjectUpdated: {
        __typename?: 'Project';
        id: string;
        workspaceId: string;
        name: string;
        description?: string | null;
        key: string;
        status: Types.ProjectStatus;
        methodology: Types.ProjectMethodology;
        startDate?: string | null;
        endDate?: string | null;
        defaultAssigneeId?: string | null;
        ownerId: string;
        programId?: string | null;
        tags: Array<string>;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
    };
};
export type OnWorkItemUpdatedSubscriptionVariables = Types.Exact<{
    projectId: Types.Scalars['ID']['input'];
}>;
export type OnWorkItemUpdatedSubscription = {
    __typename?: 'Subscription';
    planmagnetOnWorkItemUpdated: {
        __typename?: 'WorkItem';
        id: string;
        workspaceId: string;
        projectId: string;
        key: string;
        title: string;
        description?: string | null;
        type: Types.WorkItemType;
        status: Types.WorkItemStatus;
        priority: Types.WorkItemPriority;
        assigneeId?: string | null;
        reporterId?: string | null;
        parentId?: string | null;
        sprintId?: string | null;
        storyPoints?: number | null;
        estimateMinutes?: number | null;
        timeSpentMinutes?: number | null;
        dueDate?: string | null;
        labels: Array<string>;
        tags: Array<string>;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
    };
};
export type OnSprintUpdatedSubscriptionVariables = Types.Exact<{
    projectId: Types.Scalars['ID']['input'];
}>;
export type OnSprintUpdatedSubscription = {
    __typename?: 'Subscription';
    planmagnetOnSprintUpdated: {
        __typename?: 'Sprint';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        goal?: string | null;
        status: Types.SprintStatus;
        startDate?: string | null;
        endDate?: string | null;
        capacity?: number | null;
        velocity?: number | null;
        sortOrder: number;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
    };
};
export type OnBoardCardMovedSubscriptionVariables = Types.Exact<{
    boardId: Types.Scalars['ID']['input'];
}>;
export type OnBoardCardMovedSubscription = {
    __typename?: 'Subscription';
    planmagnetOnBoardCardMoved: {
        __typename?: 'Board';
        id: string;
        workspaceId: string;
        projectId: string;
        name: string;
        description?: string | null;
        type: Types.BoardType;
        isDefault: boolean;
        metadata?: Record<string, unknown> | null;
        createdBy: string;
        createdAt: string;
        updatedAt: string;
        updatedBy?: string | null;
        deletedAt?: string | null;
        columns: Array<{
            __typename?: 'BoardColumn';
            id: string;
            boardId: string;
            name: string;
            type: Types.BoardColumnType;
            mappedStatus?: Types.WorkItemStatus | null;
            wipLimit?: number | null;
            sortOrder: number;
            metadata?: Record<string, unknown> | null;
            createdAt: string;
            updatedAt: string;
        }>;
    };
};
export declare const BoardColumnFieldsFragmentDoc: Apollo.DocumentNode;
export declare const BoardFieldsFragmentDoc: Apollo.DocumentNode;
export declare const BoardSummaryFieldsFragmentDoc: Apollo.DocumentNode;
export declare const MilestoneFieldsFragmentDoc: Apollo.DocumentNode;
export declare const MilestoneSummaryFieldsFragmentDoc: Apollo.DocumentNode;
export declare const PortfolioFieldsFragmentDoc: Apollo.DocumentNode;
export declare const PortfolioSummaryFieldsFragmentDoc: Apollo.DocumentNode;
export declare const PortfolioOverviewFieldsFragmentDoc: Apollo.DocumentNode;
export declare const ProgramFieldsFragmentDoc: Apollo.DocumentNode;
export declare const ProgramSummaryFieldsFragmentDoc: Apollo.DocumentNode;
export declare const RoadmapFieldsFragmentDoc: Apollo.DocumentNode;
export declare const RoadmapItemFieldsFragmentDoc: Apollo.DocumentNode;
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 ProjectFieldsFragmentDoc: Apollo.DocumentNode;
export declare const ProjectSummaryFieldsFragmentDoc: Apollo.DocumentNode;
export declare const SprintFieldsFragmentDoc: Apollo.DocumentNode;
export declare const SprintSummaryFieldsFragmentDoc: Apollo.DocumentNode;
export declare const TimeEntryFieldsFragmentDoc: Apollo.DocumentNode;
export declare const TimesheetFieldsFragmentDoc: Apollo.DocumentNode;
export declare const WorkItemFieldsFragmentDoc: Apollo.DocumentNode;
export declare const WorkItemSummaryFieldsFragmentDoc: Apollo.DocumentNode;
export declare const WorkItemDependencyFieldsFragmentDoc: Apollo.DocumentNode;
export declare const CreateAutomationRuleDocument: Apollo.DocumentNode;
export type CreateAutomationRuleMutationFn = Apollo.MutationFunction<Types.CreateAutomationRuleMutation, Types.CreateAutomationRuleMutationVariables>;
/**
 * __useCreateAutomationRuleMutation__
 *
 * To run a mutation, you first call `useCreateAutomationRuleMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateAutomationRuleMutation` 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 [createAutomationRuleMutation, { data, loading, error }] = useCreateAutomationRuleMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateAutomationRuleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateAutomationRuleMutation, Types.CreateAutomationRuleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateAutomationRuleMutation, any, Apollo.ApolloCache>;
export type CreateAutomationRuleMutationHookResult = ReturnType<typeof useCreateAutomationRuleMutation>;
export type CreateAutomationRuleMutationResult = Apollo.MutationResult<Types.CreateAutomationRuleMutation>;
export type CreateAutomationRuleMutationOptions = Apollo.BaseMutationOptions<Types.CreateAutomationRuleMutation, Types.CreateAutomationRuleMutationVariables>;
export declare const UpdateAutomationRuleDocument: Apollo.DocumentNode;
export type UpdateAutomationRuleMutationFn = Apollo.MutationFunction<Types.UpdateAutomationRuleMutation, Types.UpdateAutomationRuleMutationVariables>;
/**
 * __useUpdateAutomationRuleMutation__
 *
 * To run a mutation, you first call `useUpdateAutomationRuleMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateAutomationRuleMutation` 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 [updateAutomationRuleMutation, { data, loading, error }] = useUpdateAutomationRuleMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateAutomationRuleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateAutomationRuleMutation, Types.UpdateAutomationRuleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateAutomationRuleMutation, any, Apollo.ApolloCache>;
export type UpdateAutomationRuleMutationHookResult = ReturnType<typeof useUpdateAutomationRuleMutation>;
export type UpdateAutomationRuleMutationResult = Apollo.MutationResult<Types.UpdateAutomationRuleMutation>;
export type UpdateAutomationRuleMutationOptions = Apollo.BaseMutationOptions<Types.UpdateAutomationRuleMutation, Types.UpdateAutomationRuleMutationVariables>;
export declare const DeleteAutomationRuleDocument: Apollo.DocumentNode;
export type DeleteAutomationRuleMutationFn = Apollo.MutationFunction<Types.DeleteAutomationRuleMutation, Types.DeleteAutomationRuleMutationVariables>;
/**
 * __useDeleteAutomationRuleMutation__
 *
 * To run a mutation, you first call `useDeleteAutomationRuleMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteAutomationRuleMutation` 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 [deleteAutomationRuleMutation, { data, loading, error }] = useDeleteAutomationRuleMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteAutomationRuleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteAutomationRuleMutation, Types.DeleteAutomationRuleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteAutomationRuleMutation, any, Apollo.ApolloCache>;
export type DeleteAutomationRuleMutationHookResult = ReturnType<typeof useDeleteAutomationRuleMutation>;
export type DeleteAutomationRuleMutationResult = Apollo.MutationResult<Types.DeleteAutomationRuleMutation>;
export type DeleteAutomationRuleMutationOptions = Apollo.BaseMutationOptions<Types.DeleteAutomationRuleMutation, Types.DeleteAutomationRuleMutationVariables>;
export declare const ToggleAutomationRuleDocument: Apollo.DocumentNode;
export type ToggleAutomationRuleMutationFn = Apollo.MutationFunction<Types.ToggleAutomationRuleMutation, Types.ToggleAutomationRuleMutationVariables>;
/**
 * __useToggleAutomationRuleMutation__
 *
 * To run a mutation, you first call `useToggleAutomationRuleMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useToggleAutomationRuleMutation` 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 [toggleAutomationRuleMutation, { data, loading, error }] = useToggleAutomationRuleMutation({
 *   variables: {
 *      id: // value for 'id'
 *      status: // value for 'status'
 *   },
 * });
 */
export declare function useToggleAutomationRuleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ToggleAutomationRuleMutation, Types.ToggleAutomationRuleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ToggleAutomationRuleMutation, any, Apollo.ApolloCache>;
export type ToggleAutomationRuleMutationHookResult = ReturnType<typeof useToggleAutomationRuleMutation>;
export type ToggleAutomationRuleMutationResult = Apollo.MutationResult<Types.ToggleAutomationRuleMutation>;
export type ToggleAutomationRuleMutationOptions = Apollo.BaseMutationOptions<Types.ToggleAutomationRuleMutation, Types.ToggleAutomationRuleMutationVariables>;
export declare const ExecuteAutomationRuleDocument: Apollo.DocumentNode;
export type ExecuteAutomationRuleMutationFn = Apollo.MutationFunction<Types.ExecuteAutomationRuleMutation, Types.ExecuteAutomationRuleMutationVariables>;
/**
 * __useExecuteAutomationRuleMutation__
 *
 * To run a mutation, you first call `useExecuteAutomationRuleMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useExecuteAutomationRuleMutation` 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 [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'
 *      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>;
/**
 * __useDeleteCustomFieldDefinitionMutation__
 *
 * 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 [deleteCustomFieldDefinitionMutation, { data, loading, error }] = useDeleteCustomFieldDefinitionMutation({
 *   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>;
/**
 * __useSetCustomFieldValueMutation__
 *
 * 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 [setCustomFieldValueMutation, { data, loading, error }] = useSetCustomFieldValueMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
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>;
/**
 * __useRemoveCustomFieldValueMutation__
 *
 * 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 [removeCustomFieldValueMutation, { data, loading, error }] = useRemoveCustomFieldValueMutation({
 *   variables: {
 *      definitionId: // value for 'definitionId'
 *      workItemId: // value for 'workItemId'
 *   },
 * });
 */
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>;
/**
 * __useCreateMilestoneMutation__
 *
 * 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 [createMilestoneMutation, { data, loading, error }] = useCreateMilestoneMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
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>;
/**
 * __useUpdateMilestoneMutation__
 *
 * 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 [updateMilestoneMutation, { data, loading, error }] = useUpdateMilestoneMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
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>;
/**
 * __useDeleteMilestoneMutation__
 *
 * 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 [deleteMilestoneMutation, { data, loading, error }] = useDeleteMilestoneMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
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 CreateRoadmapDocument: Apollo.DocumentNode;
export type CreateRoadmapMutationFn = Apollo.MutationFunction<Types.CreateRoadmapMutation, Types.CreateRoadmapMutationVariables>;
/**
 * __useCreateRoadmapMutation__
 *
 * To run a mutation, you first call `useCreateRoadmapMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateRoadmapMutation` 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 [createRoadmapMutation, { data, loading, error }] = useCreateRoadmapMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateRoadmapMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateRoadmapMutation, Types.CreateRoadmapMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateRoadmapMutation, any, Apollo.ApolloCache>;
export type CreateRoadmapMutationHookResult = ReturnType<typeof useCreateRoadmapMutation>;
export type CreateRoadmapMutationResult = Apollo.MutationResult<Types.CreateRoadmapMutation>;
export type CreateRoadmapMutationOptions = Apollo.BaseMutationOptions<Types.CreateRoadmapMutation, Types.CreateRoadmapMutationVariables>;
export declare const UpdateRoadmapDocument: Apollo.DocumentNode;
export type UpdateRoadmapMutationFn = Apollo.MutationFunction<Types.UpdateRoadmapMutation, Types.UpdateRoadmapMutationVariables>;
/**
 * __useUpdateRoadmapMutation__
 *
 * To run a mutation, you first call `useUpdateRoadmapMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateRoadmapMutation` 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 [updateRoadmapMutation, { data, loading, error }] = useUpdateRoadmapMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateRoadmapMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateRoadmapMutation, Types.UpdateRoadmapMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateRoadmapMutation, any, Apollo.ApolloCache>;
export type UpdateRoadmapMutationHookResult = ReturnType<typeof useUpdateRoadmapMutation>;
export type UpdateRoadmapMutationResult = Apollo.MutationResult<Types.UpdateRoadmapMutation>;
export type UpdateRoadmapMutationOptions = Apollo.BaseMutationOptions<Types.UpdateRoadmapMutation, Types.UpdateRoadmapMutationVariables>;
export declare const DeleteRoadmapDocument: Apollo.DocumentNode;
export type DeleteRoadmapMutationFn = Apollo.MutationFunction<Types.DeleteRoadmapMutation, Types.DeleteRoadmapMutationVariables>;
/**
 * __useDeleteRoadmapMutation__
 *
 * To run a mutation, you first call `useDeleteRoadmapMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteRoadmapMutation` 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 [deleteRoadmapMutation, { data, loading, error }] = useDeleteRoadmapMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteRoadmapMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteRoadmapMutation, Types.DeleteRoadmapMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteRoadmapMutation, any, Apollo.ApolloCache>;
export type DeleteRoadmapMutationHookResult = ReturnType<typeof useDeleteRoadmapMutation>;
export type DeleteRoadmapMutationResult = Apollo.MutationResult<Types.DeleteRoadmapMutation>;
export type DeleteRoadmapMutationOptions = Apollo.BaseMutationOptions<Types.DeleteRoadmapMutation, Types.DeleteRoadmapMutationVariables>;
export declare const CreateRoadmapItemDocument: Apollo.DocumentNode;
export type CreateRoadmapItemMutationFn = Apollo.MutationFunction<Types.CreateRoadmapItemMutation, Types.CreateRoadmapItemMutationVariables>;
/**
 * __useCreateRoadmapItemMutation__
 *
 * To run a mutation, you first call `useCreateRoadmapItemMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateRoadmapItemMutation` 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 [createRoadmapItemMutation, { data, loading, error }] = useCreateRoadmapItemMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateRoadmapItemMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateRoadmapItemMutation, Types.CreateRoadmapItemMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateRoadmapItemMutation, any, Apollo.ApolloCache>;
export type CreateRoadmapItemMutationHookResult = ReturnType<typeof useCreateRoadmapItemMutation>;
export type CreateRoadmapItemMutationResult = Apollo.MutationResult<Types.CreateRoadmapItemMutation>;
export type CreateRoadmapItemMutationOptions = Apollo.BaseMutationOptions<Types.CreateRoadmapItemMutation, Types.CreateRoadmapItemMutationVariables>;
export declare const UpdateRoadmapItemDocument: Apollo.DocumentNode;
export type UpdateRoadmapItemMutationFn = Apollo.MutationFunction<Types.UpdateRoadmapItemMutation, Types.UpdateRoadmapItemMutationVariables>;
/**
 * __useUpdateRoadmapItemMutation__
 *
 * To run a mutation, you first call `useUpdateRoadmapItemMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateRoadmapItemMutation` 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 [updateRoadmapItemMutation, { data, loading, error }] = useUpdateRoadmapItemMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateRoadmapItemMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateRoadmapItemMutation, Types.UpdateRoadmapItemMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateRoadmapItemMutation, any, Apollo.ApolloCache>;
export type UpdateRoadmapItemMutationHookResult = ReturnType<typeof useUpdateRoadmapItemMutation>;
export type UpdateRoadmapItemMutationResult = Apollo.MutationResult<Types.UpdateRoadmapItemMutation>;
export type UpdateRoadmapItemMutationOptions = Apollo.BaseMutationOptions<Types.UpdateRoadmapItemMutation, Types.UpdateRoadmapItemMutationVariables>;
export declare const DeleteRoadmapItemDocument: Apollo.DocumentNode;
export type DeleteRoadmapItemMutationFn = Apollo.MutationFunction<Types.DeleteRoadmapItemMutation, Types.DeleteRoadmapItemMutationVariables>;
/**
 * __useDeleteRoadmapItemMutation__
 *
 * To run a mutation, you first call `useDeleteRoadmapItemMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteRoadmapItemMutation` 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 [deleteRoadmapItemMutation, { data, loading, error }] = useDeleteRoadmapItemMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteRoadmapItemMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteRoadmapItemMutation, Types.DeleteRoadmapItemMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteRoadmapItemMutation, any, Apollo.ApolloCache>;
export type DeleteRoadmapItemMutationHookResult = ReturnType<typeof useDeleteRoadmapItemMutation>;
export type DeleteRoadmapItemMutationResult = Apollo.MutationResult<Types.DeleteRoadmapItemMutation>;
export type DeleteRoadmapItemMutationOptions = Apollo.BaseMutationOptions<Types.DeleteRoadmapItemMutation, Types.DeleteRoadmapItemMutationVariables>;
export declare const CreateReleaseDocument: Apollo.DocumentNode;
export type CreateReleaseMutationFn = Apollo.MutationFunction<Types.CreateReleaseMutation, Types.CreateReleaseMutationVariables>;
/**
 * __useCreateReleaseMutation__
 *
 * To run a mutation, you first call `useCreateReleaseMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateReleaseMutation` 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 [createReleaseMutation, { data, loading, error }] = useCreateReleaseMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateReleaseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateReleaseMutation, Types.CreateReleaseMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateReleaseMutation, any, Apollo.ApolloCache>;
export type CreateReleaseMutationHookResult = ReturnType<typeof useCreateReleaseMutation>;
export type CreateReleaseMutationResult = Apollo.MutationResult<Types.CreateReleaseMutation>;
export type CreateReleaseMutationOptions = Apollo.BaseMutationOptions<Types.CreateReleaseMutation, Types.CreateReleaseMutationVariables>;
export declare const UpdateReleaseDocument: Apollo.DocumentNode;
export type UpdateReleaseMutationFn = Apollo.MutationFunction<Types.UpdateReleaseMutation, Types.UpdateReleaseMutationVariables>;
/**
 * __useUpdateReleaseMutation__
 *
 * To run a mutation, you first call `useUpdateReleaseMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateReleaseMutation` 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 [updateReleaseMutation, { data, loading, error }] = useUpdateReleaseMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateReleaseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateReleaseMutation, Types.UpdateReleaseMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateReleaseMutation, any, Apollo.ApolloCache>;
export type UpdateReleaseMutationHookResult = ReturnType<typeof useUpdateReleaseMutation>;
export type UpdateReleaseMutationResult = Apollo.MutationResult<Types.UpdateReleaseMutation>;
export type UpdateReleaseMutationOptions = Apollo.BaseMutationOptions<Types.UpdateReleaseMutation, Types.UpdateReleaseMutationVariables>;
export declare const DeleteReleaseDocument: Apollo.DocumentNode;
export type DeleteReleaseMutationFn = Apollo.MutationFunction<Types.DeleteReleaseMutation, Types.DeleteReleaseMutationVariables>;
/**
 * __useDeleteReleaseMutation__
 *
 * To run a mutation, you first call `useDeleteReleaseMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteReleaseMutation` 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 [deleteReleaseMutation, { data, loading, error }] = useDeleteReleaseMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteReleaseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteReleaseMutation, Types.DeleteReleaseMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteReleaseMutation, any, Apollo.ApolloCache>;
export type DeleteReleaseMutationHookResult = ReturnType<typeof useDeleteReleaseMutation>;
export type DeleteReleaseMutationResult = Apollo.MutationResult<Types.DeleteReleaseMutation>;
export type DeleteReleaseMutationOptions = Apollo.BaseMutationOptions<Types.DeleteReleaseMutation, Types.DeleteReleaseMutationVariables>;
export declare const CreateFeatureRequestDocument: Apollo.DocumentNode;
export type CreateFeatureRequestMutationFn = Apollo.MutationFunction<Types.CreateFeatureRequestMutation, Types.CreateFeatureRequestMutationVariables>;
/**
 * __useCreateFeatureRequestMutation__
 *
 * To run a mutation, you first call `useCreateFeatureRequestMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateFeatureRequestMutation` 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 [createFeatureRequestMutation, { data, loading, error }] = useCreateFeatureRequestMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateFeatureRequestMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateFeatureRequestMutation, Types.CreateFeatureRequestMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateFeatureRequestMutation, any, Apollo.ApolloCache>;
export type CreateFeatureRequestMutationHookResult = ReturnType<typeof useCreateFeatureRequestMutation>;
export type CreateFeatureRequestMutationResult = Apollo.MutationResult<Types.CreateFeatureRequestMutation>;
export type CreateFeatureRequestMutationOptions = Apollo.BaseMutationOptions<Types.CreateFeatureRequestMutation, Types.CreateFeatureRequestMutationVariables>;
export declare const UpdateFeatureRequestDocument: Apollo.DocumentNode;
export type UpdateFeatureRequestMutationFn = Apollo.MutationFunction<Types.UpdateFeatureRequestMutation, Types.UpdateFeatureRequestMutationVariables>;
/**
 * __useUpdateFeatureRequestMutation__
 *
 * To run a mutation, you first call `useUpdateFeatureRequestMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateFeatureRequestMutation` 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 [updateFeatureRequestMutation, { data, loading, error }] = useUpdateFeatureRequestMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateFeatureRequestMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateFeatureRequestMutation, Types.UpdateFeatureRequestMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateFeatureRequestMutation, any, Apollo.ApolloCache>;
export type UpdateFeatureRequestMutationHookResult = ReturnType<typeof useUpdateFeatureRequestMutation>;
export type UpdateFeatureRequestMutationResult = Apollo.MutationResult<Types.UpdateFeatureRequestMutation>;
export type UpdateFeatureRequestMutationOptions = Apollo.BaseMutationOptions<Types.UpdateFeatureRequestMutation, Types.UpdateFeatureRequestMutationVariables>;
export declare const DeleteFeatureRequestDocument: Apollo.DocumentNode;
export type DeleteFeatureRequestMutationFn = Apollo.MutationFunction<Types.DeleteFeatureRequestMutation, Types.DeleteFeatureRequestMutationVariables>;
/**
 * __useDeleteFeatureRequestMutation__
 *
 * To run a mutation, you first call `useDeleteFeatureRequestMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteFeatureRequestMutation` 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 [deleteFeatureRequestMutation, { data, loading, error }] = useDeleteFeatureRequestMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteFeatureRequestMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteFeatureRequestMutation, Types.DeleteFeatureRequestMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteFeatureRequestMutation, any, Apollo.ApolloCache>;
export type DeleteFeatureRequestMutationHookResult = ReturnType<typeof useDeleteFeatureRequestMutation>;
export type DeleteFeatureRequestMutationResult = Apollo.MutationResult<Types.DeleteFeatureRequestMutation>;
export type DeleteFeatureRequestMutationOptions = Apollo.BaseMutationOptions<Types.DeleteFeatureRequestMutation, Types.DeleteFeatureRequestMutationVariables>;
export declare const VoteOnFeatureDocument: Apollo.DocumentNode;
export type VoteOnFeatureMutationFn = Apollo.MutationFunction<Types.VoteOnFeatureMutation, Types.VoteOnFeatureMutationVariables>;
/**
 * __useVoteOnFeatureMutation__
 *
 * To run a mutation, you first call `useVoteOnFeatureMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useVoteOnFeatureMutation` 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 [voteOnFeatureMutation, { data, loading, error }] = useVoteOnFeatureMutation({
 *   variables: {
 *      featureRequestId: // value for 'featureRequestId'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useVoteOnFeatureMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.VoteOnFeatureMutation, Types.VoteOnFeatureMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.VoteOnFeatureMutation, any, Apollo.ApolloCache>;
export type VoteOnFeatureMutationHookResult = ReturnType<typeof useVoteOnFeatureMutation>;
export type VoteOnFeatureMutationResult = Apollo.MutationResult<Types.VoteOnFeatureMutation>;
export type VoteOnFeatureMutationOptions = Apollo.BaseMutationOptions<Types.VoteOnFeatureMutation, Types.VoteOnFeatureMutationVariables>;
export declare const RemoveFeatureVoteDocument: Apollo.DocumentNode;
export type RemoveFeatureVoteMutationFn = Apollo.MutationFunction<Types.RemoveFeatureVoteMutation, Types.RemoveFeatureVoteMutationVariables>;
/**
 * __useRemoveFeatureVoteMutation__
 *
 * To run a mutation, you first call `useRemoveFeatureVoteMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRemoveFeatureVoteMutation` 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 [removeFeatureVoteMutation, { data, loading, error }] = useRemoveFeatureVoteMutation({
 *   variables: {
 *      featureRequestId: // value for 'featureRequestId'
 *   },
 * });
 */
export declare function useRemoveFeatureVoteMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RemoveFeatureVoteMutation, Types.RemoveFeatureVoteMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RemoveFeatureVoteMutation, any, Apollo.ApolloCache>;
export type RemoveFeatureVoteMutationHookResult = ReturnType<typeof useRemoveFeatureVoteMutation>;
export type RemoveFeatureVoteMutationResult = Apollo.MutationResult<Types.RemoveFeatureVoteMutation>;
export type RemoveFeatureVoteMutationOptions = Apollo.BaseMutationOptions<Types.RemoveFeatureVoteMutation, Types.RemoveFeatureVoteMutationVariables>;
export declare const CreateCompetitorDocument: Apollo.DocumentNode;
export type CreateCompetitorMutationFn = Apollo.MutationFunction<Types.CreateCompetitorMutation, Types.CreateCompetitorMutationVariables>;
/**
 * __useCreateCompetitorMutation__
 *
 * To run a mutation, you first call `useCreateCompetitorMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateCompetitorMutation` 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 [createCompetitorMutation, { data, loading, error }] = useCreateCompetitorMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateCompetitorMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateCompetitorMutation, Types.CreateCompetitorMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateCompetitorMutation, any, Apollo.ApolloCache>;
export type CreateCompetitorMutationHookResult = ReturnType<typeof useCreateCompetitorMutation>;
export type CreateCompetitorMutationResult = Apollo.MutationResult<Types.CreateCompetitorMutation>;
export type CreateCompetitorMutationOptions = Apollo.BaseMutationOptions<Types.CreateCompetitorMutation, Types.CreateCompetitorMutationVariables>;
export declare const UpdateCompetitorDocument: Apollo.DocumentNode;
export type UpdateCompetitorMutationFn = Apollo.MutationFunction<Types.UpdateCompetitorMutation, Types.UpdateCompetitorMutationVariables>;
/**
 * __useUpdateCompetitorMutation__
 *
 * To run a mutation, you first call `useUpdateCompetitorMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateCompetitorMutation` 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 [updateCompetitorMutation, { data, loading, error }] = useUpdateCompetitorMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateCompetitorMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateCompetitorMutation, Types.UpdateCompetitorMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateCompetitorMutation, any, Apollo.ApolloCache>;
export type UpdateCompetitorMutationHookResult = ReturnType<typeof useUpdateCompetitorMutation>;
export type UpdateCompetitorMutationResult = Apollo.MutationResult<Types.UpdateCompetitorMutation>;
export type UpdateCompetitorMutationOptions = Apollo.BaseMutationOptions<Types.UpdateCompetitorMutation, Types.UpdateCompetitorMutationVariables>;
export declare const DeleteCompetitorDocument: Apollo.DocumentNode;
export type DeleteCompetitorMutationFn = Apollo.MutationFunction<Types.DeleteCompetitorMutation, Types.DeleteCompetitorMutationVariables>;
/**
 * __useDeleteCompetitorMutation__
 *
 * To run a mutation, you first call `useDeleteCompetitorMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteCompetitorMutation` 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 [deleteCompetitorMutation, { data, loading, error }] = useDeleteCompetitorMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteCompetitorMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteCompetitorMutation, Types.DeleteCompetitorMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteCompetitorMutation, any, Apollo.ApolloCache>;
export type DeleteCompetitorMutationHookResult = ReturnType<typeof useDeleteCompetitorMutation>;
export type DeleteCompetitorMutationResult = Apollo.MutationResult<Types.DeleteCompetitorMutation>;
export type DeleteCompetitorMutationOptions = Apollo.BaseMutationOptions<Types.DeleteCompetitorMutation, Types.DeleteCompetitorMutationVariables>;
export declare const LinkCompetitorToFeatureDocument: Apollo.DocumentNode;
export type LinkCompetitorToFeatureMutationFn = Apollo.MutationFunction<Types.LinkCompetitorToFeatureMutation, Types.LinkCompetitorToFeatureMutationVariables>;
/**
 * __useLinkCompetitorToFeatureMutation__
 *
 * To run a mutation, you first call `useLinkCompetitorToFeatureMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useLinkCompetitorToFeatureMutation` 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 [linkCompetitorToFeatureMutation, { data, loading, error }] = useLinkCompetitorToFeatureMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useLinkCompetitorToFeatureMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.LinkCompetitorToFeatureMutation, Types.LinkCompetitorToFeatureMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.LinkCompetitorToFeatureMutation, any, Apollo.ApolloCache>;
export type LinkCompetitorToFeatureMutationHookResult = ReturnType<typeof useLinkCompetitorToFeatureMutation>;
export type LinkCompetitorToFeatureMutationResult = Apollo.MutationResult<Types.LinkCompetitorToFeatureMutation>;
export type LinkCompetitorToFeatureMutationOptions = Apollo.BaseMutationOptions<Types.LinkCompetitorToFeatureMutation, Types.LinkCompetitorToFeatureMutationVariables>;
export declare const UnlinkCompetitorFromFeatureDocument: Apollo.DocumentNode;
export type UnlinkCompetitorFromFeatureMutationFn = Apollo.MutationFunction<Types.UnlinkCompetitorFromFeatureMutation, Types.UnlinkCompetitorFromFeatureMutationVariables>;
/**
 * __useUnlinkCompetitorFromFeatureMutation__
 *
 * To run a mutation, you first call `useUnlinkCompetitorFromFeatureMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUnlinkCompetitorFromFeatureMutation` 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 [unlinkCompetitorFromFeatureMutation, { data, loading, error }] = useUnlinkCompetitorFromFeatureMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUnlinkCompetitorFromFeatureMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UnlinkCompetitorFromFeatureMutation, Types.UnlinkCompetitorFromFeatureMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UnlinkCompetitorFromFeatureMutation, any, Apollo.ApolloCache>;
export type UnlinkCompetitorFromFeatureMutationHookResult = ReturnType<typeof useUnlinkCompetitorFromFeatureMutation>;
export type UnlinkCompetitorFromFeatureMutationResult = Apollo.MutationResult<Types.UnlinkCompetitorFromFeatureMutation>;
export type UnlinkCompetitorFromFeatureMutationOptions = Apollo.BaseMutationOptions<Types.UnlinkCompetitorFromFeatureMutation, Types.UnlinkCompetitorFromFeatureMutationVariables>;
export declare const CreateProgramDocument: Apollo.DocumentNode;
export type CreateProgramMutationFn = Apollo.MutationFunction<Types.CreateProgramMutation, Types.CreateProgramMutationVariables>;
/**
 * __useCreateProgramMutation__
 *
 * To run a mutation, you first call `useCreateProgramMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateProgramMutation` 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 [createProgramMutation, { data, loading, error }] = useCreateProgramMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateProgramMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateProgramMutation, Types.CreateProgramMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateProgramMutation, any, Apollo.ApolloCache>;
export type CreateProgramMutationHookResult = ReturnType<typeof useCreateProgramMutation>;
export type CreateProgramMutationResult = Apollo.MutationResult<Types.CreateProgramMutation>;
export type CreateProgramMutationOptions = Apollo.BaseMutationOptions<Types.CreateProgramMutation, Types.CreateProgramMutationVariables>;
export declare const UpdateProgramDocument: Apollo.DocumentNode;
export type UpdateProgramMutationFn = Apollo.MutationFunction<Types.UpdateProgramMutation, Types.UpdateProgramMutationVariables>;
/**
 * __useUpdateProgramMutation__
 *
 * To run a mutation, you first call `useUpdateProgramMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateProgramMutation` 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 [updateProgramMutation, { data, loading, error }] = useUpdateProgramMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateProgramMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateProgramMutation, Types.UpdateProgramMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateProgramMutation, any, Apollo.ApolloCache>;
export type UpdateProgramMutationHookResult = ReturnType<typeof useUpdateProgramMutation>;
export type UpdateProgramMutationResult = Apollo.MutationResult<Types.UpdateProgramMutation>;
export type UpdateProgramMutationOptions = Apollo.BaseMutationOptions<Types.UpdateProgramMutation, Types.UpdateProgramMutationVariables>;
export declare const DeleteProgramDocument: Apollo.DocumentNode;
export type DeleteProgramMutationFn = Apollo.MutationFunction<Types.DeleteProgramMutation, Types.DeleteProgramMutationVariables>;
/**
 * __useDeleteProgramMutation__
 *
 * To run a mutation, you first call `useDeleteProgramMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteProgramMutation` 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 [deleteProgramMutation, { data, loading, error }] = useDeleteProgramMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteProgramMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteProgramMutation, Types.DeleteProgramMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteProgramMutation, any, Apollo.ApolloCache>;
export type DeleteProgramMutationHookResult = ReturnType<typeof useDeleteProgramMutation>;
export type DeleteProgramMutationResult = Apollo.MutationResult<Types.DeleteProgramMutation>;
export type DeleteProgramMutationOptions = Apollo.BaseMutationOptions<Types.DeleteProgramMutation, Types.DeleteProgramMutationVariables>;
export declare const CreateProjectDocument: Apollo.DocumentNode;
export type CreateProjectMutationFn = Apollo.MutationFunction<Types.CreateProjectMutation, Types.CreateProjectMutationVariables>;
/**
 * __useCreateProjectMutation__
 *
 * To run a mutation, you first call `useCreateProjectMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateProjectMutation` 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 [createProjectMutation, { data, loading, error }] = useCreateProjectMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateProjectMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateProjectMutation, Types.CreateProjectMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateProjectMutation, any, Apollo.ApolloCache>;
export type CreateProjectMutationHookResult = ReturnType<typeof useCreateProjectMutation>;
export type CreateProjectMutationResult = Apollo.MutationResult<Types.CreateProjectMutation>;
export type CreateProjectMutationOptions = Apollo.BaseMutationOptions<Types.CreateProjectMutation, Types.CreateProjectMutationVariables>;
export declare const UpdateProjectDocument: Apollo.DocumentNode;
export type UpdateProjectMutationFn = Apollo.MutationFunction<Types.UpdateProjectMutation, Types.UpdateProjectMutationVariables>;
/**
 * __useUpdateProjectMutation__
 *
 * To run a mutation, you first call `useUpdateProjectMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateProjectMutation` 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 [updateProjectMutation, { data, loading, error }] = useUpdateProjectMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateProjectMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateProjectMutation, Types.UpdateProjectMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateProjectMutation, any, Apollo.ApolloCache>;
export type UpdateProjectMutationHookResult = ReturnType<typeof useUpdateProjectMutation>;
export type UpdateProjectMutationResult = Apollo.MutationResult<Types.UpdateProjectMutation>;
export type UpdateProjectMutationOptions = Apollo.BaseMutationOptions<Types.UpdateProjectMutation, Types.UpdateProjectMutationVariables>;
export declare const DeleteProjectDocument: Apollo.DocumentNode;
export type DeleteProjectMutationFn = Apollo.MutationFunction<Types.DeleteProjectMutation, Types.DeleteProjectMutationVariables>;
/**
 * __useDeleteProjectMutation__
 *
 * To run a mutation, you first call `useDeleteProjectMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteProjectMutation` 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 [deleteProjectMutation, { data, loading, error }] = useDeleteProjectMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteProjectMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteProjectMutation, Types.DeleteProjectMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteProjectMutation, any, Apollo.ApolloCache>;
export type DeleteProjectMutationHookResult = ReturnType<typeof useDeleteProjectMutation>;
export type DeleteProjectMutationResult = Apollo.MutationResult<Types.DeleteProjectMutation>;
export type DeleteProjectMutationOptions = Apollo.BaseMutationOptions<Types.DeleteProjectMutation, Types.DeleteProjectMutationVariables>;
export declare const CreateQualityGateDocument: Apollo.DocumentNode;
export type CreateQualityGateMutationFn = Apollo.MutationFunction<Types.CreateQualityGateMutation, Types.CreateQualityGateMutationVariables>;
/**
 * __useCreateQualityGateMutation__
 *
 * To run a mutation, you first call `useCreateQualityGateMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateQualityGateMutation` 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 [createQualityGateMutation, { data, loading, error }] = useCreateQualityGateMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateQualityGateMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateQualityGateMutation, Types.CreateQualityGateMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateQualityGateMutation, any, Apollo.ApolloCache>;
export type CreateQualityGateMutationHookResult = ReturnType<typeof useCreateQualityGateMutation>;
export type CreateQualityGateMutationResult = Apollo.MutationResult<Types.CreateQualityGateMutation>;
export type CreateQualityGateMutationOptions = Apollo.BaseMutationOptions<Types.CreateQualityGateMutation, Types.CreateQualityGateMutationVariables>;
export declare const UpdateQualityGateDocument: Apollo.DocumentNode;
export type UpdateQualityGateMutationFn = Apollo.MutationFunction<Types.UpdateQualityGateMutation, Types.UpdateQualityGateMutationVariables>;
/**
 * __useUpdateQualityGateMutation__
 *
 * To run a mutation, you first call `useUpdateQualityGateMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateQualityGateMutation` 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 [updateQualityGateMutation, { data, loading, error }] = useUpdateQualityGateMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateQualityGateMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateQualityGateMutation, Types.UpdateQualityGateMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateQualityGateMutation, any, Apollo.ApolloCache>;
export type UpdateQualityGateMutationHookResult = ReturnType<typeof useUpdateQualityGateMutation>;
export type UpdateQualityGateMutationResult = Apollo.MutationResult<Types.UpdateQualityGateMutation>;
export type UpdateQualityGateMutationOptions = Apollo.BaseMutationOptions<Types.UpdateQualityGateMutation, Types.UpdateQualityGateMutationVariables>;
export declare const DeleteQualityGateDocument: Apollo.DocumentNode;
export type DeleteQualityGateMutationFn = Apollo.MutationFunction<Types.DeleteQualityGateMutation, Types.DeleteQualityGateMutationVariables>;
/**
 * __useDeleteQualityGateMutation__
 *
 * To run a mutation, you first call `useDeleteQualityGateMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteQualityGateMutation` 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 [deleteQualityGateMutation, { data, loading, error }] = useDeleteQualityGateMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteQualityGateMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteQualityGateMutation, Types.DeleteQualityGateMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteQualityGateMutation, any, Apollo.ApolloCache>;
export type DeleteQualityGateMutationHookResult = ReturnType<typeof useDeleteQualityGateMutation>;
export type DeleteQualityGateMutationResult = Apollo.MutationResult<Types.DeleteQualityGateMutation>;
export type DeleteQualityGateMutationOptions = Apollo.BaseMutationOptions<Types.DeleteQualityGateMutation, Types.DeleteQualityGateMutationVariables>;
export declare const ReviewQualityGateDocument: Apollo.DocumentNode;
export type ReviewQualityGateMutationFn = Apollo.MutationFunction<Types.ReviewQualityGateMutation, Types.ReviewQualityGateMutationVariables>;
/**
 * __useReviewQualityGateMutation__
 *
 * To run a mutation, you first call `useReviewQualityGateMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useReviewQualityGateMutation` 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 [reviewQualityGateMutation, { data, loading, error }] = useReviewQualityGateMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useReviewQualityGateMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ReviewQualityGateMutation, Types.ReviewQualityGateMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ReviewQualityGateMutation, any, Apollo.ApolloCache>;
export type ReviewQualityGateMutationHookResult = ReturnType<typeof useReviewQualityGateMutation>;
export type ReviewQualityGateMutationResult = Apollo.MutationResult<Types.ReviewQualityGateMutation>;
export type ReviewQualityGateMutationOptions = Apollo.BaseMutationOptions<Types.ReviewQualityGateMutation, Types.ReviewQualityGateMutationVariables>;
export declare const CreateRiskDocument: Apollo.DocumentNode;
export type CreateRiskMutationFn = Apollo.MutationFunction<Types.CreateRiskMutation, Types.CreateRiskMutationVariables>;
/**
 * __useCreateRiskMutation__
 *
 * To run a mutation, you first call `useCreateRiskMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateRiskMutation` 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 [createRiskMutation, { data, loading, error }] = useCreateRiskMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateRiskMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateRiskMutation, Types.CreateRiskMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateRiskMutation, any, Apollo.ApolloCache>;
export type CreateRiskMutationHookResult = ReturnType<typeof useCreateRiskMutation>;
export type CreateRiskMutationResult = Apollo.MutationResult<Types.CreateRiskMutation>;
export type CreateRiskMutationOptions = Apollo.BaseMutationOptions<Types.CreateRiskMutation, Types.CreateRiskMutationVariables>;
export declare const UpdateRiskDocument: Apollo.DocumentNode;
export type UpdateRiskMutationFn = Apollo.MutationFunction<Types.UpdateRiskMutation, Types.UpdateRiskMutationVariables>;
/**
 * __useUpdateRiskMutation__
 *
 * To run a mutation, you first call `useUpdateRiskMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateRiskMutation` 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 [updateRiskMutation, { data, loading, error }] = useUpdateRiskMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateRiskMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateRiskMutation, Types.UpdateRiskMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateRiskMutation, any, Apollo.ApolloCache>;
export type UpdateRiskMutationHookResult = ReturnType<typeof useUpdateRiskMutation>;
export type UpdateRiskMutationResult = Apollo.MutationResult<Types.UpdateRiskMutation>;
export type UpdateRiskMutationOptions = Apollo.BaseMutationOptions<Types.UpdateRiskMutation, Types.UpdateRiskMutationVariables>;
export declare const DeleteRiskDocument: Apollo.DocumentNode;
export type DeleteRiskMutationFn = Apollo.MutationFunction<Types.DeleteRiskMutation, Types.DeleteRiskMutationVariables>;
/**
 * __useDeleteRiskMutation__
 *
 * To run a mutation, you first call `useDeleteRiskMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteRiskMutation` 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 [deleteRiskMutation, { data, loading, error }] = useDeleteRiskMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteRiskMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteRiskMutation, Types.DeleteRiskMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteRiskMutation, any, Apollo.ApolloCache>;
export type DeleteRiskMutationHookResult = ReturnType<typeof useDeleteRiskMutation>;
export type DeleteRiskMutationResult = Apollo.MutationResult<Types.DeleteRiskMutation>;
export type DeleteRiskMutationOptions = Apollo.BaseMutationOptions<Types.DeleteRiskMutation, Types.DeleteRiskMutationVariables>;
export declare const CreateSprintDocument: Apollo.DocumentNode;
export type CreateSprintMutationFn = Apollo.MutationFunction<Types.CreateSprintMutation, Types.CreateSprintMutationVariables>;
/**
 * __useCreateSprintMutation__
 *
 * To run a mutation, you first call `useCreateSprintMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateSprintMutation` 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 [createSprintMutation, { data, loading, error }] = useCreateSprintMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateSprintMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateSprintMutation, Types.CreateSprintMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateSprintMutation, any, Apollo.ApolloCache>;
export type CreateSprintMutationHookResult = ReturnType<typeof useCreateSprintMutation>;
export type CreateSprintMutationResult = Apollo.MutationResult<Types.CreateSprintMutation>;
export type CreateSprintMutationOptions = Apollo.BaseMutationOptions<Types.CreateSprintMutation, Types.CreateSprintMutationVariables>;
export declare const UpdateSprintDocument: Apollo.DocumentNode;
export type UpdateSprintMutationFn = Apollo.MutationFunction<Types.UpdateSprintMutation, Types.UpdateSprintMutationVariables>;
/**
 * __useUpdateSprintMutation__
 *
 * To run a mutation, you first call `useUpdateSprintMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateSprintMutation` 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 [updateSprintMutation, { data, loading, error }] = useUpdateSprintMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateSprintMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateSprintMutation, Types.UpdateSprintMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateSprintMutation, any, Apollo.ApolloCache>;
export type UpdateSprintMutationHookResult = ReturnType<typeof useUpdateSprintMutation>;
export type UpdateSprintMutationResult = Apollo.MutationResult<Types.UpdateSprintMutation>;
export type UpdateSprintMutationOptions = Apollo.BaseMutationOptions<Types.UpdateSprintMutation, Types.UpdateSprintMutationVariables>;
export declare const DeleteSprintDocument: Apollo.DocumentNode;
export type DeleteSprintMutationFn = Apollo.MutationFunction<Types.DeleteSprintMutation, Types.DeleteSprintMutationVariables>;
/**
 * __useDeleteSprintMutation__
 *
 * To run a mutation, you first call `useDeleteSprintMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteSprintMutation` 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 [deleteSprintMutation, { data, loading, error }] = useDeleteSprintMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteSprintMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteSprintMutation, Types.DeleteSprintMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteSprintMutation, any, Apollo.ApolloCache>;
export type DeleteSprintMutationHookResult = ReturnType<typeof useDeleteSprintMutation>;
export type DeleteSprintMutationResult = Apollo.MutationResult<Types.DeleteSprintMutation>;
export type DeleteSprintMutationOptions = Apollo.BaseMutationOptions<Types.DeleteSprintMutation, Types.DeleteSprintMutationVariables>;
export declare const StartSprintDocument: Apollo.DocumentNode;
export type StartSprintMutationFn = Apollo.MutationFunction<Types.StartSprintMutation, Types.StartSprintMutationVariables>;
/**
 * __useStartSprintMutation__
 *
 * To run a mutation, you first call `useStartSprintMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useStartSprintMutation` 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 [startSprintMutation, { data, loading, error }] = useStartSprintMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useStartSprintMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.StartSprintMutation, Types.StartSprintMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.StartSprintMutation, any, Apollo.ApolloCache>;
export type StartSprintMutationHookResult = ReturnType<typeof useStartSprintMutation>;
export type StartSprintMutationResult = Apollo.MutationResult<Types.StartSprintMutation>;
export type StartSprintMutationOptions = Apollo.BaseMutationOptions<Types.StartSprintMutation, Types.StartSprintMutationVariables>;
export declare const CompleteSprintDocument: Apollo.DocumentNode;
export type CompleteSprintMutationFn = Apollo.MutationFunction<Types.CompleteSprintMutation, Types.CompleteSprintMutationVariables>;
/**
 * __useCompleteSprintMutation__
 *
 * To run a mutation, you first call `useCompleteSprintMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCompleteSprintMutation` 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 [completeSprintMutation, { data, loading, error }] = useCompleteSprintMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useCompleteSprintMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CompleteSprintMutation, Types.CompleteSprintMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CompleteSprintMutation, any, Apollo.ApolloCache>;
export type CompleteSprintMutationHookResult = ReturnType<typeof useCompleteSprintMutation>;
export type CompleteSprintMutationResult = Apollo.MutationResult<Types.CompleteSprintMutation>;
export type CompleteSprintMutationOptions = Apollo.BaseMutationOptions<Types.CompleteSprintMutation, Types.CompleteSprintMutationVariables>;
export declare const CancelSprintDocument: Apollo.DocumentNode;
export type CancelSprintMutationFn = Apollo.MutationFunction<Types.CancelSprintMutation, Types.CancelSprintMutationVariables>;
/**
 * __useCancelSprintMutation__
 *
 * To run a mutation, you first call `useCancelSprintMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCancelSprintMutation` 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 [cancelSprintMutation, { data, loading, error }] = useCancelSprintMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useCancelSprintMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CancelSprintMutation, Types.CancelSprintMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CancelSprintMutation, any, Apollo.ApolloCache>;
export type CancelSprintMutationHookResult = ReturnType<typeof useCancelSprintMutation>;
export type CancelSprintMutationResult = Apollo.MutationResult<Types.CancelSprintMutation>;
export type CancelSprintMutationOptions = Apollo.BaseMutationOptions<Types.CancelSprintMutation, Types.CancelSprintMutationVariables>;
export declare const AddWorkItemsToSprintDocument: Apollo.DocumentNode;
export type AddWorkItemsToSprintMutationFn = Apollo.MutationFunction<Types.AddWorkItemsToSprintMutation, Types.AddWorkItemsToSprintMutationVariables>;
/**
 * __useAddWorkItemsToSprintMutation__
 *
 * To run a mutation, you first call `useAddWorkItemsToSprintMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useAddWorkItemsToSprintMutation` 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 [addWorkItemsToSprintMutation, { data, loading, error }] = useAddWorkItemsToSprintMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useAddWorkItemsToSprintMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AddWorkItemsToSprintMutation, Types.AddWorkItemsToSprintMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AddWorkItemsToSprintMutation, any, Apollo.ApolloCache>;
export type AddWorkItemsToSprintMutationHookResult = ReturnType<typeof useAddWorkItemsToSprintMutation>;
export type AddWorkItemsToSprintMutationResult = Apollo.MutationResult<Types.AddWorkItemsToSprintMutation>;
export type AddWorkItemsToSprintMutationOptions = Apollo.BaseMutationOptions<Types.AddWorkItemsToSprintMutation, Types.AddWorkItemsToSprintMutationVariables>;
export declare const RemoveWorkItemsFromSprintDocument: Apollo.DocumentNode;
export type RemoveWorkItemsFromSprintMutationFn = Apollo.MutationFunction<Types.RemoveWorkItemsFromSprintMutation, Types.RemoveWorkItemsFromSprintMutationVariables>;
/**
 * __useRemoveWorkItemsFromSprintMutation__
 *
 * To run a mutation, you first call `useRemoveWorkItemsFromSprintMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRemoveWorkItemsFromSprintMutation` 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 [removeWorkItemsFromSprintMutation, { data, loading, error }] = useRemoveWorkItemsFromSprintMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useRemoveWorkItemsFromSprintMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RemoveWorkItemsFromSprintMutation, Types.RemoveWorkItemsFromSprintMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RemoveWorkItemsFromSprintMutation, any, Apollo.ApolloCache>;
export type RemoveWorkItemsFromSprintMutationHookResult = ReturnType<typeof useRemoveWorkItemsFromSprintMutation>;
export type RemoveWorkItemsFromSprintMutationResult = Apollo.MutationResult<Types.RemoveWorkItemsFromSprintMutation>;
export type RemoveWorkItemsFromSprintMutationOptions = Apollo.BaseMutationOptions<Types.RemoveWorkItemsFromSprintMutation, Types.RemoveWorkItemsFromSprintMutationVariables>;
export declare const CreateExternalSyncDocument: Apollo.DocumentNode;
export type CreateExternalSyncMutationFn = Apollo.MutationFunction<Types.CreateExternalSyncMutation, Types.CreateExternalSyncMutationVariables>;
/**
 * __useCreateExternalSyncMutation__
 *
 * To run a mutation, you first call `useCreateExternalSyncMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateExternalSyncMutation` 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 [createExternalSyncMutation, { data, loading, error }] = useCreateExternalSyncMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateExternalSyncMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateExternalSyncMutation, Types.CreateExternalSyncMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateExternalSyncMutation, any, Apollo.ApolloCache>;
export type CreateExternalSyncMutationHookResult = ReturnType<typeof useCreateExternalSyncMutation>;
export type CreateExternalSyncMutationResult = Apollo.MutationResult<Types.CreateExternalSyncMutation>;
export type CreateExternalSyncMutationOptions = Apollo.BaseMutationOptions<Types.CreateExternalSyncMutation, Types.CreateExternalSyncMutationVariables>;
export declare const UpdateExternalSyncDocument: Apollo.DocumentNode;
export type UpdateExternalSyncMutationFn = Apollo.MutationFunction<Types.UpdateExternalSyncMutation, Types.UpdateExternalSyncMutationVariables>;
/**
 * __useUpdateExternalSyncMutation__
 *
 * To run a mutation, you first call `useUpdateExternalSyncMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateExternalSyncMutation` 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 [updateExternalSyncMutation, { data, loading, error }] = useUpdateExternalSyncMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateExternalSyncMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateExternalSyncMutation, Types.UpdateExternalSyncMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateExternalSyncMutation, any, Apollo.ApolloCache>;
export type UpdateExternalSyncMutationHookResult = ReturnType<typeof useUpdateExternalSyncMutation>;
export type UpdateExternalSyncMutationResult = Apollo.MutationResult<Types.UpdateExternalSyncMutation>;
export type UpdateExternalSyncMutationOptions = Apollo.BaseMutationOptions<Types.UpdateExternalSyncMutation, Types.UpdateExternalSyncMutationVariables>;
export declare const DeleteExternalSyncDocument: Apollo.DocumentNode;
export type DeleteExternalSyncMutationFn = Apollo.MutationFunction<Types.DeleteExternalSyncMutation, Types.DeleteExternalSyncMutationVariables>;
/**
 * __useDeleteExternalSyncMutation__
 *
 * To run a mutation, you first call `useDeleteExternalSyncMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteExternalSyncMutation` 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 [deleteExternalSyncMutation, { data, loading, error }] = useDeleteExternalSyncMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteExternalSyncMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteExternalSyncMutation, Types.DeleteExternalSyncMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteExternalSyncMutation, any, Apollo.ApolloCache>;
export type DeleteExternalSyncMutationHookResult = ReturnType<typeof useDeleteExternalSyncMutation>;
export type DeleteExternalSyncMutationResult = Apollo.MutationResult<Types.DeleteExternalSyncMutation>;
export type DeleteExternalSyncMutationOptions = Apollo.BaseMutationOptions<Types.DeleteExternalSyncMutation, Types.DeleteExternalSyncMutationVariables>;
export declare const PauseExternalSyncDocument: Apollo.DocumentNode;
export type PauseExternalSyncMutationFn = Apollo.MutationFunction<Types.PauseExternalSyncMutation, Types.PauseExternalSyncMutationVariables>;
/**
 * __usePauseExternalSyncMutation__
 *
 * To run a mutation, you first call `usePauseExternalSyncMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `usePauseExternalSyncMutation` 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 [pauseExternalSyncMutation, { data, loading, error }] = usePauseExternalSyncMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function usePauseExternalSyncMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.PauseExternalSyncMutation, Types.PauseExternalSyncMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.PauseExternalSyncMutation, any, Apollo.ApolloCache>;
export type PauseExternalSyncMutationHookResult = ReturnType<typeof usePauseExternalSyncMutation>;
export type PauseExternalSyncMutationResult = Apollo.MutationResult<Types.PauseExternalSyncMutation>;
export type PauseExternalSyncMutationOptions = Apollo.BaseMutationOptions<Types.PauseExternalSyncMutation, Types.PauseExternalSyncMutationVariables>;
export declare const ResumeExternalSyncDocument: Apollo.DocumentNode;
export type ResumeExternalSyncMutationFn = Apollo.MutationFunction<Types.ResumeExternalSyncMutation, Types.ResumeExternalSyncMutationVariables>;
/**
 * __useResumeExternalSyncMutation__
 *
 * To run a mutation, you first call `useResumeExternalSyncMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useResumeExternalSyncMutation` 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 [resumeExternalSyncMutation, { data, loading, error }] = useResumeExternalSyncMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useResumeExternalSyncMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ResumeExternalSyncMutation, Types.ResumeExternalSyncMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ResumeExternalSyncMutation, any, Apollo.ApolloCache>;
export type ResumeExternalSyncMutationHookResult = ReturnType<typeof useResumeExternalSyncMutation>;
export type ResumeExternalSyncMutationResult = Apollo.MutationResult<Types.ResumeExternalSyncMutation>;
export type ResumeExternalSyncMutationOptions = Apollo.BaseMutationOptions<Types.ResumeExternalSyncMutation, Types.ResumeExternalSyncMutationVariables>;
export declare const StartSyncDocument: Apollo.DocumentNode;
export type StartSyncMutationFn = Apollo.MutationFunction<Types.StartSyncMutation, Types.StartSyncMutationVariables>;
/**
 * __useStartSyncMutation__
 *
 * To run a mutation, you first call `useStartSyncMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useStartSyncMutation` 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 [startSyncMutation, { data, loading, error }] = useStartSyncMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useStartSyncMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.StartSyncMutation, Types.StartSyncMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.StartSyncMutation, any, Apollo.ApolloCache>;
export type StartSyncMutationHookResult = ReturnType<typeof useStartSyncMutation>;
export type StartSyncMutationResult = Apollo.MutationResult<Types.StartSyncMutation>;
export type StartSyncMutationOptions = Apollo.BaseMutationOptions<Types.StartSyncMutation, Types.StartSyncMutationVariables>;
export declare const ImportFromExternalDocument: Apollo.DocumentNode;
export type ImportFromExternalMutationFn = Apollo.MutationFunction<Types.ImportFromExternalMutation, Types.ImportFromExternalMutationVariables>;
/**
 * __useImportFromExternalMutation__
 *
 * To run a mutation, you first call `useImportFromExternalMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useImportFromExternalMutation` 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 [importFromExternalMutation, { data, loading, error }] = useImportFromExternalMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useImportFromExternalMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ImportFromExternalMutation, Types.ImportFromExternalMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ImportFromExternalMutation, any, Apollo.ApolloCache>;
export type ImportFromExternalMutationHookResult = ReturnType<typeof useImportFromExternalMutation>;
export type ImportFromExternalMutationResult = Apollo.MutationResult<Types.ImportFromExternalMutation>;
export type ImportFromExternalMutationOptions = Apollo.BaseMutationOptions<Types.ImportFromExternalMutation, Types.ImportFromExternalMutationVariables>;
export declare const ExportToExternalDocument: Apollo.DocumentNode;
export type ExportToExternalMutationFn = Apollo.MutationFunction<Types.ExportToExternalMutation, Types.ExportToExternalMutationVariables>;
/**
 * __useExportToExternalMutation__
 *
 * To run a mutation, you first call `useExportToExternalMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useExportToExternalMutation` 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 [exportToExternalMutation, { data, loading, error }] = useExportToExternalMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useExportToExternalMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ExportToExternalMutation, Types.ExportToExternalMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ExportToExternalMutation, any, Apollo.ApolloCache>;
export type ExportToExternalMutationHookResult = ReturnType<typeof useExportToExternalMutation>;
export type ExportToExternalMutationResult = Apollo.MutationResult<Types.ExportToExternalMutation>;
export type ExportToExternalMutationOptions = Apollo.BaseMutationOptions<Types.ExportToExternalMutation, Types.ExportToExternalMutationVariables>;
export declare const CreateProjectTemplateDocument: Apollo.DocumentNode;
export type CreateProjectTemplateMutationFn = Apollo.MutationFunction<Types.CreateProjectTemplateMutation, Types.CreateProjectTemplateMutationVariables>;
/**
 * __useCreateProjectTemplateMutation__
 *
 * To run a mutation, you first call `useCreateProjectTemplateMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateProjectTemplateMutation` 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 [createProjectTemplateMutation, { data, loading, error }] = useCreateProjectTemplateMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateProjectTemplateMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateProjectTemplateMutation, Types.CreateProjectTemplateMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateProjectTemplateMutation, any, Apollo.ApolloCache>;
export type CreateProjectTemplateMutationHookResult = ReturnType<typeof useCreateProjectTemplateMutation>;
export type CreateProjectTemplateMutationResult = Apollo.MutationResult<Types.CreateProjectTemplateMutation>;
export type CreateProjectTemplateMutationOptions = Apollo.BaseMutationOptions<Types.CreateProjectTemplateMutation, Types.CreateProjectTemplateMutationVariables>;
export declare const UpdateProjectTemplateDocument: Apollo.DocumentNode;
export type UpdateProjectTemplateMutationFn = Apollo.MutationFunction<Types.UpdateProjectTemplateMutation, Types.UpdateProjectTemplateMutationVariables>;
/**
 * __useUpdateProjectTemplateMutation__
 *
 * To run a mutation, you first call `useUpdateProjectTemplateMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateProjectTemplateMutation` 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 [updateProjectTemplateMutation, { data, loading, error }] = useUpdateProjectTemplateMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateProjectTemplateMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateProjectTemplateMutation, Types.UpdateProjectTemplateMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateProjectTemplateMutation, any, Apollo.ApolloCache>;
export type UpdateProjectTemplateMutationHookResult = ReturnType<typeof useUpdateProjectTemplateMutation>;
export type UpdateProjectTemplateMutationResult = Apollo.MutationResult<Types.UpdateProjectTemplateMutation>;
export type UpdateProjectTemplateMutationOptions = Apollo.BaseMutationOptions<Types.UpdateProjectTemplateMutation, Types.UpdateProjectTemplateMutationVariables>;
export declare const DeleteProjectTemplateDocument: Apollo.DocumentNode;
export type DeleteProjectTemplateMutationFn = Apollo.MutationFunction<Types.DeleteProjectTemplateMutation, Types.DeleteProjectTemplateMutationVariables>;
/**
 * __useDeleteProjectTemplateMutation__
 *
 * To run a mutation, you first call `useDeleteProjectTemplateMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteProjectTemplateMutation` 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 [deleteProjectTemplateMutation, { data, loading, error }] = useDeleteProjectTemplateMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteProjectTemplateMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteProjectTemplateMutation, Types.DeleteProjectTemplateMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteProjectTemplateMutation, any, Apollo.ApolloCache>;
export type DeleteProjectTemplateMutationHookResult = ReturnType<typeof useDeleteProjectTemplateMutation>;
export type DeleteProjectTemplateMutationResult = Apollo.MutationResult<Types.DeleteProjectTemplateMutation>;
export type DeleteProjectTemplateMutationOptions = Apollo.BaseMutationOptions<Types.DeleteProjectTemplateMutation, Types.DeleteProjectTemplateMutationVariables>;
export declare const ApplyTemplateDocument: Apollo.DocumentNode;
export type ApplyTemplateMutationFn = Apollo.MutationFunction<Types.ApplyTemplateMutation, Types.ApplyTemplateMutationVariables>;
/**
 * __useApplyTemplateMutation__
 *
 * To run a mutation, you first call `useApplyTemplateMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useApplyTemplateMutation` 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 [applyTemplateMutation, { data, loading, error }] = useApplyTemplateMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useApplyTemplateMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ApplyTemplateMutation, Types.ApplyTemplateMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ApplyTemplateMutation, any, Apollo.ApolloCache>;
export type ApplyTemplateMutationHookResult = ReturnType<typeof useApplyTemplateMutation>;
export type ApplyTemplateMutationResult = Apollo.MutationResult<Types.ApplyTemplateMutation>;
export type ApplyTemplateMutationOptions = Apollo.BaseMutationOptions<Types.ApplyTemplateMutation, Types.ApplyTemplateMutationVariables>;
export declare const CreateTemplateFromProjectDocument: Apollo.DocumentNode;
export type CreateTemplateFromProjectMutationFn = Apollo.MutationFunction<Types.CreateTemplateFromProjectMutation, Types.CreateTemplateFromProjectMutationVariables>;
/**
 * __useCreateTemplateFromProjectMutation__
 *
 * To run a mutation, you first call `useCreateTemplateFromProjectMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateTemplateFromProjectMutation` 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 [createTemplateFromProjectMutation, { data, loading, error }] = useCreateTemplateFromProjectMutation({
 *   variables: {
 *      projectId: // value for 'projectId'
 *      name: // value for 'name'
 *      description: // value for 'description'
 *   },
 * });
 */
export declare function useCreateTemplateFromProjectMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateTemplateFromProjectMutation, Types.CreateTemplateFromProjectMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateTemplateFromProjectMutation, any, Apollo.ApolloCache>;
export type CreateTemplateFromProjectMutationHookResult = ReturnType<typeof useCreateTemplateFromProjectMutation>;
export type CreateTemplateFromProjectMutationResult = Apollo.MutationResult<Types.CreateTemplateFromProjectMutation>;
export type CreateTemplateFromProjectMutationOptions = Apollo.BaseMutationOptions<Types.CreateTemplateFromProjectMutation, Types.CreateTemplateFromProjectMutationVariables>;
export declare const CreateTimeEntryDocument: Apollo.DocumentNode;
export type CreateTimeEntryMutationFn = Apollo.MutationFunction<Types.CreateTimeEntryMutation, Types.CreateTimeEntryMutationVariables>;
/**
 * __useCreateTimeEntryMutation__
 *
 * To run a mutation, you first call `useCreateTimeEntryMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateTimeEntryMutation` 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 [createTimeEntryMutation, { data, loading, error }] = useCreateTimeEntryMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateTimeEntryMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateTimeEntryMutation, Types.CreateTimeEntryMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateTimeEntryMutation, any, Apollo.ApolloCache>;
export type CreateTimeEntryMutationHookResult = ReturnType<typeof useCreateTimeEntryMutation>;
export type CreateTimeEntryMutationResult = Apollo.MutationResult<Types.CreateTimeEntryMutation>;
export type CreateTimeEntryMutationOptions = Apollo.BaseMutationOptions<Types.CreateTimeEntryMutation, Types.CreateTimeEntryMutationVariables>;
export declare const UpdateTimeEntryDocument: Apollo.DocumentNode;
export type UpdateTimeEntryMutationFn = Apollo.MutationFunction<Types.UpdateTimeEntryMutation, Types.UpdateTimeEntryMutationVariables>;
/**
 * __useUpdateTimeEntryMutation__
 *
 * To run a mutation, you first call `useUpdateTimeEntryMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateTimeEntryMutation` 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 [updateTimeEntryMutation, { data, loading, error }] = useUpdateTimeEntryMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateTimeEntryMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateTimeEntryMutation, Types.UpdateTimeEntryMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateTimeEntryMutation, any, Apollo.ApolloCache>;
export type UpdateTimeEntryMutationHookResult = ReturnType<typeof useUpdateTimeEntryMutation>;
export type UpdateTimeEntryMutationResult = Apollo.MutationResult<Types.UpdateTimeEntryMutation>;
export type UpdateTimeEntryMutationOptions = Apollo.BaseMutationOptions<Types.UpdateTimeEntryMutation, Types.UpdateTimeEntryMutationVariables>;
export declare const DeleteTimeEntryDocument: Apollo.DocumentNode;
export type DeleteTimeEntryMutationFn = Apollo.MutationFunction<Types.DeleteTimeEntryMutation, Types.DeleteTimeEntryMutationVariables>;
/**
 * __useDeleteTimeEntryMutation__
 *
 * To run a mutation, you first call `useDeleteTimeEntryMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteTimeEntryMutation` 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 [deleteTimeEntryMutation, { data, loading, error }] = useDeleteTimeEntryMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteTimeEntryMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteTimeEntryMutation, Types.DeleteTimeEntryMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteTimeEntryMutation, any, Apollo.ApolloCache>;
export type DeleteTimeEntryMutationHookResult = ReturnType<typeof useDeleteTimeEntryMutation>;
export type DeleteTimeEntryMutationResult = Apollo.MutationResult<Types.DeleteTimeEntryMutation>;
export type DeleteTimeEntryMutationOptions = Apollo.BaseMutationOptions<Types.DeleteTimeEntryMutation, Types.DeleteTimeEntryMutationVariables>;
export declare const LogTimeDocument: Apollo.DocumentNode;
export type LogTimeMutationFn = Apollo.MutationFunction<Types.LogTimeMutation, Types.LogTimeMutationVariables>;
/**
 * __useLogTimeMutation__
 *
 * To run a mutation, you first call `useLogTimeMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useLogTimeMutation` 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 [logTimeMutation, { data, loading, error }] = useLogTimeMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useLogTimeMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.LogTimeMutation, Types.LogTimeMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.LogTimeMutation, any, Apollo.ApolloCache>;
export type LogTimeMutationHookResult = ReturnType<typeof useLogTimeMutation>;
export type LogTimeMutationResult = Apollo.MutationResult<Types.LogTimeMutation>;
export type LogTimeMutationOptions = Apollo.BaseMutationOptions<Types.LogTimeMutation, Types.LogTimeMutationVariables>;
export declare const CreateTimesheetDocument: Apollo.DocumentNode;
export type CreateTimesheetMutationFn = Apollo.MutationFunction<Types.CreateTimesheetMutation, Types.CreateTimesheetMutationVariables>;
/**
 * __useCreateTimesheetMutation__
 *
 * To run a mutation, you first call `useCreateTimesheetMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateTimesheetMutation` 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 [createTimesheetMutation, { data, loading, error }] = useCreateTimesheetMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateTimesheetMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateTimesheetMutation, Types.CreateTimesheetMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateTimesheetMutation, any, Apollo.ApolloCache>;
export type CreateTimesheetMutationHookResult = ReturnType<typeof useCreateTimesheetMutation>;
export type CreateTimesheetMutationResult = Apollo.MutationResult<Types.CreateTimesheetMutation>;
export type CreateTimesheetMutationOptions = Apollo.BaseMutationOptions<Types.CreateTimesheetMutation, Types.CreateTimesheetMutationVariables>;
export declare const SubmitTimesheetDocument: Apollo.DocumentNode;
export type SubmitTimesheetMutationFn = Apollo.MutationFunction<Types.SubmitTimesheetMutation, Types.SubmitTimesheetMutationVariables>;
/**
 * __useSubmitTimesheetMutation__
 *
 * To run a mutation, you first call `useSubmitTimesheetMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSubmitTimesheetMutation` 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 [submitTimesheetMutation, { data, loading, error }] = useSubmitTimesheetMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useSubmitTimesheetMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SubmitTimesheetMutation, Types.SubmitTimesheetMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.SubmitTimesheetMutation, any, Apollo.ApolloCache>;
export type SubmitTimesheetMutationHookResult = ReturnType<typeof useSubmitTimesheetMutation>;
export type SubmitTimesheetMutationResult = Apollo.MutationResult<Types.SubmitTimesheetMutation>;
export type SubmitTimesheetMutationOptions = Apollo.BaseMutationOptions<Types.SubmitTimesheetMutation, Types.SubmitTimesheetMutationVariables>;
export declare const ApproveTimesheetDocument: Apollo.DocumentNode;
export type ApproveTimesheetMutationFn = Apollo.MutationFunction<Types.ApproveTimesheetMutation, Types.ApproveTimesheetMutationVariables>;
/**
 * __useApproveTimesheetMutation__
 *
 * To run a mutation, you first call `useApproveTimesheetMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useApproveTimesheetMutation` 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 [approveTimesheetMutation, { data, loading, error }] = useApproveTimesheetMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useApproveTimesheetMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ApproveTimesheetMutation, Types.ApproveTimesheetMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ApproveTimesheetMutation, any, Apollo.ApolloCache>;
export type ApproveTimesheetMutationHookResult = ReturnType<typeof useApproveTimesheetMutation>;
export type ApproveTimesheetMutationResult = Apollo.MutationResult<Types.ApproveTimesheetMutation>;
export type ApproveTimesheetMutationOptions = Apollo.BaseMutationOptions<Types.ApproveTimesheetMutation, Types.ApproveTimesheetMutationVariables>;
export declare const RejectTimesheetDocument: Apollo.DocumentNode;
export type RejectTimesheetMutationFn = Apollo.MutationFunction<Types.RejectTimesheetMutation, Types.RejectTimesheetMutationVariables>;
/**
 * __useRejectTimesheetMutation__
 *
 * To run a mutation, you first call `useRejectTimesheetMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRejectTimesheetMutation` 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 [rejectTimesheetMutation, { data, loading, error }] = useRejectTimesheetMutation({
 *   variables: {
 *      id: // value for 'id'
 *      reason: // value for 'reason'
 *   },
 * });
 */
export declare function useRejectTimesheetMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RejectTimesheetMutation, Types.RejectTimesheetMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RejectTimesheetMutation, any, Apollo.ApolloCache>;
export type RejectTimesheetMutationHookResult = ReturnType<typeof useRejectTimesheetMutation>;
export type RejectTimesheetMutationResult = Apollo.MutationResult<Types.RejectTimesheetMutation>;
export type RejectTimesheetMutationOptions = Apollo.BaseMutationOptions<Types.RejectTimesheetMutation, Types.RejectTimesheetMutationVariables>;
export declare const UpdateUiSessionDocument: Apollo.DocumentNode;
export type UpdateUiSessionMutationFn = Apollo.MutationFunction<Types.UpdateUiSessionMutation, Types.UpdateUiSessionMutationVariables>;
/**
 * __useUpdateUiSessionMutation__
 *
 * To run a mutation, you first call `useUpdateUiSessionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateUiSessionMutation` 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 [updateUiSessionMutation, { data, loading, error }] = useUpdateUiSessionMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateUiSessionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateUiSessionMutation, Types.UpdateUiSessionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateUiSessionMutation, any, Apollo.ApolloCache>;
export type UpdateUiSessionMutationHookResult = ReturnType<typeof useUpdateUiSessionMutation>;
export type UpdateUiSessionMutationResult = Apollo.MutationResult<Types.UpdateUiSessionMutation>;
export type UpdateUiSessionMutationOptions = Apollo.BaseMutationOptions<Types.UpdateUiSessionMutation, Types.UpdateUiSessionMutationVariables>;
export declare const CreateWorkItemDocument: Apollo.DocumentNode;
export type CreateWorkItemMutationFn = Apollo.MutationFunction<Types.CreateWorkItemMutation, Types.CreateWorkItemMutationVariables>;
/**
 * __useCreateWorkItemMutation__
 *
 * To run a mutation, you first call `useCreateWorkItemMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateWorkItemMutation` 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 [createWorkItemMutation, { data, loading, error }] = useCreateWorkItemMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateWorkItemMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateWorkItemMutation, Types.CreateWorkItemMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateWorkItemMutation, any, Apollo.ApolloCache>;
export type CreateWorkItemMutationHookResult = ReturnType<typeof useCreateWorkItemMutation>;
export type CreateWorkItemMutationResult = Apollo.MutationResult<Types.CreateWorkItemMutation>;
export type CreateWorkItemMutationOptions = Apollo.BaseMutationOptions<Types.CreateWorkItemMutation, Types.CreateWorkItemMutationVariables>;
export declare const UpdateWorkItemDocument: Apollo.DocumentNode;
export type UpdateWorkItemMutationFn = Apollo.MutationFunction<Types.UpdateWorkItemMutation, Types.UpdateWorkItemMutationVariables>;
/**
 * __useUpdateWorkItemMutation__
 *
 * To run a mutation, you first call `useUpdateWorkItemMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateWorkItemMutation` 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 [updateWorkItemMutation, { data, loading, error }] = useUpdateWorkItemMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateWorkItemMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateWorkItemMutation, Types.UpdateWorkItemMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateWorkItemMutation, any, Apollo.ApolloCache>;
export type UpdateWorkItemMutationHookResult = ReturnType<typeof useUpdateWorkItemMutation>;
export type UpdateWorkItemMutationResult = Apollo.MutationResult<Types.UpdateWorkItemMutation>;
export type UpdateWorkItemMutationOptions = Apollo.BaseMutationOptions<Types.UpdateWorkItemMutation, Types.UpdateWorkItemMutationVariables>;
export declare const DeleteWorkItemDocument: Apollo.DocumentNode;
export type DeleteWorkItemMutationFn = Apollo.MutationFunction<Types.DeleteWorkItemMutation, Types.DeleteWorkItemMutationVariables>;
/**
 * __useDeleteWorkItemMutation__
 *
 * To run a mutation, you first call `useDeleteWorkItemMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteWorkItemMutation` 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 [deleteWorkItemMutation, { data, loading, error }] = useDeleteWorkItemMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteWorkItemMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteWorkItemMutation, Types.DeleteWorkItemMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteWorkItemMutation, any, Apollo.ApolloCache>;
export type DeleteWorkItemMutationHookResult = ReturnType<typeof useDeleteWorkItemMutation>;
export type DeleteWorkItemMutationResult = Apollo.MutationResult<Types.DeleteWorkItemMutation>;
export type DeleteWorkItemMutationOptions = Apollo.BaseMutationOptions<Types.DeleteWorkItemMutation, Types.DeleteWorkItemMutationVariables>;
export declare const MoveWorkItemDocument: Apollo.DocumentNode;
export type MoveWorkItemMutationFn = Apollo.MutationFunction<Types.MoveWorkItemMutation, Types.MoveWorkItemMutationVariables>;
/**
 * __useMoveWorkItemMutation__
 *
 * To run a mutation, you first call `useMoveWorkItemMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useMoveWorkItemMutation` 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 [moveWorkItemMutation, { data, loading, error }] = useMoveWorkItemMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useMoveWorkItemMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.MoveWorkItemMutation, Types.MoveWorkItemMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.MoveWorkItemMutation, any, Apollo.ApolloCache>;
export type MoveWorkItemMutationHookResult = ReturnType<typeof useMoveWorkItemMutation>;
export type MoveWorkItemMutationResult = Apollo.MutationResult<Types.MoveWorkItemMutation>;
export type MoveWorkItemMutationOptions = Apollo.BaseMutationOptions<Types.MoveWorkItemMutation, Types.MoveWorkItemMutationVariables>;
export declare const BulkUpdateWorkItemsDocument: Apollo.DocumentNode;
export type BulkUpdateWorkItemsMutationFn = Apollo.MutationFunction<Types.BulkUpdateWorkItemsMutation, Types.BulkUpdateWorkItemsMutationVariables>;
/**
 * __useBulkUpdateWorkItemsMutation__
 *
 * To run a mutation, you first call `useBulkUpdateWorkItemsMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useBulkUpdateWorkItemsMutation` 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 [bulkUpdateWorkItemsMutation, { data, loading, error }] = useBulkUpdateWorkItemsMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useBulkUpdateWorkItemsMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.BulkUpdateWorkItemsMutation, Types.BulkUpdateWorkItemsMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.BulkUpdateWorkItemsMutation, any, Apollo.ApolloCache>;
export type BulkUpdateWorkItemsMutationHookResult = ReturnType<typeof useBulkUpdateWorkItemsMutation>;
export type BulkUpdateWorkItemsMutationResult = Apollo.MutationResult<Types.BulkUpdateWorkItemsMutation>;
export type BulkUpdateWorkItemsMutationOptions = Apollo.BaseMutationOptions<Types.BulkUpdateWorkItemsMutation, Types.BulkUpdateWorkItemsMutationVariables>;
export declare const AssignWorkItemDocument: Apollo.DocumentNode;
export type AssignWorkItemMutationFn = Apollo.MutationFunction<Types.AssignWorkItemMutation, Types.AssignWorkItemMutationVariables>;
/**
 * __useAssignWorkItemMutation__
 *
 * To run a mutation, you first call `useAssignWorkItemMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useAssignWorkItemMutation` 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 [assignWorkItemMutation, { data, loading, error }] = useAssignWorkItemMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useAssignWorkItemMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AssignWorkItemMutation, Types.AssignWorkItemMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AssignWorkItemMutation, any, Apollo.ApolloCache>;
export type AssignWorkItemMutationHookResult = ReturnType<typeof useAssignWorkItemMutation>;
export type AssignWorkItemMutationResult = Apollo.MutationResult<Types.AssignWorkItemMutation>;
export type AssignWorkItemMutationOptions = Apollo.BaseMutationOptions<Types.AssignWorkItemMutation, Types.AssignWorkItemMutationVariables>;
export declare const CreateDependencyDocument: Apollo.DocumentNode;
export type CreateDependencyMutationFn = Apollo.MutationFunction<Types.CreateDependencyMutation, Types.CreateDependencyMutationVariables>;
/**
 * __useCreateDependencyMutation__
 *
 * To run a mutation, you first call `useCreateDependencyMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCreateDependencyMutation` 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 [createDependencyMutation, { data, loading, error }] = useCreateDependencyMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCreateDependencyMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateDependencyMutation, Types.CreateDependencyMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateDependencyMutation, any, Apollo.ApolloCache>;
export type CreateDependencyMutationHookResult = ReturnType<typeof useCreateDependencyMutation>;
export type CreateDependencyMutationResult = Apollo.MutationResult<Types.CreateDependencyMutation>;
export type CreateDependencyMutationOptions = Apollo.BaseMutationOptions<Types.CreateDependencyMutation, Types.CreateDependencyMutationVariables>;
export declare const UpdateDependencyDocument: Apollo.DocumentNode;
export type UpdateDependencyMutationFn = Apollo.MutationFunction<Types.UpdateDependencyMutation, Types.UpdateDependencyMutationVariables>;
/**
 * __useUpdateDependencyMutation__
 *
 * To run a mutation, you first call `useUpdateDependencyMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateDependencyMutation` 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 [updateDependencyMutation, { data, loading, error }] = useUpdateDependencyMutation({
 *   variables: {
 *      id: // value for 'id'
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateDependencyMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateDependencyMutation, Types.UpdateDependencyMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateDependencyMutation, any, Apollo.ApolloCache>;
export type UpdateDependencyMutationHookResult = ReturnType<typeof useUpdateDependencyMutation>;
export type UpdateDependencyMutationResult = Apollo.MutationResult<Types.UpdateDependencyMutation>;
export type UpdateDependencyMutationOptions = Apollo.BaseMutationOptions<Types.UpdateDependencyMutation, Types.UpdateDependencyMutationVariables>;
export declare const DeleteDependencyDocument: Apollo.DocumentNode;
export type DeleteDependencyMutationFn = Apollo.MutationFunction<Types.DeleteDependencyMutation, Types.DeleteDependencyMutationVariables>;
/**
 * __useDeleteDependencyMutation__
 *
 * To run a mutation, you first call `useDeleteDependencyMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useDeleteDependencyMutation` 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 [deleteDependencyMutation, { data, loading, error }] = useDeleteDependencyMutation({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useDeleteDependencyMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteDependencyMutation, Types.DeleteDependencyMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteDependencyMutation, any, Apollo.ApolloCache>;
export type DeleteDependencyMutationHookResult = ReturnType<typeof useDeleteDependencyMutation>;
export type DeleteDependencyMutationResult = Apollo.MutationResult<Types.DeleteDependencyMutation>;
export type DeleteDependencyMutationOptions = Apollo.BaseMutationOptions<Types.DeleteDependencyMutation, Types.DeleteDependencyMutationVariables>;
export declare const ListAutomationRulesDocument: Apollo.DocumentNode;
/**
 * __useListAutomationRulesQuery__
 *
 * To run a query within a React component, call `useListAutomationRulesQuery` and pass it any options that fit your needs.
 * When your component renders, `useListAutomationRulesQuery` 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 } = useListAutomationRulesQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListAutomationRulesQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListAutomationRulesQuery, Types.ListAutomationRulesQueryVariables> & ({
    variables: Types.ListAutomationRulesQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListAutomationRulesQuery, Types.ListAutomationRulesQueryVariables, "empty" | "complete" | "streaming", Types.ListAutomationRulesQueryVariables>;
export declare function useListAutomationRulesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListAutomationRulesQuery, Types.ListAutomationRulesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListAutomationRulesQuery, Types.ListAutomationRulesQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListAutomationRulesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListAutomationRulesQuery, Types.ListAutomationRulesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListAutomationRulesQuery, Types.ListAutomationRulesQueryVariables>;
export declare function useListAutomationRulesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListAutomationRulesQuery, Types.ListAutomationRulesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListAutomationRulesQuery | undefined, Types.ListAutomationRulesQueryVariables>;
export type ListAutomationRulesQueryHookResult = ReturnType<typeof useListAutomationRulesQuery>;
export type ListAutomationRulesLazyQueryHookResult = ReturnType<typeof useListAutomationRulesLazyQuery>;
export type ListAutomationRulesSuspenseQueryHookResult = ReturnType<typeof useListAutomationRulesSuspenseQuery>;
export type ListAutomationRulesQueryResult = Apollo.QueryResult<Types.ListAutomationRulesQuery, Types.ListAutomationRulesQueryVariables>;
export declare const GetAutomationRuleDocument: Apollo.DocumentNode;
/**
 * __useGetAutomationRuleQuery__
 *
 * To run a query within a React component, call `useGetAutomationRuleQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetAutomationRuleQuery` 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 } = useGetAutomationRuleQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetAutomationRuleQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetAutomationRuleQuery, Types.GetAutomationRuleQueryVariables> & ({
    variables: Types.GetAutomationRuleQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetAutomationRuleQuery, Types.GetAutomationRuleQueryVariables, "empty" | "complete" | "streaming", Types.GetAutomationRuleQueryVariables>;
export declare function useGetAutomationRuleLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetAutomationRuleQuery, Types.GetAutomationRuleQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetAutomationRuleQuery, Types.GetAutomationRuleQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetAutomationRuleSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetAutomationRuleQuery, Types.GetAutomationRuleQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetAutomationRuleQuery, Types.GetAutomationRuleQueryVariables>;
export declare function useGetAutomationRuleSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetAutomationRuleQuery, Types.GetAutomationRuleQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetAutomationRuleQuery | undefined, Types.GetAutomationRuleQueryVariables>;
export type GetAutomationRuleQueryHookResult = ReturnType<typeof useGetAutomationRuleQuery>;
export type GetAutomationRuleLazyQueryHookResult = ReturnType<typeof useGetAutomationRuleLazyQuery>;
export type GetAutomationRuleSuspenseQueryHookResult = ReturnType<typeof useGetAutomationRuleSuspenseQuery>;
export type GetAutomationRuleQueryResult = Apollo.QueryResult<Types.GetAutomationRuleQuery, Types.GetAutomationRuleQueryVariables>;
export declare const ListAutomationExecutionsDocument: Apollo.DocumentNode;
/**
 * __useListAutomationExecutionsQuery__
 *
 * To run a query within a React component, call `useListAutomationExecutionsQuery` and pass it any options that fit your needs.
 * When your component renders, `useListAutomationExecutionsQuery` 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 } = useListAutomationExecutionsQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListAutomationExecutionsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListAutomationExecutionsQuery, Types.ListAutomationExecutionsQueryVariables> & ({
    variables: Types.ListAutomationExecutionsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListAutomationExecutionsQuery, Types.ListAutomationExecutionsQueryVariables, "empty" | "complete" | "streaming", Types.ListAutomationExecutionsQueryVariables>;
export declare function useListAutomationExecutionsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListAutomationExecutionsQuery, Types.ListAutomationExecutionsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListAutomationExecutionsQuery, Types.ListAutomationExecutionsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListAutomationExecutionsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListAutomationExecutionsQuery, Types.ListAutomationExecutionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListAutomationExecutionsQuery, Types.ListAutomationExecutionsQueryVariables>;
export declare function useListAutomationExecutionsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListAutomationExecutionsQuery, Types.ListAutomationExecutionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListAutomationExecutionsQuery | undefined, Types.ListAutomationExecutionsQueryVariables>;
export type ListAutomationExecutionsQueryHookResult = ReturnType<typeof useListAutomationExecutionsQuery>;
export type ListAutomationExecutionsLazyQueryHookResult = ReturnType<typeof useListAutomationExecutionsLazyQuery>;
export type ListAutomationExecutionsSuspenseQueryHookResult = ReturnType<typeof useListAutomationExecutionsSuspenseQuery>;
export type ListAutomationExecutionsQueryResult = Apollo.QueryResult<Types.ListAutomationExecutionsQuery, Types.ListAutomationExecutionsQueryVariables>;
export declare const ListBoardsDocument: Apollo.DocumentNode;
/**
 * __useListBoardsQuery__
 *
 * To run a query within a React component, call `useListBoardsQuery` and pass it any options that fit your needs.
 * When your component renders, `useListBoardsQuery` 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 } = useListBoardsQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListBoardsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListBoardsQuery, Types.ListBoardsQueryVariables> & ({
    variables: Types.ListBoardsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListBoardsQuery, Types.ListBoardsQueryVariables, "empty" | "complete" | "streaming", Types.ListBoardsQueryVariables>;
export declare function useListBoardsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListBoardsQuery, Types.ListBoardsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListBoardsQuery, Types.ListBoardsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListBoardsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListBoardsQuery, Types.ListBoardsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListBoardsQuery, Types.ListBoardsQueryVariables>;
export declare function useListBoardsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListBoardsQuery, Types.ListBoardsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListBoardsQuery | undefined, Types.ListBoardsQueryVariables>;
export type ListBoardsQueryHookResult = ReturnType<typeof useListBoardsQuery>;
export type ListBoardsLazyQueryHookResult = ReturnType<typeof useListBoardsLazyQuery>;
export type ListBoardsSuspenseQueryHookResult = ReturnType<typeof useListBoardsSuspenseQuery>;
export type ListBoardsQueryResult = Apollo.QueryResult<Types.ListBoardsQuery, Types.ListBoardsQueryVariables>;
export declare const GetBoardDocument: Apollo.DocumentNode;
/**
 * __useGetBoardQuery__
 *
 * To run a query within a React component, call `useGetBoardQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetBoardQuery` 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 } = useGetBoardQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetBoardQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetBoardQuery, Types.GetBoardQueryVariables> & ({
    variables: Types.GetBoardQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetBoardQuery, Types.GetBoardQueryVariables, "empty" | "complete" | "streaming", Types.GetBoardQueryVariables>;
export declare function useGetBoardLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetBoardQuery, Types.GetBoardQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetBoardQuery, Types.GetBoardQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetBoardSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetBoardQuery, Types.GetBoardQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetBoardQuery, Types.GetBoardQueryVariables>;
export declare function useGetBoardSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetBoardQuery, Types.GetBoardQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetBoardQuery | undefined, Types.GetBoardQueryVariables>;
export type GetBoardQueryHookResult = ReturnType<typeof useGetBoardQuery>;
export type GetBoardLazyQueryHookResult = ReturnType<typeof useGetBoardLazyQuery>;
export type GetBoardSuspenseQueryHookResult = ReturnType<typeof useGetBoardSuspenseQuery>;
export type GetBoardQueryResult = Apollo.QueryResult<Types.GetBoardQuery, Types.GetBoardQueryVariables>;
export declare const ListBudgetsDocument: Apollo.DocumentNode;
/**
 * __useListBudgetsQuery__
 *
 * To run a query within a React component, call `useListBudgetsQuery` and pass it any options that fit your needs.
 * When your component renders, `useListBudgetsQuery` 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 } = useListBudgetsQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListBudgetsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListBudgetsQuery, Types.ListBudgetsQueryVariables> & ({
    variables: Types.ListBudgetsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListBudgetsQuery, Types.ListBudgetsQueryVariables, "empty" | "complete" | "streaming", Types.ListBudgetsQueryVariables>;
export declare function useListBudgetsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListBudgetsQuery, Types.ListBudgetsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListBudgetsQuery, Types.ListBudgetsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListBudgetsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListBudgetsQuery, Types.ListBudgetsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListBudgetsQuery, Types.ListBudgetsQueryVariables>;
export declare function useListBudgetsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListBudgetsQuery, Types.ListBudgetsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListBudgetsQuery | undefined, Types.ListBudgetsQueryVariables>;
export type ListBudgetsQueryHookResult = ReturnType<typeof useListBudgetsQuery>;
export type ListBudgetsLazyQueryHookResult = ReturnType<typeof useListBudgetsLazyQuery>;
export type ListBudgetsSuspenseQueryHookResult = ReturnType<typeof useListBudgetsSuspenseQuery>;
export type ListBudgetsQueryResult = Apollo.QueryResult<Types.ListBudgetsQuery, Types.ListBudgetsQueryVariables>;
export declare const GetBudgetDocument: Apollo.DocumentNode;
/**
 * __useGetBudgetQuery__
 *
 * To run a query within a React component, call `useGetBudgetQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetBudgetQuery` 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 } = useGetBudgetQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetBudgetQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetBudgetQuery, Types.GetBudgetQueryVariables> & ({
    variables: Types.GetBudgetQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetBudgetQuery, Types.GetBudgetQueryVariables, "empty" | "complete" | "streaming", Types.GetBudgetQueryVariables>;
export declare function useGetBudgetLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetBudgetQuery, Types.GetBudgetQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetBudgetQuery, Types.GetBudgetQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetBudgetSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetBudgetQuery, Types.GetBudgetQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetBudgetQuery, Types.GetBudgetQueryVariables>;
export declare function useGetBudgetSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetBudgetQuery, Types.GetBudgetQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetBudgetQuery | undefined, Types.GetBudgetQueryVariables>;
export type GetBudgetQueryHookResult = ReturnType<typeof useGetBudgetQuery>;
export type GetBudgetLazyQueryHookResult = ReturnType<typeof useGetBudgetLazyQuery>;
export type GetBudgetSuspenseQueryHookResult = ReturnType<typeof useGetBudgetSuspenseQuery>;
export type GetBudgetQueryResult = Apollo.QueryResult<Types.GetBudgetQuery, Types.GetBudgetQueryVariables>;
export declare const ListBudgetExpensesDocument: Apollo.DocumentNode;
/**
 * __useListBudgetExpensesQuery__
 *
 * To run a query within a React component, call `useListBudgetExpensesQuery` and pass it any options that fit your needs.
 * When your component renders, `useListBudgetExpensesQuery` 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 } = useListBudgetExpensesQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListBudgetExpensesQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListBudgetExpensesQuery, Types.ListBudgetExpensesQueryVariables> & ({
    variables: Types.ListBudgetExpensesQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListBudgetExpensesQuery, Types.ListBudgetExpensesQueryVariables, "empty" | "complete" | "streaming", Types.ListBudgetExpensesQueryVariables>;
export declare function useListBudgetExpensesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListBudgetExpensesQuery, Types.ListBudgetExpensesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListBudgetExpensesQuery, Types.ListBudgetExpensesQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListBudgetExpensesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListBudgetExpensesQuery, Types.ListBudgetExpensesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListBudgetExpensesQuery, Types.ListBudgetExpensesQueryVariables>;
export declare function useListBudgetExpensesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListBudgetExpensesQuery, Types.ListBudgetExpensesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListBudgetExpensesQuery | undefined, Types.ListBudgetExpensesQueryVariables>;
export type ListBudgetExpensesQueryHookResult = ReturnType<typeof useListBudgetExpensesQuery>;
export type ListBudgetExpensesLazyQueryHookResult = ReturnType<typeof useListBudgetExpensesLazyQuery>;
export type ListBudgetExpensesSuspenseQueryHookResult = ReturnType<typeof useListBudgetExpensesSuspenseQuery>;
export type ListBudgetExpensesQueryResult = Apollo.QueryResult<Types.ListBudgetExpensesQuery, Types.ListBudgetExpensesQueryVariables>;
export declare const ListCustomFieldDefinitionsDocument: Apollo.DocumentNode;
/**
 * __useListCustomFieldDefinitionsQuery__
 *
 * To run a query within a React component, call `useListCustomFieldDefinitionsQuery` and pass it any options that fit your needs.
 * When your component renders, `useListCustomFieldDefinitionsQuery` 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 } = useListCustomFieldDefinitionsQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListCustomFieldDefinitionsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListCustomFieldDefinitionsQuery, Types.ListCustomFieldDefinitionsQueryVariables> & ({
    variables: Types.ListCustomFieldDefinitionsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListCustomFieldDefinitionsQuery, Types.ListCustomFieldDefinitionsQueryVariables, "empty" | "complete" | "streaming", Types.ListCustomFieldDefinitionsQueryVariables>;
export declare function useListCustomFieldDefinitionsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListCustomFieldDefinitionsQuery, Types.ListCustomFieldDefinitionsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListCustomFieldDefinitionsQuery, Types.ListCustomFieldDefinitionsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListCustomFieldDefinitionsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListCustomFieldDefinitionsQuery, Types.ListCustomFieldDefinitionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListCustomFieldDefinitionsQuery, Types.ListCustomFieldDefinitionsQueryVariables>;
export declare function useListCustomFieldDefinitionsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListCustomFieldDefinitionsQuery, Types.ListCustomFieldDefinitionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListCustomFieldDefinitionsQuery | undefined, Types.ListCustomFieldDefinitionsQueryVariables>;
export type ListCustomFieldDefinitionsQueryHookResult = ReturnType<typeof useListCustomFieldDefinitionsQuery>;
export type ListCustomFieldDefinitionsLazyQueryHookResult = ReturnType<typeof useListCustomFieldDefinitionsLazyQuery>;
export type ListCustomFieldDefinitionsSuspenseQueryHookResult = ReturnType<typeof useListCustomFieldDefinitionsSuspenseQuery>;
export type ListCustomFieldDefinitionsQueryResult = Apollo.QueryResult<Types.ListCustomFieldDefinitionsQuery, Types.ListCustomFieldDefinitionsQueryVariables>;
export declare const ListCustomFieldValuesDocument: Apollo.DocumentNode;
/**
 * __useListCustomFieldValuesQuery__
 *
 * To run a query within a React component, call `useListCustomFieldValuesQuery` and pass it any options that fit your needs.
 * When your component renders, `useListCustomFieldValuesQuery` 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 } = useListCustomFieldValuesQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListCustomFieldValuesQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListCustomFieldValuesQuery, Types.ListCustomFieldValuesQueryVariables> & ({
    variables: Types.ListCustomFieldValuesQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListCustomFieldValuesQuery, Types.ListCustomFieldValuesQueryVariables, "empty" | "complete" | "streaming", Types.ListCustomFieldValuesQueryVariables>;
export declare function useListCustomFieldValuesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListCustomFieldValuesQuery, Types.ListCustomFieldValuesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListCustomFieldValuesQuery, Types.ListCustomFieldValuesQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListCustomFieldValuesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListCustomFieldValuesQuery, Types.ListCustomFieldValuesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListCustomFieldValuesQuery, Types.ListCustomFieldValuesQueryVariables>;
export declare function useListCustomFieldValuesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListCustomFieldValuesQuery, Types.ListCustomFieldValuesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListCustomFieldValuesQuery | undefined, Types.ListCustomFieldValuesQueryVariables>;
export type ListCustomFieldValuesQueryHookResult = ReturnType<typeof useListCustomFieldValuesQuery>;
export type ListCustomFieldValuesLazyQueryHookResult = ReturnType<typeof useListCustomFieldValuesLazyQuery>;
export type ListCustomFieldValuesSuspenseQueryHookResult = ReturnType<typeof useListCustomFieldValuesSuspenseQuery>;
export type ListCustomFieldValuesQueryResult = Apollo.QueryResult<Types.ListCustomFieldValuesQuery, Types.ListCustomFieldValuesQueryVariables>;
export declare const DashboardProjectsDocument: Apollo.DocumentNode;
/**
 * __useDashboardProjectsQuery__
 *
 * To run a query within a React component, call `useDashboardProjectsQuery` and pass it any options that fit your needs.
 * When your component renders, `useDashboardProjectsQuery` 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 } = useDashboardProjectsQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useDashboardProjectsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.DashboardProjectsQuery, Types.DashboardProjectsQueryVariables> & ({
    variables: Types.DashboardProjectsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.DashboardProjectsQuery, Types.DashboardProjectsQueryVariables, "empty" | "complete" | "streaming", Types.DashboardProjectsQueryVariables>;
export declare function useDashboardProjectsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.DashboardProjectsQuery, Types.DashboardProjectsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.DashboardProjectsQuery, Types.DashboardProjectsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useDashboardProjectsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.DashboardProjectsQuery, Types.DashboardProjectsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.DashboardProjectsQuery, Types.DashboardProjectsQueryVariables>;
export declare function useDashboardProjectsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.DashboardProjectsQuery, Types.DashboardProjectsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.DashboardProjectsQuery | undefined, Types.DashboardProjectsQueryVariables>;
export type DashboardProjectsQueryHookResult = ReturnType<typeof useDashboardProjectsQuery>;
export type DashboardProjectsLazyQueryHookResult = ReturnType<typeof useDashboardProjectsLazyQuery>;
export type DashboardProjectsSuspenseQueryHookResult = ReturnType<typeof useDashboardProjectsSuspenseQuery>;
export type DashboardProjectsQueryResult = Apollo.QueryResult<Types.DashboardProjectsQuery, Types.DashboardProjectsQueryVariables>;
export declare const DashboardWorkItemsDocument: Apollo.DocumentNode;
/**
 * __useDashboardWorkItemsQuery__
 *
 * To run a query within a React component, call `useDashboardWorkItemsQuery` and pass it any options that fit your needs.
 * When your component renders, `useDashboardWorkItemsQuery` 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 } = useDashboardWorkItemsQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useDashboardWorkItemsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.DashboardWorkItemsQuery, Types.DashboardWorkItemsQueryVariables> & ({
    variables: Types.DashboardWorkItemsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.DashboardWorkItemsQuery, Types.DashboardWorkItemsQueryVariables, "empty" | "complete" | "streaming", Types.DashboardWorkItemsQueryVariables>;
export declare function useDashboardWorkItemsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.DashboardWorkItemsQuery, Types.DashboardWorkItemsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.DashboardWorkItemsQuery, Types.DashboardWorkItemsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useDashboardWorkItemsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.DashboardWorkItemsQuery, Types.DashboardWorkItemsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.DashboardWorkItemsQuery, Types.DashboardWorkItemsQueryVariables>;
export declare function useDashboardWorkItemsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.DashboardWorkItemsQuery, Types.DashboardWorkItemsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.DashboardWorkItemsQuery | undefined, Types.DashboardWorkItemsQueryVariables>;
export type DashboardWorkItemsQueryHookResult = ReturnType<typeof useDashboardWorkItemsQuery>;
export type DashboardWorkItemsLazyQueryHookResult = ReturnType<typeof useDashboardWorkItemsLazyQuery>;
export type DashboardWorkItemsSuspenseQueryHookResult = ReturnType<typeof useDashboardWorkItemsSuspenseQuery>;
export type DashboardWorkItemsQueryResult = Apollo.QueryResult<Types.DashboardWorkItemsQuery, Types.DashboardWorkItemsQueryVariables>;
export declare const DashboardSprintsDocument: Apollo.DocumentNode;
/**
 * __useDashboardSprintsQuery__
 *
 * To run a query within a React component, call `useDashboardSprintsQuery` and pass it any options that fit your needs.
 * When your component renders, `useDashboardSprintsQuery` 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 } = useDashboardSprintsQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useDashboardSprintsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.DashboardSprintsQuery, Types.DashboardSprintsQueryVariables> & ({
    variables: Types.DashboardSprintsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.DashboardSprintsQuery, Types.DashboardSprintsQueryVariables, "empty" | "complete" | "streaming", Types.DashboardSprintsQueryVariables>;
export declare function useDashboardSprintsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.DashboardSprintsQuery, Types.DashboardSprintsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.DashboardSprintsQuery, Types.DashboardSprintsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useDashboardSprintsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.DashboardSprintsQuery, Types.DashboardSprintsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.DashboardSprintsQuery, Types.DashboardSprintsQueryVariables>;
export declare function useDashboardSprintsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.DashboardSprintsQuery, Types.DashboardSprintsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.DashboardSprintsQuery | undefined, Types.DashboardSprintsQueryVariables>;
export type DashboardSprintsQueryHookResult = ReturnType<typeof useDashboardSprintsQuery>;
export type DashboardSprintsLazyQueryHookResult = ReturnType<typeof useDashboardSprintsLazyQuery>;
export type DashboardSprintsSuspenseQueryHookResult = ReturnType<typeof useDashboardSprintsSuspenseQuery>;
export type DashboardSprintsQueryResult = Apollo.QueryResult<Types.DashboardSprintsQuery, Types.DashboardSprintsQueryVariables>;
export declare const DashboardMilestonesDocument: Apollo.DocumentNode;
/**
 * __useDashboardMilestonesQuery__
 *
 * To run a query within a React component, call `useDashboardMilestonesQuery` and pass it any options that fit your needs.
 * When your component renders, `useDashboardMilestonesQuery` 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 } = useDashboardMilestonesQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useDashboardMilestonesQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.DashboardMilestonesQuery, Types.DashboardMilestonesQueryVariables> & ({
    variables: Types.DashboardMilestonesQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.DashboardMilestonesQuery, Types.DashboardMilestonesQueryVariables, "empty" | "complete" | "streaming", Types.DashboardMilestonesQueryVariables>;
export declare function useDashboardMilestonesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.DashboardMilestonesQuery, Types.DashboardMilestonesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.DashboardMilestonesQuery, Types.DashboardMilestonesQueryVariables, "empty" | "complete" | "streaming">;
export declare function useDashboardMilestonesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.DashboardMilestonesQuery, Types.DashboardMilestonesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.DashboardMilestonesQuery, Types.DashboardMilestonesQueryVariables>;
export declare function useDashboardMilestonesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.DashboardMilestonesQuery, Types.DashboardMilestonesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.DashboardMilestonesQuery | undefined, Types.DashboardMilestonesQueryVariables>;
export type DashboardMilestonesQueryHookResult = ReturnType<typeof useDashboardMilestonesQuery>;
export type DashboardMilestonesLazyQueryHookResult = ReturnType<typeof useDashboardMilestonesLazyQuery>;
export type DashboardMilestonesSuspenseQueryHookResult = ReturnType<typeof useDashboardMilestonesSuspenseQuery>;
export type DashboardMilestonesQueryResult = Apollo.QueryResult<Types.DashboardMilestonesQuery, Types.DashboardMilestonesQueryVariables>;
export declare const DashboardRisksDocument: Apollo.DocumentNode;
/**
 * __useDashboardRisksQuery__
 *
 * To run a query within a React component, call `useDashboardRisksQuery` and pass it any options that fit your needs.
 * When your component renders, `useDashboardRisksQuery` 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 } = useDashboardRisksQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useDashboardRisksQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.DashboardRisksQuery, Types.DashboardRisksQueryVariables> & ({
    variables: Types.DashboardRisksQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.DashboardRisksQuery, Types.DashboardRisksQueryVariables, "empty" | "complete" | "streaming", Types.DashboardRisksQueryVariables>;
export declare function useDashboardRisksLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.DashboardRisksQuery, Types.DashboardRisksQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.DashboardRisksQuery, Types.DashboardRisksQueryVariables, "empty" | "complete" | "streaming">;
export declare function useDashboardRisksSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.DashboardRisksQuery, Types.DashboardRisksQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.DashboardRisksQuery, Types.DashboardRisksQueryVariables>;
export declare function useDashboardRisksSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.DashboardRisksQuery, Types.DashboardRisksQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.DashboardRisksQuery | undefined, Types.DashboardRisksQueryVariables>;
export type DashboardRisksQueryHookResult = ReturnType<typeof useDashboardRisksQuery>;
export type DashboardRisksLazyQueryHookResult = ReturnType<typeof useDashboardRisksLazyQuery>;
export type DashboardRisksSuspenseQueryHookResult = ReturnType<typeof useDashboardRisksSuspenseQuery>;
export type DashboardRisksQueryResult = Apollo.QueryResult<Types.DashboardRisksQuery, Types.DashboardRisksQueryVariables>;
export declare const DashboardPortfolioOverviewDocument: Apollo.DocumentNode;
/**
 * __useDashboardPortfolioOverviewQuery__
 *
 * To run a query within a React component, call `useDashboardPortfolioOverviewQuery` and pass it any options that fit your needs.
 * When your component renders, `useDashboardPortfolioOverviewQuery` 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 } = useDashboardPortfolioOverviewQuery({
 *   variables: {
 *      portfolioId: // value for 'portfolioId'
 *   },
 * });
 */
export declare function useDashboardPortfolioOverviewQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.DashboardPortfolioOverviewQuery, Types.DashboardPortfolioOverviewQueryVariables> & ({
    variables: Types.DashboardPortfolioOverviewQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.DashboardPortfolioOverviewQuery, Types.DashboardPortfolioOverviewQueryVariables, "empty" | "complete" | "streaming", Types.DashboardPortfolioOverviewQueryVariables>;
export declare function useDashboardPortfolioOverviewLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.DashboardPortfolioOverviewQuery, Types.DashboardPortfolioOverviewQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.DashboardPortfolioOverviewQuery, Types.DashboardPortfolioOverviewQueryVariables, "empty" | "complete" | "streaming">;
export declare function useDashboardPortfolioOverviewSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.DashboardPortfolioOverviewQuery, Types.DashboardPortfolioOverviewQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.DashboardPortfolioOverviewQuery, Types.DashboardPortfolioOverviewQueryVariables>;
export declare function useDashboardPortfolioOverviewSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.DashboardPortfolioOverviewQuery, Types.DashboardPortfolioOverviewQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.DashboardPortfolioOverviewQuery | undefined, Types.DashboardPortfolioOverviewQueryVariables>;
export type DashboardPortfolioOverviewQueryHookResult = ReturnType<typeof useDashboardPortfolioOverviewQuery>;
export type DashboardPortfolioOverviewLazyQueryHookResult = ReturnType<typeof useDashboardPortfolioOverviewLazyQuery>;
export type DashboardPortfolioOverviewSuspenseQueryHookResult = ReturnType<typeof useDashboardPortfolioOverviewSuspenseQuery>;
export type DashboardPortfolioOverviewQueryResult = Apollo.QueryResult<Types.DashboardPortfolioOverviewQuery, Types.DashboardPortfolioOverviewQueryVariables>;
export declare const ListMilestonesDocument: Apollo.DocumentNode;
/**
 * __useListMilestonesQuery__
 *
 * To run a query within a React component, call `useListMilestonesQuery` and pass it any options that fit your needs.
 * When your component renders, `useListMilestonesQuery` 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 } = useListMilestonesQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListMilestonesQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListMilestonesQuery, Types.ListMilestonesQueryVariables> & ({
    variables: Types.ListMilestonesQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListMilestonesQuery, Types.ListMilestonesQueryVariables, "empty" | "complete" | "streaming", Types.ListMilestonesQueryVariables>;
export declare function useListMilestonesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListMilestonesQuery, Types.ListMilestonesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListMilestonesQuery, Types.ListMilestonesQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListMilestonesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListMilestonesQuery, Types.ListMilestonesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListMilestonesQuery, Types.ListMilestonesQueryVariables>;
export declare function useListMilestonesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListMilestonesQuery, Types.ListMilestonesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListMilestonesQuery | undefined, Types.ListMilestonesQueryVariables>;
export type ListMilestonesQueryHookResult = ReturnType<typeof useListMilestonesQuery>;
export type ListMilestonesLazyQueryHookResult = ReturnType<typeof useListMilestonesLazyQuery>;
export type ListMilestonesSuspenseQueryHookResult = ReturnType<typeof useListMilestonesSuspenseQuery>;
export type ListMilestonesQueryResult = Apollo.QueryResult<Types.ListMilestonesQuery, Types.ListMilestonesQueryVariables>;
export declare const GetMilestoneDocument: Apollo.DocumentNode;
/**
 * __useGetMilestoneQuery__
 *
 * To run a query within a React component, call `useGetMilestoneQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetMilestoneQuery` 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 } = useGetMilestoneQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetMilestoneQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetMilestoneQuery, Types.GetMilestoneQueryVariables> & ({
    variables: Types.GetMilestoneQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetMilestoneQuery, Types.GetMilestoneQueryVariables, "empty" | "complete" | "streaming", Types.GetMilestoneQueryVariables>;
export declare function useGetMilestoneLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetMilestoneQuery, Types.GetMilestoneQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetMilestoneQuery, Types.GetMilestoneQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetMilestoneSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMilestoneQuery, Types.GetMilestoneQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMilestoneQuery, Types.GetMilestoneQueryVariables>;
export declare function useGetMilestoneSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMilestoneQuery, Types.GetMilestoneQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMilestoneQuery | undefined, Types.GetMilestoneQueryVariables>;
export type GetMilestoneQueryHookResult = ReturnType<typeof useGetMilestoneQuery>;
export type GetMilestoneLazyQueryHookResult = ReturnType<typeof useGetMilestoneLazyQuery>;
export type GetMilestoneSuspenseQueryHookResult = ReturnType<typeof useGetMilestoneSuspenseQuery>;
export type GetMilestoneQueryResult = Apollo.QueryResult<Types.GetMilestoneQuery, Types.GetMilestoneQueryVariables>;
export declare const ListPortfoliosDocument: Apollo.DocumentNode;
/**
 * __useListPortfoliosQuery__
 *
 * To run a query within a React component, call `useListPortfoliosQuery` and pass it any options that fit your needs.
 * When your component renders, `useListPortfoliosQuery` 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 } = useListPortfoliosQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListPortfoliosQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListPortfoliosQuery, Types.ListPortfoliosQueryVariables> & ({
    variables: Types.ListPortfoliosQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListPortfoliosQuery, Types.ListPortfoliosQueryVariables, "empty" | "complete" | "streaming", Types.ListPortfoliosQueryVariables>;
export declare function useListPortfoliosLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListPortfoliosQuery, Types.ListPortfoliosQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListPortfoliosQuery, Types.ListPortfoliosQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListPortfoliosSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListPortfoliosQuery, Types.ListPortfoliosQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListPortfoliosQuery, Types.ListPortfoliosQueryVariables>;
export declare function useListPortfoliosSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListPortfoliosQuery, Types.ListPortfoliosQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListPortfoliosQuery | undefined, Types.ListPortfoliosQueryVariables>;
export type ListPortfoliosQueryHookResult = ReturnType<typeof useListPortfoliosQuery>;
export type ListPortfoliosLazyQueryHookResult = ReturnType<typeof useListPortfoliosLazyQuery>;
export type ListPortfoliosSuspenseQueryHookResult = ReturnType<typeof useListPortfoliosSuspenseQuery>;
export type ListPortfoliosQueryResult = Apollo.QueryResult<Types.ListPortfoliosQuery, Types.ListPortfoliosQueryVariables>;
export declare const GetPortfolioDocument: Apollo.DocumentNode;
/**
 * __useGetPortfolioQuery__
 *
 * To run a query within a React component, call `useGetPortfolioQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetPortfolioQuery` 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 } = useGetPortfolioQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetPortfolioQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetPortfolioQuery, Types.GetPortfolioQueryVariables> & ({
    variables: Types.GetPortfolioQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetPortfolioQuery, Types.GetPortfolioQueryVariables, "empty" | "complete" | "streaming", Types.GetPortfolioQueryVariables>;
export declare function useGetPortfolioLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetPortfolioQuery, Types.GetPortfolioQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetPortfolioQuery, Types.GetPortfolioQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetPortfolioSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetPortfolioQuery, Types.GetPortfolioQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetPortfolioQuery, Types.GetPortfolioQueryVariables>;
export declare function useGetPortfolioSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetPortfolioQuery, Types.GetPortfolioQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetPortfolioQuery | undefined, Types.GetPortfolioQueryVariables>;
export type GetPortfolioQueryHookResult = ReturnType<typeof useGetPortfolioQuery>;
export type GetPortfolioLazyQueryHookResult = ReturnType<typeof useGetPortfolioLazyQuery>;
export type GetPortfolioSuspenseQueryHookResult = ReturnType<typeof useGetPortfolioSuspenseQuery>;
export type GetPortfolioQueryResult = Apollo.QueryResult<Types.GetPortfolioQuery, Types.GetPortfolioQueryVariables>;
export declare const GetPortfolioOverviewDocument: Apollo.DocumentNode;
/**
 * __useGetPortfolioOverviewQuery__
 *
 * To run a query within a React component, call `useGetPortfolioOverviewQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetPortfolioOverviewQuery` 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 } = useGetPortfolioOverviewQuery({
 *   variables: {
 *      portfolioId: // value for 'portfolioId'
 *   },
 * });
 */
export declare function useGetPortfolioOverviewQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetPortfolioOverviewQuery, Types.GetPortfolioOverviewQueryVariables> & ({
    variables: Types.GetPortfolioOverviewQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetPortfolioOverviewQuery, Types.GetPortfolioOverviewQueryVariables, "empty" | "complete" | "streaming", Types.GetPortfolioOverviewQueryVariables>;
export declare function useGetPortfolioOverviewLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetPortfolioOverviewQuery, Types.GetPortfolioOverviewQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetPortfolioOverviewQuery, Types.GetPortfolioOverviewQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetPortfolioOverviewSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetPortfolioOverviewQuery, Types.GetPortfolioOverviewQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetPortfolioOverviewQuery, Types.GetPortfolioOverviewQueryVariables>;
export declare function useGetPortfolioOverviewSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetPortfolioOverviewQuery, Types.GetPortfolioOverviewQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetPortfolioOverviewQuery | undefined, Types.GetPortfolioOverviewQueryVariables>;
export type GetPortfolioOverviewQueryHookResult = ReturnType<typeof useGetPortfolioOverviewQuery>;
export type GetPortfolioOverviewLazyQueryHookResult = ReturnType<typeof useGetPortfolioOverviewLazyQuery>;
export type GetPortfolioOverviewSuspenseQueryHookResult = ReturnType<typeof useGetPortfolioOverviewSuspenseQuery>;
export type GetPortfolioOverviewQueryResult = Apollo.QueryResult<Types.GetPortfolioOverviewQuery, Types.GetPortfolioOverviewQueryVariables>;
export declare const ListRoadmapsDocument: Apollo.DocumentNode;
/**
 * __useListRoadmapsQuery__
 *
 * To run a query within a React component, call `useListRoadmapsQuery` and pass it any options that fit your needs.
 * When your component renders, `useListRoadmapsQuery` 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 } = useListRoadmapsQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListRoadmapsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListRoadmapsQuery, Types.ListRoadmapsQueryVariables> & ({
    variables: Types.ListRoadmapsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListRoadmapsQuery, Types.ListRoadmapsQueryVariables, "empty" | "complete" | "streaming", Types.ListRoadmapsQueryVariables>;
export declare function useListRoadmapsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListRoadmapsQuery, Types.ListRoadmapsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListRoadmapsQuery, Types.ListRoadmapsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListRoadmapsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListRoadmapsQuery, Types.ListRoadmapsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListRoadmapsQuery, Types.ListRoadmapsQueryVariables>;
export declare function useListRoadmapsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListRoadmapsQuery, Types.ListRoadmapsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListRoadmapsQuery | undefined, Types.ListRoadmapsQueryVariables>;
export type ListRoadmapsQueryHookResult = ReturnType<typeof useListRoadmapsQuery>;
export type ListRoadmapsLazyQueryHookResult = ReturnType<typeof useListRoadmapsLazyQuery>;
export type ListRoadmapsSuspenseQueryHookResult = ReturnType<typeof useListRoadmapsSuspenseQuery>;
export type ListRoadmapsQueryResult = Apollo.QueryResult<Types.ListRoadmapsQuery, Types.ListRoadmapsQueryVariables>;
export declare const GetRoadmapDocument: Apollo.DocumentNode;
/**
 * __useGetRoadmapQuery__
 *
 * To run a query within a React component, call `useGetRoadmapQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetRoadmapQuery` 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 } = useGetRoadmapQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetRoadmapQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetRoadmapQuery, Types.GetRoadmapQueryVariables> & ({
    variables: Types.GetRoadmapQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetRoadmapQuery, Types.GetRoadmapQueryVariables, "empty" | "complete" | "streaming", Types.GetRoadmapQueryVariables>;
export declare function useGetRoadmapLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetRoadmapQuery, Types.GetRoadmapQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetRoadmapQuery, Types.GetRoadmapQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetRoadmapSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetRoadmapQuery, Types.GetRoadmapQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetRoadmapQuery, Types.GetRoadmapQueryVariables>;
export declare function useGetRoadmapSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetRoadmapQuery, Types.GetRoadmapQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetRoadmapQuery | undefined, Types.GetRoadmapQueryVariables>;
export type GetRoadmapQueryHookResult = ReturnType<typeof useGetRoadmapQuery>;
export type GetRoadmapLazyQueryHookResult = ReturnType<typeof useGetRoadmapLazyQuery>;
export type GetRoadmapSuspenseQueryHookResult = ReturnType<typeof useGetRoadmapSuspenseQuery>;
export type GetRoadmapQueryResult = Apollo.QueryResult<Types.GetRoadmapQuery, Types.GetRoadmapQueryVariables>;
export declare const ListRoadmapItemsDocument: Apollo.DocumentNode;
/**
 * __useListRoadmapItemsQuery__
 *
 * To run a query within a React component, call `useListRoadmapItemsQuery` and pass it any options that fit your needs.
 * When your component renders, `useListRoadmapItemsQuery` 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 } = useListRoadmapItemsQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListRoadmapItemsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListRoadmapItemsQuery, Types.ListRoadmapItemsQueryVariables> & ({
    variables: Types.ListRoadmapItemsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListRoadmapItemsQuery, Types.ListRoadmapItemsQueryVariables, "empty" | "complete" | "streaming", Types.ListRoadmapItemsQueryVariables>;
export declare function useListRoadmapItemsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListRoadmapItemsQuery, Types.ListRoadmapItemsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListRoadmapItemsQuery, Types.ListRoadmapItemsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListRoadmapItemsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListRoadmapItemsQuery, Types.ListRoadmapItemsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListRoadmapItemsQuery, Types.ListRoadmapItemsQueryVariables>;
export declare function useListRoadmapItemsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListRoadmapItemsQuery, Types.ListRoadmapItemsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListRoadmapItemsQuery | undefined, Types.ListRoadmapItemsQueryVariables>;
export type ListRoadmapItemsQueryHookResult = ReturnType<typeof useListRoadmapItemsQuery>;
export type ListRoadmapItemsLazyQueryHookResult = ReturnType<typeof useListRoadmapItemsLazyQuery>;
export type ListRoadmapItemsSuspenseQueryHookResult = ReturnType<typeof useListRoadmapItemsSuspenseQuery>;
export type ListRoadmapItemsQueryResult = Apollo.QueryResult<Types.ListRoadmapItemsQuery, Types.ListRoadmapItemsQueryVariables>;
export declare const ListReleasesDocument: Apollo.DocumentNode;
/**
 * __useListReleasesQuery__
 *
 * To run a query within a React component, call `useListReleasesQuery` and pass it any options that fit your needs.
 * When your component renders, `useListReleasesQuery` 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 } = useListReleasesQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListReleasesQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListReleasesQuery, Types.ListReleasesQueryVariables> & ({
    variables: Types.ListReleasesQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListReleasesQuery, Types.ListReleasesQueryVariables, "empty" | "complete" | "streaming", Types.ListReleasesQueryVariables>;
export declare function useListReleasesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListReleasesQuery, Types.ListReleasesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListReleasesQuery, Types.ListReleasesQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListReleasesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListReleasesQuery, Types.ListReleasesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListReleasesQuery, Types.ListReleasesQueryVariables>;
export declare function useListReleasesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListReleasesQuery, Types.ListReleasesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListReleasesQuery | undefined, Types.ListReleasesQueryVariables>;
export type ListReleasesQueryHookResult = ReturnType<typeof useListReleasesQuery>;
export type ListReleasesLazyQueryHookResult = ReturnType<typeof useListReleasesLazyQuery>;
export type ListReleasesSuspenseQueryHookResult = ReturnType<typeof useListReleasesSuspenseQuery>;
export type ListReleasesQueryResult = Apollo.QueryResult<Types.ListReleasesQuery, Types.ListReleasesQueryVariables>;
export declare const GetReleaseDocument: Apollo.DocumentNode;
/**
 * __useGetReleaseQuery__
 *
 * To run a query within a React component, call `useGetReleaseQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetReleaseQuery` 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 } = useGetReleaseQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetReleaseQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetReleaseQuery, Types.GetReleaseQueryVariables> & ({
    variables: Types.GetReleaseQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetReleaseQuery, Types.GetReleaseQueryVariables, "empty" | "complete" | "streaming", Types.GetReleaseQueryVariables>;
export declare function useGetReleaseLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetReleaseQuery, Types.GetReleaseQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetReleaseQuery, Types.GetReleaseQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetReleaseSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetReleaseQuery, Types.GetReleaseQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetReleaseQuery, Types.GetReleaseQueryVariables>;
export declare function useGetReleaseSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetReleaseQuery, Types.GetReleaseQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetReleaseQuery | undefined, Types.GetReleaseQueryVariables>;
export type GetReleaseQueryHookResult = ReturnType<typeof useGetReleaseQuery>;
export type GetReleaseLazyQueryHookResult = ReturnType<typeof useGetReleaseLazyQuery>;
export type GetReleaseSuspenseQueryHookResult = ReturnType<typeof useGetReleaseSuspenseQuery>;
export type GetReleaseQueryResult = Apollo.QueryResult<Types.GetReleaseQuery, Types.GetReleaseQueryVariables>;
export declare const ListFeatureRequestsDocument: Apollo.DocumentNode;
/**
 * __useListFeatureRequestsQuery__
 *
 * To run a query within a React component, call `useListFeatureRequestsQuery` and pass it any options that fit your needs.
 * When your component renders, `useListFeatureRequestsQuery` 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 } = useListFeatureRequestsQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListFeatureRequestsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListFeatureRequestsQuery, Types.ListFeatureRequestsQueryVariables> & ({
    variables: Types.ListFeatureRequestsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListFeatureRequestsQuery, Types.ListFeatureRequestsQueryVariables, "empty" | "complete" | "streaming", Types.ListFeatureRequestsQueryVariables>;
export declare function useListFeatureRequestsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListFeatureRequestsQuery, Types.ListFeatureRequestsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListFeatureRequestsQuery, Types.ListFeatureRequestsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListFeatureRequestsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListFeatureRequestsQuery, Types.ListFeatureRequestsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListFeatureRequestsQuery, Types.ListFeatureRequestsQueryVariables>;
export declare function useListFeatureRequestsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListFeatureRequestsQuery, Types.ListFeatureRequestsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListFeatureRequestsQuery | undefined, Types.ListFeatureRequestsQueryVariables>;
export type ListFeatureRequestsQueryHookResult = ReturnType<typeof useListFeatureRequestsQuery>;
export type ListFeatureRequestsLazyQueryHookResult = ReturnType<typeof useListFeatureRequestsLazyQuery>;
export type ListFeatureRequestsSuspenseQueryHookResult = ReturnType<typeof useListFeatureRequestsSuspenseQuery>;
export type ListFeatureRequestsQueryResult = Apollo.QueryResult<Types.ListFeatureRequestsQuery, Types.ListFeatureRequestsQueryVariables>;
export declare const GetFeatureRequestDocument: Apollo.DocumentNode;
/**
 * __useGetFeatureRequestQuery__
 *
 * To run a query within a React component, call `useGetFeatureRequestQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetFeatureRequestQuery` 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 } = useGetFeatureRequestQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetFeatureRequestQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetFeatureRequestQuery, Types.GetFeatureRequestQueryVariables> & ({
    variables: Types.GetFeatureRequestQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetFeatureRequestQuery, Types.GetFeatureRequestQueryVariables, "empty" | "complete" | "streaming", Types.GetFeatureRequestQueryVariables>;
export declare function useGetFeatureRequestLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetFeatureRequestQuery, Types.GetFeatureRequestQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetFeatureRequestQuery, Types.GetFeatureRequestQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetFeatureRequestSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFeatureRequestQuery, Types.GetFeatureRequestQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFeatureRequestQuery, Types.GetFeatureRequestQueryVariables>;
export declare function useGetFeatureRequestSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetFeatureRequestQuery, Types.GetFeatureRequestQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetFeatureRequestQuery | undefined, Types.GetFeatureRequestQueryVariables>;
export type GetFeatureRequestQueryHookResult = ReturnType<typeof useGetFeatureRequestQuery>;
export type GetFeatureRequestLazyQueryHookResult = ReturnType<typeof useGetFeatureRequestLazyQuery>;
export type GetFeatureRequestSuspenseQueryHookResult = ReturnType<typeof useGetFeatureRequestSuspenseQuery>;
export type GetFeatureRequestQueryResult = Apollo.QueryResult<Types.GetFeatureRequestQuery, Types.GetFeatureRequestQueryVariables>;
export declare const ListCompetitorsDocument: Apollo.DocumentNode;
/**
 * __useListCompetitorsQuery__
 *
 * To run a query within a React component, call `useListCompetitorsQuery` and pass it any options that fit your needs.
 * When your component renders, `useListCompetitorsQuery` 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 } = useListCompetitorsQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListCompetitorsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListCompetitorsQuery, Types.ListCompetitorsQueryVariables> & ({
    variables: Types.ListCompetitorsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListCompetitorsQuery, Types.ListCompetitorsQueryVariables, "empty" | "complete" | "streaming", Types.ListCompetitorsQueryVariables>;
export declare function useListCompetitorsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListCompetitorsQuery, Types.ListCompetitorsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListCompetitorsQuery, Types.ListCompetitorsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListCompetitorsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListCompetitorsQuery, Types.ListCompetitorsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListCompetitorsQuery, Types.ListCompetitorsQueryVariables>;
export declare function useListCompetitorsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListCompetitorsQuery, Types.ListCompetitorsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListCompetitorsQuery | undefined, Types.ListCompetitorsQueryVariables>;
export type ListCompetitorsQueryHookResult = ReturnType<typeof useListCompetitorsQuery>;
export type ListCompetitorsLazyQueryHookResult = ReturnType<typeof useListCompetitorsLazyQuery>;
export type ListCompetitorsSuspenseQueryHookResult = ReturnType<typeof useListCompetitorsSuspenseQuery>;
export type ListCompetitorsQueryResult = Apollo.QueryResult<Types.ListCompetitorsQuery, Types.ListCompetitorsQueryVariables>;
export declare const ListProgramsDocument: Apollo.DocumentNode;
/**
 * __useListProgramsQuery__
 *
 * To run a query within a React component, call `useListProgramsQuery` and pass it any options that fit your needs.
 * When your component renders, `useListProgramsQuery` 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 } = useListProgramsQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListProgramsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListProgramsQuery, Types.ListProgramsQueryVariables> & ({
    variables: Types.ListProgramsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListProgramsQuery, Types.ListProgramsQueryVariables, "empty" | "complete" | "streaming", Types.ListProgramsQueryVariables>;
export declare function useListProgramsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListProgramsQuery, Types.ListProgramsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListProgramsQuery, Types.ListProgramsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListProgramsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListProgramsQuery, Types.ListProgramsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListProgramsQuery, Types.ListProgramsQueryVariables>;
export declare function useListProgramsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListProgramsQuery, Types.ListProgramsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListProgramsQuery | undefined, Types.ListProgramsQueryVariables>;
export type ListProgramsQueryHookResult = ReturnType<typeof useListProgramsQuery>;
export type ListProgramsLazyQueryHookResult = ReturnType<typeof useListProgramsLazyQuery>;
export type ListProgramsSuspenseQueryHookResult = ReturnType<typeof useListProgramsSuspenseQuery>;
export type ListProgramsQueryResult = Apollo.QueryResult<Types.ListProgramsQuery, Types.ListProgramsQueryVariables>;
export declare const GetProgramDocument: Apollo.DocumentNode;
/**
 * __useGetProgramQuery__
 *
 * To run a query within a React component, call `useGetProgramQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetProgramQuery` 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 } = useGetProgramQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetProgramQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetProgramQuery, Types.GetProgramQueryVariables> & ({
    variables: Types.GetProgramQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetProgramQuery, Types.GetProgramQueryVariables, "empty" | "complete" | "streaming", Types.GetProgramQueryVariables>;
export declare function useGetProgramLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetProgramQuery, Types.GetProgramQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetProgramQuery, Types.GetProgramQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetProgramSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProgramQuery, Types.GetProgramQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProgramQuery, Types.GetProgramQueryVariables>;
export declare function useGetProgramSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProgramQuery, Types.GetProgramQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProgramQuery | undefined, Types.GetProgramQueryVariables>;
export type GetProgramQueryHookResult = ReturnType<typeof useGetProgramQuery>;
export type GetProgramLazyQueryHookResult = ReturnType<typeof useGetProgramLazyQuery>;
export type GetProgramSuspenseQueryHookResult = ReturnType<typeof useGetProgramSuspenseQuery>;
export type GetProgramQueryResult = Apollo.QueryResult<Types.GetProgramQuery, Types.GetProgramQueryVariables>;
export declare const GetProjectsDocument: Apollo.DocumentNode;
/**
 * __useGetProjectsQuery__
 *
 * To run a query within a React component, call `useGetProjectsQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetProjectsQuery` 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 } = useGetProjectsQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useGetProjectsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetProjectsQuery, Types.GetProjectsQueryVariables> & ({
    variables: Types.GetProjectsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetProjectsQuery, Types.GetProjectsQueryVariables, "empty" | "complete" | "streaming", Types.GetProjectsQueryVariables>;
export declare function useGetProjectsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetProjectsQuery, Types.GetProjectsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetProjectsQuery, Types.GetProjectsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetProjectsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProjectsQuery, Types.GetProjectsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProjectsQuery, Types.GetProjectsQueryVariables>;
export declare function useGetProjectsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProjectsQuery, Types.GetProjectsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProjectsQuery | undefined, Types.GetProjectsQueryVariables>;
export type GetProjectsQueryHookResult = ReturnType<typeof useGetProjectsQuery>;
export type GetProjectsLazyQueryHookResult = ReturnType<typeof useGetProjectsLazyQuery>;
export type GetProjectsSuspenseQueryHookResult = ReturnType<typeof useGetProjectsSuspenseQuery>;
export type GetProjectsQueryResult = Apollo.QueryResult<Types.GetProjectsQuery, Types.GetProjectsQueryVariables>;
export declare const GetProjectDocument: Apollo.DocumentNode;
/**
 * __useGetProjectQuery__
 *
 * To run a query within a React component, call `useGetProjectQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetProjectQuery` 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 } = useGetProjectQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetProjectQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetProjectQuery, Types.GetProjectQueryVariables> & ({
    variables: Types.GetProjectQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetProjectQuery, Types.GetProjectQueryVariables, "empty" | "complete" | "streaming", Types.GetProjectQueryVariables>;
export declare function useGetProjectLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetProjectQuery, Types.GetProjectQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetProjectQuery, Types.GetProjectQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetProjectSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProjectQuery, Types.GetProjectQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProjectQuery, Types.GetProjectQueryVariables>;
export declare function useGetProjectSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProjectQuery, Types.GetProjectQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProjectQuery | undefined, Types.GetProjectQueryVariables>;
export type GetProjectQueryHookResult = ReturnType<typeof useGetProjectQuery>;
export type GetProjectLazyQueryHookResult = ReturnType<typeof useGetProjectLazyQuery>;
export type GetProjectSuspenseQueryHookResult = ReturnType<typeof useGetProjectSuspenseQuery>;
export type GetProjectQueryResult = Apollo.QueryResult<Types.GetProjectQuery, Types.GetProjectQueryVariables>;
export declare const ListRisksDocument: Apollo.DocumentNode;
/**
 * __useListRisksQuery__
 *
 * To run a query within a React component, call `useListRisksQuery` and pass it any options that fit your needs.
 * When your component renders, `useListRisksQuery` 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 } = useListRisksQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListRisksQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListRisksQuery, Types.ListRisksQueryVariables> & ({
    variables: Types.ListRisksQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListRisksQuery, Types.ListRisksQueryVariables, "empty" | "complete" | "streaming", Types.ListRisksQueryVariables>;
export declare function useListRisksLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListRisksQuery, Types.ListRisksQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListRisksQuery, Types.ListRisksQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListRisksSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListRisksQuery, Types.ListRisksQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListRisksQuery, Types.ListRisksQueryVariables>;
export declare function useListRisksSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListRisksQuery, Types.ListRisksQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListRisksQuery | undefined, Types.ListRisksQueryVariables>;
export type ListRisksQueryHookResult = ReturnType<typeof useListRisksQuery>;
export type ListRisksLazyQueryHookResult = ReturnType<typeof useListRisksLazyQuery>;
export type ListRisksSuspenseQueryHookResult = ReturnType<typeof useListRisksSuspenseQuery>;
export type ListRisksQueryResult = Apollo.QueryResult<Types.ListRisksQuery, Types.ListRisksQueryVariables>;
export declare const GetRiskDocument: Apollo.DocumentNode;
/**
 * __useGetRiskQuery__
 *
 * To run a query within a React component, call `useGetRiskQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetRiskQuery` 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 } = useGetRiskQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetRiskQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetRiskQuery, Types.GetRiskQueryVariables> & ({
    variables: Types.GetRiskQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetRiskQuery, Types.GetRiskQueryVariables, "empty" | "complete" | "streaming", Types.GetRiskQueryVariables>;
export declare function useGetRiskLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetRiskQuery, Types.GetRiskQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetRiskQuery, Types.GetRiskQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetRiskSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetRiskQuery, Types.GetRiskQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetRiskQuery, Types.GetRiskQueryVariables>;
export declare function useGetRiskSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetRiskQuery, Types.GetRiskQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetRiskQuery | undefined, Types.GetRiskQueryVariables>;
export type GetRiskQueryHookResult = ReturnType<typeof useGetRiskQuery>;
export type GetRiskLazyQueryHookResult = ReturnType<typeof useGetRiskLazyQuery>;
export type GetRiskSuspenseQueryHookResult = ReturnType<typeof useGetRiskSuspenseQuery>;
export type GetRiskQueryResult = Apollo.QueryResult<Types.GetRiskQuery, Types.GetRiskQueryVariables>;
export declare const GetRiskMatrixDocument: Apollo.DocumentNode;
/**
 * __useGetRiskMatrixQuery__
 *
 * To run a query within a React component, call `useGetRiskMatrixQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetRiskMatrixQuery` 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 } = useGetRiskMatrixQuery({
 *   variables: {
 *      projectId: // value for 'projectId'
 *   },
 * });
 */
export declare function useGetRiskMatrixQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetRiskMatrixQuery, Types.GetRiskMatrixQueryVariables> & ({
    variables: Types.GetRiskMatrixQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetRiskMatrixQuery, Types.GetRiskMatrixQueryVariables, "empty" | "complete" | "streaming", Types.GetRiskMatrixQueryVariables>;
export declare function useGetRiskMatrixLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetRiskMatrixQuery, Types.GetRiskMatrixQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetRiskMatrixQuery, Types.GetRiskMatrixQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetRiskMatrixSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetRiskMatrixQuery, Types.GetRiskMatrixQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetRiskMatrixQuery, Types.GetRiskMatrixQueryVariables>;
export declare function useGetRiskMatrixSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetRiskMatrixQuery, Types.GetRiskMatrixQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetRiskMatrixQuery | undefined, Types.GetRiskMatrixQueryVariables>;
export type GetRiskMatrixQueryHookResult = ReturnType<typeof useGetRiskMatrixQuery>;
export type GetRiskMatrixLazyQueryHookResult = ReturnType<typeof useGetRiskMatrixLazyQuery>;
export type GetRiskMatrixSuspenseQueryHookResult = ReturnType<typeof useGetRiskMatrixSuspenseQuery>;
export type GetRiskMatrixQueryResult = Apollo.QueryResult<Types.GetRiskMatrixQuery, Types.GetRiskMatrixQueryVariables>;
export declare const ListSprintsDocument: Apollo.DocumentNode;
/**
 * __useListSprintsQuery__
 *
 * To run a query within a React component, call `useListSprintsQuery` and pass it any options that fit your needs.
 * When your component renders, `useListSprintsQuery` 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 } = useListSprintsQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListSprintsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListSprintsQuery, Types.ListSprintsQueryVariables> & ({
    variables: Types.ListSprintsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListSprintsQuery, Types.ListSprintsQueryVariables, "empty" | "complete" | "streaming", Types.ListSprintsQueryVariables>;
export declare function useListSprintsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListSprintsQuery, Types.ListSprintsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListSprintsQuery, Types.ListSprintsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListSprintsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListSprintsQuery, Types.ListSprintsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListSprintsQuery, Types.ListSprintsQueryVariables>;
export declare function useListSprintsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListSprintsQuery, Types.ListSprintsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListSprintsQuery | undefined, Types.ListSprintsQueryVariables>;
export type ListSprintsQueryHookResult = ReturnType<typeof useListSprintsQuery>;
export type ListSprintsLazyQueryHookResult = ReturnType<typeof useListSprintsLazyQuery>;
export type ListSprintsSuspenseQueryHookResult = ReturnType<typeof useListSprintsSuspenseQuery>;
export type ListSprintsQueryResult = Apollo.QueryResult<Types.ListSprintsQuery, Types.ListSprintsQueryVariables>;
export declare const GetSprintDocument: Apollo.DocumentNode;
/**
 * __useGetSprintQuery__
 *
 * To run a query within a React component, call `useGetSprintQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetSprintQuery` 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 } = useGetSprintQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetSprintQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetSprintQuery, Types.GetSprintQueryVariables> & ({
    variables: Types.GetSprintQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetSprintQuery, Types.GetSprintQueryVariables, "empty" | "complete" | "streaming", Types.GetSprintQueryVariables>;
export declare function useGetSprintLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetSprintQuery, Types.GetSprintQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetSprintQuery, Types.GetSprintQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetSprintSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSprintQuery, Types.GetSprintQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSprintQuery, Types.GetSprintQueryVariables>;
export declare function useGetSprintSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSprintQuery, Types.GetSprintQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSprintQuery | undefined, Types.GetSprintQueryVariables>;
export type GetSprintQueryHookResult = ReturnType<typeof useGetSprintQuery>;
export type GetSprintLazyQueryHookResult = ReturnType<typeof useGetSprintLazyQuery>;
export type GetSprintSuspenseQueryHookResult = ReturnType<typeof useGetSprintSuspenseQuery>;
export type GetSprintQueryResult = Apollo.QueryResult<Types.GetSprintQuery, Types.GetSprintQueryVariables>;
export declare const ListExternalSyncsDocument: Apollo.DocumentNode;
/**
 * __useListExternalSyncsQuery__
 *
 * To run a query within a React component, call `useListExternalSyncsQuery` and pass it any options that fit your needs.
 * When your component renders, `useListExternalSyncsQuery` 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 } = useListExternalSyncsQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListExternalSyncsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListExternalSyncsQuery, Types.ListExternalSyncsQueryVariables> & ({
    variables: Types.ListExternalSyncsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListExternalSyncsQuery, Types.ListExternalSyncsQueryVariables, "empty" | "complete" | "streaming", Types.ListExternalSyncsQueryVariables>;
export declare function useListExternalSyncsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListExternalSyncsQuery, Types.ListExternalSyncsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListExternalSyncsQuery, Types.ListExternalSyncsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListExternalSyncsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListExternalSyncsQuery, Types.ListExternalSyncsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListExternalSyncsQuery, Types.ListExternalSyncsQueryVariables>;
export declare function useListExternalSyncsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListExternalSyncsQuery, Types.ListExternalSyncsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListExternalSyncsQuery | undefined, Types.ListExternalSyncsQueryVariables>;
export type ListExternalSyncsQueryHookResult = ReturnType<typeof useListExternalSyncsQuery>;
export type ListExternalSyncsLazyQueryHookResult = ReturnType<typeof useListExternalSyncsLazyQuery>;
export type ListExternalSyncsSuspenseQueryHookResult = ReturnType<typeof useListExternalSyncsSuspenseQuery>;
export type ListExternalSyncsQueryResult = Apollo.QueryResult<Types.ListExternalSyncsQuery, Types.ListExternalSyncsQueryVariables>;
export declare const GetExternalSyncDocument: Apollo.DocumentNode;
/**
 * __useGetExternalSyncQuery__
 *
 * To run a query within a React component, call `useGetExternalSyncQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetExternalSyncQuery` 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 } = useGetExternalSyncQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetExternalSyncQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetExternalSyncQuery, Types.GetExternalSyncQueryVariables> & ({
    variables: Types.GetExternalSyncQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetExternalSyncQuery, Types.GetExternalSyncQueryVariables, "empty" | "complete" | "streaming", Types.GetExternalSyncQueryVariables>;
export declare function useGetExternalSyncLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetExternalSyncQuery, Types.GetExternalSyncQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetExternalSyncQuery, Types.GetExternalSyncQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetExternalSyncSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetExternalSyncQuery, Types.GetExternalSyncQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetExternalSyncQuery, Types.GetExternalSyncQueryVariables>;
export declare function useGetExternalSyncSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetExternalSyncQuery, Types.GetExternalSyncQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetExternalSyncQuery | undefined, Types.GetExternalSyncQueryVariables>;
export type GetExternalSyncQueryHookResult = ReturnType<typeof useGetExternalSyncQuery>;
export type GetExternalSyncLazyQueryHookResult = ReturnType<typeof useGetExternalSyncLazyQuery>;
export type GetExternalSyncSuspenseQueryHookResult = ReturnType<typeof useGetExternalSyncSuspenseQuery>;
export type GetExternalSyncQueryResult = Apollo.QueryResult<Types.GetExternalSyncQuery, Types.GetExternalSyncQueryVariables>;
export declare const ListExternalMappingsDocument: Apollo.DocumentNode;
/**
 * __useListExternalMappingsQuery__
 *
 * To run a query within a React component, call `useListExternalMappingsQuery` and pass it any options that fit your needs.
 * When your component renders, `useListExternalMappingsQuery` 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 } = useListExternalMappingsQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListExternalMappingsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListExternalMappingsQuery, Types.ListExternalMappingsQueryVariables> & ({
    variables: Types.ListExternalMappingsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListExternalMappingsQuery, Types.ListExternalMappingsQueryVariables, "empty" | "complete" | "streaming", Types.ListExternalMappingsQueryVariables>;
export declare function useListExternalMappingsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListExternalMappingsQuery, Types.ListExternalMappingsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListExternalMappingsQuery, Types.ListExternalMappingsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListExternalMappingsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListExternalMappingsQuery, Types.ListExternalMappingsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListExternalMappingsQuery, Types.ListExternalMappingsQueryVariables>;
export declare function useListExternalMappingsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListExternalMappingsQuery, Types.ListExternalMappingsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListExternalMappingsQuery | undefined, Types.ListExternalMappingsQueryVariables>;
export type ListExternalMappingsQueryHookResult = ReturnType<typeof useListExternalMappingsQuery>;
export type ListExternalMappingsLazyQueryHookResult = ReturnType<typeof useListExternalMappingsLazyQuery>;
export type ListExternalMappingsSuspenseQueryHookResult = ReturnType<typeof useListExternalMappingsSuspenseQuery>;
export type ListExternalMappingsQueryResult = Apollo.QueryResult<Types.ListExternalMappingsQuery, Types.ListExternalMappingsQueryVariables>;
export declare const ListProjectTemplatesDocument: Apollo.DocumentNode;
/**
 * __useListProjectTemplatesQuery__
 *
 * To run a query within a React component, call `useListProjectTemplatesQuery` and pass it any options that fit your needs.
 * When your component renders, `useListProjectTemplatesQuery` 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 } = useListProjectTemplatesQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListProjectTemplatesQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListProjectTemplatesQuery, Types.ListProjectTemplatesQueryVariables> & ({
    variables: Types.ListProjectTemplatesQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListProjectTemplatesQuery, Types.ListProjectTemplatesQueryVariables, "empty" | "complete" | "streaming", Types.ListProjectTemplatesQueryVariables>;
export declare function useListProjectTemplatesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListProjectTemplatesQuery, Types.ListProjectTemplatesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListProjectTemplatesQuery, Types.ListProjectTemplatesQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListProjectTemplatesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListProjectTemplatesQuery, Types.ListProjectTemplatesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListProjectTemplatesQuery, Types.ListProjectTemplatesQueryVariables>;
export declare function useListProjectTemplatesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListProjectTemplatesQuery, Types.ListProjectTemplatesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListProjectTemplatesQuery | undefined, Types.ListProjectTemplatesQueryVariables>;
export type ListProjectTemplatesQueryHookResult = ReturnType<typeof useListProjectTemplatesQuery>;
export type ListProjectTemplatesLazyQueryHookResult = ReturnType<typeof useListProjectTemplatesLazyQuery>;
export type ListProjectTemplatesSuspenseQueryHookResult = ReturnType<typeof useListProjectTemplatesSuspenseQuery>;
export type ListProjectTemplatesQueryResult = Apollo.QueryResult<Types.ListProjectTemplatesQuery, Types.ListProjectTemplatesQueryVariables>;
export declare const GetProjectTemplateDocument: Apollo.DocumentNode;
/**
 * __useGetProjectTemplateQuery__
 *
 * To run a query within a React component, call `useGetProjectTemplateQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetProjectTemplateQuery` 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 } = useGetProjectTemplateQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetProjectTemplateQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetProjectTemplateQuery, Types.GetProjectTemplateQueryVariables> & ({
    variables: Types.GetProjectTemplateQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetProjectTemplateQuery, Types.GetProjectTemplateQueryVariables, "empty" | "complete" | "streaming", Types.GetProjectTemplateQueryVariables>;
export declare function useGetProjectTemplateLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetProjectTemplateQuery, Types.GetProjectTemplateQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetProjectTemplateQuery, Types.GetProjectTemplateQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetProjectTemplateSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProjectTemplateQuery, Types.GetProjectTemplateQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProjectTemplateQuery, Types.GetProjectTemplateQueryVariables>;
export declare function useGetProjectTemplateSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProjectTemplateQuery, Types.GetProjectTemplateQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProjectTemplateQuery | undefined, Types.GetProjectTemplateQueryVariables>;
export type GetProjectTemplateQueryHookResult = ReturnType<typeof useGetProjectTemplateQuery>;
export type GetProjectTemplateLazyQueryHookResult = ReturnType<typeof useGetProjectTemplateLazyQuery>;
export type GetProjectTemplateSuspenseQueryHookResult = ReturnType<typeof useGetProjectTemplateSuspenseQuery>;
export type GetProjectTemplateQueryResult = Apollo.QueryResult<Types.GetProjectTemplateQuery, Types.GetProjectTemplateQueryVariables>;
export declare const ListTimeEntriesDocument: Apollo.DocumentNode;
/**
 * __useListTimeEntriesQuery__
 *
 * To run a query within a React component, call `useListTimeEntriesQuery` and pass it any options that fit your needs.
 * When your component renders, `useListTimeEntriesQuery` 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 } = useListTimeEntriesQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListTimeEntriesQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListTimeEntriesQuery, Types.ListTimeEntriesQueryVariables> & ({
    variables: Types.ListTimeEntriesQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListTimeEntriesQuery, Types.ListTimeEntriesQueryVariables, "empty" | "complete" | "streaming", Types.ListTimeEntriesQueryVariables>;
export declare function useListTimeEntriesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListTimeEntriesQuery, Types.ListTimeEntriesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListTimeEntriesQuery, Types.ListTimeEntriesQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListTimeEntriesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListTimeEntriesQuery, Types.ListTimeEntriesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListTimeEntriesQuery, Types.ListTimeEntriesQueryVariables>;
export declare function useListTimeEntriesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListTimeEntriesQuery, Types.ListTimeEntriesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListTimeEntriesQuery | undefined, Types.ListTimeEntriesQueryVariables>;
export type ListTimeEntriesQueryHookResult = ReturnType<typeof useListTimeEntriesQuery>;
export type ListTimeEntriesLazyQueryHookResult = ReturnType<typeof useListTimeEntriesLazyQuery>;
export type ListTimeEntriesSuspenseQueryHookResult = ReturnType<typeof useListTimeEntriesSuspenseQuery>;
export type ListTimeEntriesQueryResult = Apollo.QueryResult<Types.ListTimeEntriesQuery, Types.ListTimeEntriesQueryVariables>;
export declare const ListTimesheetsDocument: Apollo.DocumentNode;
/**
 * __useListTimesheetsQuery__
 *
 * To run a query within a React component, call `useListTimesheetsQuery` and pass it any options that fit your needs.
 * When your component renders, `useListTimesheetsQuery` 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 } = useListTimesheetsQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListTimesheetsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListTimesheetsQuery, Types.ListTimesheetsQueryVariables> & ({
    variables: Types.ListTimesheetsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListTimesheetsQuery, Types.ListTimesheetsQueryVariables, "empty" | "complete" | "streaming", Types.ListTimesheetsQueryVariables>;
export declare function useListTimesheetsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListTimesheetsQuery, Types.ListTimesheetsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListTimesheetsQuery, Types.ListTimesheetsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListTimesheetsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListTimesheetsQuery, Types.ListTimesheetsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListTimesheetsQuery, Types.ListTimesheetsQueryVariables>;
export declare function useListTimesheetsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListTimesheetsQuery, Types.ListTimesheetsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListTimesheetsQuery | undefined, Types.ListTimesheetsQueryVariables>;
export type ListTimesheetsQueryHookResult = ReturnType<typeof useListTimesheetsQuery>;
export type ListTimesheetsLazyQueryHookResult = ReturnType<typeof useListTimesheetsLazyQuery>;
export type ListTimesheetsSuspenseQueryHookResult = ReturnType<typeof useListTimesheetsSuspenseQuery>;
export type ListTimesheetsQueryResult = Apollo.QueryResult<Types.ListTimesheetsQuery, Types.ListTimesheetsQueryVariables>;
export declare const GetTimesheetDocument: Apollo.DocumentNode;
/**
 * __useGetTimesheetQuery__
 *
 * To run a query within a React component, call `useGetTimesheetQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetTimesheetQuery` 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 } = useGetTimesheetQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetTimesheetQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetTimesheetQuery, Types.GetTimesheetQueryVariables> & ({
    variables: Types.GetTimesheetQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetTimesheetQuery, Types.GetTimesheetQueryVariables, "empty" | "complete" | "streaming", Types.GetTimesheetQueryVariables>;
export declare function useGetTimesheetLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetTimesheetQuery, Types.GetTimesheetQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetTimesheetQuery, Types.GetTimesheetQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetTimesheetSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTimesheetQuery, Types.GetTimesheetQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTimesheetQuery, Types.GetTimesheetQueryVariables>;
export declare function useGetTimesheetSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTimesheetQuery, Types.GetTimesheetQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTimesheetQuery | undefined, Types.GetTimesheetQueryVariables>;
export type GetTimesheetQueryHookResult = ReturnType<typeof useGetTimesheetQuery>;
export type GetTimesheetLazyQueryHookResult = ReturnType<typeof useGetTimesheetLazyQuery>;
export type GetTimesheetSuspenseQueryHookResult = ReturnType<typeof useGetTimesheetSuspenseQuery>;
export type GetTimesheetQueryResult = Apollo.QueryResult<Types.GetTimesheetQuery, Types.GetTimesheetQueryVariables>;
export declare const ListWorkItemsDocument: Apollo.DocumentNode;
/**
 * __useListWorkItemsQuery__
 *
 * To run a query within a React component, call `useListWorkItemsQuery` and pass it any options that fit your needs.
 * When your component renders, `useListWorkItemsQuery` 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 } = useListWorkItemsQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListWorkItemsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListWorkItemsQuery, Types.ListWorkItemsQueryVariables> & ({
    variables: Types.ListWorkItemsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListWorkItemsQuery, Types.ListWorkItemsQueryVariables, "empty" | "complete" | "streaming", Types.ListWorkItemsQueryVariables>;
export declare function useListWorkItemsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListWorkItemsQuery, Types.ListWorkItemsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListWorkItemsQuery, Types.ListWorkItemsQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListWorkItemsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListWorkItemsQuery, Types.ListWorkItemsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListWorkItemsQuery, Types.ListWorkItemsQueryVariables>;
export declare function useListWorkItemsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListWorkItemsQuery, Types.ListWorkItemsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListWorkItemsQuery | undefined, Types.ListWorkItemsQueryVariables>;
export type ListWorkItemsQueryHookResult = ReturnType<typeof useListWorkItemsQuery>;
export type ListWorkItemsLazyQueryHookResult = ReturnType<typeof useListWorkItemsLazyQuery>;
export type ListWorkItemsSuspenseQueryHookResult = ReturnType<typeof useListWorkItemsSuspenseQuery>;
export type ListWorkItemsQueryResult = Apollo.QueryResult<Types.ListWorkItemsQuery, Types.ListWorkItemsQueryVariables>;
export declare const GetWorkItemDocument: Apollo.DocumentNode;
/**
 * __useGetWorkItemQuery__
 *
 * To run a query within a React component, call `useGetWorkItemQuery` and pass it any options that fit your needs.
 * When your component renders, `useGetWorkItemQuery` 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 } = useGetWorkItemQuery({
 *   variables: {
 *      id: // value for 'id'
 *   },
 * });
 */
export declare function useGetWorkItemQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetWorkItemQuery, Types.GetWorkItemQueryVariables> & ({
    variables: Types.GetWorkItemQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.GetWorkItemQuery, Types.GetWorkItemQueryVariables, "empty" | "complete" | "streaming", Types.GetWorkItemQueryVariables>;
export declare function useGetWorkItemLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetWorkItemQuery, Types.GetWorkItemQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetWorkItemQuery, Types.GetWorkItemQueryVariables, "empty" | "complete" | "streaming">;
export declare function useGetWorkItemSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkItemQuery, Types.GetWorkItemQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkItemQuery, Types.GetWorkItemQueryVariables>;
export declare function useGetWorkItemSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkItemQuery, Types.GetWorkItemQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkItemQuery | undefined, Types.GetWorkItemQueryVariables>;
export type GetWorkItemQueryHookResult = ReturnType<typeof useGetWorkItemQuery>;
export type GetWorkItemLazyQueryHookResult = ReturnType<typeof useGetWorkItemLazyQuery>;
export type GetWorkItemSuspenseQueryHookResult = ReturnType<typeof useGetWorkItemSuspenseQuery>;
export type GetWorkItemQueryResult = Apollo.QueryResult<Types.GetWorkItemQuery, Types.GetWorkItemQueryVariables>;
export declare const ListDependenciesDocument: Apollo.DocumentNode;
/**
 * __useListDependenciesQuery__
 *
 * To run a query within a React component, call `useListDependenciesQuery` and pass it any options that fit your needs.
 * When your component renders, `useListDependenciesQuery` 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 } = useListDependenciesQuery({
 *   variables: {
 *      workspaceId: // value for 'workspaceId'
 *      filter: // value for 'filter'
 *      pagination: // value for 'pagination'
 *   },
 * });
 */
export declare function useListDependenciesQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.ListDependenciesQuery, Types.ListDependenciesQueryVariables> & ({
    variables: Types.ListDependenciesQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useQuery.Result<Types.ListDependenciesQuery, Types.ListDependenciesQueryVariables, "empty" | "complete" | "streaming", Types.ListDependenciesQueryVariables>;
export declare function useListDependenciesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListDependenciesQuery, Types.ListDependenciesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListDependenciesQuery, Types.ListDependenciesQueryVariables, "empty" | "complete" | "streaming">;
export declare function useListDependenciesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListDependenciesQuery, Types.ListDependenciesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListDependenciesQuery, Types.ListDependenciesQueryVariables>;
export declare function useListDependenciesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListDependenciesQuery, Types.ListDependenciesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListDependenciesQuery | undefined, Types.ListDependenciesQueryVariables>;
export type ListDependenciesQueryHookResult = ReturnType<typeof useListDependenciesQuery>;
export type ListDependenciesLazyQueryHookResult = ReturnType<typeof useListDependenciesLazyQuery>;
export type ListDependenciesSuspenseQueryHookResult = ReturnType<typeof useListDependenciesSuspenseQuery>;
export type ListDependenciesQueryResult = Apollo.QueryResult<Types.ListDependenciesQuery, Types.ListDependenciesQueryVariables>;
export declare const OnProjectUpdatedDocument: Apollo.DocumentNode;
/**
 * __useOnProjectUpdatedSubscription__
 *
 * To run a query within a React component, call `useOnProjectUpdatedSubscription` and pass it any options that fit your needs.
 * When your component renders, `useOnProjectUpdatedSubscription` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useOnProjectUpdatedSubscription({
 *   variables: {
 *      projectId: // value for 'projectId'
 *   },
 * });
 */
export declare function useOnProjectUpdatedSubscription(baseOptions: ApolloReactHooks.SubscriptionHookOptions<Types.OnProjectUpdatedSubscription, Types.OnProjectUpdatedSubscriptionVariables> & ({
    variables: Types.OnProjectUpdatedSubscriptionVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useSubscription.Result<Types.OnProjectUpdatedSubscription>;
export type OnProjectUpdatedSubscriptionHookResult = ReturnType<typeof useOnProjectUpdatedSubscription>;
export type OnProjectUpdatedSubscriptionResult = Apollo.SubscriptionResult<Types.OnProjectUpdatedSubscription>;
export declare const OnWorkItemUpdatedDocument: Apollo.DocumentNode;
/**
 * __useOnWorkItemUpdatedSubscription__
 *
 * To run a query within a React component, call `useOnWorkItemUpdatedSubscription` and pass it any options that fit your needs.
 * When your component renders, `useOnWorkItemUpdatedSubscription` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useOnWorkItemUpdatedSubscription({
 *   variables: {
 *      projectId: // value for 'projectId'
 *   },
 * });
 */
export declare function useOnWorkItemUpdatedSubscription(baseOptions: ApolloReactHooks.SubscriptionHookOptions<Types.OnWorkItemUpdatedSubscription, Types.OnWorkItemUpdatedSubscriptionVariables> & ({
    variables: Types.OnWorkItemUpdatedSubscriptionVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useSubscription.Result<Types.OnWorkItemUpdatedSubscription>;
export type OnWorkItemUpdatedSubscriptionHookResult = ReturnType<typeof useOnWorkItemUpdatedSubscription>;
export type OnWorkItemUpdatedSubscriptionResult = Apollo.SubscriptionResult<Types.OnWorkItemUpdatedSubscription>;
export declare const OnSprintUpdatedDocument: Apollo.DocumentNode;
/**
 * __useOnSprintUpdatedSubscription__
 *
 * To run a query within a React component, call `useOnSprintUpdatedSubscription` and pass it any options that fit your needs.
 * When your component renders, `useOnSprintUpdatedSubscription` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useOnSprintUpdatedSubscription({
 *   variables: {
 *      projectId: // value for 'projectId'
 *   },
 * });
 */
export declare function useOnSprintUpdatedSubscription(baseOptions: ApolloReactHooks.SubscriptionHookOptions<Types.OnSprintUpdatedSubscription, Types.OnSprintUpdatedSubscriptionVariables> & ({
    variables: Types.OnSprintUpdatedSubscriptionVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useSubscription.Result<Types.OnSprintUpdatedSubscription>;
export type OnSprintUpdatedSubscriptionHookResult = ReturnType<typeof useOnSprintUpdatedSubscription>;
export type OnSprintUpdatedSubscriptionResult = Apollo.SubscriptionResult<Types.OnSprintUpdatedSubscription>;
export declare const OnBoardCardMovedDocument: Apollo.DocumentNode;
/**
 * __useOnBoardCardMovedSubscription__
 *
 * To run a query within a React component, call `useOnBoardCardMovedSubscription` and pass it any options that fit your needs.
 * When your component renders, `useOnBoardCardMovedSubscription` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useOnBoardCardMovedSubscription({
 *   variables: {
 *      boardId: // value for 'boardId'
 *   },
 * });
 */
export declare function useOnBoardCardMovedSubscription(baseOptions: ApolloReactHooks.SubscriptionHookOptions<Types.OnBoardCardMovedSubscription, Types.OnBoardCardMovedSubscriptionVariables> & ({
    variables: Types.OnBoardCardMovedSubscriptionVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): ApolloReactHooks.useSubscription.Result<Types.OnBoardCardMovedSubscription>;
export type OnBoardCardMovedSubscriptionHookResult = ReturnType<typeof useOnBoardCardMovedSubscription>;
export type OnBoardCardMovedSubscriptionResult = Apollo.SubscriptionResult<Types.OnBoardCardMovedSubscription>;
//# sourceMappingURL=wspace-operations.d.ts.map