@burdenoff/microfe-organization 2026.1101.1 → 2026.1101.3

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

@@ -0,0 +1,1845 @@
+import * as Types from './global-types';
+import * as Apollo from '@apollo/client';
+import * as ApolloReactHooks from '@apollo/client/react';
+export type MyOrganizationInviteListItemFragment = {
+    __typename?: 'OrganizationInvite';
+    id: string;
+    organizationId: string;
+    email: string;
+    role: Types.UserRole;
+    status: Types.InviteStatus;
+    invitedBy: string;
+    expiresAt: string;
+    message?: string | null;
+    createdAt: string;
+    organization: {
+        __typename?: 'Organization';
+        id: string;
+        name: string;
+        slug: string;
+    };
+};
+export type OrganizationInviteListItemFragment = {
+    __typename?: 'OrganizationInvite';
+    id: string;
+    organizationId: string;
+    email: string;
+    role: Types.UserRole;
+    status: Types.InviteStatus;
+    invitedBy: string;
+    expiresAt: string;
+    message?: string | null;
+    createdAt: string;
+};
+export type AcceptOrganizationInviteMutationVariables = Types.Exact<{
+    inviteId: Types.Scalars['ID']['input'];
+}>;
+export type AcceptOrganizationInviteMutation = {
+    __typename?: 'Mutation';
+    acceptOrganizationInvite: {
+        __typename?: 'OrganizationMember';
+        id: string;
+        userId: string;
+        organizationId: string;
+        role: Types.UserRole;
+        joinedAt: string;
+    };
+};
+export type CancelOrganizationInviteMutationVariables = Types.Exact<{
+    inviteId: Types.Scalars['ID']['input'];
+}>;
+export type CancelOrganizationInviteMutation = {
+    __typename?: 'Mutation';
+    cancelOrganizationInvite: {
+        __typename?: 'OrganizationInvite';
+        id: string;
+        status: Types.InviteStatus;
+    };
+};
+export type InviteOrganizationMemberMutationVariables = Types.Exact<{
+    input: Types.InviteOrganizationMemberInput;
+}>;
+export type InviteOrganizationMemberMutation = {
+    __typename?: 'Mutation';
+    inviteOrganizationMember: {
+        __typename?: 'OrganizationInvite';
+        id: string;
+        organizationId: string;
+        email: string;
+        role: Types.UserRole;
+        status: Types.InviteStatus;
+        invitedBy: string;
+        expiresAt: string;
+        message?: string | null;
+        createdAt: string;
+    };
+};
+export type RejectOrganizationInviteMutationVariables = Types.Exact<{
+    inviteId: Types.Scalars['ID']['input'];
+}>;
+export type RejectOrganizationInviteMutation = {
+    __typename?: 'Mutation';
+    rejectOrganizationInvite: {
+        __typename?: 'OrganizationInvite';
+        id: string;
+        status: Types.InviteStatus;
+        respondedAt?: string | null;
+    };
+};
+export type ResendOrganizationInviteMutationVariables = Types.Exact<{
+    inviteId: Types.Scalars['ID']['input'];
+}>;
+export type ResendOrganizationInviteMutation = {
+    __typename?: 'Mutation';
+    resendOrganizationInvite: {
+        __typename?: 'OrganizationInvite';
+        id: string;
+        status: Types.InviteStatus;
+        expiresAt: string;
+    };
+};
+export type GetMyOrganizationInviteQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetMyOrganizationInviteQuery = {
+    __typename?: 'Query';
+    myOrganizationInvite?: {
+        __typename?: 'OrganizationInvite';
+        id: string;
+        organizationId: string;
+        email: string;
+        role: Types.UserRole;
+        status: Types.InviteStatus;
+        invitedBy: string;
+        expiresAt: string;
+        message?: string | null;
+        createdAt: string;
+        organization: {
+            __typename?: 'Organization';
+            id: string;
+            name: string;
+            slug: string;
+        };
+    } | null;
+};
+export type GetMyOrganizationInvitesQueryVariables = Types.Exact<{
+    status?: Types.InputMaybe<Types.InviteStatus>;
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type GetMyOrganizationInvitesQuery = {
+    __typename?: 'Query';
+    myOrganizationInvites: {
+        __typename?: 'OrganizationInviteList';
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'OrganizationInvite';
+            id: string;
+            organizationId: string;
+            email: string;
+            role: Types.UserRole;
+            status: Types.InviteStatus;
+            invitedBy: string;
+            expiresAt: string;
+            message?: string | null;
+            createdAt: string;
+            organization: {
+                __typename?: 'Organization';
+                id: string;
+                name: string;
+                slug: string;
+            };
+        }>;
+    };
+};
+export type GetOrganizationInvitesQueryVariables = Types.Exact<{
+    organizationId: Types.Scalars['String']['input'];
+    filter?: Types.InputMaybe<Types.OrganizationInviteFilterInput>;
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type GetOrganizationInvitesQuery = {
+    __typename?: 'Query';
+    organizationInvites: {
+        __typename?: 'OrganizationInviteList';
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'OrganizationInvite';
+            id: string;
+            organizationId: string;
+            email: string;
+            role: Types.UserRole;
+            status: Types.InviteStatus;
+            invitedBy: string;
+            expiresAt: string;
+            message?: string | null;
+            createdAt: string;
+        }>;
+    };
+};
+export type AddOrganizationMemberMutationVariables = Types.Exact<{
+    input: Types.AddOrganizationMemberInput;
+}>;
+export type AddOrganizationMemberMutation = {
+    __typename?: 'Mutation';
+    addOrganizationMember: {
+        __typename?: 'OrganizationMember';
+        id: string;
+        userId: string;
+        organizationId: string;
+        role: Types.UserRole;
+        invitedBy?: string | null;
+        joinedAt: string;
+    };
+};
+export type RemoveOrganizationMemberMutationVariables = Types.Exact<{
+    organizationId: Types.Scalars['String']['input'];
+    userId: Types.Scalars['String']['input'];
+}>;
+export type RemoveOrganizationMemberMutation = {
+    __typename?: 'Mutation';
+    removeOrganizationMember: boolean;
+};
+export type UpdateOrganizationMemberMutationVariables = Types.Exact<{
+    organizationId: Types.Scalars['String']['input'];
+    userId: Types.Scalars['String']['input'];
+    input: Types.UpdateOrganizationMemberInput;
+}>;
+export type UpdateOrganizationMemberMutation = {
+    __typename?: 'Mutation';
+    updateOrganizationMember: {
+        __typename?: 'OrganizationMember';
+        id: string;
+        userId: string;
+        organizationId: string;
+        role: Types.UserRole;
+        invitedBy?: string | null;
+        joinedAt: string;
+    };
+};
+export type GetMemberQueryVariables = Types.Exact<{
+    organizationId: Types.Scalars['String']['input'];
+}>;
+export type GetMemberQuery = {
+    __typename?: 'Query';
+    organizationMembers: {
+        __typename?: 'OrganizationMemberList';
+        total: number;
+        items: Array<{
+            __typename?: 'OrganizationMember';
+            id: string;
+            userId: string;
+            organizationId: string;
+            role: Types.UserRole;
+            invitedBy?: string | null;
+            joinedAt: string;
+        }>;
+    };
+};
+export type GetMemberByEmailQueryVariables = Types.Exact<{
+    organizationId: Types.Scalars['String']['input'];
+}>;
+export type GetMemberByEmailQuery = {
+    __typename?: 'Query';
+    organizationMembers: {
+        __typename?: 'OrganizationMemberList';
+        total: number;
+        items: Array<{
+            __typename?: 'OrganizationMember';
+            id: string;
+            userId: string;
+            organizationId: string;
+            role: Types.UserRole;
+            invitedBy?: string | null;
+            joinedAt: string;
+        }>;
+    };
+};
+export type GetMembersQueryVariables = Types.Exact<{
+    organizationId: Types.Scalars['String']['input'];
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type GetMembersQuery = {
+    __typename?: 'Query';
+    organizationMembers: {
+        __typename?: 'OrganizationMemberList';
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'OrganizationMember';
+            id: string;
+            userId: string;
+            organizationId: string;
+            role: Types.UserRole;
+            invitedBy?: string | null;
+            joinedAt: string;
+        }>;
+    };
+};
+export type GetMembersByContextQueryVariables = Types.Exact<{
+    organizationId: Types.Scalars['String']['input'];
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type GetMembersByContextQuery = {
+    __typename?: 'Query';
+    organizationMembers: {
+        __typename?: 'OrganizationMemberList';
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'OrganizationMember';
+            id: string;
+            userId: string;
+            organizationId: string;
+            role: Types.UserRole;
+            invitedBy?: string | null;
+            joinedAt: string;
+        }>;
+    };
+};
+export type OrganizationDetailsFragment = {
+    __typename?: 'Organization';
+    id: string;
+    tenantId: string;
+    name: string;
+    slug: string;
+    description?: string | null;
+    logo?: string | null;
+    website?: string | null;
+    status: string;
+    createdAt: string;
+    updatedAt: string;
+    memberCount: number;
+    workspaceCount: number;
+};
+export type OrganizationListItemFragment = {
+    __typename?: 'Organization';
+    id: string;
+    name: string;
+    slug: string;
+    logo?: string | null;
+    status: string;
+    workspaceCount: number;
+    createdAt: string;
+};
+export type CreateOrganizationMutationVariables = Types.Exact<{
+    input: Types.CreateOrganizationInput;
+}>;
+export type CreateOrganizationMutation = {
+    __typename?: 'Mutation';
+    createOrganization: {
+        __typename?: 'Organization';
+        id: string;
+        tenantId: string;
+        name: string;
+        slug: string;
+        description?: string | null;
+        logo?: string | null;
+        status: string;
+        metadata?: Record<string, unknown> | null;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type DeleteOrganizationMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type DeleteOrganizationMutation = {
+    __typename?: 'Mutation';
+    deleteOrganization: boolean;
+};
+export type UpdateOrganizationMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.UpdateOrganizationInput;
+}>;
+export type UpdateOrganizationMutation = {
+    __typename?: 'Mutation';
+    updateOrganization: {
+        __typename?: 'Organization';
+        id: string;
+        tenantId: string;
+        name: string;
+        slug: string;
+        description?: string | null;
+        logo?: string | null;
+        status: string;
+        metadata?: Record<string, unknown> | null;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type GetMyOrganizationsQueryVariables = Types.Exact<{
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type GetMyOrganizationsQuery = {
+    __typename?: 'Query';
+    myOrganizations: {
+        __typename?: 'OrganizationList';
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'Organization';
+            id: string;
+            name: string;
+            slug: string;
+            logo?: string | null;
+            status: string;
+            workspaceCount: number;
+            createdAt: string;
+        }>;
+    };
+};
+export type GetOrganizationQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetOrganizationQuery = {
+    __typename?: 'Query';
+    organization?: {
+        __typename?: 'Organization';
+        id: string;
+        tenantId: string;
+        name: string;
+        slug: string;
+        description?: string | null;
+        logo?: string | null;
+        website?: string | null;
+        status: string;
+        createdAt: string;
+        updatedAt: string;
+        memberCount: number;
+        workspaceCount: number;
+    } | null;
+};
+export type GetOrganizationBySlugQueryVariables = Types.Exact<{
+    tenantId: Types.Scalars['String']['input'];
+    slug: Types.Scalars['String']['input'];
+}>;
+export type GetOrganizationBySlugQuery = {
+    __typename?: 'Query';
+    organizationBySlug?: {
+        __typename?: 'Organization';
+        id: string;
+        tenantId: string;
+        name: string;
+        slug: string;
+        description?: string | null;
+        logo?: string | null;
+        status: string;
+        metadata?: Record<string, unknown> | null;
+        createdAt: string;
+        updatedAt: string;
+        memberCount: number;
+    } | null;
+};
+export type GetOrganizationsQueryVariables = Types.Exact<{
+    filter?: Types.InputMaybe<Types.OrganizationFilterInput>;
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type GetOrganizationsQuery = {
+    __typename?: 'Query';
+    allOrganizations: {
+        __typename?: 'OrganizationList';
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'Organization';
+            id: string;
+            name: string;
+            slug: string;
+            logo?: string | null;
+            status: string;
+            workspaceCount: number;
+            createdAt: string;
+        }>;
+    };
+};
+export type GetOrganizationsByTenantQueryVariables = Types.Exact<{
+    tenantId: Types.Scalars['String']['input'];
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type GetOrganizationsByTenantQuery = {
+    __typename?: 'Query';
+    allOrganizations: {
+        __typename?: 'OrganizationList';
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'Organization';
+            id: string;
+            tenantId: string;
+            name: string;
+            slug: string;
+            description?: string | null;
+            logo?: string | null;
+            status: string;
+            metadata?: Record<string, unknown> | null;
+            createdAt: string;
+            updatedAt: string;
+            memberCount: number;
+        }>;
+    };
+};
+export type CheckRbacPermissionsQueryVariables = Types.Exact<{
+    inputs: Array<Types.PermissionCheckInput> | Types.PermissionCheckInput;
+}>;
+export type CheckRbacPermissionsQuery = {
+    __typename?: 'Query';
+    checkPermissions: Array<{
+        __typename?: 'PermissionCheckResult';
+        allowed: boolean;
+        decisionPath: string;
+    }>;
+};
+export type ActivateWorkspaceMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type ActivateWorkspaceMutation = {
+    __typename?: 'Mutation';
+    activateWorkspace: {
+        __typename?: 'Workspace';
+        id: string;
+        status: Types.WorkspaceStatus;
+        updatedAt: string;
+    };
+};
+export type AddWorkspaceMemberMutationVariables = Types.Exact<{
+    input: Types.AddWorkspaceMemberInput;
+}>;
+export type AddWorkspaceMemberMutation = {
+    __typename?: 'Mutation';
+    addWorkspaceMember: {
+        __typename?: 'WorkspaceMember';
+        id: string;
+        userId: string;
+        role: Types.UserRole;
+        invitedBy?: string | null;
+        joinedAt: string;
+    };
+};
+export type ArchiveWorkspaceMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type ArchiveWorkspaceMutation = {
+    __typename?: 'Mutation';
+    archiveWorkspace: {
+        __typename?: 'Workspace';
+        id: string;
+        status: Types.WorkspaceStatus;
+        updatedAt: string;
+    };
+};
+export type CreateWorkspaceMutationVariables = Types.Exact<{
+    input: Types.CreateWorkspaceInput;
+}>;
+export type CreateWorkspaceMutation = {
+    __typename?: 'Mutation';
+    createWorkspace: {
+        __typename?: 'Workspace';
+        id: string;
+        organizationId?: string | null;
+        tenantId: string;
+        name: string;
+        slug: string;
+        status: Types.WorkspaceStatus;
+        type: Types.WorkspaceType;
+        metadata?: Record<string, unknown> | null;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type RemoveWorkspaceMemberMutationVariables = Types.Exact<{
+    workspaceId: Types.Scalars['String']['input'];
+    userId: Types.Scalars['String']['input'];
+}>;
+export type RemoveWorkspaceMemberMutation = {
+    __typename?: 'Mutation';
+    removeWorkspaceMember: boolean;
+};
+export type SuspendWorkspaceMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type SuspendWorkspaceMutation = {
+    __typename?: 'Mutation';
+    suspendWorkspace: {
+        __typename?: 'Workspace';
+        id: string;
+        status: Types.WorkspaceStatus;
+        updatedAt: string;
+    };
+};
+export type UpdateWorkspaceMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.UpdateWorkspaceInput;
+}>;
+export type UpdateWorkspaceMutation = {
+    __typename?: 'Mutation';
+    updateWorkspace: {
+        __typename?: 'Workspace';
+        id: string;
+        organizationId?: string | null;
+        tenantId: string;
+        name: string;
+        slug: string;
+        status: Types.WorkspaceStatus;
+        type: Types.WorkspaceType;
+        metadata?: Record<string, unknown> | null;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type GetMyWorkspacesQueryVariables = Types.Exact<{
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type GetMyWorkspacesQuery = {
+    __typename?: 'Query';
+    myWorkspaces: {
+        __typename?: 'WorkspaceList';
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'Workspace';
+            id: string;
+            organizationId?: string | null;
+            tenantId: string;
+            name: string;
+            slug: string;
+            status: Types.WorkspaceStatus;
+            type: Types.WorkspaceType;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+};
+export type GetTenantsQueryVariables = Types.Exact<{
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type GetTenantsQuery = {
+    __typename?: 'Query';
+    myTenants: {
+        __typename?: 'TenantList';
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'Tenant';
+            id: string;
+            name: string;
+            slug: string;
+            status: Types.TenantStatus;
+            type: Types.TenantType;
+        }>;
+    };
+};
+export type GetWorkspaceQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetWorkspaceQuery = {
+    __typename?: 'Query';
+    workspace?: {
+        __typename?: 'Workspace';
+        id: string;
+        organizationId?: string | null;
+        tenantId: string;
+        name: string;
+        slug: string;
+        status: Types.WorkspaceStatus;
+        type: Types.WorkspaceType;
+        metadata?: Record<string, unknown> | null;
+        memberCount: number;
+        endpoint?: string | null;
+        region?: string | null;
+        createdAt: string;
+        updatedAt: string;
+    } | null;
+};
+export type GetWorkspaceBySlugQueryVariables = Types.Exact<{
+    tenantId: Types.Scalars['String']['input'];
+    slug: Types.Scalars['String']['input'];
+}>;
+export type GetWorkspaceBySlugQuery = {
+    __typename?: 'Query';
+    workspaceBySlug?: {
+        __typename?: 'Workspace';
+        id: string;
+        organizationId?: string | null;
+        tenantId: string;
+        name: string;
+        slug: string;
+        status: Types.WorkspaceStatus;
+        type: Types.WorkspaceType;
+        metadata?: Record<string, unknown> | null;
+        memberCount: number;
+        createdAt: string;
+        updatedAt: string;
+    } | null;
+};
+export type GetWorkspaceMemberQueryVariables = Types.Exact<{
+    userId: Types.Scalars['String']['input'];
+    workspaceId: Types.Scalars['String']['input'];
+}>;
+export type GetWorkspaceMemberQuery = {
+    __typename?: 'Query';
+    workspaceMembers: {
+        __typename?: 'WorkspaceMemberList';
+        total: number;
+        items: Array<{
+            __typename?: 'WorkspaceMember';
+            id: string;
+            userId: string;
+            role: Types.UserRole;
+            invitedBy?: string | null;
+            joinedAt: string;
+        }>;
+    };
+};
+export type GetWorkspaceMembersQueryVariables = Types.Exact<{
+    workspaceId: Types.Scalars['String']['input'];
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type GetWorkspaceMembersQuery = {
+    __typename?: 'Query';
+    workspaceMembers: {
+        __typename?: 'WorkspaceMemberList';
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'WorkspaceMember';
+            id: string;
+            userId: string;
+            role: Types.UserRole;
+            invitedBy?: string | null;
+            joinedAt: string;
+        }>;
+    };
+};
+export type GetWorkspacesQueryVariables = Types.Exact<{
+    filter?: Types.InputMaybe<Types.WorkspaceFilterInput>;
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type GetWorkspacesQuery = {
+    __typename?: 'Query';
+    allWorkspaces: {
+        __typename?: 'WorkspaceList';
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'Workspace';
+            id: string;
+            organizationId?: string | null;
+            tenantId: string;
+            name: string;
+            slug: string;
+            status: Types.WorkspaceStatus;
+            type: Types.WorkspaceType;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+};
+export type GetWorkspacesByOrganizationQueryVariables = Types.Exact<{
+    organizationId: Types.Scalars['String']['input'];
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type GetWorkspacesByOrganizationQuery = {
+    __typename?: 'Query';
+    allWorkspaces: {
+        __typename?: 'WorkspaceList';
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        items: Array<{
+            __typename?: 'Workspace';
+            id: string;
+            name: string;
+            slug: string;
+            status: Types.WorkspaceStatus;
+            type: Types.WorkspaceType;
+            memberCount: number;
+            createdAt: string;
+        }>;
+    };
+};
+export declare const MyOrganizationInviteListItemFragmentDoc: Apollo.DocumentNode;
+export declare const OrganizationInviteListItemFragmentDoc: Apollo.DocumentNode;
+export declare const OrganizationDetailsFragmentDoc: Apollo.DocumentNode;
+export declare const OrganizationListItemFragmentDoc: Apollo.DocumentNode;
+export declare const AcceptOrganizationInviteDocument: Apollo.DocumentNode;
+export type AcceptOrganizationInviteMutationFn = Apollo.MutationFunction<Types.AcceptOrganizationInviteMutation, Types.AcceptOrganizationInviteMutationVariables>;
+/**
+ * __useAcceptOrganizationInviteMutation__
+ *
+ * To run a mutation, you first call `useAcceptOrganizationInviteMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAcceptOrganizationInviteMutation` 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 [acceptOrganizationInviteMutation, { data, loading, error }] = useAcceptOrganizationInviteMutation({
+ *   variables: {
+ *      inviteId: // value for 'inviteId'
+ *   },
+ * });
+ */
+export declare function useAcceptOrganizationInviteMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AcceptOrganizationInviteMutation, Types.AcceptOrganizationInviteMutationVariables>): Apollo.MutationTuple<Types.AcceptOrganizationInviteMutation, Types.AcceptOrganizationInviteMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type AcceptOrganizationInviteMutationHookResult = ReturnType<typeof useAcceptOrganizationInviteMutation>;
+export type AcceptOrganizationInviteMutationResult = Apollo.MutationResult<Types.AcceptOrganizationInviteMutation>;
+export type AcceptOrganizationInviteMutationOptions = Apollo.BaseMutationOptions<Types.AcceptOrganizationInviteMutation, Types.AcceptOrganizationInviteMutationVariables>;
+export declare const CancelOrganizationInviteDocument: Apollo.DocumentNode;
+export type CancelOrganizationInviteMutationFn = Apollo.MutationFunction<Types.CancelOrganizationInviteMutation, Types.CancelOrganizationInviteMutationVariables>;
+/**
+ * __useCancelOrganizationInviteMutation__
+ *
+ * To run a mutation, you first call `useCancelOrganizationInviteMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCancelOrganizationInviteMutation` 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 [cancelOrganizationInviteMutation, { data, loading, error }] = useCancelOrganizationInviteMutation({
+ *   variables: {
+ *      inviteId: // value for 'inviteId'
+ *   },
+ * });
+ */
+export declare function useCancelOrganizationInviteMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CancelOrganizationInviteMutation, Types.CancelOrganizationInviteMutationVariables>): Apollo.MutationTuple<Types.CancelOrganizationInviteMutation, Types.CancelOrganizationInviteMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type CancelOrganizationInviteMutationHookResult = ReturnType<typeof useCancelOrganizationInviteMutation>;
+export type CancelOrganizationInviteMutationResult = Apollo.MutationResult<Types.CancelOrganizationInviteMutation>;
+export type CancelOrganizationInviteMutationOptions = Apollo.BaseMutationOptions<Types.CancelOrganizationInviteMutation, Types.CancelOrganizationInviteMutationVariables>;
+export declare const InviteOrganizationMemberDocument: Apollo.DocumentNode;
+export type InviteOrganizationMemberMutationFn = Apollo.MutationFunction<Types.InviteOrganizationMemberMutation, Types.InviteOrganizationMemberMutationVariables>;
+/**
+ * __useInviteOrganizationMemberMutation__
+ *
+ * To run a mutation, you first call `useInviteOrganizationMemberMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useInviteOrganizationMemberMutation` 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 [inviteOrganizationMemberMutation, { data, loading, error }] = useInviteOrganizationMemberMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useInviteOrganizationMemberMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.InviteOrganizationMemberMutation, Types.InviteOrganizationMemberMutationVariables>): Apollo.MutationTuple<Types.InviteOrganizationMemberMutation, Types.InviteOrganizationMemberMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type InviteOrganizationMemberMutationHookResult = ReturnType<typeof useInviteOrganizationMemberMutation>;
+export type InviteOrganizationMemberMutationResult = Apollo.MutationResult<Types.InviteOrganizationMemberMutation>;
+export type InviteOrganizationMemberMutationOptions = Apollo.BaseMutationOptions<Types.InviteOrganizationMemberMutation, Types.InviteOrganizationMemberMutationVariables>;
+export declare const RejectOrganizationInviteDocument: Apollo.DocumentNode;
+export type RejectOrganizationInviteMutationFn = Apollo.MutationFunction<Types.RejectOrganizationInviteMutation, Types.RejectOrganizationInviteMutationVariables>;
+/**
+ * __useRejectOrganizationInviteMutation__
+ *
+ * To run a mutation, you first call `useRejectOrganizationInviteMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRejectOrganizationInviteMutation` 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 [rejectOrganizationInviteMutation, { data, loading, error }] = useRejectOrganizationInviteMutation({
+ *   variables: {
+ *      inviteId: // value for 'inviteId'
+ *   },
+ * });
+ */
+export declare function useRejectOrganizationInviteMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RejectOrganizationInviteMutation, Types.RejectOrganizationInviteMutationVariables>): Apollo.MutationTuple<Types.RejectOrganizationInviteMutation, Types.RejectOrganizationInviteMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type RejectOrganizationInviteMutationHookResult = ReturnType<typeof useRejectOrganizationInviteMutation>;
+export type RejectOrganizationInviteMutationResult = Apollo.MutationResult<Types.RejectOrganizationInviteMutation>;
+export type RejectOrganizationInviteMutationOptions = Apollo.BaseMutationOptions<Types.RejectOrganizationInviteMutation, Types.RejectOrganizationInviteMutationVariables>;
+export declare const ResendOrganizationInviteDocument: Apollo.DocumentNode;
+export type ResendOrganizationInviteMutationFn = Apollo.MutationFunction<Types.ResendOrganizationInviteMutation, Types.ResendOrganizationInviteMutationVariables>;
+/**
+ * __useResendOrganizationInviteMutation__
+ *
+ * To run a mutation, you first call `useResendOrganizationInviteMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useResendOrganizationInviteMutation` 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 [resendOrganizationInviteMutation, { data, loading, error }] = useResendOrganizationInviteMutation({
+ *   variables: {
+ *      inviteId: // value for 'inviteId'
+ *   },
+ * });
+ */
+export declare function useResendOrganizationInviteMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ResendOrganizationInviteMutation, Types.ResendOrganizationInviteMutationVariables>): Apollo.MutationTuple<Types.ResendOrganizationInviteMutation, Types.ResendOrganizationInviteMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type ResendOrganizationInviteMutationHookResult = ReturnType<typeof useResendOrganizationInviteMutation>;
+export type ResendOrganizationInviteMutationResult = Apollo.MutationResult<Types.ResendOrganizationInviteMutation>;
+export type ResendOrganizationInviteMutationOptions = Apollo.BaseMutationOptions<Types.ResendOrganizationInviteMutation, Types.ResendOrganizationInviteMutationVariables>;
+export declare const GetMyOrganizationInviteDocument: Apollo.DocumentNode;
+/**
+ * __useGetMyOrganizationInviteQuery__
+ *
+ * To run a query within a React component, call `useGetMyOrganizationInviteQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetMyOrganizationInviteQuery` 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 } = useGetMyOrganizationInviteQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetMyOrganizationInviteQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetMyOrganizationInviteQuery, Types.GetMyOrganizationInviteQueryVariables> & ({
+    variables: Types.GetMyOrganizationInviteQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): Apollo.InteropQueryResult<Types.GetMyOrganizationInviteQuery, Types.GetMyOrganizationInviteQueryVariables>;
+export declare function useGetMyOrganizationInviteLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetMyOrganizationInviteQuery, Types.GetMyOrganizationInviteQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetMyOrganizationInviteQuery, Types.GetMyOrganizationInviteQueryVariables>;
+export declare function useGetMyOrganizationInviteSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMyOrganizationInviteQuery, Types.GetMyOrganizationInviteQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMyOrganizationInviteQuery, Types.GetMyOrganizationInviteQueryVariables>;
+export declare function useGetMyOrganizationInviteSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMyOrganizationInviteQuery, Types.GetMyOrganizationInviteQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMyOrganizationInviteQuery | undefined, Types.GetMyOrganizationInviteQueryVariables>;
+export type GetMyOrganizationInviteQueryHookResult = ReturnType<typeof useGetMyOrganizationInviteQuery>;
+export type GetMyOrganizationInviteLazyQueryHookResult = ReturnType<typeof useGetMyOrganizationInviteLazyQuery>;
+export type GetMyOrganizationInviteSuspenseQueryHookResult = ReturnType<typeof useGetMyOrganizationInviteSuspenseQuery>;
+export type GetMyOrganizationInviteQueryResult = Apollo.QueryResult<Types.GetMyOrganizationInviteQuery, Types.GetMyOrganizationInviteQueryVariables>;
+export declare const GetMyOrganizationInvitesDocument: Apollo.DocumentNode;
+/**
+ * __useGetMyOrganizationInvitesQuery__
+ *
+ * To run a query within a React component, call `useGetMyOrganizationInvitesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetMyOrganizationInvitesQuery` 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 } = useGetMyOrganizationInvitesQuery({
+ *   variables: {
+ *      status: // value for 'status'
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useGetMyOrganizationInvitesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetMyOrganizationInvitesQuery, Types.GetMyOrganizationInvitesQueryVariables>): Apollo.InteropQueryResult<Types.GetMyOrganizationInvitesQuery, Types.GetMyOrganizationInvitesQueryVariables>;
+export declare function useGetMyOrganizationInvitesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetMyOrganizationInvitesQuery, Types.GetMyOrganizationInvitesQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetMyOrganizationInvitesQuery, Types.GetMyOrganizationInvitesQueryVariables>;
+export declare function useGetMyOrganizationInvitesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMyOrganizationInvitesQuery, Types.GetMyOrganizationInvitesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMyOrganizationInvitesQuery, Types.GetMyOrganizationInvitesQueryVariables>;
+export declare function useGetMyOrganizationInvitesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMyOrganizationInvitesQuery, Types.GetMyOrganizationInvitesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMyOrganizationInvitesQuery | undefined, Types.GetMyOrganizationInvitesQueryVariables>;
+export type GetMyOrganizationInvitesQueryHookResult = ReturnType<typeof useGetMyOrganizationInvitesQuery>;
+export type GetMyOrganizationInvitesLazyQueryHookResult = ReturnType<typeof useGetMyOrganizationInvitesLazyQuery>;
+export type GetMyOrganizationInvitesSuspenseQueryHookResult = ReturnType<typeof useGetMyOrganizationInvitesSuspenseQuery>;
+export type GetMyOrganizationInvitesQueryResult = Apollo.QueryResult<Types.GetMyOrganizationInvitesQuery, Types.GetMyOrganizationInvitesQueryVariables>;
+export declare const GetOrganizationInvitesDocument: Apollo.DocumentNode;
+/**
+ * __useGetOrganizationInvitesQuery__
+ *
+ * To run a query within a React component, call `useGetOrganizationInvitesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetOrganizationInvitesQuery` 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 } = useGetOrganizationInvitesQuery({
+ *   variables: {
+ *      organizationId: // value for 'organizationId'
+ *      filter: // value for 'filter'
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useGetOrganizationInvitesQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetOrganizationInvitesQuery, Types.GetOrganizationInvitesQueryVariables> & ({
+    variables: Types.GetOrganizationInvitesQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): Apollo.InteropQueryResult<Types.GetOrganizationInvitesQuery, Types.GetOrganizationInvitesQueryVariables>;
+export declare function useGetOrganizationInvitesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetOrganizationInvitesQuery, Types.GetOrganizationInvitesQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetOrganizationInvitesQuery, Types.GetOrganizationInvitesQueryVariables>;
+export declare function useGetOrganizationInvitesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetOrganizationInvitesQuery, Types.GetOrganizationInvitesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetOrganizationInvitesQuery, Types.GetOrganizationInvitesQueryVariables>;
+export declare function useGetOrganizationInvitesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetOrganizationInvitesQuery, Types.GetOrganizationInvitesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetOrganizationInvitesQuery | undefined, Types.GetOrganizationInvitesQueryVariables>;
+export type GetOrganizationInvitesQueryHookResult = ReturnType<typeof useGetOrganizationInvitesQuery>;
+export type GetOrganizationInvitesLazyQueryHookResult = ReturnType<typeof useGetOrganizationInvitesLazyQuery>;
+export type GetOrganizationInvitesSuspenseQueryHookResult = ReturnType<typeof useGetOrganizationInvitesSuspenseQuery>;
+export type GetOrganizationInvitesQueryResult = Apollo.QueryResult<Types.GetOrganizationInvitesQuery, Types.GetOrganizationInvitesQueryVariables>;
+export declare const AddOrganizationMemberDocument: Apollo.DocumentNode;
+export type AddOrganizationMemberMutationFn = Apollo.MutationFunction<Types.AddOrganizationMemberMutation, Types.AddOrganizationMemberMutationVariables>;
+/**
+ * __useAddOrganizationMemberMutation__
+ *
+ * To run a mutation, you first call `useAddOrganizationMemberMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddOrganizationMemberMutation` 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 [addOrganizationMemberMutation, { data, loading, error }] = useAddOrganizationMemberMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useAddOrganizationMemberMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AddOrganizationMemberMutation, Types.AddOrganizationMemberMutationVariables>): Apollo.MutationTuple<Types.AddOrganizationMemberMutation, Types.AddOrganizationMemberMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type AddOrganizationMemberMutationHookResult = ReturnType<typeof useAddOrganizationMemberMutation>;
+export type AddOrganizationMemberMutationResult = Apollo.MutationResult<Types.AddOrganizationMemberMutation>;
+export type AddOrganizationMemberMutationOptions = Apollo.BaseMutationOptions<Types.AddOrganizationMemberMutation, Types.AddOrganizationMemberMutationVariables>;
+export declare const RemoveOrganizationMemberDocument: Apollo.DocumentNode;
+export type RemoveOrganizationMemberMutationFn = Apollo.MutationFunction<Types.RemoveOrganizationMemberMutation, Types.RemoveOrganizationMemberMutationVariables>;
+/**
+ * __useRemoveOrganizationMemberMutation__
+ *
+ * To run a mutation, you first call `useRemoveOrganizationMemberMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRemoveOrganizationMemberMutation` 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 [removeOrganizationMemberMutation, { data, loading, error }] = useRemoveOrganizationMemberMutation({
+ *   variables: {
+ *      organizationId: // value for 'organizationId'
+ *      userId: // value for 'userId'
+ *   },
+ * });
+ */
+export declare function useRemoveOrganizationMemberMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RemoveOrganizationMemberMutation, Types.RemoveOrganizationMemberMutationVariables>): Apollo.MutationTuple<Types.RemoveOrganizationMemberMutation, Types.RemoveOrganizationMemberMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type RemoveOrganizationMemberMutationHookResult = ReturnType<typeof useRemoveOrganizationMemberMutation>;
+export type RemoveOrganizationMemberMutationResult = Apollo.MutationResult<Types.RemoveOrganizationMemberMutation>;
+export type RemoveOrganizationMemberMutationOptions = Apollo.BaseMutationOptions<Types.RemoveOrganizationMemberMutation, Types.RemoveOrganizationMemberMutationVariables>;
+export declare const UpdateOrganizationMemberDocument: Apollo.DocumentNode;
+export type UpdateOrganizationMemberMutationFn = Apollo.MutationFunction<Types.UpdateOrganizationMemberMutation, Types.UpdateOrganizationMemberMutationVariables>;
+/**
+ * __useUpdateOrganizationMemberMutation__
+ *
+ * To run a mutation, you first call `useUpdateOrganizationMemberMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateOrganizationMemberMutation` 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 [updateOrganizationMemberMutation, { data, loading, error }] = useUpdateOrganizationMemberMutation({
+ *   variables: {
+ *      organizationId: // value for 'organizationId'
+ *      userId: // value for 'userId'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateOrganizationMemberMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateOrganizationMemberMutation, Types.UpdateOrganizationMemberMutationVariables>): Apollo.MutationTuple<Types.UpdateOrganizationMemberMutation, Types.UpdateOrganizationMemberMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type UpdateOrganizationMemberMutationHookResult = ReturnType<typeof useUpdateOrganizationMemberMutation>;
+export type UpdateOrganizationMemberMutationResult = Apollo.MutationResult<Types.UpdateOrganizationMemberMutation>;
+export type UpdateOrganizationMemberMutationOptions = Apollo.BaseMutationOptions<Types.UpdateOrganizationMemberMutation, Types.UpdateOrganizationMemberMutationVariables>;
+export declare const GetMemberDocument: Apollo.DocumentNode;
+/**
+ * __useGetMemberQuery__
+ *
+ * To run a query within a React component, call `useGetMemberQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetMemberQuery` 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 } = useGetMemberQuery({
+ *   variables: {
+ *      organizationId: // value for 'organizationId'
+ *   },
+ * });
+ */
+export declare function useGetMemberQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetMemberQuery, Types.GetMemberQueryVariables> & ({
+    variables: Types.GetMemberQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): Apollo.InteropQueryResult<Types.GetMemberQuery, Types.GetMemberQueryVariables>;
+export declare function useGetMemberLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetMemberQuery, Types.GetMemberQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetMemberQuery, Types.GetMemberQueryVariables>;
+export declare function useGetMemberSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMemberQuery, Types.GetMemberQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMemberQuery, Types.GetMemberQueryVariables>;
+export declare function useGetMemberSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMemberQuery, Types.GetMemberQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMemberQuery | undefined, Types.GetMemberQueryVariables>;
+export type GetMemberQueryHookResult = ReturnType<typeof useGetMemberQuery>;
+export type GetMemberLazyQueryHookResult = ReturnType<typeof useGetMemberLazyQuery>;
+export type GetMemberSuspenseQueryHookResult = ReturnType<typeof useGetMemberSuspenseQuery>;
+export type GetMemberQueryResult = Apollo.QueryResult<Types.GetMemberQuery, Types.GetMemberQueryVariables>;
+export declare const GetMemberByEmailDocument: Apollo.DocumentNode;
+/**
+ * __useGetMemberByEmailQuery__
+ *
+ * To run a query within a React component, call `useGetMemberByEmailQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetMemberByEmailQuery` 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 } = useGetMemberByEmailQuery({
+ *   variables: {
+ *      organizationId: // value for 'organizationId'
+ *   },
+ * });
+ */
+export declare function useGetMemberByEmailQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetMemberByEmailQuery, Types.GetMemberByEmailQueryVariables> & ({
+    variables: Types.GetMemberByEmailQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): Apollo.InteropQueryResult<Types.GetMemberByEmailQuery, Types.GetMemberByEmailQueryVariables>;
+export declare function useGetMemberByEmailLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetMemberByEmailQuery, Types.GetMemberByEmailQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetMemberByEmailQuery, Types.GetMemberByEmailQueryVariables>;
+export declare function useGetMemberByEmailSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMemberByEmailQuery, Types.GetMemberByEmailQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMemberByEmailQuery, Types.GetMemberByEmailQueryVariables>;
+export declare function useGetMemberByEmailSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMemberByEmailQuery, Types.GetMemberByEmailQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMemberByEmailQuery | undefined, Types.GetMemberByEmailQueryVariables>;
+export type GetMemberByEmailQueryHookResult = ReturnType<typeof useGetMemberByEmailQuery>;
+export type GetMemberByEmailLazyQueryHookResult = ReturnType<typeof useGetMemberByEmailLazyQuery>;
+export type GetMemberByEmailSuspenseQueryHookResult = ReturnType<typeof useGetMemberByEmailSuspenseQuery>;
+export type GetMemberByEmailQueryResult = Apollo.QueryResult<Types.GetMemberByEmailQuery, Types.GetMemberByEmailQueryVariables>;
+export declare const GetMembersDocument: Apollo.DocumentNode;
+/**
+ * __useGetMembersQuery__
+ *
+ * To run a query within a React component, call `useGetMembersQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetMembersQuery` 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 } = useGetMembersQuery({
+ *   variables: {
+ *      organizationId: // value for 'organizationId'
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useGetMembersQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetMembersQuery, Types.GetMembersQueryVariables> & ({
+    variables: Types.GetMembersQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): Apollo.InteropQueryResult<Types.GetMembersQuery, Types.GetMembersQueryVariables>;
+export declare function useGetMembersLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetMembersQuery, Types.GetMembersQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetMembersQuery, Types.GetMembersQueryVariables>;
+export declare function useGetMembersSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMembersQuery, Types.GetMembersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMembersQuery, Types.GetMembersQueryVariables>;
+export declare function useGetMembersSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMembersQuery, Types.GetMembersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMembersQuery | undefined, Types.GetMembersQueryVariables>;
+export type GetMembersQueryHookResult = ReturnType<typeof useGetMembersQuery>;
+export type GetMembersLazyQueryHookResult = ReturnType<typeof useGetMembersLazyQuery>;
+export type GetMembersSuspenseQueryHookResult = ReturnType<typeof useGetMembersSuspenseQuery>;
+export type GetMembersQueryResult = Apollo.QueryResult<Types.GetMembersQuery, Types.GetMembersQueryVariables>;
+export declare const GetMembersByContextDocument: Apollo.DocumentNode;
+/**
+ * __useGetMembersByContextQuery__
+ *
+ * To run a query within a React component, call `useGetMembersByContextQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetMembersByContextQuery` 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 } = useGetMembersByContextQuery({
+ *   variables: {
+ *      organizationId: // value for 'organizationId'
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useGetMembersByContextQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetMembersByContextQuery, Types.GetMembersByContextQueryVariables> & ({
+    variables: Types.GetMembersByContextQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): Apollo.InteropQueryResult<Types.GetMembersByContextQuery, Types.GetMembersByContextQueryVariables>;
+export declare function useGetMembersByContextLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetMembersByContextQuery, Types.GetMembersByContextQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetMembersByContextQuery, Types.GetMembersByContextQueryVariables>;
+export declare function useGetMembersByContextSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMembersByContextQuery, Types.GetMembersByContextQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMembersByContextQuery, Types.GetMembersByContextQueryVariables>;
+export declare function useGetMembersByContextSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMembersByContextQuery, Types.GetMembersByContextQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMembersByContextQuery | undefined, Types.GetMembersByContextQueryVariables>;
+export type GetMembersByContextQueryHookResult = ReturnType<typeof useGetMembersByContextQuery>;
+export type GetMembersByContextLazyQueryHookResult = ReturnType<typeof useGetMembersByContextLazyQuery>;
+export type GetMembersByContextSuspenseQueryHookResult = ReturnType<typeof useGetMembersByContextSuspenseQuery>;
+export type GetMembersByContextQueryResult = Apollo.QueryResult<Types.GetMembersByContextQuery, Types.GetMembersByContextQueryVariables>;
+export declare const CreateOrganizationDocument: Apollo.DocumentNode;
+export type CreateOrganizationMutationFn = Apollo.MutationFunction<Types.CreateOrganizationMutation, Types.CreateOrganizationMutationVariables>;
+/**
+ * __useCreateOrganizationMutation__
+ *
+ * To run a mutation, you first call `useCreateOrganizationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateOrganizationMutation` 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 [createOrganizationMutation, { data, loading, error }] = useCreateOrganizationMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateOrganizationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateOrganizationMutation, Types.CreateOrganizationMutationVariables>): Apollo.MutationTuple<Types.CreateOrganizationMutation, Types.CreateOrganizationMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type CreateOrganizationMutationHookResult = ReturnType<typeof useCreateOrganizationMutation>;
+export type CreateOrganizationMutationResult = Apollo.MutationResult<Types.CreateOrganizationMutation>;
+export type CreateOrganizationMutationOptions = Apollo.BaseMutationOptions<Types.CreateOrganizationMutation, Types.CreateOrganizationMutationVariables>;
+export declare const DeleteOrganizationDocument: Apollo.DocumentNode;
+export type DeleteOrganizationMutationFn = Apollo.MutationFunction<Types.DeleteOrganizationMutation, Types.DeleteOrganizationMutationVariables>;
+/**
+ * __useDeleteOrganizationMutation__
+ *
+ * To run a mutation, you first call `useDeleteOrganizationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteOrganizationMutation` 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 [deleteOrganizationMutation, { data, loading, error }] = useDeleteOrganizationMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useDeleteOrganizationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteOrganizationMutation, Types.DeleteOrganizationMutationVariables>): Apollo.MutationTuple<Types.DeleteOrganizationMutation, Types.DeleteOrganizationMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type DeleteOrganizationMutationHookResult = ReturnType<typeof useDeleteOrganizationMutation>;
+export type DeleteOrganizationMutationResult = Apollo.MutationResult<Types.DeleteOrganizationMutation>;
+export type DeleteOrganizationMutationOptions = Apollo.BaseMutationOptions<Types.DeleteOrganizationMutation, Types.DeleteOrganizationMutationVariables>;
+export declare const UpdateOrganizationDocument: Apollo.DocumentNode;
+export type UpdateOrganizationMutationFn = Apollo.MutationFunction<Types.UpdateOrganizationMutation, Types.UpdateOrganizationMutationVariables>;
+/**
+ * __useUpdateOrganizationMutation__
+ *
+ * To run a mutation, you first call `useUpdateOrganizationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateOrganizationMutation` 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 [updateOrganizationMutation, { data, loading, error }] = useUpdateOrganizationMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateOrganizationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateOrganizationMutation, Types.UpdateOrganizationMutationVariables>): Apollo.MutationTuple<Types.UpdateOrganizationMutation, Types.UpdateOrganizationMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type UpdateOrganizationMutationHookResult = ReturnType<typeof useUpdateOrganizationMutation>;
+export type UpdateOrganizationMutationResult = Apollo.MutationResult<Types.UpdateOrganizationMutation>;
+export type UpdateOrganizationMutationOptions = Apollo.BaseMutationOptions<Types.UpdateOrganizationMutation, Types.UpdateOrganizationMutationVariables>;
+export declare const GetMyOrganizationsDocument: Apollo.DocumentNode;
+/**
+ * __useGetMyOrganizationsQuery__
+ *
+ * To run a query within a React component, call `useGetMyOrganizationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetMyOrganizationsQuery` 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 } = useGetMyOrganizationsQuery({
+ *   variables: {
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useGetMyOrganizationsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetMyOrganizationsQuery, Types.GetMyOrganizationsQueryVariables>): Apollo.InteropQueryResult<Types.GetMyOrganizationsQuery, Types.GetMyOrganizationsQueryVariables>;
+export declare function useGetMyOrganizationsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetMyOrganizationsQuery, Types.GetMyOrganizationsQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetMyOrganizationsQuery, Types.GetMyOrganizationsQueryVariables>;
+export declare function useGetMyOrganizationsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMyOrganizationsQuery, Types.GetMyOrganizationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMyOrganizationsQuery, Types.GetMyOrganizationsQueryVariables>;
+export declare function useGetMyOrganizationsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMyOrganizationsQuery, Types.GetMyOrganizationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMyOrganizationsQuery | undefined, Types.GetMyOrganizationsQueryVariables>;
+export type GetMyOrganizationsQueryHookResult = ReturnType<typeof useGetMyOrganizationsQuery>;
+export type GetMyOrganizationsLazyQueryHookResult = ReturnType<typeof useGetMyOrganizationsLazyQuery>;
+export type GetMyOrganizationsSuspenseQueryHookResult = ReturnType<typeof useGetMyOrganizationsSuspenseQuery>;
+export type GetMyOrganizationsQueryResult = Apollo.QueryResult<Types.GetMyOrganizationsQuery, Types.GetMyOrganizationsQueryVariables>;
+export declare const GetOrganizationDocument: Apollo.DocumentNode;
+/**
+ * __useGetOrganizationQuery__
+ *
+ * To run a query within a React component, call `useGetOrganizationQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetOrganizationQuery` 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 } = useGetOrganizationQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetOrganizationQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetOrganizationQuery, Types.GetOrganizationQueryVariables> & ({
+    variables: Types.GetOrganizationQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): Apollo.InteropQueryResult<Types.GetOrganizationQuery, Types.GetOrganizationQueryVariables>;
+export declare function useGetOrganizationLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetOrganizationQuery, Types.GetOrganizationQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetOrganizationQuery, Types.GetOrganizationQueryVariables>;
+export declare function useGetOrganizationSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetOrganizationQuery, Types.GetOrganizationQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetOrganizationQuery, Types.GetOrganizationQueryVariables>;
+export declare function useGetOrganizationSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetOrganizationQuery, Types.GetOrganizationQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetOrganizationQuery | undefined, Types.GetOrganizationQueryVariables>;
+export type GetOrganizationQueryHookResult = ReturnType<typeof useGetOrganizationQuery>;
+export type GetOrganizationLazyQueryHookResult = ReturnType<typeof useGetOrganizationLazyQuery>;
+export type GetOrganizationSuspenseQueryHookResult = ReturnType<typeof useGetOrganizationSuspenseQuery>;
+export type GetOrganizationQueryResult = Apollo.QueryResult<Types.GetOrganizationQuery, Types.GetOrganizationQueryVariables>;
+export declare const GetOrganizationBySlugDocument: Apollo.DocumentNode;
+/**
+ * __useGetOrganizationBySlugQuery__
+ *
+ * To run a query within a React component, call `useGetOrganizationBySlugQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetOrganizationBySlugQuery` 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 } = useGetOrganizationBySlugQuery({
+ *   variables: {
+ *      tenantId: // value for 'tenantId'
+ *      slug: // value for 'slug'
+ *   },
+ * });
+ */
+export declare function useGetOrganizationBySlugQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetOrganizationBySlugQuery, Types.GetOrganizationBySlugQueryVariables> & ({
+    variables: Types.GetOrganizationBySlugQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): Apollo.InteropQueryResult<Types.GetOrganizationBySlugQuery, Types.GetOrganizationBySlugQueryVariables>;
+export declare function useGetOrganizationBySlugLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetOrganizationBySlugQuery, Types.GetOrganizationBySlugQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetOrganizationBySlugQuery, Types.GetOrganizationBySlugQueryVariables>;
+export declare function useGetOrganizationBySlugSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetOrganizationBySlugQuery, Types.GetOrganizationBySlugQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetOrganizationBySlugQuery, Types.GetOrganizationBySlugQueryVariables>;
+export declare function useGetOrganizationBySlugSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetOrganizationBySlugQuery, Types.GetOrganizationBySlugQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetOrganizationBySlugQuery | undefined, Types.GetOrganizationBySlugQueryVariables>;
+export type GetOrganizationBySlugQueryHookResult = ReturnType<typeof useGetOrganizationBySlugQuery>;
+export type GetOrganizationBySlugLazyQueryHookResult = ReturnType<typeof useGetOrganizationBySlugLazyQuery>;
+export type GetOrganizationBySlugSuspenseQueryHookResult = ReturnType<typeof useGetOrganizationBySlugSuspenseQuery>;
+export type GetOrganizationBySlugQueryResult = Apollo.QueryResult<Types.GetOrganizationBySlugQuery, Types.GetOrganizationBySlugQueryVariables>;
+export declare const GetOrganizationsDocument: Apollo.DocumentNode;
+/**
+ * __useGetOrganizationsQuery__
+ *
+ * To run a query within a React component, call `useGetOrganizationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetOrganizationsQuery` 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 } = useGetOrganizationsQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useGetOrganizationsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetOrganizationsQuery, Types.GetOrganizationsQueryVariables>): Apollo.InteropQueryResult<Types.GetOrganizationsQuery, Types.GetOrganizationsQueryVariables>;
+export declare function useGetOrganizationsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetOrganizationsQuery, Types.GetOrganizationsQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetOrganizationsQuery, Types.GetOrganizationsQueryVariables>;
+export declare function useGetOrganizationsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetOrganizationsQuery, Types.GetOrganizationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetOrganizationsQuery, Types.GetOrganizationsQueryVariables>;
+export declare function useGetOrganizationsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetOrganizationsQuery, Types.GetOrganizationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetOrganizationsQuery | undefined, Types.GetOrganizationsQueryVariables>;
+export type GetOrganizationsQueryHookResult = ReturnType<typeof useGetOrganizationsQuery>;
+export type GetOrganizationsLazyQueryHookResult = ReturnType<typeof useGetOrganizationsLazyQuery>;
+export type GetOrganizationsSuspenseQueryHookResult = ReturnType<typeof useGetOrganizationsSuspenseQuery>;
+export type GetOrganizationsQueryResult = Apollo.QueryResult<Types.GetOrganizationsQuery, Types.GetOrganizationsQueryVariables>;
+export declare const GetOrganizationsByTenantDocument: Apollo.DocumentNode;
+/**
+ * __useGetOrganizationsByTenantQuery__
+ *
+ * To run a query within a React component, call `useGetOrganizationsByTenantQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetOrganizationsByTenantQuery` 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 } = useGetOrganizationsByTenantQuery({
+ *   variables: {
+ *      tenantId: // value for 'tenantId'
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useGetOrganizationsByTenantQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetOrganizationsByTenantQuery, Types.GetOrganizationsByTenantQueryVariables> & ({
+    variables: Types.GetOrganizationsByTenantQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): Apollo.InteropQueryResult<Types.GetOrganizationsByTenantQuery, Types.GetOrganizationsByTenantQueryVariables>;
+export declare function useGetOrganizationsByTenantLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetOrganizationsByTenantQuery, Types.GetOrganizationsByTenantQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetOrganizationsByTenantQuery, Types.GetOrganizationsByTenantQueryVariables>;
+export declare function useGetOrganizationsByTenantSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetOrganizationsByTenantQuery, Types.GetOrganizationsByTenantQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetOrganizationsByTenantQuery, Types.GetOrganizationsByTenantQueryVariables>;
+export declare function useGetOrganizationsByTenantSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetOrganizationsByTenantQuery, Types.GetOrganizationsByTenantQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetOrganizationsByTenantQuery | undefined, Types.GetOrganizationsByTenantQueryVariables>;
+export type GetOrganizationsByTenantQueryHookResult = ReturnType<typeof useGetOrganizationsByTenantQuery>;
+export type GetOrganizationsByTenantLazyQueryHookResult = ReturnType<typeof useGetOrganizationsByTenantLazyQuery>;
+export type GetOrganizationsByTenantSuspenseQueryHookResult = ReturnType<typeof useGetOrganizationsByTenantSuspenseQuery>;
+export type GetOrganizationsByTenantQueryResult = Apollo.QueryResult<Types.GetOrganizationsByTenantQuery, Types.GetOrganizationsByTenantQueryVariables>;
+export declare const CheckRbacPermissionsDocument: Apollo.DocumentNode;
+/**
+ * __useCheckRbacPermissionsQuery__
+ *
+ * To run a query within a React component, call `useCheckRbacPermissionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCheckRbacPermissionsQuery` 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 } = useCheckRbacPermissionsQuery({
+ *   variables: {
+ *      inputs: // value for 'inputs'
+ *   },
+ * });
+ */
+export declare function useCheckRbacPermissionsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.CheckRbacPermissionsQuery, Types.CheckRbacPermissionsQueryVariables> & ({
+    variables: Types.CheckRbacPermissionsQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): Apollo.InteropQueryResult<Types.CheckRbacPermissionsQuery, Types.CheckRbacPermissionsQueryVariables>;
+export declare function useCheckRbacPermissionsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.CheckRbacPermissionsQuery, Types.CheckRbacPermissionsQueryVariables>): Apollo.LazyQueryResultTuple<Types.CheckRbacPermissionsQuery, Types.CheckRbacPermissionsQueryVariables>;
+export declare function useCheckRbacPermissionsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.CheckRbacPermissionsQuery, Types.CheckRbacPermissionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.CheckRbacPermissionsQuery, Types.CheckRbacPermissionsQueryVariables>;
+export declare function useCheckRbacPermissionsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.CheckRbacPermissionsQuery, Types.CheckRbacPermissionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.CheckRbacPermissionsQuery | undefined, Types.CheckRbacPermissionsQueryVariables>;
+export type CheckRbacPermissionsQueryHookResult = ReturnType<typeof useCheckRbacPermissionsQuery>;
+export type CheckRbacPermissionsLazyQueryHookResult = ReturnType<typeof useCheckRbacPermissionsLazyQuery>;
+export type CheckRbacPermissionsSuspenseQueryHookResult = ReturnType<typeof useCheckRbacPermissionsSuspenseQuery>;
+export type CheckRbacPermissionsQueryResult = Apollo.QueryResult<Types.CheckRbacPermissionsQuery, Types.CheckRbacPermissionsQueryVariables>;
+export declare const ActivateWorkspaceDocument: Apollo.DocumentNode;
+export type ActivateWorkspaceMutationFn = Apollo.MutationFunction<Types.ActivateWorkspaceMutation, Types.ActivateWorkspaceMutationVariables>;
+/**
+ * __useActivateWorkspaceMutation__
+ *
+ * To run a mutation, you first call `useActivateWorkspaceMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useActivateWorkspaceMutation` 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 [activateWorkspaceMutation, { data, loading, error }] = useActivateWorkspaceMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useActivateWorkspaceMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ActivateWorkspaceMutation, Types.ActivateWorkspaceMutationVariables>): Apollo.MutationTuple<Types.ActivateWorkspaceMutation, Types.ActivateWorkspaceMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type ActivateWorkspaceMutationHookResult = ReturnType<typeof useActivateWorkspaceMutation>;
+export type ActivateWorkspaceMutationResult = Apollo.MutationResult<Types.ActivateWorkspaceMutation>;
+export type ActivateWorkspaceMutationOptions = Apollo.BaseMutationOptions<Types.ActivateWorkspaceMutation, Types.ActivateWorkspaceMutationVariables>;
+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>): Apollo.MutationTuple<Types.AddWorkspaceMemberMutation, Types.AddWorkspaceMemberMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+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 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>): Apollo.MutationTuple<Types.ArchiveWorkspaceMutation, Types.ArchiveWorkspaceMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+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 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>): Apollo.MutationTuple<Types.CreateWorkspaceMutation, Types.CreateWorkspaceMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+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 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: {
+ *      workspaceId: // value for 'workspaceId'
+ *      userId: // value for 'userId'
+ *   },
+ * });
+ */
+export declare function useRemoveWorkspaceMemberMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RemoveWorkspaceMemberMutation, Types.RemoveWorkspaceMemberMutationVariables>): Apollo.MutationTuple<Types.RemoveWorkspaceMemberMutation, Types.RemoveWorkspaceMemberMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+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 SuspendWorkspaceDocument: Apollo.DocumentNode;
+export type SuspendWorkspaceMutationFn = Apollo.MutationFunction<Types.SuspendWorkspaceMutation, Types.SuspendWorkspaceMutationVariables>;
+/**
+ * __useSuspendWorkspaceMutation__
+ *
+ * To run a mutation, you first call `useSuspendWorkspaceMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSuspendWorkspaceMutation` 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 [suspendWorkspaceMutation, { data, loading, error }] = useSuspendWorkspaceMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useSuspendWorkspaceMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SuspendWorkspaceMutation, Types.SuspendWorkspaceMutationVariables>): Apollo.MutationTuple<Types.SuspendWorkspaceMutation, Types.SuspendWorkspaceMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type SuspendWorkspaceMutationHookResult = ReturnType<typeof useSuspendWorkspaceMutation>;
+export type SuspendWorkspaceMutationResult = Apollo.MutationResult<Types.SuspendWorkspaceMutation>;
+export type SuspendWorkspaceMutationOptions = Apollo.BaseMutationOptions<Types.SuspendWorkspaceMutation, Types.SuspendWorkspaceMutationVariables>;
+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>): Apollo.MutationTuple<Types.UpdateWorkspaceMutation, Types.UpdateWorkspaceMutationVariables, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+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 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: {
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useGetMyWorkspacesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetMyWorkspacesQuery, Types.GetMyWorkspacesQueryVariables>): Apollo.InteropQueryResult<Types.GetMyWorkspacesQuery, Types.GetMyWorkspacesQueryVariables>;
+export declare function useGetMyWorkspacesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetMyWorkspacesQuery, Types.GetMyWorkspacesQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetMyWorkspacesQuery, Types.GetMyWorkspacesQueryVariables>;
+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 GetTenantsDocument: Apollo.DocumentNode;
+/**
+ * __useGetTenantsQuery__
+ *
+ * To run a query within a React component, call `useGetTenantsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetTenantsQuery` 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 } = useGetTenantsQuery({
+ *   variables: {
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useGetTenantsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetTenantsQuery, Types.GetTenantsQueryVariables>): Apollo.InteropQueryResult<Types.GetTenantsQuery, Types.GetTenantsQueryVariables>;
+export declare function useGetTenantsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetTenantsQuery, Types.GetTenantsQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetTenantsQuery, Types.GetTenantsQueryVariables>;
+export declare function useGetTenantsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTenantsQuery, Types.GetTenantsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTenantsQuery, Types.GetTenantsQueryVariables>;
+export declare function useGetTenantsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTenantsQuery, Types.GetTenantsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTenantsQuery | undefined, Types.GetTenantsQueryVariables>;
+export type GetTenantsQueryHookResult = ReturnType<typeof useGetTenantsQuery>;
+export type GetTenantsLazyQueryHookResult = ReturnType<typeof useGetTenantsLazyQuery>;
+export type GetTenantsSuspenseQueryHookResult = ReturnType<typeof useGetTenantsSuspenseQuery>;
+export type GetTenantsQueryResult = Apollo.QueryResult<Types.GetTenantsQuery, Types.GetTenantsQueryVariables>;
+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;
+})): Apollo.InteropQueryResult<Types.GetWorkspaceQuery, Types.GetWorkspaceQueryVariables>;
+export declare function useGetWorkspaceLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetWorkspaceQuery, Types.GetWorkspaceQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetWorkspaceQuery, Types.GetWorkspaceQueryVariables>;
+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 GetWorkspaceBySlugDocument: Apollo.DocumentNode;
+/**
+ * __useGetWorkspaceBySlugQuery__
+ *
+ * To run a query within a React component, call `useGetWorkspaceBySlugQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkspaceBySlugQuery` 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 } = useGetWorkspaceBySlugQuery({
+ *   variables: {
+ *      tenantId: // value for 'tenantId'
+ *      slug: // value for 'slug'
+ *   },
+ * });
+ */
+export declare function useGetWorkspaceBySlugQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetWorkspaceBySlugQuery, Types.GetWorkspaceBySlugQueryVariables> & ({
+    variables: Types.GetWorkspaceBySlugQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): Apollo.InteropQueryResult<Types.GetWorkspaceBySlugQuery, Types.GetWorkspaceBySlugQueryVariables>;
+export declare function useGetWorkspaceBySlugLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetWorkspaceBySlugQuery, Types.GetWorkspaceBySlugQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetWorkspaceBySlugQuery, Types.GetWorkspaceBySlugQueryVariables>;
+export declare function useGetWorkspaceBySlugSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkspaceBySlugQuery, Types.GetWorkspaceBySlugQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkspaceBySlugQuery, Types.GetWorkspaceBySlugQueryVariables>;
+export declare function useGetWorkspaceBySlugSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkspaceBySlugQuery, Types.GetWorkspaceBySlugQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkspaceBySlugQuery | undefined, Types.GetWorkspaceBySlugQueryVariables>;
+export type GetWorkspaceBySlugQueryHookResult = ReturnType<typeof useGetWorkspaceBySlugQuery>;
+export type GetWorkspaceBySlugLazyQueryHookResult = ReturnType<typeof useGetWorkspaceBySlugLazyQuery>;
+export type GetWorkspaceBySlugSuspenseQueryHookResult = ReturnType<typeof useGetWorkspaceBySlugSuspenseQuery>;
+export type GetWorkspaceBySlugQueryResult = Apollo.QueryResult<Types.GetWorkspaceBySlugQuery, Types.GetWorkspaceBySlugQueryVariables>;
+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: {
+ *      userId: // value for 'userId'
+ *      workspaceId: // value for 'workspaceId'
+ *   },
+ * });
+ */
+export declare function useGetWorkspaceMemberQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetWorkspaceMemberQuery, Types.GetWorkspaceMemberQueryVariables> & ({
+    variables: Types.GetWorkspaceMemberQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): Apollo.InteropQueryResult<Types.GetWorkspaceMemberQuery, Types.GetWorkspaceMemberQueryVariables>;
+export declare function useGetWorkspaceMemberLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetWorkspaceMemberQuery, Types.GetWorkspaceMemberQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetWorkspaceMemberQuery, Types.GetWorkspaceMemberQueryVariables>;
+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 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'
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useGetWorkspaceMembersQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetWorkspaceMembersQuery, Types.GetWorkspaceMembersQueryVariables> & ({
+    variables: Types.GetWorkspaceMembersQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): Apollo.InteropQueryResult<Types.GetWorkspaceMembersQuery, Types.GetWorkspaceMembersQueryVariables>;
+export declare function useGetWorkspaceMembersLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetWorkspaceMembersQuery, Types.GetWorkspaceMembersQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetWorkspaceMembersQuery, Types.GetWorkspaceMembersQueryVariables>;
+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 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'
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useGetWorkspacesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetWorkspacesQuery, Types.GetWorkspacesQueryVariables>): Apollo.InteropQueryResult<Types.GetWorkspacesQuery, Types.GetWorkspacesQueryVariables>;
+export declare function useGetWorkspacesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetWorkspacesQuery, Types.GetWorkspacesQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetWorkspacesQuery, Types.GetWorkspacesQueryVariables>;
+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 GetWorkspacesByOrganizationDocument: Apollo.DocumentNode;
+/**
+ * __useGetWorkspacesByOrganizationQuery__
+ *
+ * To run a query within a React component, call `useGetWorkspacesByOrganizationQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetWorkspacesByOrganizationQuery` 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 } = useGetWorkspacesByOrganizationQuery({
+ *   variables: {
+ *      organizationId: // value for 'organizationId'
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useGetWorkspacesByOrganizationQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetWorkspacesByOrganizationQuery, Types.GetWorkspacesByOrganizationQueryVariables> & ({
+    variables: Types.GetWorkspacesByOrganizationQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): Apollo.InteropQueryResult<Types.GetWorkspacesByOrganizationQuery, Types.GetWorkspacesByOrganizationQueryVariables>;
+export declare function useGetWorkspacesByOrganizationLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetWorkspacesByOrganizationQuery, Types.GetWorkspacesByOrganizationQueryVariables>): Apollo.LazyQueryResultTuple<Types.GetWorkspacesByOrganizationQuery, Types.GetWorkspacesByOrganizationQueryVariables>;
+export declare function useGetWorkspacesByOrganizationSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkspacesByOrganizationQuery, Types.GetWorkspacesByOrganizationQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkspacesByOrganizationQuery, Types.GetWorkspacesByOrganizationQueryVariables>;
+export declare function useGetWorkspacesByOrganizationSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetWorkspacesByOrganizationQuery, Types.GetWorkspacesByOrganizationQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetWorkspacesByOrganizationQuery | undefined, Types.GetWorkspacesByOrganizationQueryVariables>;
+export type GetWorkspacesByOrganizationQueryHookResult = ReturnType<typeof useGetWorkspacesByOrganizationQuery>;
+export type GetWorkspacesByOrganizationLazyQueryHookResult = ReturnType<typeof useGetWorkspacesByOrganizationLazyQuery>;
+export type GetWorkspacesByOrganizationSuspenseQueryHookResult = ReturnType<typeof useGetWorkspacesByOrganizationSuspenseQuery>;
+export type GetWorkspacesByOrganizationQueryResult = Apollo.QueryResult<Types.GetWorkspacesByOrganizationQuery, Types.GetWorkspacesByOrganizationQueryVariables>;
+//# sourceMappingURL=global-operations.d.ts.map