@burdenoff/microfe-workspaces 2026.510.50

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

@@ -0,0 +1,2209 @@
+import * as Types from './wspace-types';
+import * as Apollo from '@apollo/client';
+import * as ApolloReactHooks from '@apollo/client/react';
+export type DashboardProjectsQueryVariables = Types.Exact<{
+    filter?: Types.InputMaybe<Types.ProjectFilterInput>;
+}>;
+export type DashboardProjectsQuery = {
+    __typename?: 'Query';
+    projects: {
+        __typename?: 'ProjectList';
+        total: number;
+        items: Array<{
+            __typename?: 'Project';
+            id: string;
+            name: string;
+            key: string;
+            status: Types.ProjectStatus;
+            workspaceId: string;
+            createdAt: string;
+        }>;
+    };
+};
+export type DashboardWorkspaceDataQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type DashboardWorkspaceDataQuery = {
+    __typename?: 'Query';
+    getRecentActivities: Array<{
+        __typename?: 'ActivityLog';
+        id: string;
+        action: string;
+        resourceType?: string | null;
+        resourceId?: string | null;
+        userId: string;
+        description?: string | null;
+        details?: Record<string, unknown> | null;
+        timestamp: string;
+    }>;
+    upcomingEvents: Array<{
+        __typename?: 'CalendarEvent';
+        id: string;
+        title: string;
+        startTime: string;
+        endTime: string;
+        calendarId: string;
+        allDay: boolean;
+    }>;
+    getTags: {
+        __typename?: 'TagList';
+        total: number;
+        items: Array<{
+            __typename?: 'UniversalTag';
+            id: string;
+            label: string;
+            key: string;
+        }>;
+    };
+    myGroups: {
+        __typename?: 'GroupConnection';
+        totalCount: number;
+        edges: Array<{
+            __typename?: 'GroupEdge';
+            node: {
+                __typename?: 'Group';
+                id: string;
+                name: string;
+                description?: string | null;
+            };
+        }>;
+    };
+    dashboardSummary: {
+        __typename?: 'DashboardSummary';
+        activeWorkflowsCount: number;
+        archivedWorkflowsCount: number;
+        recentRuns: Array<{
+            __typename?: 'RecentRun';
+            id: string;
+            status: string;
+            workflowKey: string;
+            startedAt?: string | null;
+        }>;
+    };
+    workspaceResourceUsage?: {
+        __typename?: 'WorkspaceResourceUsage';
+        currentStorageGb: number;
+    } | null;
+    workspaceResourceLimits?: {
+        __typename?: 'WorkspaceResourceLimits';
+        maxStorageGb?: number | null;
+    } | null;
+};
+export type AddWorkspaceMemberMutationVariables = Types.Exact<{
+    input: Types.AddWorkspaceMemberInput;
+}>;
+export type AddWorkspaceMemberMutation = {
+    __typename?: 'Mutation';
+    addWorkspaceMember: {
+        __typename?: 'WorkspaceMember';
+        id: string;
+        workspaceId: string;
+        userId: string;
+        createdAt: string;
+        updatedAt: string;
+        context?: {
+            __typename?: 'WorkspaceOperationContext';
+            type?: string | null;
+            metadata?: Record<string, unknown> | null;
+        } | null;
+    };
+};
+export type RemoveWorkspaceMemberMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type RemoveWorkspaceMemberMutation = {
+    __typename?: 'Mutation';
+    removeWorkspaceMember: boolean;
+};
+export type RemoveUserFromWorkspaceMutationVariables = Types.Exact<{
+    userId: Types.Scalars['ID']['input'];
+}>;
+export type RemoveUserFromWorkspaceMutation = {
+    __typename?: 'Mutation';
+    removeUserFromWorkspace: boolean;
+};
+export type CreateInvitationMutationVariables = Types.Exact<{
+    input: Types.CreateInvitationInput;
+}>;
+export type CreateInvitationMutation = {
+    __typename?: 'Mutation';
+    createInvitation: {
+        __typename?: 'Invitation';
+        id: string;
+        email: string;
+        status: Types.InviteStatus;
+        roleIds: Array<string>;
+        workspaceId?: string | null;
+        projectId?: string | null;
+        invitedUserId?: string | null;
+        invitedById?: string | null;
+        expiresAt?: string | null;
+        createdAt: string;
+        context?: {
+            __typename?: 'WorkspaceOperationContext';
+            type?: string | null;
+            metadata?: Record<string, unknown> | null;
+        } | null;
+    };
+};
+export type UpdateInvitationMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.UpdateInvitationInput;
+}>;
+export type UpdateInvitationMutation = {
+    __typename?: 'Mutation';
+    updateInvitation: {
+        __typename?: 'Invitation';
+        id: string;
+        email: string;
+        status: Types.InviteStatus;
+        roleIds: Array<string>;
+        expiresAt?: string | null;
+        updatedAt: string;
+        context?: {
+            __typename?: 'WorkspaceOperationContext';
+            type?: string | null;
+            metadata?: Record<string, unknown> | null;
+        } | null;
+    };
+};
+export type AcceptInvitationMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type AcceptInvitationMutation = {
+    __typename?: 'Mutation';
+    acceptInvitation: {
+        __typename?: 'Invitation';
+        id: string;
+        status: Types.InviteStatus;
+        updatedAt: string;
+    };
+};
+export type RejectInvitationMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type RejectInvitationMutation = {
+    __typename?: 'Mutation';
+    rejectInvitation: {
+        __typename?: 'Invitation';
+        id: string;
+        status: Types.InviteStatus;
+        updatedAt: string;
+    };
+};
+export type CancelInvitationMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type CancelInvitationMutation = {
+    __typename?: 'Mutation';
+    cancelInvitation: {
+        __typename?: 'Invitation';
+        id: string;
+        status: Types.InviteStatus;
+        updatedAt: string;
+    };
+};
+export type ResendInvitationMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type ResendInvitationMutation = {
+    __typename?: 'Mutation';
+    resendInvitation: {
+        __typename?: 'Invitation';
+        id: string;
+        updatedAt: string;
+    };
+};
+export type DeleteInvitationMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type DeleteInvitationMutation = {
+    __typename?: 'Mutation';
+    deleteInvitation: boolean;
+};
+export type BulkCreateInvitationsMutationVariables = Types.Exact<{
+    inputs: Array<Types.CreateInvitationInput> | Types.CreateInvitationInput;
+}>;
+export type BulkCreateInvitationsMutation = {
+    __typename?: 'Mutation';
+    bulkCreateInvitations: Array<{
+        __typename?: 'Invitation';
+        id: string;
+        email: string;
+        status: Types.InviteStatus;
+        workspaceId?: string | null;
+        projectId?: string | null;
+        createdAt: string;
+        context?: {
+            __typename?: 'WorkspaceOperationContext';
+            type?: string | null;
+            metadata?: Record<string, unknown> | null;
+        } | null;
+    }>;
+};
+export type CreateProjectMutationVariables = Types.Exact<{
+    input: Types.CreateProjectInput;
+}>;
+export type CreateProjectMutation = {
+    __typename?: 'Mutation';
+    createProject: {
+        __typename?: 'Project';
+        id: string;
+        name: string;
+        key: string;
+        workspaceId: string;
+        creatorId: string;
+        status: Types.ProjectStatus;
+        tags: Record<string, unknown>;
+        createdAt: string;
+    };
+};
+export type UpdateProjectMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.UpdateProjectInput;
+}>;
+export type UpdateProjectMutation = {
+    __typename?: 'Mutation';
+    updateProject: {
+        __typename?: 'Project';
+        id: string;
+        name: string;
+        key: string;
+        status: Types.ProjectStatus;
+        config?: Record<string, unknown> | null;
+        tags: Record<string, unknown>;
+        archived: boolean;
+        updatedAt: string;
+    };
+};
+export type DeleteProjectMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type DeleteProjectMutation = {
+    __typename?: 'Mutation';
+    deleteProject: boolean;
+};
+export type ArchiveProjectMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type ArchiveProjectMutation = {
+    __typename?: 'Mutation';
+    archiveProject: {
+        __typename?: 'Project';
+        id: string;
+        archived: boolean;
+        updatedAt: string;
+    };
+};
+export type UnarchiveProjectMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type UnarchiveProjectMutation = {
+    __typename?: 'Mutation';
+    unarchiveProject: {
+        __typename?: 'Project';
+        id: string;
+        archived: boolean;
+        updatedAt: string;
+    };
+};
+export type SwitchProjectMutationVariables = Types.Exact<{
+    projectId: Types.Scalars['ID']['input'];
+}>;
+export type SwitchProjectMutation = {
+    __typename?: 'Mutation';
+    switchProject: {
+        __typename?: 'ProjectAuthResponse';
+        token: string;
+        expiresAt: string;
+        project: {
+            __typename?: 'Project';
+            id: string;
+            name: string;
+            key: string;
+            workspaceId: string;
+            status: Types.ProjectStatus;
+            tags: Record<string, unknown>;
+            archived: boolean;
+        };
+    };
+};
+export type TagProjectMutationVariables = Types.Exact<{
+    input: Types.TagProjectInput;
+}>;
+export type TagProjectMutation = {
+    __typename?: 'Mutation';
+    tagProject: {
+        __typename?: 'ProjectTagAssignment';
+        id: string;
+        tagId: string;
+        entityType: string;
+        entityId: string;
+        source: string;
+        assignedBy?: string | null;
+        assignedAt?: string | null;
+        validFrom?: string | null;
+        validTo?: string | null;
+        metadata?: Record<string, unknown> | null;
+    };
+};
+export type UntagProjectMutationVariables = Types.Exact<{
+    input: Types.UntagProjectInput;
+}>;
+export type UntagProjectMutation = {
+    __typename?: 'Mutation';
+    untagProject: boolean;
+};
+export type ReplaceProjectTagsMutationVariables = Types.Exact<{
+    input: Types.ReplaceProjectTagsInput;
+}>;
+export type ReplaceProjectTagsMutation = {
+    __typename?: 'Mutation';
+    replaceProjectTags: Array<{
+        __typename?: 'ProjectTagAssignment';
+        id: string;
+        tagId: string;
+        entityType: string;
+        entityId: string;
+        source: string;
+        assignedBy?: string | null;
+        assignedAt?: string | null;
+        validFrom?: string | null;
+        validTo?: string | null;
+        metadata?: Record<string, unknown> | null;
+    }>;
+};
+export type CreateWorkspaceMutationVariables = Types.Exact<{
+    input: Types.CreateWorkspaceInput;
+}>;
+export type CreateWorkspaceMutation = {
+    __typename?: 'Mutation';
+    createWorkspace: {
+        __typename?: 'Workspace';
+        id: string;
+        name: string;
+        type: Types.WorkspaceType;
+        status: Types.WorkspaceStatus;
+        tenantId: string;
+        ownerId: string;
+        createdAt: string;
+        context?: {
+            __typename?: 'WorkspaceOperationContext';
+            type?: string | null;
+            metadata?: Record<string, unknown> | null;
+        } | null;
+    };
+};
+export type UpdateWorkspaceMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.UpdateWorkspaceInput;
+}>;
+export type UpdateWorkspaceMutation = {
+    __typename?: 'Mutation';
+    updateWorkspace: {
+        __typename?: 'Workspace';
+        id: string;
+        name: string;
+        type: Types.WorkspaceType;
+        status: Types.WorkspaceStatus;
+        domain?: string | null;
+        contactEmail?: string | null;
+        website?: string | null;
+        address?: string | null;
+        ownerId: string;
+        updatedAt: string;
+        context?: {
+            __typename?: 'WorkspaceOperationContext';
+            type?: string | null;
+            metadata?: Record<string, unknown> | null;
+        } | null;
+    };
+};
+export type DeleteWorkspaceMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type DeleteWorkspaceMutation = {
+    __typename?: 'Mutation';
+    deleteWorkspace: boolean;
+};
+export type ArchiveWorkspaceMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type ArchiveWorkspaceMutation = {
+    __typename?: 'Mutation';
+    updateWorkspace: {
+        __typename?: 'Workspace';
+        id: string;
+        name: string;
+        status: Types.WorkspaceStatus;
+        updatedAt: string;
+    };
+};
+export type ReactivateWorkspaceMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type ReactivateWorkspaceMutation = {
+    __typename?: 'Mutation';
+    updateWorkspace: {
+        __typename?: 'Workspace';
+        id: string;
+        name: string;
+        status: Types.WorkspaceStatus;
+        updatedAt: string;
+    };
+};
+export type InitializeWorkspaceMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type InitializeWorkspaceMutation = {
+    __typename?: 'Mutation';
+    initializeWorkspace: {
+        __typename?: 'Workspace';
+        id: string;
+        status: Types.WorkspaceStatus;
+        updatedAt: string;
+    };
+};
+export type TagWorkspaceMutationVariables = Types.Exact<{
+    input: Types.TagWorkspaceInput;
+}>;
+export type TagWorkspaceMutation = {
+    __typename?: 'Mutation';
+    tagWorkspace: {
+        __typename?: 'WorkspaceTagAssignment';
+        id: string;
+        tagId: string;
+        entityType: string;
+        entityId: string;
+        source: string;
+        assignedBy?: string | null;
+        assignedAt?: string | null;
+        validFrom?: string | null;
+        validTo?: string | null;
+        metadata?: Record<string, unknown> | null;
+    };
+};
+export type UntagWorkspaceMutationVariables = Types.Exact<{
+    input: Types.UntagWorkspaceInput;
+}>;
+export type UntagWorkspaceMutation = {
+    __typename?: 'Mutation';
+    untagWorkspace: boolean;
+};
+export type ReplaceWorkspaceTagsMutationVariables = Types.Exact<{
+    input: Types.ReplaceWorkspaceTagsInput;
+}>;
+export type ReplaceWorkspaceTagsMutation = {
+    __typename?: 'Mutation';
+    replaceWorkspaceTags: Array<{
+        __typename?: 'WorkspaceTagAssignment';
+        id: string;
+        tagId: string;
+        entityType: string;
+        entityId: string;
+        source: string;
+        assignedBy?: string | null;
+        assignedAt?: string | null;
+        validFrom?: string | null;
+        validTo?: string | null;
+        metadata?: Record<string, unknown> | null;
+    }>;
+};
+export type WorkspaceMemberFieldsFragment = {
+    __typename?: 'WorkspaceMember';
+    id: string;
+    workspaceId: string;
+    userId: string;
+    createdAt: string;
+    updatedAt: string;
+    context?: {
+        __typename?: 'WorkspaceOperationContext';
+        type?: string | null;
+        metadata?: Record<string, unknown> | null;
+    } | null;
+};
+export type InvitationCardFieldsFragment = {
+    __typename?: 'Invitation';
+    id: string;
+    email: string;
+    status: Types.InviteStatus;
+    roleIds: Array<string>;
+    workspaceId?: string | null;
+    invitedById?: string | null;
+    expiresAt?: string | null;
+    createdAt: string;
+    context?: {
+        __typename?: 'WorkspaceOperationContext';
+        type?: string | null;
+        metadata?: Record<string, unknown> | null;
+    } | null;
+};
+export type InvitationFullFieldsFragment = {
+    __typename?: 'Invitation';
+    projectId?: string | null;
+    invitedUserId?: string | null;
+    updatedAt: string;
+    deletedAt?: string | null;
+    id: string;
+    email: string;
+    status: Types.InviteStatus;
+    roleIds: Array<string>;
+    workspaceId?: string | null;
+    invitedById?: string | null;
+    expiresAt?: string | null;
+    createdAt: string;
+    context?: {
+        __typename?: 'WorkspaceOperationContext';
+        type?: string | null;
+        metadata?: Record<string, unknown> | null;
+    } | null;
+};
+export type GetWorkspaceMembersQueryVariables = Types.Exact<{
+    workspaceId: Types.Scalars['ID']['input'];
+    pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+export type GetWorkspaceMembersQuery = {
+    __typename?: 'Query';
+    workspaceMembers: {
+        __typename?: 'WorkspaceMemberList';
+        total: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'WorkspaceMember';
+            id: string;
+            workspaceId: string;
+            userId: string;
+            createdAt: string;
+            updatedAt: string;
+            context?: {
+                __typename?: 'WorkspaceOperationContext';
+                type?: string | null;
+                metadata?: Record<string, unknown> | null;
+            } | null;
+        }>;
+    };
+};
+export type GetWorkspaceMemberQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetWorkspaceMemberQuery = {
+    __typename?: 'Query';
+    workspaceMember?: {
+        __typename?: 'WorkspaceMember';
+        id: string;
+        workspaceId: string;
+        userId: string;
+        createdAt: string;
+        updatedAt: string;
+        context?: {
+            __typename?: 'WorkspaceOperationContext';
+            type?: string | null;
+            metadata?: Record<string, unknown> | null;
+        } | null;
+    } | null;
+};
+export type GetUserWorkspacesQueryVariables = Types.Exact<{
+    userId: Types.Scalars['ID']['input'];
+    pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+export type GetUserWorkspacesQuery = {
+    __typename?: 'Query';
+    userWorkspaces: {
+        __typename?: 'WorkspaceMemberList';
+        total: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'WorkspaceMember';
+            id: string;
+            workspaceId: string;
+            userId: string;
+            createdAt: string;
+            updatedAt: string;
+            context?: {
+                __typename?: 'WorkspaceOperationContext';
+                type?: string | null;
+                metadata?: Record<string, unknown> | null;
+            } | null;
+        }>;
+    };
+};
+export type GetWorkspaceInvitationsQueryVariables = Types.Exact<{
+    status?: Types.InputMaybe<Types.InviteStatus>;
+    pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+export type GetWorkspaceInvitationsQuery = {
+    __typename?: 'Query';
+    workspaceInvitations: {
+        __typename?: 'InvitationList';
+        total: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'Invitation';
+            projectId?: string | null;
+            invitedUserId?: string | null;
+            updatedAt: string;
+            deletedAt?: string | null;
+            id: string;
+            email: string;
+            status: Types.InviteStatus;
+            roleIds: Array<string>;
+            workspaceId?: string | null;
+            invitedById?: string | null;
+            expiresAt?: string | null;
+            createdAt: string;
+            context?: {
+                __typename?: 'WorkspaceOperationContext';
+                type?: string | null;
+                metadata?: Record<string, unknown> | null;
+            } | null;
+        }>;
+    };
+};
+export type GetInvitationQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetInvitationQuery = {
+    __typename?: 'Query';
+    invitation?: {
+        __typename?: 'Invitation';
+        projectId?: string | null;
+        invitedUserId?: string | null;
+        updatedAt: string;
+        deletedAt?: string | null;
+        id: string;
+        email: string;
+        status: Types.InviteStatus;
+        roleIds: Array<string>;
+        workspaceId?: string | null;
+        invitedById?: string | null;
+        expiresAt?: string | null;
+        createdAt: string;
+        context?: {
+            __typename?: 'WorkspaceOperationContext';
+            type?: string | null;
+            metadata?: Record<string, unknown> | null;
+        } | null;
+    } | null;
+};
+export type GetMyPendingInvitationsQueryVariables = Types.Exact<{
+    email: Types.Scalars['String']['input'];
+}>;
+export type GetMyPendingInvitationsQuery = {
+    __typename?: 'Query';
+    myPendingInvitations: Array<{
+        __typename?: 'Invitation';
+        deletedAt?: string | null;
+        id: string;
+        email: string;
+        status: Types.InviteStatus;
+        roleIds: Array<string>;
+        workspaceId?: string | null;
+        invitedById?: string | null;
+        expiresAt?: string | null;
+        createdAt: string;
+        context?: {
+            __typename?: 'WorkspaceOperationContext';
+            type?: string | null;
+            metadata?: Record<string, unknown> | null;
+        } | null;
+    }>;
+};
+export type ProjectCardFieldsFragment = {
+    __typename?: 'Project';
+    id: string;
+    name: string;
+    key: string;
+    workspaceId: string;
+    status: Types.ProjectStatus;
+    tags: Record<string, unknown>;
+    archived: boolean;
+    createdAt: string;
+    updatedAt: string;
+};
+export type ProjectFullFieldsFragment = {
+    __typename?: 'Project';
+    creatorId: string;
+    config?: Record<string, unknown> | null;
+    deletedAt?: string | null;
+    id: string;
+    name: string;
+    key: string;
+    workspaceId: string;
+    status: Types.ProjectStatus;
+    tags: Record<string, unknown>;
+    archived: boolean;
+    createdAt: string;
+    updatedAt: string;
+    tagAssignments?: Array<{
+        __typename?: 'ProjectTagAssignment';
+        id: string;
+        tagId: string;
+        entityType: string;
+        entityId: string;
+        source: string;
+        assignedBy?: string | null;
+        assignedAt?: string | null;
+        validFrom?: string | null;
+        validTo?: string | null;
+        metadata?: Record<string, unknown> | null;
+    }> | null;
+};
+export type GetProjectsQueryVariables = Types.Exact<{
+    filter?: Types.InputMaybe<Types.ProjectFilterInput>;
+    pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+export type GetProjectsQuery = {
+    __typename?: 'Query';
+    projects: {
+        __typename?: 'ProjectList';
+        total: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'Project';
+            creatorId: string;
+            config?: Record<string, unknown> | null;
+            deletedAt?: string | null;
+            id: string;
+            name: string;
+            key: string;
+            workspaceId: string;
+            status: Types.ProjectStatus;
+            tags: Record<string, unknown>;
+            archived: boolean;
+            createdAt: string;
+            updatedAt: string;
+            tagAssignments?: Array<{
+                __typename?: 'ProjectTagAssignment';
+                id: string;
+                tagId: string;
+                entityType: string;
+                entityId: string;
+                source: string;
+                assignedBy?: string | null;
+                assignedAt?: string | null;
+                validFrom?: string | null;
+                validTo?: string | null;
+                metadata?: Record<string, unknown> | null;
+            }> | null;
+        }>;
+    };
+};
+export type GetProjectQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetProjectQuery = {
+    __typename?: 'Query';
+    project?: {
+        __typename?: 'Project';
+        creatorId: string;
+        config?: Record<string, unknown> | null;
+        deletedAt?: string | null;
+        id: string;
+        name: string;
+        key: string;
+        workspaceId: string;
+        status: Types.ProjectStatus;
+        tags: Record<string, unknown>;
+        archived: boolean;
+        createdAt: string;
+        updatedAt: string;
+        tagAssignments?: Array<{
+            __typename?: 'ProjectTagAssignment';
+            id: string;
+            tagId: string;
+            entityType: string;
+            entityId: string;
+            source: string;
+            assignedBy?: string | null;
+            assignedAt?: string | null;
+            validFrom?: string | null;
+            validTo?: string | null;
+            metadata?: Record<string, unknown> | null;
+        }> | null;
+    } | null;
+};
+export type GetMyProjectsQueryVariables = Types.Exact<{
+    pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+export type GetMyProjectsQuery = {
+    __typename?: 'Query';
+    myProjects: {
+        __typename?: 'ProjectList';
+        total: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'Project';
+            id: string;
+            name: string;
+            key: string;
+            workspaceId: string;
+            status: Types.ProjectStatus;
+            tags: Record<string, unknown>;
+            archived: boolean;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+};
+export type ProjectTagAssignmentFieldsFragment = {
+    __typename?: 'ProjectTagAssignment';
+    id: string;
+    tagId: string;
+    entityType: string;
+    entityId: string;
+    source: string;
+    assignedBy?: string | null;
+    assignedAt?: string | null;
+    validFrom?: string | null;
+    validTo?: string | null;
+    metadata?: Record<string, unknown> | null;
+};
+export type GetProjectTagsQueryVariables = Types.Exact<{
+    input: Types.GetProjectTagsInput;
+}>;
+export type GetProjectTagsQuery = {
+    __typename?: 'Query';
+    getProjectTags: Array<{
+        __typename?: 'ProjectTagAssignment';
+        id: string;
+        tagId: string;
+        entityType: string;
+        entityId: string;
+        source: string;
+        assignedBy?: string | null;
+        assignedAt?: string | null;
+        validFrom?: string | null;
+        validTo?: string | null;
+        metadata?: Record<string, unknown> | null;
+    }>;
+};
+export type WorkspaceCardFieldsFragment = {
+    __typename?: 'Workspace';
+    id: string;
+    name: string;
+    type: Types.WorkspaceType;
+    status: Types.WorkspaceStatus;
+    domain?: string | null;
+    contactEmail?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    context?: {
+        __typename?: 'WorkspaceOperationContext';
+        type?: string | null;
+        metadata?: Record<string, unknown> | null;
+    } | null;
+};
+export type WorkspaceFullFieldsFragment = {
+    __typename?: 'Workspace';
+    website?: string | null;
+    address?: string | null;
+    tenantId: string;
+    orgId?: string | null;
+    createdBy?: string | null;
+    ownerId: string;
+    deletedAt?: string | null;
+    id: string;
+    name: string;
+    type: Types.WorkspaceType;
+    status: Types.WorkspaceStatus;
+    domain?: string | null;
+    contactEmail?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    tagAssignments?: Array<{
+        __typename?: 'WorkspaceTagAssignment';
+        id: string;
+        tagId: string;
+        entityType: string;
+        entityId: string;
+        source: string;
+        assignedBy?: string | null;
+        assignedAt?: string | null;
+        validFrom?: string | null;
+        validTo?: string | null;
+        metadata?: Record<string, unknown> | null;
+    }> | null;
+    context?: {
+        __typename?: 'WorkspaceOperationContext';
+        type?: string | null;
+        metadata?: Record<string, unknown> | null;
+    } | null;
+};
+export type GetWorkspacesQueryVariables = Types.Exact<{
+    filter?: Types.InputMaybe<Types.WorkspaceFilterInput>;
+    pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+export type GetWorkspacesQuery = {
+    __typename?: 'Query';
+    workspaces: {
+        __typename?: 'WorkspaceList';
+        total: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'Workspace';
+            website?: string | null;
+            address?: string | null;
+            tenantId: string;
+            orgId?: string | null;
+            createdBy?: string | null;
+            ownerId: string;
+            deletedAt?: string | null;
+            id: string;
+            name: string;
+            type: Types.WorkspaceType;
+            status: Types.WorkspaceStatus;
+            domain?: string | null;
+            contactEmail?: string | null;
+            createdAt: string;
+            updatedAt: string;
+            tagAssignments?: Array<{
+                __typename?: 'WorkspaceTagAssignment';
+                id: string;
+                tagId: string;
+                entityType: string;
+                entityId: string;
+                source: string;
+                assignedBy?: string | null;
+                assignedAt?: string | null;
+                validFrom?: string | null;
+                validTo?: string | null;
+                metadata?: Record<string, unknown> | null;
+            }> | null;
+            context?: {
+                __typename?: 'WorkspaceOperationContext';
+                type?: string | null;
+                metadata?: Record<string, unknown> | null;
+            } | null;
+        }>;
+    };
+};
+export type GetWorkspaceQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetWorkspaceQuery = {
+    __typename?: 'Query';
+    workspace?: {
+        __typename?: 'Workspace';
+        website?: string | null;
+        address?: string | null;
+        tenantId: string;
+        orgId?: string | null;
+        createdBy?: string | null;
+        ownerId: string;
+        deletedAt?: string | null;
+        id: string;
+        name: string;
+        type: Types.WorkspaceType;
+        status: Types.WorkspaceStatus;
+        domain?: string | null;
+        contactEmail?: string | null;
+        createdAt: string;
+        updatedAt: string;
+        tagAssignments?: Array<{
+            __typename?: 'WorkspaceTagAssignment';
+            id: string;
+            tagId: string;
+            entityType: string;
+            entityId: string;
+            source: string;
+            assignedBy?: string | null;
+            assignedAt?: string | null;
+            validFrom?: string | null;
+            validTo?: string | null;
+            metadata?: Record<string, unknown> | null;
+        }> | null;
+        context?: {
+            __typename?: 'WorkspaceOperationContext';
+            type?: string | null;
+            metadata?: Record<string, unknown> | null;
+        } | null;
+    } | null;
+};
+export type GetMyWorkspacesQueryVariables = Types.Exact<{
+    pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+export type GetMyWorkspacesQuery = {
+    __typename?: 'Query';
+    myWorkspaces: {
+        __typename?: 'WorkspaceList';
+        total: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'Workspace';
+            id: string;
+            name: string;
+            type: Types.WorkspaceType;
+            status: Types.WorkspaceStatus;
+            domain?: string | null;
+            contactEmail?: string | null;
+            createdAt: string;
+            updatedAt: string;
+            context?: {
+                __typename?: 'WorkspaceOperationContext';
+                type?: string | null;
+                metadata?: Record<string, unknown> | null;
+            } | null;
+        }>;
+    };
+};
+export type WorkspaceTagAssignmentFieldsFragment = {
+    __typename?: 'WorkspaceTagAssignment';
+    id: string;
+    tagId: string;
+    entityType: string;
+    entityId: string;
+    source: string;
+    assignedBy?: string | null;
+    assignedAt?: string | null;
+    validFrom?: string | null;
+    validTo?: string | null;
+    metadata?: Record<string, unknown> | null;
+};
+export type GetWorkspaceTagsQueryVariables = Types.Exact<{
+    input: Types.GetWorkspaceTagsInput;
+}>;
+export type GetWorkspaceTagsQuery = {
+    __typename?: 'Query';
+    getWorkspaceTags: Array<{
+        __typename?: 'WorkspaceTagAssignment';
+        id: string;
+        tagId: string;
+        entityType: string;
+        entityId: string;
+        source: string;
+        assignedBy?: string | null;
+        assignedAt?: string | null;
+        validFrom?: string | null;
+        validTo?: string | null;
+        metadata?: Record<string, unknown> | null;
+    }>;
+};
+export declare const WorkspaceMemberFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const InvitationCardFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const InvitationFullFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const ProjectCardFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const ProjectTagAssignmentFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const ProjectFullFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const WorkspaceCardFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const WorkspaceTagAssignmentFieldsFragmentDoc: Apollo.DocumentNode;
+export declare const WorkspaceFullFieldsFragmentDoc: Apollo.DocumentNode;
+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: {
+ *      filter: // value for 'filter'
+ *   },
+ * });
+ */
+export declare function useDashboardProjectsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.DashboardProjectsQuery, Types.DashboardProjectsQueryVariables>): 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 DashboardWorkspaceDataDocument: Apollo.DocumentNode;
+/**
+ * __useDashboardWorkspaceDataQuery__
+ *
+ * To run a query within a React component, call `useDashboardWorkspaceDataQuery` and pass it any options that fit your needs.
+ * When your component renders, `useDashboardWorkspaceDataQuery` 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 } = useDashboardWorkspaceDataQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useDashboardWorkspaceDataQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.DashboardWorkspaceDataQuery, Types.DashboardWorkspaceDataQueryVariables>): ApolloReactHooks.useQuery.Result<Types.DashboardWorkspaceDataQuery, Types.DashboardWorkspaceDataQueryVariables, "empty" | "complete" | "streaming", Types.DashboardWorkspaceDataQueryVariables>;
+export declare function useDashboardWorkspaceDataLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.DashboardWorkspaceDataQuery, Types.DashboardWorkspaceDataQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.DashboardWorkspaceDataQuery, Types.DashboardWorkspaceDataQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useDashboardWorkspaceDataSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.DashboardWorkspaceDataQuery, Types.DashboardWorkspaceDataQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.DashboardWorkspaceDataQuery, Types.DashboardWorkspaceDataQueryVariables>;
+export declare function useDashboardWorkspaceDataSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.DashboardWorkspaceDataQuery, Types.DashboardWorkspaceDataQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.DashboardWorkspaceDataQuery | undefined, Types.DashboardWorkspaceDataQueryVariables>;
+export type DashboardWorkspaceDataQueryHookResult = ReturnType<typeof useDashboardWorkspaceDataQuery>;
+export type DashboardWorkspaceDataLazyQueryHookResult = ReturnType<typeof useDashboardWorkspaceDataLazyQuery>;
+export type DashboardWorkspaceDataSuspenseQueryHookResult = ReturnType<typeof useDashboardWorkspaceDataSuspenseQuery>;
+export type DashboardWorkspaceDataQueryResult = Apollo.QueryResult<Types.DashboardWorkspaceDataQuery, Types.DashboardWorkspaceDataQueryVariables>;
+export declare const AddWorkspaceMemberDocument: Apollo.DocumentNode;
+export type AddWorkspaceMemberMutationFn = Apollo.MutationFunction<Types.AddWorkspaceMemberMutation, Types.AddWorkspaceMemberMutationVariables>;
+/**
+ * __useAddWorkspaceMemberMutation__
+ *
+ * To run a mutation, you first call `useAddWorkspaceMemberMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddWorkspaceMemberMutation` 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 [addWorkspaceMemberMutation, { data, loading, error }] = useAddWorkspaceMemberMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useAddWorkspaceMemberMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AddWorkspaceMemberMutation, Types.AddWorkspaceMemberMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AddWorkspaceMemberMutation, any, Apollo.ApolloCache>;
+export type AddWorkspaceMemberMutationHookResult = ReturnType<typeof useAddWorkspaceMemberMutation>;
+export type AddWorkspaceMemberMutationResult = Apollo.MutationResult<Types.AddWorkspaceMemberMutation>;
+export type AddWorkspaceMemberMutationOptions = Apollo.BaseMutationOptions<Types.AddWorkspaceMemberMutation, Types.AddWorkspaceMemberMutationVariables>;
+export declare const RemoveWorkspaceMemberDocument: Apollo.DocumentNode;
+export type RemoveWorkspaceMemberMutationFn = Apollo.MutationFunction<Types.RemoveWorkspaceMemberMutation, Types.RemoveWorkspaceMemberMutationVariables>;
+/**
+ * __useRemoveWorkspaceMemberMutation__
+ *
+ * To run a mutation, you first call `useRemoveWorkspaceMemberMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRemoveWorkspaceMemberMutation` 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 [removeWorkspaceMemberMutation, { data, loading, error }] = useRemoveWorkspaceMemberMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useRemoveWorkspaceMemberMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RemoveWorkspaceMemberMutation, Types.RemoveWorkspaceMemberMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RemoveWorkspaceMemberMutation, any, Apollo.ApolloCache>;
+export type RemoveWorkspaceMemberMutationHookResult = ReturnType<typeof useRemoveWorkspaceMemberMutation>;
+export type RemoveWorkspaceMemberMutationResult = Apollo.MutationResult<Types.RemoveWorkspaceMemberMutation>;
+export type RemoveWorkspaceMemberMutationOptions = Apollo.BaseMutationOptions<Types.RemoveWorkspaceMemberMutation, Types.RemoveWorkspaceMemberMutationVariables>;
+export declare const RemoveUserFromWorkspaceDocument: Apollo.DocumentNode;
+export type RemoveUserFromWorkspaceMutationFn = Apollo.MutationFunction<Types.RemoveUserFromWorkspaceMutation, Types.RemoveUserFromWorkspaceMutationVariables>;
+/**
+ * __useRemoveUserFromWorkspaceMutation__
+ *
+ * To run a mutation, you first call `useRemoveUserFromWorkspaceMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRemoveUserFromWorkspaceMutation` 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 [removeUserFromWorkspaceMutation, { data, loading, error }] = useRemoveUserFromWorkspaceMutation({
+ *   variables: {
+ *      userId: // value for 'userId'
+ *   },
+ * });
+ */
+export declare function useRemoveUserFromWorkspaceMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RemoveUserFromWorkspaceMutation, Types.RemoveUserFromWorkspaceMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RemoveUserFromWorkspaceMutation, any, Apollo.ApolloCache>;
+export type RemoveUserFromWorkspaceMutationHookResult = ReturnType<typeof useRemoveUserFromWorkspaceMutation>;
+export type RemoveUserFromWorkspaceMutationResult = Apollo.MutationResult<Types.RemoveUserFromWorkspaceMutation>;
+export type RemoveUserFromWorkspaceMutationOptions = Apollo.BaseMutationOptions<Types.RemoveUserFromWorkspaceMutation, Types.RemoveUserFromWorkspaceMutationVariables>;
+export declare const CreateInvitationDocument: Apollo.DocumentNode;
+export type CreateInvitationMutationFn = Apollo.MutationFunction<Types.CreateInvitationMutation, Types.CreateInvitationMutationVariables>;
+/**
+ * __useCreateInvitationMutation__
+ *
+ * To run a mutation, you first call `useCreateInvitationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateInvitationMutation` 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 [createInvitationMutation, { data, loading, error }] = useCreateInvitationMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateInvitationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateInvitationMutation, Types.CreateInvitationMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateInvitationMutation, any, Apollo.ApolloCache>;
+export type CreateInvitationMutationHookResult = ReturnType<typeof useCreateInvitationMutation>;
+export type CreateInvitationMutationResult = Apollo.MutationResult<Types.CreateInvitationMutation>;
+export type CreateInvitationMutationOptions = Apollo.BaseMutationOptions<Types.CreateInvitationMutation, Types.CreateInvitationMutationVariables>;
+export declare const UpdateInvitationDocument: Apollo.DocumentNode;
+export type UpdateInvitationMutationFn = Apollo.MutationFunction<Types.UpdateInvitationMutation, Types.UpdateInvitationMutationVariables>;
+/**
+ * __useUpdateInvitationMutation__
+ *
+ * To run a mutation, you first call `useUpdateInvitationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateInvitationMutation` 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 [updateInvitationMutation, { data, loading, error }] = useUpdateInvitationMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateInvitationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateInvitationMutation, Types.UpdateInvitationMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateInvitationMutation, any, Apollo.ApolloCache>;
+export type UpdateInvitationMutationHookResult = ReturnType<typeof useUpdateInvitationMutation>;
+export type UpdateInvitationMutationResult = Apollo.MutationResult<Types.UpdateInvitationMutation>;
+export type UpdateInvitationMutationOptions = Apollo.BaseMutationOptions<Types.UpdateInvitationMutation, Types.UpdateInvitationMutationVariables>;
+export declare const AcceptInvitationDocument: Apollo.DocumentNode;
+export type AcceptInvitationMutationFn = Apollo.MutationFunction<Types.AcceptInvitationMutation, Types.AcceptInvitationMutationVariables>;
+/**
+ * __useAcceptInvitationMutation__
+ *
+ * To run a mutation, you first call `useAcceptInvitationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAcceptInvitationMutation` 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 [acceptInvitationMutation, { data, loading, error }] = useAcceptInvitationMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useAcceptInvitationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AcceptInvitationMutation, Types.AcceptInvitationMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AcceptInvitationMutation, any, Apollo.ApolloCache>;
+export type AcceptInvitationMutationHookResult = ReturnType<typeof useAcceptInvitationMutation>;
+export type AcceptInvitationMutationResult = Apollo.MutationResult<Types.AcceptInvitationMutation>;
+export type AcceptInvitationMutationOptions = Apollo.BaseMutationOptions<Types.AcceptInvitationMutation, Types.AcceptInvitationMutationVariables>;
+export declare const RejectInvitationDocument: Apollo.DocumentNode;
+export type RejectInvitationMutationFn = Apollo.MutationFunction<Types.RejectInvitationMutation, Types.RejectInvitationMutationVariables>;
+/**
+ * __useRejectInvitationMutation__
+ *
+ * To run a mutation, you first call `useRejectInvitationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRejectInvitationMutation` 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 [rejectInvitationMutation, { data, loading, error }] = useRejectInvitationMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useRejectInvitationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RejectInvitationMutation, Types.RejectInvitationMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RejectInvitationMutation, any, Apollo.ApolloCache>;
+export type RejectInvitationMutationHookResult = ReturnType<typeof useRejectInvitationMutation>;
+export type RejectInvitationMutationResult = Apollo.MutationResult<Types.RejectInvitationMutation>;
+export type RejectInvitationMutationOptions = Apollo.BaseMutationOptions<Types.RejectInvitationMutation, Types.RejectInvitationMutationVariables>;
+export declare const CancelInvitationDocument: Apollo.DocumentNode;
+export type CancelInvitationMutationFn = Apollo.MutationFunction<Types.CancelInvitationMutation, Types.CancelInvitationMutationVariables>;
+/**
+ * __useCancelInvitationMutation__
+ *
+ * To run a mutation, you first call `useCancelInvitationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCancelInvitationMutation` 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 [cancelInvitationMutation, { data, loading, error }] = useCancelInvitationMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useCancelInvitationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CancelInvitationMutation, Types.CancelInvitationMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CancelInvitationMutation, any, Apollo.ApolloCache>;
+export type CancelInvitationMutationHookResult = ReturnType<typeof useCancelInvitationMutation>;
+export type CancelInvitationMutationResult = Apollo.MutationResult<Types.CancelInvitationMutation>;
+export type CancelInvitationMutationOptions = Apollo.BaseMutationOptions<Types.CancelInvitationMutation, Types.CancelInvitationMutationVariables>;
+export declare const ResendInvitationDocument: Apollo.DocumentNode;
+export type ResendInvitationMutationFn = Apollo.MutationFunction<Types.ResendInvitationMutation, Types.ResendInvitationMutationVariables>;
+/**
+ * __useResendInvitationMutation__
+ *
+ * To run a mutation, you first call `useResendInvitationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useResendInvitationMutation` 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 [resendInvitationMutation, { data, loading, error }] = useResendInvitationMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useResendInvitationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ResendInvitationMutation, Types.ResendInvitationMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ResendInvitationMutation, any, Apollo.ApolloCache>;
+export type ResendInvitationMutationHookResult = ReturnType<typeof useResendInvitationMutation>;
+export type ResendInvitationMutationResult = Apollo.MutationResult<Types.ResendInvitationMutation>;
+export type ResendInvitationMutationOptions = Apollo.BaseMutationOptions<Types.ResendInvitationMutation, Types.ResendInvitationMutationVariables>;
+export declare const DeleteInvitationDocument: Apollo.DocumentNode;
+export type DeleteInvitationMutationFn = Apollo.MutationFunction<Types.DeleteInvitationMutation, Types.DeleteInvitationMutationVariables>;
+/**
+ * __useDeleteInvitationMutation__
+ *
+ * To run a mutation, you first call `useDeleteInvitationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteInvitationMutation` 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 [deleteInvitationMutation, { data, loading, error }] = useDeleteInvitationMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useDeleteInvitationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteInvitationMutation, Types.DeleteInvitationMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteInvitationMutation, any, Apollo.ApolloCache>;
+export type DeleteInvitationMutationHookResult = ReturnType<typeof useDeleteInvitationMutation>;
+export type DeleteInvitationMutationResult = Apollo.MutationResult<Types.DeleteInvitationMutation>;
+export type DeleteInvitationMutationOptions = Apollo.BaseMutationOptions<Types.DeleteInvitationMutation, Types.DeleteInvitationMutationVariables>;
+export declare const BulkCreateInvitationsDocument: Apollo.DocumentNode;
+export type BulkCreateInvitationsMutationFn = Apollo.MutationFunction<Types.BulkCreateInvitationsMutation, Types.BulkCreateInvitationsMutationVariables>;
+/**
+ * __useBulkCreateInvitationsMutation__
+ *
+ * To run a mutation, you first call `useBulkCreateInvitationsMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useBulkCreateInvitationsMutation` 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 [bulkCreateInvitationsMutation, { data, loading, error }] = useBulkCreateInvitationsMutation({
+ *   variables: {
+ *      inputs: // value for 'inputs'
+ *   },
+ * });
+ */
+export declare function useBulkCreateInvitationsMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.BulkCreateInvitationsMutation, Types.BulkCreateInvitationsMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.BulkCreateInvitationsMutation, any, Apollo.ApolloCache>;
+export type BulkCreateInvitationsMutationHookResult = ReturnType<typeof useBulkCreateInvitationsMutation>;
+export type BulkCreateInvitationsMutationResult = Apollo.MutationResult<Types.BulkCreateInvitationsMutation>;
+export type BulkCreateInvitationsMutationOptions = Apollo.BaseMutationOptions<Types.BulkCreateInvitationsMutation, Types.BulkCreateInvitationsMutationVariables>;
+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 ArchiveProjectDocument: Apollo.DocumentNode;
+export type ArchiveProjectMutationFn = Apollo.MutationFunction<Types.ArchiveProjectMutation, Types.ArchiveProjectMutationVariables>;
+/**
+ * __useArchiveProjectMutation__
+ *
+ * To run a mutation, you first call `useArchiveProjectMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useArchiveProjectMutation` 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 [archiveProjectMutation, { data, loading, error }] = useArchiveProjectMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useArchiveProjectMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ArchiveProjectMutation, Types.ArchiveProjectMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ArchiveProjectMutation, any, Apollo.ApolloCache>;
+export type ArchiveProjectMutationHookResult = ReturnType<typeof useArchiveProjectMutation>;
+export type ArchiveProjectMutationResult = Apollo.MutationResult<Types.ArchiveProjectMutation>;
+export type ArchiveProjectMutationOptions = Apollo.BaseMutationOptions<Types.ArchiveProjectMutation, Types.ArchiveProjectMutationVariables>;
+export declare const UnarchiveProjectDocument: Apollo.DocumentNode;
+export type UnarchiveProjectMutationFn = Apollo.MutationFunction<Types.UnarchiveProjectMutation, Types.UnarchiveProjectMutationVariables>;
+/**
+ * __useUnarchiveProjectMutation__
+ *
+ * To run a mutation, you first call `useUnarchiveProjectMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUnarchiveProjectMutation` 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 [unarchiveProjectMutation, { data, loading, error }] = useUnarchiveProjectMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useUnarchiveProjectMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UnarchiveProjectMutation, Types.UnarchiveProjectMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UnarchiveProjectMutation, any, Apollo.ApolloCache>;
+export type UnarchiveProjectMutationHookResult = ReturnType<typeof useUnarchiveProjectMutation>;
+export type UnarchiveProjectMutationResult = Apollo.MutationResult<Types.UnarchiveProjectMutation>;
+export type UnarchiveProjectMutationOptions = Apollo.BaseMutationOptions<Types.UnarchiveProjectMutation, Types.UnarchiveProjectMutationVariables>;
+export declare const SwitchProjectDocument: Apollo.DocumentNode;
+export type SwitchProjectMutationFn = Apollo.MutationFunction<Types.SwitchProjectMutation, Types.SwitchProjectMutationVariables>;
+/**
+ * __useSwitchProjectMutation__
+ *
+ * To run a mutation, you first call `useSwitchProjectMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSwitchProjectMutation` 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 [switchProjectMutation, { data, loading, error }] = useSwitchProjectMutation({
+ *   variables: {
+ *      projectId: // value for 'projectId'
+ *   },
+ * });
+ */
+export declare function useSwitchProjectMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SwitchProjectMutation, Types.SwitchProjectMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.SwitchProjectMutation, any, Apollo.ApolloCache>;
+export type SwitchProjectMutationHookResult = ReturnType<typeof useSwitchProjectMutation>;
+export type SwitchProjectMutationResult = Apollo.MutationResult<Types.SwitchProjectMutation>;
+export type SwitchProjectMutationOptions = Apollo.BaseMutationOptions<Types.SwitchProjectMutation, Types.SwitchProjectMutationVariables>;
+export declare const TagProjectDocument: Apollo.DocumentNode;
+export type TagProjectMutationFn = Apollo.MutationFunction<Types.TagProjectMutation, Types.TagProjectMutationVariables>;
+/**
+ * __useTagProjectMutation__
+ *
+ * To run a mutation, you first call `useTagProjectMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useTagProjectMutation` 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 [tagProjectMutation, { data, loading, error }] = useTagProjectMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useTagProjectMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.TagProjectMutation, Types.TagProjectMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.TagProjectMutation, any, Apollo.ApolloCache>;
+export type TagProjectMutationHookResult = ReturnType<typeof useTagProjectMutation>;
+export type TagProjectMutationResult = Apollo.MutationResult<Types.TagProjectMutation>;
+export type TagProjectMutationOptions = Apollo.BaseMutationOptions<Types.TagProjectMutation, Types.TagProjectMutationVariables>;
+export declare const UntagProjectDocument: Apollo.DocumentNode;
+export type UntagProjectMutationFn = Apollo.MutationFunction<Types.UntagProjectMutation, Types.UntagProjectMutationVariables>;
+/**
+ * __useUntagProjectMutation__
+ *
+ * To run a mutation, you first call `useUntagProjectMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUntagProjectMutation` 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 [untagProjectMutation, { data, loading, error }] = useUntagProjectMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUntagProjectMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UntagProjectMutation, Types.UntagProjectMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UntagProjectMutation, any, Apollo.ApolloCache>;
+export type UntagProjectMutationHookResult = ReturnType<typeof useUntagProjectMutation>;
+export type UntagProjectMutationResult = Apollo.MutationResult<Types.UntagProjectMutation>;
+export type UntagProjectMutationOptions = Apollo.BaseMutationOptions<Types.UntagProjectMutation, Types.UntagProjectMutationVariables>;
+export declare const ReplaceProjectTagsDocument: Apollo.DocumentNode;
+export type ReplaceProjectTagsMutationFn = Apollo.MutationFunction<Types.ReplaceProjectTagsMutation, Types.ReplaceProjectTagsMutationVariables>;
+/**
+ * __useReplaceProjectTagsMutation__
+ *
+ * To run a mutation, you first call `useReplaceProjectTagsMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useReplaceProjectTagsMutation` 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 [replaceProjectTagsMutation, { data, loading, error }] = useReplaceProjectTagsMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useReplaceProjectTagsMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ReplaceProjectTagsMutation, Types.ReplaceProjectTagsMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ReplaceProjectTagsMutation, any, Apollo.ApolloCache>;
+export type ReplaceProjectTagsMutationHookResult = ReturnType<typeof useReplaceProjectTagsMutation>;
+export type ReplaceProjectTagsMutationResult = Apollo.MutationResult<Types.ReplaceProjectTagsMutation>;
+export type ReplaceProjectTagsMutationOptions = Apollo.BaseMutationOptions<Types.ReplaceProjectTagsMutation, Types.ReplaceProjectTagsMutationVariables>;
+export declare const CreateWorkspaceDocument: Apollo.DocumentNode;
+export type CreateWorkspaceMutationFn = Apollo.MutationFunction<Types.CreateWorkspaceMutation, Types.CreateWorkspaceMutationVariables>;
+/**
+ * __useCreateWorkspaceMutation__
+ *
+ * To run a mutation, you first call `useCreateWorkspaceMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateWorkspaceMutation` 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 [createWorkspaceMutation, { data, loading, error }] = useCreateWorkspaceMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateWorkspaceMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateWorkspaceMutation, Types.CreateWorkspaceMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateWorkspaceMutation, any, Apollo.ApolloCache>;
+export type CreateWorkspaceMutationHookResult = ReturnType<typeof useCreateWorkspaceMutation>;
+export type CreateWorkspaceMutationResult = Apollo.MutationResult<Types.CreateWorkspaceMutation>;
+export type CreateWorkspaceMutationOptions = Apollo.BaseMutationOptions<Types.CreateWorkspaceMutation, Types.CreateWorkspaceMutationVariables>;
+export declare const UpdateWorkspaceDocument: Apollo.DocumentNode;
+export type UpdateWorkspaceMutationFn = Apollo.MutationFunction<Types.UpdateWorkspaceMutation, Types.UpdateWorkspaceMutationVariables>;
+/**
+ * __useUpdateWorkspaceMutation__
+ *
+ * To run a mutation, you first call `useUpdateWorkspaceMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateWorkspaceMutation` 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 [updateWorkspaceMutation, { data, loading, error }] = useUpdateWorkspaceMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateWorkspaceMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateWorkspaceMutation, Types.UpdateWorkspaceMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateWorkspaceMutation, any, Apollo.ApolloCache>;
+export type UpdateWorkspaceMutationHookResult = ReturnType<typeof useUpdateWorkspaceMutation>;
+export type UpdateWorkspaceMutationResult = Apollo.MutationResult<Types.UpdateWorkspaceMutation>;
+export type UpdateWorkspaceMutationOptions = Apollo.BaseMutationOptions<Types.UpdateWorkspaceMutation, Types.UpdateWorkspaceMutationVariables>;
+export declare const DeleteWorkspaceDocument: Apollo.DocumentNode;
+export type DeleteWorkspaceMutationFn = Apollo.MutationFunction<Types.DeleteWorkspaceMutation, Types.DeleteWorkspaceMutationVariables>;
+/**
+ * __useDeleteWorkspaceMutation__
+ *
+ * To run a mutation, you first call `useDeleteWorkspaceMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteWorkspaceMutation` 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 [deleteWorkspaceMutation, { data, loading, error }] = useDeleteWorkspaceMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useDeleteWorkspaceMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteWorkspaceMutation, Types.DeleteWorkspaceMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteWorkspaceMutation, any, Apollo.ApolloCache>;
+export type DeleteWorkspaceMutationHookResult = ReturnType<typeof useDeleteWorkspaceMutation>;
+export type DeleteWorkspaceMutationResult = Apollo.MutationResult<Types.DeleteWorkspaceMutation>;
+export type DeleteWorkspaceMutationOptions = Apollo.BaseMutationOptions<Types.DeleteWorkspaceMutation, Types.DeleteWorkspaceMutationVariables>;
+export declare const ArchiveWorkspaceDocument: Apollo.DocumentNode;
+export type ArchiveWorkspaceMutationFn = Apollo.MutationFunction<Types.ArchiveWorkspaceMutation, Types.ArchiveWorkspaceMutationVariables>;
+/**
+ * __useArchiveWorkspaceMutation__
+ *
+ * To run a mutation, you first call `useArchiveWorkspaceMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useArchiveWorkspaceMutation` 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 [archiveWorkspaceMutation, { data, loading, error }] = useArchiveWorkspaceMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useArchiveWorkspaceMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ArchiveWorkspaceMutation, Types.ArchiveWorkspaceMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ArchiveWorkspaceMutation, any, Apollo.ApolloCache>;
+export type ArchiveWorkspaceMutationHookResult = ReturnType<typeof useArchiveWorkspaceMutation>;
+export type ArchiveWorkspaceMutationResult = Apollo.MutationResult<Types.ArchiveWorkspaceMutation>;
+export type ArchiveWorkspaceMutationOptions = Apollo.BaseMutationOptions<Types.ArchiveWorkspaceMutation, Types.ArchiveWorkspaceMutationVariables>;
+export declare const ReactivateWorkspaceDocument: Apollo.DocumentNode;
+export type ReactivateWorkspaceMutationFn = Apollo.MutationFunction<Types.ReactivateWorkspaceMutation, Types.ReactivateWorkspaceMutationVariables>;
+/**
+ * __useReactivateWorkspaceMutation__
+ *
+ * To run a mutation, you first call `useReactivateWorkspaceMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useReactivateWorkspaceMutation` 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 [reactivateWorkspaceMutation, { data, loading, error }] = useReactivateWorkspaceMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useReactivateWorkspaceMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ReactivateWorkspaceMutation, Types.ReactivateWorkspaceMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ReactivateWorkspaceMutation, any, Apollo.ApolloCache>;
+export type ReactivateWorkspaceMutationHookResult = ReturnType<typeof useReactivateWorkspaceMutation>;
+export type ReactivateWorkspaceMutationResult = Apollo.MutationResult<Types.ReactivateWorkspaceMutation>;
+export type ReactivateWorkspaceMutationOptions = Apollo.BaseMutationOptions<Types.ReactivateWorkspaceMutation, Types.ReactivateWorkspaceMutationVariables>;
+export declare const InitializeWorkspaceDocument: Apollo.DocumentNode;
+export type InitializeWorkspaceMutationFn = Apollo.MutationFunction<Types.InitializeWorkspaceMutation, Types.InitializeWorkspaceMutationVariables>;
+/**
+ * __useInitializeWorkspaceMutation__
+ *
+ * To run a mutation, you first call `useInitializeWorkspaceMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useInitializeWorkspaceMutation` 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 [initializeWorkspaceMutation, { data, loading, error }] = useInitializeWorkspaceMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useInitializeWorkspaceMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.InitializeWorkspaceMutation, Types.InitializeWorkspaceMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.InitializeWorkspaceMutation, any, Apollo.ApolloCache>;
+export type InitializeWorkspaceMutationHookResult = ReturnType<typeof useInitializeWorkspaceMutation>;
+export type InitializeWorkspaceMutationResult = Apollo.MutationResult<Types.InitializeWorkspaceMutation>;
+export type InitializeWorkspaceMutationOptions = Apollo.BaseMutationOptions<Types.InitializeWorkspaceMutation, Types.InitializeWorkspaceMutationVariables>;
+export declare const TagWorkspaceDocument: Apollo.DocumentNode;
+export type TagWorkspaceMutationFn = Apollo.MutationFunction<Types.TagWorkspaceMutation, Types.TagWorkspaceMutationVariables>;
+/**
+ * __useTagWorkspaceMutation__
+ *
+ * To run a mutation, you first call `useTagWorkspaceMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useTagWorkspaceMutation` 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 [tagWorkspaceMutation, { data, loading, error }] = useTagWorkspaceMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useTagWorkspaceMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.TagWorkspaceMutation, Types.TagWorkspaceMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.TagWorkspaceMutation, any, Apollo.ApolloCache>;
+export type TagWorkspaceMutationHookResult = ReturnType<typeof useTagWorkspaceMutation>;
+export type TagWorkspaceMutationResult = Apollo.MutationResult<Types.TagWorkspaceMutation>;
+export type TagWorkspaceMutationOptions = Apollo.BaseMutationOptions<Types.TagWorkspaceMutation, Types.TagWorkspaceMutationVariables>;
+export declare const UntagWorkspaceDocument: Apollo.DocumentNode;
+export type UntagWorkspaceMutationFn = Apollo.MutationFunction<Types.UntagWorkspaceMutation, Types.UntagWorkspaceMutationVariables>;
+/**
+ * __useUntagWorkspaceMutation__
+ *
+ * To run a mutation, you first call `useUntagWorkspaceMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUntagWorkspaceMutation` 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 [untagWorkspaceMutation, { data, loading, error }] = useUntagWorkspaceMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUntagWorkspaceMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UntagWorkspaceMutation, Types.UntagWorkspaceMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UntagWorkspaceMutation, any, Apollo.ApolloCache>;
+export type UntagWorkspaceMutationHookResult = ReturnType<typeof useUntagWorkspaceMutation>;
+export type UntagWorkspaceMutationResult = Apollo.MutationResult<Types.UntagWorkspaceMutation>;
+export type UntagWorkspaceMutationOptions = Apollo.BaseMutationOptions<Types.UntagWorkspaceMutation, Types.UntagWorkspaceMutationVariables>;
+export declare const ReplaceWorkspaceTagsDocument: Apollo.DocumentNode;
+export type ReplaceWorkspaceTagsMutationFn = Apollo.MutationFunction<Types.ReplaceWorkspaceTagsMutation, Types.ReplaceWorkspaceTagsMutationVariables>;
+/**
+ * __useReplaceWorkspaceTagsMutation__
+ *
+ * To run a mutation, you first call `useReplaceWorkspaceTagsMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useReplaceWorkspaceTagsMutation` 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 [replaceWorkspaceTagsMutation, { data, loading, error }] = useReplaceWorkspaceTagsMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useReplaceWorkspaceTagsMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ReplaceWorkspaceTagsMutation, Types.ReplaceWorkspaceTagsMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ReplaceWorkspaceTagsMutation, any, Apollo.ApolloCache>;
+export type ReplaceWorkspaceTagsMutationHookResult = ReturnType<typeof useReplaceWorkspaceTagsMutation>;
+export type ReplaceWorkspaceTagsMutationResult = Apollo.MutationResult<Types.ReplaceWorkspaceTagsMutation>;
+export type ReplaceWorkspaceTagsMutationOptions = Apollo.BaseMutationOptions<Types.ReplaceWorkspaceTagsMutation, Types.ReplaceWorkspaceTagsMutationVariables>;
+export declare const GetWorkspaceMembersDocument: Apollo.DocumentNode;
+/**
+ * __useGetWorkspaceMembersQuery__
+ *
+ * To run a query within a React component, call `useGetWorkspaceMembersQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkspaceMembersQuery` 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 } = useGetWorkspaceMembersQuery({
+ *   variables: {
+ *      workspaceId: // value for 'workspaceId'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useGetWorkspaceMembersQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetWorkspaceMembersQuery, Types.GetWorkspaceMembersQueryVariables> & ({
+    variables: Types.GetWorkspaceMembersQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetWorkspaceMembersQuery, Types.GetWorkspaceMembersQueryVariables, "empty" | "complete" | "streaming", Types.GetWorkspaceMembersQueryVariables>;
+export declare function useGetWorkspaceMembersLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetWorkspaceMembersQuery, Types.GetWorkspaceMembersQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetWorkspaceMembersQuery, Types.GetWorkspaceMembersQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetWorkspaceMembersSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkspaceMembersQuery, Types.GetWorkspaceMembersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkspaceMembersQuery, Types.GetWorkspaceMembersQueryVariables>;
+export declare function useGetWorkspaceMembersSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkspaceMembersQuery, Types.GetWorkspaceMembersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkspaceMembersQuery | undefined, Types.GetWorkspaceMembersQueryVariables>;
+export type GetWorkspaceMembersQueryHookResult = ReturnType<typeof useGetWorkspaceMembersQuery>;
+export type GetWorkspaceMembersLazyQueryHookResult = ReturnType<typeof useGetWorkspaceMembersLazyQuery>;
+export type GetWorkspaceMembersSuspenseQueryHookResult = ReturnType<typeof useGetWorkspaceMembersSuspenseQuery>;
+export type GetWorkspaceMembersQueryResult = Apollo.QueryResult<Types.GetWorkspaceMembersQuery, Types.GetWorkspaceMembersQueryVariables>;
+export declare const GetWorkspaceMemberDocument: Apollo.DocumentNode;
+/**
+ * __useGetWorkspaceMemberQuery__
+ *
+ * To run a query within a React component, call `useGetWorkspaceMemberQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkspaceMemberQuery` 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 } = useGetWorkspaceMemberQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetWorkspaceMemberQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetWorkspaceMemberQuery, Types.GetWorkspaceMemberQueryVariables> & ({
+    variables: Types.GetWorkspaceMemberQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetWorkspaceMemberQuery, Types.GetWorkspaceMemberQueryVariables, "empty" | "complete" | "streaming", Types.GetWorkspaceMemberQueryVariables>;
+export declare function useGetWorkspaceMemberLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetWorkspaceMemberQuery, Types.GetWorkspaceMemberQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetWorkspaceMemberQuery, Types.GetWorkspaceMemberQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetWorkspaceMemberSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkspaceMemberQuery, Types.GetWorkspaceMemberQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkspaceMemberQuery, Types.GetWorkspaceMemberQueryVariables>;
+export declare function useGetWorkspaceMemberSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkspaceMemberQuery, Types.GetWorkspaceMemberQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkspaceMemberQuery | undefined, Types.GetWorkspaceMemberQueryVariables>;
+export type GetWorkspaceMemberQueryHookResult = ReturnType<typeof useGetWorkspaceMemberQuery>;
+export type GetWorkspaceMemberLazyQueryHookResult = ReturnType<typeof useGetWorkspaceMemberLazyQuery>;
+export type GetWorkspaceMemberSuspenseQueryHookResult = ReturnType<typeof useGetWorkspaceMemberSuspenseQuery>;
+export type GetWorkspaceMemberQueryResult = Apollo.QueryResult<Types.GetWorkspaceMemberQuery, Types.GetWorkspaceMemberQueryVariables>;
+export declare const GetUserWorkspacesDocument: Apollo.DocumentNode;
+/**
+ * __useGetUserWorkspacesQuery__
+ *
+ * To run a query within a React component, call `useGetUserWorkspacesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetUserWorkspacesQuery` 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 } = useGetUserWorkspacesQuery({
+ *   variables: {
+ *      userId: // value for 'userId'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useGetUserWorkspacesQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetUserWorkspacesQuery, Types.GetUserWorkspacesQueryVariables> & ({
+    variables: Types.GetUserWorkspacesQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetUserWorkspacesQuery, Types.GetUserWorkspacesQueryVariables, "empty" | "complete" | "streaming", Types.GetUserWorkspacesQueryVariables>;
+export declare function useGetUserWorkspacesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetUserWorkspacesQuery, Types.GetUserWorkspacesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetUserWorkspacesQuery, Types.GetUserWorkspacesQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetUserWorkspacesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetUserWorkspacesQuery, Types.GetUserWorkspacesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetUserWorkspacesQuery, Types.GetUserWorkspacesQueryVariables>;
+export declare function useGetUserWorkspacesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetUserWorkspacesQuery, Types.GetUserWorkspacesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetUserWorkspacesQuery | undefined, Types.GetUserWorkspacesQueryVariables>;
+export type GetUserWorkspacesQueryHookResult = ReturnType<typeof useGetUserWorkspacesQuery>;
+export type GetUserWorkspacesLazyQueryHookResult = ReturnType<typeof useGetUserWorkspacesLazyQuery>;
+export type GetUserWorkspacesSuspenseQueryHookResult = ReturnType<typeof useGetUserWorkspacesSuspenseQuery>;
+export type GetUserWorkspacesQueryResult = Apollo.QueryResult<Types.GetUserWorkspacesQuery, Types.GetUserWorkspacesQueryVariables>;
+export declare const GetWorkspaceInvitationsDocument: Apollo.DocumentNode;
+/**
+ * __useGetWorkspaceInvitationsQuery__
+ *
+ * To run a query within a React component, call `useGetWorkspaceInvitationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkspaceInvitationsQuery` 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 } = useGetWorkspaceInvitationsQuery({
+ *   variables: {
+ *      status: // value for 'status'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useGetWorkspaceInvitationsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetWorkspaceInvitationsQuery, Types.GetWorkspaceInvitationsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetWorkspaceInvitationsQuery, Types.GetWorkspaceInvitationsQueryVariables, "empty" | "complete" | "streaming", Types.GetWorkspaceInvitationsQueryVariables>;
+export declare function useGetWorkspaceInvitationsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetWorkspaceInvitationsQuery, Types.GetWorkspaceInvitationsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetWorkspaceInvitationsQuery, Types.GetWorkspaceInvitationsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetWorkspaceInvitationsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkspaceInvitationsQuery, Types.GetWorkspaceInvitationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkspaceInvitationsQuery, Types.GetWorkspaceInvitationsQueryVariables>;
+export declare function useGetWorkspaceInvitationsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkspaceInvitationsQuery, Types.GetWorkspaceInvitationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkspaceInvitationsQuery | undefined, Types.GetWorkspaceInvitationsQueryVariables>;
+export type GetWorkspaceInvitationsQueryHookResult = ReturnType<typeof useGetWorkspaceInvitationsQuery>;
+export type GetWorkspaceInvitationsLazyQueryHookResult = ReturnType<typeof useGetWorkspaceInvitationsLazyQuery>;
+export type GetWorkspaceInvitationsSuspenseQueryHookResult = ReturnType<typeof useGetWorkspaceInvitationsSuspenseQuery>;
+export type GetWorkspaceInvitationsQueryResult = Apollo.QueryResult<Types.GetWorkspaceInvitationsQuery, Types.GetWorkspaceInvitationsQueryVariables>;
+export declare const GetInvitationDocument: Apollo.DocumentNode;
+/**
+ * __useGetInvitationQuery__
+ *
+ * To run a query within a React component, call `useGetInvitationQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetInvitationQuery` 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 } = useGetInvitationQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetInvitationQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetInvitationQuery, Types.GetInvitationQueryVariables> & ({
+    variables: Types.GetInvitationQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetInvitationQuery, Types.GetInvitationQueryVariables, "empty" | "complete" | "streaming", Types.GetInvitationQueryVariables>;
+export declare function useGetInvitationLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetInvitationQuery, Types.GetInvitationQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetInvitationQuery, Types.GetInvitationQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetInvitationSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetInvitationQuery, Types.GetInvitationQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetInvitationQuery, Types.GetInvitationQueryVariables>;
+export declare function useGetInvitationSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetInvitationQuery, Types.GetInvitationQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetInvitationQuery | undefined, Types.GetInvitationQueryVariables>;
+export type GetInvitationQueryHookResult = ReturnType<typeof useGetInvitationQuery>;
+export type GetInvitationLazyQueryHookResult = ReturnType<typeof useGetInvitationLazyQuery>;
+export type GetInvitationSuspenseQueryHookResult = ReturnType<typeof useGetInvitationSuspenseQuery>;
+export type GetInvitationQueryResult = Apollo.QueryResult<Types.GetInvitationQuery, Types.GetInvitationQueryVariables>;
+export declare const GetMyPendingInvitationsDocument: Apollo.DocumentNode;
+/**
+ * __useGetMyPendingInvitationsQuery__
+ *
+ * To run a query within a React component, call `useGetMyPendingInvitationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetMyPendingInvitationsQuery` 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 } = useGetMyPendingInvitationsQuery({
+ *   variables: {
+ *      email: // value for 'email'
+ *   },
+ * });
+ */
+export declare function useGetMyPendingInvitationsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetMyPendingInvitationsQuery, Types.GetMyPendingInvitationsQueryVariables> & ({
+    variables: Types.GetMyPendingInvitationsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetMyPendingInvitationsQuery, Types.GetMyPendingInvitationsQueryVariables, "empty" | "complete" | "streaming", Types.GetMyPendingInvitationsQueryVariables>;
+export declare function useGetMyPendingInvitationsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetMyPendingInvitationsQuery, Types.GetMyPendingInvitationsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetMyPendingInvitationsQuery, Types.GetMyPendingInvitationsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetMyPendingInvitationsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMyPendingInvitationsQuery, Types.GetMyPendingInvitationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMyPendingInvitationsQuery, Types.GetMyPendingInvitationsQueryVariables>;
+export declare function useGetMyPendingInvitationsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMyPendingInvitationsQuery, Types.GetMyPendingInvitationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMyPendingInvitationsQuery | undefined, Types.GetMyPendingInvitationsQueryVariables>;
+export type GetMyPendingInvitationsQueryHookResult = ReturnType<typeof useGetMyPendingInvitationsQuery>;
+export type GetMyPendingInvitationsLazyQueryHookResult = ReturnType<typeof useGetMyPendingInvitationsLazyQuery>;
+export type GetMyPendingInvitationsSuspenseQueryHookResult = ReturnType<typeof useGetMyPendingInvitationsSuspenseQuery>;
+export type GetMyPendingInvitationsQueryResult = Apollo.QueryResult<Types.GetMyPendingInvitationsQuery, Types.GetMyPendingInvitationsQueryVariables>;
+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: {
+ *      filter: // value for 'filter'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useGetProjectsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetProjectsQuery, Types.GetProjectsQueryVariables>): 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 GetMyProjectsDocument: Apollo.DocumentNode;
+/**
+ * __useGetMyProjectsQuery__
+ *
+ * To run a query within a React component, call `useGetMyProjectsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetMyProjectsQuery` 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 } = useGetMyProjectsQuery({
+ *   variables: {
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useGetMyProjectsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetMyProjectsQuery, Types.GetMyProjectsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetMyProjectsQuery, Types.GetMyProjectsQueryVariables, "empty" | "complete" | "streaming", Types.GetMyProjectsQueryVariables>;
+export declare function useGetMyProjectsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetMyProjectsQuery, Types.GetMyProjectsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetMyProjectsQuery, Types.GetMyProjectsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetMyProjectsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMyProjectsQuery, Types.GetMyProjectsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMyProjectsQuery, Types.GetMyProjectsQueryVariables>;
+export declare function useGetMyProjectsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMyProjectsQuery, Types.GetMyProjectsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMyProjectsQuery | undefined, Types.GetMyProjectsQueryVariables>;
+export type GetMyProjectsQueryHookResult = ReturnType<typeof useGetMyProjectsQuery>;
+export type GetMyProjectsLazyQueryHookResult = ReturnType<typeof useGetMyProjectsLazyQuery>;
+export type GetMyProjectsSuspenseQueryHookResult = ReturnType<typeof useGetMyProjectsSuspenseQuery>;
+export type GetMyProjectsQueryResult = Apollo.QueryResult<Types.GetMyProjectsQuery, Types.GetMyProjectsQueryVariables>;
+export declare const GetProjectTagsDocument: Apollo.DocumentNode;
+/**
+ * __useGetProjectTagsQuery__
+ *
+ * To run a query within a React component, call `useGetProjectTagsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetProjectTagsQuery` 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 } = useGetProjectTagsQuery({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useGetProjectTagsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetProjectTagsQuery, Types.GetProjectTagsQueryVariables> & ({
+    variables: Types.GetProjectTagsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetProjectTagsQuery, Types.GetProjectTagsQueryVariables, "empty" | "complete" | "streaming", Types.GetProjectTagsQueryVariables>;
+export declare function useGetProjectTagsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetProjectTagsQuery, Types.GetProjectTagsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetProjectTagsQuery, Types.GetProjectTagsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetProjectTagsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProjectTagsQuery, Types.GetProjectTagsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProjectTagsQuery, Types.GetProjectTagsQueryVariables>;
+export declare function useGetProjectTagsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetProjectTagsQuery, Types.GetProjectTagsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetProjectTagsQuery | undefined, Types.GetProjectTagsQueryVariables>;
+export type GetProjectTagsQueryHookResult = ReturnType<typeof useGetProjectTagsQuery>;
+export type GetProjectTagsLazyQueryHookResult = ReturnType<typeof useGetProjectTagsLazyQuery>;
+export type GetProjectTagsSuspenseQueryHookResult = ReturnType<typeof useGetProjectTagsSuspenseQuery>;
+export type GetProjectTagsQueryResult = Apollo.QueryResult<Types.GetProjectTagsQuery, Types.GetProjectTagsQueryVariables>;
+export declare const GetWorkspacesDocument: Apollo.DocumentNode;
+/**
+ * __useGetWorkspacesQuery__
+ *
+ * To run a query within a React component, call `useGetWorkspacesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkspacesQuery` 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 } = useGetWorkspacesQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useGetWorkspacesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetWorkspacesQuery, Types.GetWorkspacesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetWorkspacesQuery, Types.GetWorkspacesQueryVariables, "empty" | "complete" | "streaming", Types.GetWorkspacesQueryVariables>;
+export declare function useGetWorkspacesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetWorkspacesQuery, Types.GetWorkspacesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetWorkspacesQuery, Types.GetWorkspacesQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetWorkspacesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkspacesQuery, Types.GetWorkspacesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkspacesQuery, Types.GetWorkspacesQueryVariables>;
+export declare function useGetWorkspacesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkspacesQuery, Types.GetWorkspacesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkspacesQuery | undefined, Types.GetWorkspacesQueryVariables>;
+export type GetWorkspacesQueryHookResult = ReturnType<typeof useGetWorkspacesQuery>;
+export type GetWorkspacesLazyQueryHookResult = ReturnType<typeof useGetWorkspacesLazyQuery>;
+export type GetWorkspacesSuspenseQueryHookResult = ReturnType<typeof useGetWorkspacesSuspenseQuery>;
+export type GetWorkspacesQueryResult = Apollo.QueryResult<Types.GetWorkspacesQuery, Types.GetWorkspacesQueryVariables>;
+export declare const GetWorkspaceDocument: Apollo.DocumentNode;
+/**
+ * __useGetWorkspaceQuery__
+ *
+ * To run a query within a React component, call `useGetWorkspaceQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkspaceQuery` 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 } = useGetWorkspaceQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetWorkspaceQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetWorkspaceQuery, Types.GetWorkspaceQueryVariables> & ({
+    variables: Types.GetWorkspaceQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetWorkspaceQuery, Types.GetWorkspaceQueryVariables, "empty" | "complete" | "streaming", Types.GetWorkspaceQueryVariables>;
+export declare function useGetWorkspaceLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetWorkspaceQuery, Types.GetWorkspaceQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetWorkspaceQuery, Types.GetWorkspaceQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetWorkspaceSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkspaceQuery, Types.GetWorkspaceQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkspaceQuery, Types.GetWorkspaceQueryVariables>;
+export declare function useGetWorkspaceSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkspaceQuery, Types.GetWorkspaceQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkspaceQuery | undefined, Types.GetWorkspaceQueryVariables>;
+export type GetWorkspaceQueryHookResult = ReturnType<typeof useGetWorkspaceQuery>;
+export type GetWorkspaceLazyQueryHookResult = ReturnType<typeof useGetWorkspaceLazyQuery>;
+export type GetWorkspaceSuspenseQueryHookResult = ReturnType<typeof useGetWorkspaceSuspenseQuery>;
+export type GetWorkspaceQueryResult = Apollo.QueryResult<Types.GetWorkspaceQuery, Types.GetWorkspaceQueryVariables>;
+export declare const GetMyWorkspacesDocument: Apollo.DocumentNode;
+/**
+ * __useGetMyWorkspacesQuery__
+ *
+ * To run a query within a React component, call `useGetMyWorkspacesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetMyWorkspacesQuery` 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 } = useGetMyWorkspacesQuery({
+ *   variables: {
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useGetMyWorkspacesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetMyWorkspacesQuery, Types.GetMyWorkspacesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetMyWorkspacesQuery, Types.GetMyWorkspacesQueryVariables, "empty" | "complete" | "streaming", Types.GetMyWorkspacesQueryVariables>;
+export declare function useGetMyWorkspacesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetMyWorkspacesQuery, Types.GetMyWorkspacesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetMyWorkspacesQuery, Types.GetMyWorkspacesQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetMyWorkspacesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMyWorkspacesQuery, Types.GetMyWorkspacesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMyWorkspacesQuery, Types.GetMyWorkspacesQueryVariables>;
+export declare function useGetMyWorkspacesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMyWorkspacesQuery, Types.GetMyWorkspacesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMyWorkspacesQuery | undefined, Types.GetMyWorkspacesQueryVariables>;
+export type GetMyWorkspacesQueryHookResult = ReturnType<typeof useGetMyWorkspacesQuery>;
+export type GetMyWorkspacesLazyQueryHookResult = ReturnType<typeof useGetMyWorkspacesLazyQuery>;
+export type GetMyWorkspacesSuspenseQueryHookResult = ReturnType<typeof useGetMyWorkspacesSuspenseQuery>;
+export type GetMyWorkspacesQueryResult = Apollo.QueryResult<Types.GetMyWorkspacesQuery, Types.GetMyWorkspacesQueryVariables>;
+export declare const GetWorkspaceTagsDocument: Apollo.DocumentNode;
+/**
+ * __useGetWorkspaceTagsQuery__
+ *
+ * To run a query within a React component, call `useGetWorkspaceTagsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkspaceTagsQuery` 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 } = useGetWorkspaceTagsQuery({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useGetWorkspaceTagsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetWorkspaceTagsQuery, Types.GetWorkspaceTagsQueryVariables> & ({
+    variables: Types.GetWorkspaceTagsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetWorkspaceTagsQuery, Types.GetWorkspaceTagsQueryVariables, "empty" | "complete" | "streaming", Types.GetWorkspaceTagsQueryVariables>;
+export declare function useGetWorkspaceTagsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetWorkspaceTagsQuery, Types.GetWorkspaceTagsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetWorkspaceTagsQuery, Types.GetWorkspaceTagsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetWorkspaceTagsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkspaceTagsQuery, Types.GetWorkspaceTagsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkspaceTagsQuery, Types.GetWorkspaceTagsQueryVariables>;
+export declare function useGetWorkspaceTagsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkspaceTagsQuery, Types.GetWorkspaceTagsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkspaceTagsQuery | undefined, Types.GetWorkspaceTagsQueryVariables>;
+export type GetWorkspaceTagsQueryHookResult = ReturnType<typeof useGetWorkspaceTagsQuery>;
+export type GetWorkspaceTagsLazyQueryHookResult = ReturnType<typeof useGetWorkspaceTagsLazyQuery>;
+export type GetWorkspaceTagsSuspenseQueryHookResult = ReturnType<typeof useGetWorkspaceTagsSuspenseQuery>;
+export type GetWorkspaceTagsQueryResult = Apollo.QueryResult<Types.GetWorkspaceTagsQuery, Types.GetWorkspaceTagsQueryVariables>;
+//# sourceMappingURL=wspace-operations.d.ts.map