@burdenoff/microfe-auth 2026.510.127

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

@@ -0,0 +1,2978 @@
+import * as Types from './global-types';
+import * as Apollo from '@apollo/client';
+import * as ApolloReactHooks from '@apollo/client/react';
+export type DeactivateAccountMutationVariables = Types.Exact<{
+    password: Types.Scalars['String']['input'];
+}>;
+export type DeactivateAccountMutation = {
+    __typename?: 'Mutation';
+    deactivateAccount: {
+        __typename?: 'AccountActionResult';
+        success: boolean;
+        message: string;
+    };
+};
+export type DeleteAccountMutationVariables = Types.Exact<{
+    password: Types.Scalars['String']['input'];
+    confirmPhrase: Types.Scalars['String']['input'];
+}>;
+export type DeleteAccountMutation = {
+    __typename?: 'Mutation';
+    deleteAccount: {
+        __typename?: 'AccountActionResult';
+        success: boolean;
+        message: string;
+    };
+};
+export type ReactivateAccountMutationVariables = Types.Exact<{
+    email: Types.Scalars['String']['input'];
+    password: Types.Scalars['String']['input'];
+}>;
+export type ReactivateAccountMutation = {
+    __typename?: 'Mutation';
+    reactivateAccount: {
+        __typename?: 'AuthResult';
+        success: boolean;
+        token?: string | null;
+        refreshToken?: string | null;
+        expiresIn?: number | null;
+        sessionId?: string | null;
+        error?: string | null;
+        user?: {
+            __typename?: 'User';
+            id: string;
+            email: string;
+            username: string;
+            role: string;
+            status: string;
+            emailVerified: boolean;
+            mfaEnabled: boolean;
+            firstName?: string | null;
+            lastName?: string | null;
+            name?: string | null;
+            defaultWorkspaceId?: string | null;
+            tenantId?: string | null;
+            createdAt: string;
+            updatedAt: string;
+        } | null;
+    };
+};
+export type GenerateApiKeyMutationVariables = Types.Exact<{
+    input: Types.GenerateApiKeyInput;
+}>;
+export type GenerateApiKeyMutation = {
+    __typename?: 'Mutation';
+    generateAPIKey: {
+        __typename?: 'APIKeyResult';
+        apiKey: string;
+        apiSecret: string;
+        keyId: string;
+    };
+};
+export type RevokeApiKeyMutationVariables = Types.Exact<{
+    keyId: Types.Scalars['String']['input'];
+}>;
+export type RevokeApiKeyMutation = {
+    __typename?: 'Mutation';
+    revokeAPIKey: boolean;
+};
+export type RotateApiKeyMutationVariables = Types.Exact<{
+    keyId: Types.Scalars['String']['input'];
+}>;
+export type RotateApiKeyMutation = {
+    __typename?: 'Mutation';
+    rotateAPIKey: {
+        __typename?: 'APIKeyRotateResult';
+        apiSecret: string;
+    };
+};
+export type AuthenticateApiKeyMutationVariables = Types.Exact<{
+    input: Types.ApiKeyInput;
+}>;
+export type AuthenticateApiKeyMutation = {
+    __typename?: 'Mutation';
+    authenticateAPIKey: {
+        __typename?: 'AuthResult';
+        success: boolean;
+        token?: string | null;
+        refreshToken?: string | null;
+        expiresIn?: number | null;
+        error?: string | null;
+        user?: {
+            __typename?: 'User';
+            id: string;
+            email: string;
+            username: string;
+            role: string;
+        } | null;
+    };
+};
+export type CreateAppMutationVariables = Types.Exact<{
+    input: Types.CreateAppInput;
+}>;
+export type CreateAppMutation = {
+    __typename?: 'Mutation';
+    createApp: {
+        __typename?: 'AppCreateResponse';
+        clientSecret: string;
+        app: {
+            __typename?: 'App';
+            id: string;
+            name: string;
+            description?: string | null;
+            clientId: string;
+            type: Types.AppType;
+            status: Types.AppStatus;
+            scopes: Array<string>;
+            redirectUris: Array<string>;
+            ownerUserId: string;
+            tenantId?: string | null;
+            createdAt: string;
+        };
+    };
+};
+export type UpdateAppMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.UpdateAppInput;
+}>;
+export type UpdateAppMutation = {
+    __typename?: 'Mutation';
+    updateApp: {
+        __typename?: 'App';
+        id: string;
+        name: string;
+        description?: string | null;
+        clientId: string;
+        type: Types.AppType;
+        status: Types.AppStatus;
+        scopes: Array<string>;
+        redirectUris: Array<string>;
+        updatedAt: string;
+    };
+};
+export type DeactivateAppMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type DeactivateAppMutation = {
+    __typename?: 'Mutation';
+    deactivateApp: boolean;
+};
+export type RotateAppSecretMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type RotateAppSecretMutation = {
+    __typename?: 'Mutation';
+    rotateAppSecret: {
+        __typename?: 'AppCreateResponse';
+        clientSecret: string;
+        app: {
+            __typename?: 'App';
+            id: string;
+            name: string;
+            clientId: string;
+        };
+    };
+};
+export type AuthenticateAppMutationVariables = Types.Exact<{
+    input: Types.AuthenticateAppInput;
+}>;
+export type AuthenticateAppMutation = {
+    __typename?: 'Mutation';
+    authenticateApp: {
+        __typename?: 'AppTokenResponse';
+        accessToken: string;
+        tokenType: string;
+        expiresIn: number;
+        scopes: Array<string>;
+    };
+};
+export type GenerateAppTokenMutationVariables = Types.Exact<{
+    input: Types.GenerateAppTokenInput;
+}>;
+export type GenerateAppTokenMutation = {
+    __typename?: 'Mutation';
+    generateAppToken: {
+        __typename?: 'AppTokenResponse';
+        accessToken: string;
+        tokenType: string;
+        expiresIn: number;
+        scopes: Array<string>;
+    };
+};
+export type GenerateAppAsUserTokenMutationVariables = Types.Exact<{
+    input: Types.GenerateAppAsUserTokenInput;
+}>;
+export type GenerateAppAsUserTokenMutation = {
+    __typename?: 'Mutation';
+    generateAppAsUserToken: {
+        __typename?: 'AppAsUserTokenResponse';
+        accessToken: string;
+        tokenType: string;
+        expiresIn: number;
+        scopes: Array<string>;
+        delegationId: string;
+    };
+};
+export type ExchangeTokenMutationVariables = Types.Exact<{
+    input: Types.ExchangeTokenInput;
+}>;
+export type ExchangeTokenMutation = {
+    __typename?: 'Mutation';
+    exchangeToken: {
+        __typename?: 'AppAsUserTokenResponse';
+        accessToken: string;
+        tokenType: string;
+        expiresIn: number;
+        scopes: Array<string>;
+        delegationId: string;
+    };
+};
+export type GrantDelegationMutationVariables = Types.Exact<{
+    input: Types.GrantDelegationInput;
+}>;
+export type GrantDelegationMutation = {
+    __typename?: 'Mutation';
+    grantDelegation: {
+        __typename?: 'AppUserDelegation';
+        id: string;
+        appId: string;
+        userId: string;
+        scopes: Array<string>;
+        workspaceIds: Array<string>;
+        status: Types.DelegationStatus;
+        grantedAt: string;
+        grantedBy: string;
+        expiresAt?: string | null;
+        app: {
+            __typename?: 'App';
+            id: string;
+            name: string;
+            description?: string | null;
+            type: Types.AppType;
+            status: Types.AppStatus;
+        };
+    };
+};
+export type RevokeDelegationMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    reason?: Types.InputMaybe<Types.Scalars['String']['input']>;
+}>;
+export type RevokeDelegationMutation = {
+    __typename?: 'Mutation';
+    revokeDelegation: boolean;
+};
+export type SignInMutationVariables = Types.Exact<{
+    input: Types.SignInInput;
+}>;
+export type SignInMutation = {
+    __typename?: 'Mutation';
+    signIn?: {
+        __typename?: 'AuthPayload';
+        accessToken?: string | null;
+        refreshToken?: string | null;
+        expiresIn?: number | null;
+        requiresMFA?: boolean | null;
+        mfaChallengeId?: string | null;
+        mfaMethod?: Types.MfaMethod | null;
+        user?: {
+            __typename?: 'User';
+            id: string;
+            email: string;
+            username: string;
+            firstName?: string | null;
+            lastName?: string | null;
+            name?: string | null;
+            phoneNumber?: string | null;
+            role: string;
+            emailVerified: boolean;
+            mfaEnabled: boolean;
+            createdAt: string;
+            updatedAt: string;
+        } | null;
+    } | null;
+};
+export type SignUpMutationVariables = Types.Exact<{
+    input: Types.SignUpInput;
+}>;
+export type SignUpMutation = {
+    __typename?: 'Mutation';
+    signUp?: {
+        __typename?: 'AuthPayload';
+        accessToken?: string | null;
+        refreshToken?: string | null;
+        expiresIn?: number | null;
+        user?: {
+            __typename?: 'User';
+            id: string;
+            email: string;
+            username: string;
+            firstName?: string | null;
+            lastName?: string | null;
+            name?: string | null;
+            phoneNumber?: string | null;
+            role: string;
+            emailVerified: boolean;
+            mfaEnabled: boolean;
+            createdAt: string;
+        } | null;
+    } | null;
+};
+export type RefreshTokenMutationVariables = Types.Exact<{
+    token: Types.Scalars['String']['input'];
+}>;
+export type RefreshTokenMutation = {
+    __typename?: 'Mutation';
+    refreshToken: {
+        __typename?: 'AuthPayload';
+        accessToken?: string | null;
+        refreshToken?: string | null;
+        expiresIn?: number | null;
+        user?: {
+            __typename?: 'User';
+            id: string;
+            email: string;
+            username: string;
+            firstName?: string | null;
+            lastName?: string | null;
+            name?: string | null;
+            phoneNumber?: string | null;
+            role: string;
+        } | null;
+    };
+};
+export type SignOutMutationVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type SignOutMutation = {
+    __typename?: 'Mutation';
+    signOut: boolean;
+};
+export type ResendVerificationEmailMutationVariables = Types.Exact<{
+    email: Types.Scalars['String']['input'];
+}>;
+export type ResendVerificationEmailMutation = {
+    __typename?: 'Mutation';
+    resendVerificationEmail: {
+        __typename?: 'ResendVerificationResult';
+        success: boolean;
+        message: string;
+    };
+};
+export type SendMagicLinkMutationVariables = Types.Exact<{
+    email: Types.Scalars['String']['input'];
+    context?: Types.InputMaybe<Types.AuthContext>;
+}>;
+export type SendMagicLinkMutation = {
+    __typename?: 'Mutation';
+    sendMagicLink: {
+        __typename?: 'MagicLinkSendResult';
+        success: boolean;
+        message: string;
+        expiresIn?: number | null;
+    };
+};
+export type AuthenticateMagicLinkMutationVariables = Types.Exact<{
+    token: Types.Scalars['String']['input'];
+}>;
+export type AuthenticateMagicLinkMutation = {
+    __typename?: 'Mutation';
+    authenticateMagicLink: {
+        __typename?: 'AuthResult';
+        success: boolean;
+        token?: string | null;
+        refreshToken?: string | null;
+        expiresIn?: number | null;
+        requiresMFA?: boolean | null;
+        mfaChallengeId?: string | null;
+        sessionId?: string | null;
+        error?: string | null;
+        metadata?: Record<string, unknown> | null;
+        user?: {
+            __typename?: 'User';
+            id: string;
+            email: string;
+            username: string;
+            firstName?: string | null;
+            lastName?: string | null;
+            name?: string | null;
+            phoneNumber?: string | null;
+            role: string;
+            emailVerified: boolean;
+            mfaEnabled: boolean;
+            status: string;
+            defaultWorkspaceId?: string | null;
+            tenantId?: string | null;
+            lastLoginAt?: string | null;
+            createdAt: string;
+            updatedAt: string;
+        } | null;
+    };
+};
+export type SetupMfaMutationVariables = Types.Exact<{
+    method: Types.MfaMethod;
+}>;
+export type SetupMfaMutation = {
+    __typename?: 'Mutation';
+    setupMFA: {
+        __typename?: 'MFASetupResult';
+        secret?: string | null;
+        qrCode?: string | null;
+        backupCodes?: Array<string> | null;
+        method: Types.MfaMethod;
+    };
+};
+export type EnableMfaMutationVariables = Types.Exact<{
+    code: Types.Scalars['String']['input'];
+}>;
+export type EnableMfaMutation = {
+    __typename?: 'Mutation';
+    enableMFA: boolean;
+};
+export type VerifyMfaMutationVariables = Types.Exact<{
+    input: Types.MfaVerifyInput;
+}>;
+export type VerifyMfaMutation = {
+    __typename?: 'Mutation';
+    verifyMFA: {
+        __typename?: 'AuthResult';
+        success: boolean;
+        token?: string | null;
+        refreshToken?: string | null;
+        expiresIn?: number | null;
+        requiresMFA?: boolean | null;
+        mfaChallengeId?: string | null;
+        sessionId?: string | null;
+        error?: string | null;
+        metadata?: Record<string, unknown> | null;
+        user?: {
+            __typename?: 'User';
+            id: string;
+            email: string;
+            username: string;
+            firstName?: string | null;
+            lastName?: string | null;
+            name?: string | null;
+            phoneNumber?: string | null;
+            role: string;
+            emailVerified: boolean;
+            mfaEnabled: boolean;
+            status: string;
+            defaultWorkspaceId?: string | null;
+            tenantId?: string | null;
+            lastLoginAt?: string | null;
+            createdAt: string;
+            updatedAt: string;
+        } | null;
+    };
+};
+export type DisableMfaMutationVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type DisableMfaMutation = {
+    __typename?: 'Mutation';
+    disableMFA: boolean;
+};
+export type AuthenticateOAuthMutationVariables = Types.Exact<{
+    input: Types.OAuthInput;
+}>;
+export type AuthenticateOAuthMutation = {
+    __typename?: 'Mutation';
+    authenticateOAuth: {
+        __typename?: 'AuthResult';
+        success: boolean;
+        token?: string | null;
+        refreshToken?: string | null;
+        expiresIn?: number | null;
+        requiresMFA?: boolean | null;
+        mfaChallengeId?: string | null;
+        sessionId?: string | null;
+        error?: string | null;
+        metadata?: Record<string, unknown> | null;
+        user?: {
+            __typename?: 'User';
+            id: string;
+            email: string;
+            username: string;
+            firstName?: string | null;
+            lastName?: string | null;
+            name?: string | null;
+            phoneNumber?: string | null;
+            role: string;
+            emailVerified: boolean;
+            mfaEnabled: boolean;
+        } | null;
+    };
+};
+export type ChangePasswordMutationVariables = Types.Exact<{
+    input: Types.ChangePasswordInput;
+}>;
+export type ChangePasswordMutation = {
+    __typename?: 'Mutation';
+    changePassword: boolean;
+};
+export type RequestPasswordResetMutationVariables = Types.Exact<{
+    email: Types.Scalars['String']['input'];
+    recaptchaToken?: Types.InputMaybe<Types.Scalars['String']['input']>;
+}>;
+export type RequestPasswordResetMutation = {
+    __typename?: 'Mutation';
+    requestPasswordReset: {
+        __typename?: 'PasswordResetRequestResult';
+        success: boolean;
+        message: string;
+    };
+};
+export type ResetPasswordMutationVariables = Types.Exact<{
+    token: Types.Scalars['String']['input'];
+    newPassword: Types.Scalars['String']['input'];
+}>;
+export type ResetPasswordMutation = {
+    __typename?: 'Mutation';
+    resetPassword: boolean;
+};
+export type VerifyEmailMutationVariables = Types.Exact<{
+    token: Types.Scalars['String']['input'];
+}>;
+export type VerifyEmailMutation = {
+    __typename?: 'Mutation';
+    verifyEmail: {
+        __typename?: 'EmailVerificationResult';
+        success: boolean;
+        message: string;
+    };
+};
+export type EnableAuthMethodMutationVariables = Types.Exact<{
+    authType: Types.AuthType;
+    config?: Types.InputMaybe<Types.AuthMethodConfigInput>;
+}>;
+export type EnableAuthMethodMutation = {
+    __typename?: 'Mutation';
+    enableAuthMethod: boolean;
+};
+export type DisableAuthMethodMutationVariables = Types.Exact<{
+    authType: Types.AuthType;
+}>;
+export type DisableAuthMethodMutation = {
+    __typename?: 'Mutation';
+    disableAuthMethod: boolean;
+};
+export type RevokeSessionMutationVariables = Types.Exact<{
+    sessionId: Types.Scalars['ID']['input'];
+}>;
+export type RevokeSessionMutation = {
+    __typename?: 'Mutation';
+    revokeSession: boolean;
+};
+export type RevokeAllSessionsMutationVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type RevokeAllSessionsMutation = {
+    __typename?: 'Mutation';
+    revokeAllSessions: {
+        __typename?: 'RevokeAllSessionsResult';
+        success: boolean;
+        revokedCount: number;
+    };
+};
+export type AuthenticateSamlMutationVariables = Types.Exact<{
+    input: Types.SamlInput;
+}>;
+export type AuthenticateSamlMutation = {
+    __typename?: 'Mutation';
+    authenticateSAML: {
+        __typename?: 'AuthResult';
+        success: boolean;
+        token?: string | null;
+        refreshToken?: string | null;
+        expiresIn?: number | null;
+        requiresMFA?: boolean | null;
+        mfaChallengeId?: string | null;
+        sessionId?: string | null;
+        error?: string | null;
+        metadata?: Record<string, unknown> | null;
+        user?: {
+            __typename?: 'User';
+            id: string;
+            email: string;
+            username: string;
+            firstName?: string | null;
+            lastName?: string | null;
+            name?: string | null;
+            phoneNumber?: string | null;
+            role: string;
+            emailVerified: boolean;
+            mfaEnabled: boolean;
+        } | null;
+    };
+};
+export type GenerateSamlRequestMutationVariables = Types.Exact<{
+    tenantId: Types.Scalars['String']['input'];
+    relayState?: Types.InputMaybe<Types.Scalars['String']['input']>;
+}>;
+export type GenerateSamlRequestMutation = {
+    __typename?: 'Mutation';
+    generateSAMLRequest: {
+        __typename?: 'SAMLRequestResult';
+        requestId: string;
+        ssoUrl: string;
+        samlRequest: string;
+    };
+};
+export type SaveSsoConfigMutationVariables = Types.Exact<{
+    tenantId: Types.Scalars['String']['input'];
+    input: Types.SsoConfigInput;
+}>;
+export type SaveSsoConfigMutation = {
+    __typename?: 'Mutation';
+    saveSSOConfig: {
+        __typename?: 'SSOConfig';
+        id: string;
+        tenantId: string;
+        entityId: string;
+        ssoUrl: string;
+        sloUrl?: string | null;
+        certificate: string;
+        enabled: boolean;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type DeleteSsoConfigMutationVariables = Types.Exact<{
+    tenantId: Types.Scalars['String']['input'];
+}>;
+export type DeleteSsoConfigMutation = {
+    __typename?: 'Mutation';
+    deleteSSOConfig: boolean;
+};
+export type GenerateOidcAuthUrlMutationVariables = Types.Exact<{
+    tenantId: Types.Scalars['String']['input'];
+    state?: Types.InputMaybe<Types.Scalars['String']['input']>;
+}>;
+export type GenerateOidcAuthUrlMutation = {
+    __typename?: 'Mutation';
+    generateOIDCAuthUrl: {
+        __typename?: 'OIDCAuthUrlResult';
+        authUrl: string;
+        state: string;
+        nonce: string;
+        codeVerifier: string;
+        relayState?: string | null;
+    };
+};
+export type AuthenticateOidcMutationVariables = Types.Exact<{
+    input: Types.OidcCallbackInput;
+}>;
+export type AuthenticateOidcMutation = {
+    __typename?: 'Mutation';
+    authenticateOIDC: {
+        __typename?: 'AuthPayload';
+        accessToken?: string | null;
+        refreshToken?: string | null;
+        expiresIn?: number | null;
+        user?: {
+            __typename?: 'User';
+            id: string;
+            email: string;
+            username: string;
+            firstName?: string | null;
+            lastName?: string | null;
+            name?: string | null;
+            phoneNumber?: string | null;
+            role: string;
+            emailVerified: boolean;
+            mfaEnabled: boolean;
+        } | null;
+    };
+};
+export type ValidateTokensMutationVariables = Types.Exact<{
+    input: Types.ValidateTokensInput;
+}>;
+export type ValidateTokensMutation = {
+    __typename?: 'Mutation';
+    validateTokens: {
+        __typename?: 'TokenValidationResponse';
+        valid: boolean;
+        userId?: string | null;
+        email?: string | null;
+        role?: string | null;
+        appId?: string | null;
+        delegationId?: string | null;
+        scopes?: Array<string> | null;
+        tokenType?: string | null;
+        expiresAt?: number | null;
+        error?: {
+            __typename?: 'TokenValidationError';
+            code: string;
+            message: string;
+        } | null;
+    };
+};
+export type UpdateCurrentUserProfileMutationVariables = Types.Exact<{
+    input: Types.UpdateUserInput;
+}>;
+export type UpdateCurrentUserProfileMutation = {
+    __typename?: 'Mutation';
+    updateCurrentUserProfile: {
+        __typename?: 'User';
+        id: string;
+        email: string;
+        username: string;
+        firstName?: string | null;
+        lastName?: string | null;
+        name?: string | null;
+        phoneNumber?: string | null;
+        updatedAt: string;
+    };
+};
+export type UpdateUserMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+    input: Types.AdminUpdateUserInput;
+}>;
+export type UpdateUserMutation = {
+    __typename?: 'Mutation';
+    updateUser: {
+        __typename?: 'User';
+        id: string;
+        email: string;
+        username: string;
+        firstName?: string | null;
+        lastName?: string | null;
+        name?: string | null;
+        phoneNumber?: string | null;
+        role: string;
+        status: string;
+        emailVerified: boolean;
+        updatedAt: string;
+    };
+};
+export type DeleteUserMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type DeleteUserMutation = {
+    __typename?: 'Mutation';
+    deleteUser: {
+        __typename?: 'DeleteUserResult';
+        success: boolean;
+        message: string;
+    };
+};
+export type HardDeleteUserMutationVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type HardDeleteUserMutation = {
+    __typename?: 'Mutation';
+    hardDeleteUser: {
+        __typename?: 'DeleteUserResult';
+        success: boolean;
+        message: string;
+    };
+};
+export type CreateWorkspaceMutationVariables = Types.Exact<{
+    input: Types.CreateWorkspaceInput;
+}>;
+export type CreateWorkspaceMutation = {
+    __typename?: 'Mutation';
+    createWorkspace: {
+        __typename?: 'Workspace';
+        id: string;
+        name: string;
+        slug: string;
+        tenantId: string;
+        organizationId?: string | null;
+        createdAt: string;
+        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;
+        name: string;
+        slug: string;
+        tenantId: string;
+        organizationId?: string | null;
+        createdAt: string;
+        updatedAt: string;
+    };
+};
+export type AddWorkspaceMemberMutationVariables = Types.Exact<{
+    input: Types.AddWorkspaceMemberInput;
+}>;
+export type AddWorkspaceMemberMutation = {
+    __typename?: 'Mutation';
+    addWorkspaceMember: {
+        __typename?: 'WorkspaceMember';
+        id: string;
+        workspaceId: string;
+        userId: string;
+        role: Types.UserRole;
+        joinedAt: string;
+        invitedBy?: string | null;
+    };
+};
+export type UpdateWorkspaceMemberMutationVariables = Types.Exact<{
+    workspaceId: Types.Scalars['String']['input'];
+    userId: Types.Scalars['String']['input'];
+    input: Types.UpdateWorkspaceMemberInput;
+}>;
+export type UpdateWorkspaceMemberMutation = {
+    __typename?: 'Mutation';
+    updateWorkspaceMember: {
+        __typename?: 'WorkspaceMember';
+        id: string;
+        workspaceId: string;
+        userId: string;
+        role: Types.UserRole;
+        joinedAt: string;
+        invitedBy?: string | null;
+    };
+};
+export type RemoveWorkspaceMemberMutationVariables = Types.Exact<{
+    workspaceId: Types.Scalars['String']['input'];
+    userId: Types.Scalars['String']['input'];
+}>;
+export type RemoveWorkspaceMemberMutation = {
+    __typename?: 'Mutation';
+    removeWorkspaceMember: boolean;
+};
+export type MyApiKeysQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type MyApiKeysQuery = {
+    __typename?: 'Query';
+    myApiKeys: Array<{
+        __typename?: 'APIKey';
+        id: string;
+        name: string;
+        prefix: string;
+        scopes: Array<string>;
+        appId: string;
+        appName?: string | null;
+        createdAt: string;
+        expiresAt?: string | null;
+        lastUsedAt?: string | null;
+    }>;
+};
+export type CurrentUserAppsQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type CurrentUserAppsQuery = {
+    __typename?: 'Query';
+    currentUserApps: Array<{
+        __typename?: 'App';
+        id: string;
+        name: string;
+        description?: string | null;
+        clientId: string;
+        type: Types.AppType;
+        status: Types.AppStatus;
+        scopes: Array<string>;
+        redirectUris: Array<string>;
+        ownerUserId: string;
+        tenantId?: string | null;
+        createdAt: string;
+        updatedAt: string;
+        delegations: Array<{
+            __typename?: 'AppUserDelegation';
+            id: string;
+            userId: string;
+            scopes: Array<string>;
+            workspaceIds: Array<string>;
+            status: Types.DelegationStatus;
+            grantedAt: string;
+            expiresAt?: string | null;
+        }>;
+    }>;
+};
+export type GetAppQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetAppQuery = {
+    __typename?: 'Query';
+    app?: {
+        __typename?: 'App';
+        id: string;
+        name: string;
+        description?: string | null;
+        clientId: string;
+        type: Types.AppType;
+        status: Types.AppStatus;
+        scopes: Array<string>;
+        redirectUris: Array<string>;
+        ownerUserId: string;
+        tenantId?: string | null;
+        createdAt: string;
+        updatedAt: string;
+        delegations: Array<{
+            __typename?: 'AppUserDelegation';
+            id: string;
+            userId: string;
+            scopes: Array<string>;
+            workspaceIds: Array<string>;
+            status: Types.DelegationStatus;
+            grantedAt: string;
+            expiresAt?: string | null;
+        }>;
+    } | null;
+};
+export type AppsActingAsCurrentUserQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type AppsActingAsCurrentUserQuery = {
+    __typename?: 'Query';
+    appsActingAsCurrentUser: Array<{
+        __typename?: 'App';
+        id: string;
+        name: string;
+        description?: string | null;
+        clientId: string;
+        type: Types.AppType;
+        status: Types.AppStatus;
+        scopes: Array<string>;
+        redirectUris: Array<string>;
+        ownerUserId: string;
+        tenantId?: string | null;
+        createdAt: string;
+        updatedAt: string;
+    }>;
+};
+export type CurrentUserQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type CurrentUserQuery = {
+    __typename?: 'Query';
+    currentUser?: {
+        __typename?: 'User';
+        id: string;
+        email: string;
+        username: string;
+        firstName?: string | null;
+        lastName?: string | null;
+        name?: string | null;
+        phoneNumber?: string | null;
+        role: string;
+        status: string;
+        emailVerified: boolean;
+        mfaEnabled: boolean;
+        lastLoginAt?: string | null;
+        createdAt: string;
+        updatedAt: string;
+    } | null;
+};
+export type CurrentUserDelegationsQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type CurrentUserDelegationsQuery = {
+    __typename?: 'Query';
+    currentUserDelegations: Array<{
+        __typename?: 'AppUserDelegation';
+        id: string;
+        appId: string;
+        userId: string;
+        scopes: Array<string>;
+        workspaceIds: Array<string>;
+        status: Types.DelegationStatus;
+        grantedAt: string;
+        grantedBy: string;
+        expiresAt?: string | null;
+        revokedAt?: string | null;
+        revokedBy?: string | null;
+        app: {
+            __typename?: 'App';
+            id: string;
+            name: string;
+            description?: string | null;
+            type: Types.AppType;
+            status: Types.AppStatus;
+        };
+    }>;
+};
+export type CurrentUserGrantedDelegationsQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type CurrentUserGrantedDelegationsQuery = {
+    __typename?: 'Query';
+    currentUserGrantedDelegations: Array<{
+        __typename?: 'AppUserDelegation';
+        id: string;
+        appId: string;
+        userId: string;
+        scopes: Array<string>;
+        workspaceIds: Array<string>;
+        status: Types.DelegationStatus;
+        grantedAt: string;
+        grantedBy: string;
+        expiresAt?: string | null;
+        revokedAt?: string | null;
+        revokedBy?: string | null;
+        app: {
+            __typename?: 'App';
+            id: string;
+            name: string;
+            description?: string | null;
+            type: Types.AppType;
+            status: Types.AppStatus;
+        };
+    }>;
+};
+export type AvailableAuthMethodsQueryVariables = Types.Exact<{
+    tenantId?: Types.InputMaybe<Types.Scalars['String']['input']>;
+}>;
+export type AvailableAuthMethodsQuery = {
+    __typename?: 'Query';
+    availableAuthMethods: Array<{
+        __typename?: 'AuthMethod';
+        type: Types.AuthType;
+        name: string;
+        enabled: boolean;
+        requiresMFA?: boolean | null;
+    }>;
+};
+export type AuthMethodConfigQueryVariables = Types.Exact<{
+    tenantId: Types.Scalars['String']['input'];
+    authType: Types.AuthType;
+}>;
+export type AuthMethodConfigQuery = {
+    __typename?: 'Query';
+    authMethodConfig?: {
+        __typename?: 'AuthMethodConfig';
+        type: Types.AuthType;
+        enabled: boolean;
+        config?: Record<string, unknown> | null;
+    } | null;
+};
+export type AuthStrategiesHealthQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type AuthStrategiesHealthQuery = {
+    __typename?: 'Query';
+    authStrategiesHealth: Array<{
+        __typename?: 'AuthStrategyHealth';
+        name: string;
+        type: Types.AuthType;
+        healthy: boolean;
+    }>;
+};
+export type ActiveSessionsQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type ActiveSessionsQuery = {
+    __typename?: 'Query';
+    activeSessions: Array<{
+        __typename?: 'Session';
+        id: string;
+        status: Types.SessionStatus;
+        ipAddress?: string | null;
+        userAgent?: string | null;
+        location?: string | null;
+        lastActivityAt: string;
+        expiresAt: string;
+        createdAt: string;
+        isCurrent: boolean;
+    }>;
+};
+export type GetSsoConfigQueryVariables = Types.Exact<{
+    tenantId: Types.Scalars['String']['input'];
+}>;
+export type GetSsoConfigQuery = {
+    __typename?: 'Query';
+    getSSOConfig?: {
+        __typename?: 'SSOConfig';
+        id: string;
+        tenantId: string;
+        entityId: string;
+        ssoUrl: string;
+        sloUrl?: string | null;
+        certificate: string;
+        enabled: boolean;
+        createdAt: string;
+        updatedAt: string;
+    } | null;
+};
+export type GetOidcConfigQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type GetOidcConfigQuery = {
+    __typename?: 'Query';
+    getOIDCConfig?: {
+        __typename?: 'OIDCConfig';
+        issuer: string;
+        authorizationEndpoint: string;
+        tokenEndpoint: string;
+        userinfoEndpoint?: string | null;
+        jwksUri: string;
+        registrationEndpoint?: string | null;
+        scopesSupported?: Array<string> | null;
+        responseTypesSupported?: Array<string> | null;
+        grantTypesSupported?: Array<string> | null;
+    } | null;
+};
+export type TokenInfoQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type TokenInfoQuery = {
+    __typename?: 'Query';
+    tokenInfo?: {
+        __typename?: 'TokenValidationResponse';
+        valid: boolean;
+        userId?: string | null;
+        email?: string | null;
+        role?: string | null;
+        appId?: string | null;
+        delegationId?: string | null;
+        scopes?: Array<string> | null;
+        tokenType?: string | null;
+        expiresAt?: number | null;
+        error?: {
+            __typename?: 'TokenValidationError';
+            code: string;
+            message: string;
+        } | null;
+    } | null;
+};
+export type GetUserQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type GetUserQuery = {
+    __typename?: 'Query';
+    user?: {
+        __typename?: 'User';
+        id: string;
+        email: string;
+        username: string;
+        firstName?: string | null;
+        lastName?: string | null;
+        name?: string | null;
+        phoneNumber?: string | null;
+        role: string;
+        status: string;
+        emailVerified: boolean;
+        mfaEnabled: boolean;
+        lastLoginAt?: string | null;
+        createdAt: string;
+        updatedAt: string;
+    } | null;
+};
+export type ListUsersQueryVariables = Types.Exact<{
+    filter?: Types.InputMaybe<Types.UserFilterInput>;
+    pagination?: Types.InputMaybe<Types.PaginationInput>;
+}>;
+export type ListUsersQuery = {
+    __typename?: 'Query';
+    users: {
+        __typename?: 'UserConnection';
+        totalCount: number;
+        hasMore: boolean;
+        users: Array<{
+            __typename?: 'User';
+            id: string;
+            email: string;
+            username: string;
+            firstName?: string | null;
+            lastName?: string | null;
+            name?: string | null;
+            phoneNumber?: string | null;
+            role: string;
+            status: string;
+            emailVerified: boolean;
+            mfaEnabled: boolean;
+            lastLoginAt?: string | null;
+            createdAt: string;
+            updatedAt: string;
+        }>;
+    };
+};
+export type MyWorkspacesQueryVariables = Types.Exact<{
+    [key: string]: never;
+}>;
+export type MyWorkspacesQuery = {
+    __typename?: 'Query';
+    myWorkspaces: {
+        __typename?: 'WorkspaceList';
+        total: number;
+        items: Array<{
+            __typename?: 'Workspace';
+            id: string;
+            name: string;
+            slug: string;
+            tenantId: string;
+            organizationId?: string | null;
+        }>;
+    };
+};
+export type WorkspaceQueryVariables = Types.Exact<{
+    id: Types.Scalars['ID']['input'];
+}>;
+export type WorkspaceQuery = {
+    __typename?: 'Query';
+    workspace?: {
+        __typename?: 'Workspace';
+        id: string;
+        name: string;
+        slug: string;
+        tenantId: string;
+        organizationId?: string | null;
+        createdAt: string;
+        updatedAt: string;
+    } | null;
+};
+export type WorkspaceMembersQueryVariables = Types.Exact<{
+    workspaceId: Types.Scalars['String']['input'];
+    limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+    offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
+}>;
+export type WorkspaceMembersQuery = {
+    __typename?: 'Query';
+    workspaceMembers: {
+        __typename?: 'WorkspaceMemberList';
+        total: number;
+        hasMore: boolean;
+        limit: number;
+        offset: number;
+        items: Array<{
+            __typename?: 'WorkspaceMember';
+            id: string;
+            workspaceId: string;
+            userId: string;
+            role: Types.UserRole;
+            joinedAt: string;
+            invitedBy?: string | null;
+        }>;
+    };
+};
+export declare const DeactivateAccountDocument: Apollo.DocumentNode;
+export type DeactivateAccountMutationFn = Apollo.MutationFunction<Types.DeactivateAccountMutation, Types.DeactivateAccountMutationVariables>;
+/**
+ * __useDeactivateAccountMutation__
+ *
+ * To run a mutation, you first call `useDeactivateAccountMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeactivateAccountMutation` 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 [deactivateAccountMutation, { data, loading, error }] = useDeactivateAccountMutation({
+ *   variables: {
+ *      password: // value for 'password'
+ *   },
+ * });
+ */
+export declare function useDeactivateAccountMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeactivateAccountMutation, Types.DeactivateAccountMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeactivateAccountMutation, any, Apollo.ApolloCache>;
+export type DeactivateAccountMutationHookResult = ReturnType<typeof useDeactivateAccountMutation>;
+export type DeactivateAccountMutationResult = Apollo.MutationResult<Types.DeactivateAccountMutation>;
+export type DeactivateAccountMutationOptions = Apollo.BaseMutationOptions<Types.DeactivateAccountMutation, Types.DeactivateAccountMutationVariables>;
+export declare const DeleteAccountDocument: Apollo.DocumentNode;
+export type DeleteAccountMutationFn = Apollo.MutationFunction<Types.DeleteAccountMutation, Types.DeleteAccountMutationVariables>;
+/**
+ * __useDeleteAccountMutation__
+ *
+ * To run a mutation, you first call `useDeleteAccountMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteAccountMutation` 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 [deleteAccountMutation, { data, loading, error }] = useDeleteAccountMutation({
+ *   variables: {
+ *      password: // value for 'password'
+ *      confirmPhrase: // value for 'confirmPhrase'
+ *   },
+ * });
+ */
+export declare function useDeleteAccountMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteAccountMutation, Types.DeleteAccountMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteAccountMutation, any, Apollo.ApolloCache>;
+export type DeleteAccountMutationHookResult = ReturnType<typeof useDeleteAccountMutation>;
+export type DeleteAccountMutationResult = Apollo.MutationResult<Types.DeleteAccountMutation>;
+export type DeleteAccountMutationOptions = Apollo.BaseMutationOptions<Types.DeleteAccountMutation, Types.DeleteAccountMutationVariables>;
+export declare const ReactivateAccountDocument: Apollo.DocumentNode;
+export type ReactivateAccountMutationFn = Apollo.MutationFunction<Types.ReactivateAccountMutation, Types.ReactivateAccountMutationVariables>;
+/**
+ * __useReactivateAccountMutation__
+ *
+ * To run a mutation, you first call `useReactivateAccountMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useReactivateAccountMutation` 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 [reactivateAccountMutation, { data, loading, error }] = useReactivateAccountMutation({
+ *   variables: {
+ *      email: // value for 'email'
+ *      password: // value for 'password'
+ *   },
+ * });
+ */
+export declare function useReactivateAccountMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ReactivateAccountMutation, Types.ReactivateAccountMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ReactivateAccountMutation, any, Apollo.ApolloCache>;
+export type ReactivateAccountMutationHookResult = ReturnType<typeof useReactivateAccountMutation>;
+export type ReactivateAccountMutationResult = Apollo.MutationResult<Types.ReactivateAccountMutation>;
+export type ReactivateAccountMutationOptions = Apollo.BaseMutationOptions<Types.ReactivateAccountMutation, Types.ReactivateAccountMutationVariables>;
+export declare const GenerateApiKeyDocument: Apollo.DocumentNode;
+export type GenerateApiKeyMutationFn = Apollo.MutationFunction<Types.GenerateApiKeyMutation, Types.GenerateApiKeyMutationVariables>;
+/**
+ * __useGenerateApiKeyMutation__
+ *
+ * To run a mutation, you first call `useGenerateApiKeyMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useGenerateApiKeyMutation` 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 [generateApiKeyMutation, { data, loading, error }] = useGenerateApiKeyMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useGenerateApiKeyMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.GenerateApiKeyMutation, Types.GenerateApiKeyMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.GenerateApiKeyMutation, any, Apollo.ApolloCache>;
+export type GenerateApiKeyMutationHookResult = ReturnType<typeof useGenerateApiKeyMutation>;
+export type GenerateApiKeyMutationResult = Apollo.MutationResult<Types.GenerateApiKeyMutation>;
+export type GenerateApiKeyMutationOptions = Apollo.BaseMutationOptions<Types.GenerateApiKeyMutation, Types.GenerateApiKeyMutationVariables>;
+export declare const RevokeApiKeyDocument: Apollo.DocumentNode;
+export type RevokeApiKeyMutationFn = Apollo.MutationFunction<Types.RevokeApiKeyMutation, Types.RevokeApiKeyMutationVariables>;
+/**
+ * __useRevokeApiKeyMutation__
+ *
+ * To run a mutation, you first call `useRevokeApiKeyMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRevokeApiKeyMutation` 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 [revokeApiKeyMutation, { data, loading, error }] = useRevokeApiKeyMutation({
+ *   variables: {
+ *      keyId: // value for 'keyId'
+ *   },
+ * });
+ */
+export declare function useRevokeApiKeyMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RevokeApiKeyMutation, Types.RevokeApiKeyMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RevokeApiKeyMutation, any, Apollo.ApolloCache>;
+export type RevokeApiKeyMutationHookResult = ReturnType<typeof useRevokeApiKeyMutation>;
+export type RevokeApiKeyMutationResult = Apollo.MutationResult<Types.RevokeApiKeyMutation>;
+export type RevokeApiKeyMutationOptions = Apollo.BaseMutationOptions<Types.RevokeApiKeyMutation, Types.RevokeApiKeyMutationVariables>;
+export declare const RotateApiKeyDocument: Apollo.DocumentNode;
+export type RotateApiKeyMutationFn = Apollo.MutationFunction<Types.RotateApiKeyMutation, Types.RotateApiKeyMutationVariables>;
+/**
+ * __useRotateApiKeyMutation__
+ *
+ * To run a mutation, you first call `useRotateApiKeyMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRotateApiKeyMutation` 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 [rotateApiKeyMutation, { data, loading, error }] = useRotateApiKeyMutation({
+ *   variables: {
+ *      keyId: // value for 'keyId'
+ *   },
+ * });
+ */
+export declare function useRotateApiKeyMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RotateApiKeyMutation, Types.RotateApiKeyMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RotateApiKeyMutation, any, Apollo.ApolloCache>;
+export type RotateApiKeyMutationHookResult = ReturnType<typeof useRotateApiKeyMutation>;
+export type RotateApiKeyMutationResult = Apollo.MutationResult<Types.RotateApiKeyMutation>;
+export type RotateApiKeyMutationOptions = Apollo.BaseMutationOptions<Types.RotateApiKeyMutation, Types.RotateApiKeyMutationVariables>;
+export declare const AuthenticateApiKeyDocument: Apollo.DocumentNode;
+export type AuthenticateApiKeyMutationFn = Apollo.MutationFunction<Types.AuthenticateApiKeyMutation, Types.AuthenticateApiKeyMutationVariables>;
+/**
+ * __useAuthenticateApiKeyMutation__
+ *
+ * To run a mutation, you first call `useAuthenticateApiKeyMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAuthenticateApiKeyMutation` 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 [authenticateApiKeyMutation, { data, loading, error }] = useAuthenticateApiKeyMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useAuthenticateApiKeyMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AuthenticateApiKeyMutation, Types.AuthenticateApiKeyMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AuthenticateApiKeyMutation, any, Apollo.ApolloCache>;
+export type AuthenticateApiKeyMutationHookResult = ReturnType<typeof useAuthenticateApiKeyMutation>;
+export type AuthenticateApiKeyMutationResult = Apollo.MutationResult<Types.AuthenticateApiKeyMutation>;
+export type AuthenticateApiKeyMutationOptions = Apollo.BaseMutationOptions<Types.AuthenticateApiKeyMutation, Types.AuthenticateApiKeyMutationVariables>;
+export declare const CreateAppDocument: Apollo.DocumentNode;
+export type CreateAppMutationFn = Apollo.MutationFunction<Types.CreateAppMutation, Types.CreateAppMutationVariables>;
+/**
+ * __useCreateAppMutation__
+ *
+ * To run a mutation, you first call `useCreateAppMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateAppMutation` 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 [createAppMutation, { data, loading, error }] = useCreateAppMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateAppMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateAppMutation, Types.CreateAppMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateAppMutation, any, Apollo.ApolloCache>;
+export type CreateAppMutationHookResult = ReturnType<typeof useCreateAppMutation>;
+export type CreateAppMutationResult = Apollo.MutationResult<Types.CreateAppMutation>;
+export type CreateAppMutationOptions = Apollo.BaseMutationOptions<Types.CreateAppMutation, Types.CreateAppMutationVariables>;
+export declare const UpdateAppDocument: Apollo.DocumentNode;
+export type UpdateAppMutationFn = Apollo.MutationFunction<Types.UpdateAppMutation, Types.UpdateAppMutationVariables>;
+/**
+ * __useUpdateAppMutation__
+ *
+ * To run a mutation, you first call `useUpdateAppMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateAppMutation` 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 [updateAppMutation, { data, loading, error }] = useUpdateAppMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateAppMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateAppMutation, Types.UpdateAppMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateAppMutation, any, Apollo.ApolloCache>;
+export type UpdateAppMutationHookResult = ReturnType<typeof useUpdateAppMutation>;
+export type UpdateAppMutationResult = Apollo.MutationResult<Types.UpdateAppMutation>;
+export type UpdateAppMutationOptions = Apollo.BaseMutationOptions<Types.UpdateAppMutation, Types.UpdateAppMutationVariables>;
+export declare const DeactivateAppDocument: Apollo.DocumentNode;
+export type DeactivateAppMutationFn = Apollo.MutationFunction<Types.DeactivateAppMutation, Types.DeactivateAppMutationVariables>;
+/**
+ * __useDeactivateAppMutation__
+ *
+ * To run a mutation, you first call `useDeactivateAppMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeactivateAppMutation` 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 [deactivateAppMutation, { data, loading, error }] = useDeactivateAppMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useDeactivateAppMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeactivateAppMutation, Types.DeactivateAppMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeactivateAppMutation, any, Apollo.ApolloCache>;
+export type DeactivateAppMutationHookResult = ReturnType<typeof useDeactivateAppMutation>;
+export type DeactivateAppMutationResult = Apollo.MutationResult<Types.DeactivateAppMutation>;
+export type DeactivateAppMutationOptions = Apollo.BaseMutationOptions<Types.DeactivateAppMutation, Types.DeactivateAppMutationVariables>;
+export declare const RotateAppSecretDocument: Apollo.DocumentNode;
+export type RotateAppSecretMutationFn = Apollo.MutationFunction<Types.RotateAppSecretMutation, Types.RotateAppSecretMutationVariables>;
+/**
+ * __useRotateAppSecretMutation__
+ *
+ * To run a mutation, you first call `useRotateAppSecretMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRotateAppSecretMutation` 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 [rotateAppSecretMutation, { data, loading, error }] = useRotateAppSecretMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useRotateAppSecretMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RotateAppSecretMutation, Types.RotateAppSecretMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RotateAppSecretMutation, any, Apollo.ApolloCache>;
+export type RotateAppSecretMutationHookResult = ReturnType<typeof useRotateAppSecretMutation>;
+export type RotateAppSecretMutationResult = Apollo.MutationResult<Types.RotateAppSecretMutation>;
+export type RotateAppSecretMutationOptions = Apollo.BaseMutationOptions<Types.RotateAppSecretMutation, Types.RotateAppSecretMutationVariables>;
+export declare const AuthenticateAppDocument: Apollo.DocumentNode;
+export type AuthenticateAppMutationFn = Apollo.MutationFunction<Types.AuthenticateAppMutation, Types.AuthenticateAppMutationVariables>;
+/**
+ * __useAuthenticateAppMutation__
+ *
+ * To run a mutation, you first call `useAuthenticateAppMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAuthenticateAppMutation` 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 [authenticateAppMutation, { data, loading, error }] = useAuthenticateAppMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useAuthenticateAppMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AuthenticateAppMutation, Types.AuthenticateAppMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AuthenticateAppMutation, any, Apollo.ApolloCache>;
+export type AuthenticateAppMutationHookResult = ReturnType<typeof useAuthenticateAppMutation>;
+export type AuthenticateAppMutationResult = Apollo.MutationResult<Types.AuthenticateAppMutation>;
+export type AuthenticateAppMutationOptions = Apollo.BaseMutationOptions<Types.AuthenticateAppMutation, Types.AuthenticateAppMutationVariables>;
+export declare const GenerateAppTokenDocument: Apollo.DocumentNode;
+export type GenerateAppTokenMutationFn = Apollo.MutationFunction<Types.GenerateAppTokenMutation, Types.GenerateAppTokenMutationVariables>;
+/**
+ * __useGenerateAppTokenMutation__
+ *
+ * To run a mutation, you first call `useGenerateAppTokenMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useGenerateAppTokenMutation` 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 [generateAppTokenMutation, { data, loading, error }] = useGenerateAppTokenMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useGenerateAppTokenMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.GenerateAppTokenMutation, Types.GenerateAppTokenMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.GenerateAppTokenMutation, any, Apollo.ApolloCache>;
+export type GenerateAppTokenMutationHookResult = ReturnType<typeof useGenerateAppTokenMutation>;
+export type GenerateAppTokenMutationResult = Apollo.MutationResult<Types.GenerateAppTokenMutation>;
+export type GenerateAppTokenMutationOptions = Apollo.BaseMutationOptions<Types.GenerateAppTokenMutation, Types.GenerateAppTokenMutationVariables>;
+export declare const GenerateAppAsUserTokenDocument: Apollo.DocumentNode;
+export type GenerateAppAsUserTokenMutationFn = Apollo.MutationFunction<Types.GenerateAppAsUserTokenMutation, Types.GenerateAppAsUserTokenMutationVariables>;
+/**
+ * __useGenerateAppAsUserTokenMutation__
+ *
+ * To run a mutation, you first call `useGenerateAppAsUserTokenMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useGenerateAppAsUserTokenMutation` 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 [generateAppAsUserTokenMutation, { data, loading, error }] = useGenerateAppAsUserTokenMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useGenerateAppAsUserTokenMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.GenerateAppAsUserTokenMutation, Types.GenerateAppAsUserTokenMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.GenerateAppAsUserTokenMutation, any, Apollo.ApolloCache>;
+export type GenerateAppAsUserTokenMutationHookResult = ReturnType<typeof useGenerateAppAsUserTokenMutation>;
+export type GenerateAppAsUserTokenMutationResult = Apollo.MutationResult<Types.GenerateAppAsUserTokenMutation>;
+export type GenerateAppAsUserTokenMutationOptions = Apollo.BaseMutationOptions<Types.GenerateAppAsUserTokenMutation, Types.GenerateAppAsUserTokenMutationVariables>;
+export declare const ExchangeTokenDocument: Apollo.DocumentNode;
+export type ExchangeTokenMutationFn = Apollo.MutationFunction<Types.ExchangeTokenMutation, Types.ExchangeTokenMutationVariables>;
+/**
+ * __useExchangeTokenMutation__
+ *
+ * To run a mutation, you first call `useExchangeTokenMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useExchangeTokenMutation` 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 [exchangeTokenMutation, { data, loading, error }] = useExchangeTokenMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useExchangeTokenMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ExchangeTokenMutation, Types.ExchangeTokenMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ExchangeTokenMutation, any, Apollo.ApolloCache>;
+export type ExchangeTokenMutationHookResult = ReturnType<typeof useExchangeTokenMutation>;
+export type ExchangeTokenMutationResult = Apollo.MutationResult<Types.ExchangeTokenMutation>;
+export type ExchangeTokenMutationOptions = Apollo.BaseMutationOptions<Types.ExchangeTokenMutation, Types.ExchangeTokenMutationVariables>;
+export declare const GrantDelegationDocument: Apollo.DocumentNode;
+export type GrantDelegationMutationFn = Apollo.MutationFunction<Types.GrantDelegationMutation, Types.GrantDelegationMutationVariables>;
+/**
+ * __useGrantDelegationMutation__
+ *
+ * To run a mutation, you first call `useGrantDelegationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useGrantDelegationMutation` 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 [grantDelegationMutation, { data, loading, error }] = useGrantDelegationMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useGrantDelegationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.GrantDelegationMutation, Types.GrantDelegationMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.GrantDelegationMutation, any, Apollo.ApolloCache>;
+export type GrantDelegationMutationHookResult = ReturnType<typeof useGrantDelegationMutation>;
+export type GrantDelegationMutationResult = Apollo.MutationResult<Types.GrantDelegationMutation>;
+export type GrantDelegationMutationOptions = Apollo.BaseMutationOptions<Types.GrantDelegationMutation, Types.GrantDelegationMutationVariables>;
+export declare const RevokeDelegationDocument: Apollo.DocumentNode;
+export type RevokeDelegationMutationFn = Apollo.MutationFunction<Types.RevokeDelegationMutation, Types.RevokeDelegationMutationVariables>;
+/**
+ * __useRevokeDelegationMutation__
+ *
+ * To run a mutation, you first call `useRevokeDelegationMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRevokeDelegationMutation` 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 [revokeDelegationMutation, { data, loading, error }] = useRevokeDelegationMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      reason: // value for 'reason'
+ *   },
+ * });
+ */
+export declare function useRevokeDelegationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RevokeDelegationMutation, Types.RevokeDelegationMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RevokeDelegationMutation, any, Apollo.ApolloCache>;
+export type RevokeDelegationMutationHookResult = ReturnType<typeof useRevokeDelegationMutation>;
+export type RevokeDelegationMutationResult = Apollo.MutationResult<Types.RevokeDelegationMutation>;
+export type RevokeDelegationMutationOptions = Apollo.BaseMutationOptions<Types.RevokeDelegationMutation, Types.RevokeDelegationMutationVariables>;
+export declare const SignInDocument: Apollo.DocumentNode;
+export type SignInMutationFn = Apollo.MutationFunction<Types.SignInMutation, Types.SignInMutationVariables>;
+/**
+ * __useSignInMutation__
+ *
+ * To run a mutation, you first call `useSignInMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSignInMutation` 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 [signInMutation, { data, loading, error }] = useSignInMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useSignInMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SignInMutation, Types.SignInMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.SignInMutation, any, Apollo.ApolloCache>;
+export type SignInMutationHookResult = ReturnType<typeof useSignInMutation>;
+export type SignInMutationResult = Apollo.MutationResult<Types.SignInMutation>;
+export type SignInMutationOptions = Apollo.BaseMutationOptions<Types.SignInMutation, Types.SignInMutationVariables>;
+export declare const SignUpDocument: Apollo.DocumentNode;
+export type SignUpMutationFn = Apollo.MutationFunction<Types.SignUpMutation, Types.SignUpMutationVariables>;
+/**
+ * __useSignUpMutation__
+ *
+ * To run a mutation, you first call `useSignUpMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSignUpMutation` 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 [signUpMutation, { data, loading, error }] = useSignUpMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useSignUpMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SignUpMutation, Types.SignUpMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.SignUpMutation, any, Apollo.ApolloCache>;
+export type SignUpMutationHookResult = ReturnType<typeof useSignUpMutation>;
+export type SignUpMutationResult = Apollo.MutationResult<Types.SignUpMutation>;
+export type SignUpMutationOptions = Apollo.BaseMutationOptions<Types.SignUpMutation, Types.SignUpMutationVariables>;
+export declare const RefreshTokenDocument: Apollo.DocumentNode;
+export type RefreshTokenMutationFn = Apollo.MutationFunction<Types.RefreshTokenMutation, Types.RefreshTokenMutationVariables>;
+/**
+ * __useRefreshTokenMutation__
+ *
+ * To run a mutation, you first call `useRefreshTokenMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRefreshTokenMutation` 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 [refreshTokenMutation, { data, loading, error }] = useRefreshTokenMutation({
+ *   variables: {
+ *      token: // value for 'token'
+ *   },
+ * });
+ */
+export declare function useRefreshTokenMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RefreshTokenMutation, Types.RefreshTokenMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RefreshTokenMutation, any, Apollo.ApolloCache>;
+export type RefreshTokenMutationHookResult = ReturnType<typeof useRefreshTokenMutation>;
+export type RefreshTokenMutationResult = Apollo.MutationResult<Types.RefreshTokenMutation>;
+export type RefreshTokenMutationOptions = Apollo.BaseMutationOptions<Types.RefreshTokenMutation, Types.RefreshTokenMutationVariables>;
+export declare const SignOutDocument: Apollo.DocumentNode;
+export type SignOutMutationFn = Apollo.MutationFunction<Types.SignOutMutation, Types.SignOutMutationVariables>;
+/**
+ * __useSignOutMutation__
+ *
+ * To run a mutation, you first call `useSignOutMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSignOutMutation` 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 [signOutMutation, { data, loading, error }] = useSignOutMutation({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useSignOutMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SignOutMutation, Types.SignOutMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.SignOutMutation, any, Apollo.ApolloCache>;
+export type SignOutMutationHookResult = ReturnType<typeof useSignOutMutation>;
+export type SignOutMutationResult = Apollo.MutationResult<Types.SignOutMutation>;
+export type SignOutMutationOptions = Apollo.BaseMutationOptions<Types.SignOutMutation, Types.SignOutMutationVariables>;
+export declare const ResendVerificationEmailDocument: Apollo.DocumentNode;
+export type ResendVerificationEmailMutationFn = Apollo.MutationFunction<Types.ResendVerificationEmailMutation, Types.ResendVerificationEmailMutationVariables>;
+/**
+ * __useResendVerificationEmailMutation__
+ *
+ * To run a mutation, you first call `useResendVerificationEmailMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useResendVerificationEmailMutation` 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 [resendVerificationEmailMutation, { data, loading, error }] = useResendVerificationEmailMutation({
+ *   variables: {
+ *      email: // value for 'email'
+ *   },
+ * });
+ */
+export declare function useResendVerificationEmailMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ResendVerificationEmailMutation, Types.ResendVerificationEmailMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ResendVerificationEmailMutation, any, Apollo.ApolloCache>;
+export type ResendVerificationEmailMutationHookResult = ReturnType<typeof useResendVerificationEmailMutation>;
+export type ResendVerificationEmailMutationResult = Apollo.MutationResult<Types.ResendVerificationEmailMutation>;
+export type ResendVerificationEmailMutationOptions = Apollo.BaseMutationOptions<Types.ResendVerificationEmailMutation, Types.ResendVerificationEmailMutationVariables>;
+export declare const SendMagicLinkDocument: Apollo.DocumentNode;
+export type SendMagicLinkMutationFn = Apollo.MutationFunction<Types.SendMagicLinkMutation, Types.SendMagicLinkMutationVariables>;
+/**
+ * __useSendMagicLinkMutation__
+ *
+ * To run a mutation, you first call `useSendMagicLinkMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSendMagicLinkMutation` 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 [sendMagicLinkMutation, { data, loading, error }] = useSendMagicLinkMutation({
+ *   variables: {
+ *      email: // value for 'email'
+ *      context: // value for 'context'
+ *   },
+ * });
+ */
+export declare function useSendMagicLinkMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SendMagicLinkMutation, Types.SendMagicLinkMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.SendMagicLinkMutation, any, Apollo.ApolloCache>;
+export type SendMagicLinkMutationHookResult = ReturnType<typeof useSendMagicLinkMutation>;
+export type SendMagicLinkMutationResult = Apollo.MutationResult<Types.SendMagicLinkMutation>;
+export type SendMagicLinkMutationOptions = Apollo.BaseMutationOptions<Types.SendMagicLinkMutation, Types.SendMagicLinkMutationVariables>;
+export declare const AuthenticateMagicLinkDocument: Apollo.DocumentNode;
+export type AuthenticateMagicLinkMutationFn = Apollo.MutationFunction<Types.AuthenticateMagicLinkMutation, Types.AuthenticateMagicLinkMutationVariables>;
+/**
+ * __useAuthenticateMagicLinkMutation__
+ *
+ * To run a mutation, you first call `useAuthenticateMagicLinkMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAuthenticateMagicLinkMutation` 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 [authenticateMagicLinkMutation, { data, loading, error }] = useAuthenticateMagicLinkMutation({
+ *   variables: {
+ *      token: // value for 'token'
+ *   },
+ * });
+ */
+export declare function useAuthenticateMagicLinkMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AuthenticateMagicLinkMutation, Types.AuthenticateMagicLinkMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AuthenticateMagicLinkMutation, any, Apollo.ApolloCache>;
+export type AuthenticateMagicLinkMutationHookResult = ReturnType<typeof useAuthenticateMagicLinkMutation>;
+export type AuthenticateMagicLinkMutationResult = Apollo.MutationResult<Types.AuthenticateMagicLinkMutation>;
+export type AuthenticateMagicLinkMutationOptions = Apollo.BaseMutationOptions<Types.AuthenticateMagicLinkMutation, Types.AuthenticateMagicLinkMutationVariables>;
+export declare const SetupMfaDocument: Apollo.DocumentNode;
+export type SetupMfaMutationFn = Apollo.MutationFunction<Types.SetupMfaMutation, Types.SetupMfaMutationVariables>;
+/**
+ * __useSetupMfaMutation__
+ *
+ * To run a mutation, you first call `useSetupMfaMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSetupMfaMutation` 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 [setupMfaMutation, { data, loading, error }] = useSetupMfaMutation({
+ *   variables: {
+ *      method: // value for 'method'
+ *   },
+ * });
+ */
+export declare function useSetupMfaMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SetupMfaMutation, Types.SetupMfaMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.SetupMfaMutation, any, Apollo.ApolloCache>;
+export type SetupMfaMutationHookResult = ReturnType<typeof useSetupMfaMutation>;
+export type SetupMfaMutationResult = Apollo.MutationResult<Types.SetupMfaMutation>;
+export type SetupMfaMutationOptions = Apollo.BaseMutationOptions<Types.SetupMfaMutation, Types.SetupMfaMutationVariables>;
+export declare const EnableMfaDocument: Apollo.DocumentNode;
+export type EnableMfaMutationFn = Apollo.MutationFunction<Types.EnableMfaMutation, Types.EnableMfaMutationVariables>;
+/**
+ * __useEnableMfaMutation__
+ *
+ * To run a mutation, you first call `useEnableMfaMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useEnableMfaMutation` 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 [enableMfaMutation, { data, loading, error }] = useEnableMfaMutation({
+ *   variables: {
+ *      code: // value for 'code'
+ *   },
+ * });
+ */
+export declare function useEnableMfaMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.EnableMfaMutation, Types.EnableMfaMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.EnableMfaMutation, any, Apollo.ApolloCache>;
+export type EnableMfaMutationHookResult = ReturnType<typeof useEnableMfaMutation>;
+export type EnableMfaMutationResult = Apollo.MutationResult<Types.EnableMfaMutation>;
+export type EnableMfaMutationOptions = Apollo.BaseMutationOptions<Types.EnableMfaMutation, Types.EnableMfaMutationVariables>;
+export declare const VerifyMfaDocument: Apollo.DocumentNode;
+export type VerifyMfaMutationFn = Apollo.MutationFunction<Types.VerifyMfaMutation, Types.VerifyMfaMutationVariables>;
+/**
+ * __useVerifyMfaMutation__
+ *
+ * To run a mutation, you first call `useVerifyMfaMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useVerifyMfaMutation` 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 [verifyMfaMutation, { data, loading, error }] = useVerifyMfaMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useVerifyMfaMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.VerifyMfaMutation, Types.VerifyMfaMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.VerifyMfaMutation, any, Apollo.ApolloCache>;
+export type VerifyMfaMutationHookResult = ReturnType<typeof useVerifyMfaMutation>;
+export type VerifyMfaMutationResult = Apollo.MutationResult<Types.VerifyMfaMutation>;
+export type VerifyMfaMutationOptions = Apollo.BaseMutationOptions<Types.VerifyMfaMutation, Types.VerifyMfaMutationVariables>;
+export declare const DisableMfaDocument: Apollo.DocumentNode;
+export type DisableMfaMutationFn = Apollo.MutationFunction<Types.DisableMfaMutation, Types.DisableMfaMutationVariables>;
+/**
+ * __useDisableMfaMutation__
+ *
+ * To run a mutation, you first call `useDisableMfaMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDisableMfaMutation` 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 [disableMfaMutation, { data, loading, error }] = useDisableMfaMutation({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useDisableMfaMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DisableMfaMutation, Types.DisableMfaMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DisableMfaMutation, any, Apollo.ApolloCache>;
+export type DisableMfaMutationHookResult = ReturnType<typeof useDisableMfaMutation>;
+export type DisableMfaMutationResult = Apollo.MutationResult<Types.DisableMfaMutation>;
+export type DisableMfaMutationOptions = Apollo.BaseMutationOptions<Types.DisableMfaMutation, Types.DisableMfaMutationVariables>;
+export declare const AuthenticateOAuthDocument: Apollo.DocumentNode;
+export type AuthenticateOAuthMutationFn = Apollo.MutationFunction<Types.AuthenticateOAuthMutation, Types.AuthenticateOAuthMutationVariables>;
+/**
+ * __useAuthenticateOAuthMutation__
+ *
+ * To run a mutation, you first call `useAuthenticateOAuthMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAuthenticateOAuthMutation` 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 [authenticateOAuthMutation, { data, loading, error }] = useAuthenticateOAuthMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useAuthenticateOAuthMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AuthenticateOAuthMutation, Types.AuthenticateOAuthMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AuthenticateOAuthMutation, any, Apollo.ApolloCache>;
+export type AuthenticateOAuthMutationHookResult = ReturnType<typeof useAuthenticateOAuthMutation>;
+export type AuthenticateOAuthMutationResult = Apollo.MutationResult<Types.AuthenticateOAuthMutation>;
+export type AuthenticateOAuthMutationOptions = Apollo.BaseMutationOptions<Types.AuthenticateOAuthMutation, Types.AuthenticateOAuthMutationVariables>;
+export declare const ChangePasswordDocument: Apollo.DocumentNode;
+export type ChangePasswordMutationFn = Apollo.MutationFunction<Types.ChangePasswordMutation, Types.ChangePasswordMutationVariables>;
+/**
+ * __useChangePasswordMutation__
+ *
+ * To run a mutation, you first call `useChangePasswordMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useChangePasswordMutation` 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 [changePasswordMutation, { data, loading, error }] = useChangePasswordMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useChangePasswordMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ChangePasswordMutation, Types.ChangePasswordMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ChangePasswordMutation, any, Apollo.ApolloCache>;
+export type ChangePasswordMutationHookResult = ReturnType<typeof useChangePasswordMutation>;
+export type ChangePasswordMutationResult = Apollo.MutationResult<Types.ChangePasswordMutation>;
+export type ChangePasswordMutationOptions = Apollo.BaseMutationOptions<Types.ChangePasswordMutation, Types.ChangePasswordMutationVariables>;
+export declare const RequestPasswordResetDocument: Apollo.DocumentNode;
+export type RequestPasswordResetMutationFn = Apollo.MutationFunction<Types.RequestPasswordResetMutation, Types.RequestPasswordResetMutationVariables>;
+/**
+ * __useRequestPasswordResetMutation__
+ *
+ * To run a mutation, you first call `useRequestPasswordResetMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRequestPasswordResetMutation` 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 [requestPasswordResetMutation, { data, loading, error }] = useRequestPasswordResetMutation({
+ *   variables: {
+ *      email: // value for 'email'
+ *      recaptchaToken: // value for 'recaptchaToken'
+ *   },
+ * });
+ */
+export declare function useRequestPasswordResetMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RequestPasswordResetMutation, Types.RequestPasswordResetMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RequestPasswordResetMutation, any, Apollo.ApolloCache>;
+export type RequestPasswordResetMutationHookResult = ReturnType<typeof useRequestPasswordResetMutation>;
+export type RequestPasswordResetMutationResult = Apollo.MutationResult<Types.RequestPasswordResetMutation>;
+export type RequestPasswordResetMutationOptions = Apollo.BaseMutationOptions<Types.RequestPasswordResetMutation, Types.RequestPasswordResetMutationVariables>;
+export declare const ResetPasswordDocument: Apollo.DocumentNode;
+export type ResetPasswordMutationFn = Apollo.MutationFunction<Types.ResetPasswordMutation, Types.ResetPasswordMutationVariables>;
+/**
+ * __useResetPasswordMutation__
+ *
+ * To run a mutation, you first call `useResetPasswordMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useResetPasswordMutation` 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 [resetPasswordMutation, { data, loading, error }] = useResetPasswordMutation({
+ *   variables: {
+ *      token: // value for 'token'
+ *      newPassword: // value for 'newPassword'
+ *   },
+ * });
+ */
+export declare function useResetPasswordMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ResetPasswordMutation, Types.ResetPasswordMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ResetPasswordMutation, any, Apollo.ApolloCache>;
+export type ResetPasswordMutationHookResult = ReturnType<typeof useResetPasswordMutation>;
+export type ResetPasswordMutationResult = Apollo.MutationResult<Types.ResetPasswordMutation>;
+export type ResetPasswordMutationOptions = Apollo.BaseMutationOptions<Types.ResetPasswordMutation, Types.ResetPasswordMutationVariables>;
+export declare const VerifyEmailDocument: Apollo.DocumentNode;
+export type VerifyEmailMutationFn = Apollo.MutationFunction<Types.VerifyEmailMutation, Types.VerifyEmailMutationVariables>;
+/**
+ * __useVerifyEmailMutation__
+ *
+ * To run a mutation, you first call `useVerifyEmailMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useVerifyEmailMutation` 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 [verifyEmailMutation, { data, loading, error }] = useVerifyEmailMutation({
+ *   variables: {
+ *      token: // value for 'token'
+ *   },
+ * });
+ */
+export declare function useVerifyEmailMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.VerifyEmailMutation, Types.VerifyEmailMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.VerifyEmailMutation, any, Apollo.ApolloCache>;
+export type VerifyEmailMutationHookResult = ReturnType<typeof useVerifyEmailMutation>;
+export type VerifyEmailMutationResult = Apollo.MutationResult<Types.VerifyEmailMutation>;
+export type VerifyEmailMutationOptions = Apollo.BaseMutationOptions<Types.VerifyEmailMutation, Types.VerifyEmailMutationVariables>;
+export declare const EnableAuthMethodDocument: Apollo.DocumentNode;
+export type EnableAuthMethodMutationFn = Apollo.MutationFunction<Types.EnableAuthMethodMutation, Types.EnableAuthMethodMutationVariables>;
+/**
+ * __useEnableAuthMethodMutation__
+ *
+ * To run a mutation, you first call `useEnableAuthMethodMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useEnableAuthMethodMutation` 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 [enableAuthMethodMutation, { data, loading, error }] = useEnableAuthMethodMutation({
+ *   variables: {
+ *      authType: // value for 'authType'
+ *      config: // value for 'config'
+ *   },
+ * });
+ */
+export declare function useEnableAuthMethodMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.EnableAuthMethodMutation, Types.EnableAuthMethodMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.EnableAuthMethodMutation, any, Apollo.ApolloCache>;
+export type EnableAuthMethodMutationHookResult = ReturnType<typeof useEnableAuthMethodMutation>;
+export type EnableAuthMethodMutationResult = Apollo.MutationResult<Types.EnableAuthMethodMutation>;
+export type EnableAuthMethodMutationOptions = Apollo.BaseMutationOptions<Types.EnableAuthMethodMutation, Types.EnableAuthMethodMutationVariables>;
+export declare const DisableAuthMethodDocument: Apollo.DocumentNode;
+export type DisableAuthMethodMutationFn = Apollo.MutationFunction<Types.DisableAuthMethodMutation, Types.DisableAuthMethodMutationVariables>;
+/**
+ * __useDisableAuthMethodMutation__
+ *
+ * To run a mutation, you first call `useDisableAuthMethodMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDisableAuthMethodMutation` 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 [disableAuthMethodMutation, { data, loading, error }] = useDisableAuthMethodMutation({
+ *   variables: {
+ *      authType: // value for 'authType'
+ *   },
+ * });
+ */
+export declare function useDisableAuthMethodMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DisableAuthMethodMutation, Types.DisableAuthMethodMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DisableAuthMethodMutation, any, Apollo.ApolloCache>;
+export type DisableAuthMethodMutationHookResult = ReturnType<typeof useDisableAuthMethodMutation>;
+export type DisableAuthMethodMutationResult = Apollo.MutationResult<Types.DisableAuthMethodMutation>;
+export type DisableAuthMethodMutationOptions = Apollo.BaseMutationOptions<Types.DisableAuthMethodMutation, Types.DisableAuthMethodMutationVariables>;
+export declare const RevokeSessionDocument: Apollo.DocumentNode;
+export type RevokeSessionMutationFn = Apollo.MutationFunction<Types.RevokeSessionMutation, Types.RevokeSessionMutationVariables>;
+/**
+ * __useRevokeSessionMutation__
+ *
+ * To run a mutation, you first call `useRevokeSessionMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRevokeSessionMutation` 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 [revokeSessionMutation, { data, loading, error }] = useRevokeSessionMutation({
+ *   variables: {
+ *      sessionId: // value for 'sessionId'
+ *   },
+ * });
+ */
+export declare function useRevokeSessionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RevokeSessionMutation, Types.RevokeSessionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RevokeSessionMutation, any, Apollo.ApolloCache>;
+export type RevokeSessionMutationHookResult = ReturnType<typeof useRevokeSessionMutation>;
+export type RevokeSessionMutationResult = Apollo.MutationResult<Types.RevokeSessionMutation>;
+export type RevokeSessionMutationOptions = Apollo.BaseMutationOptions<Types.RevokeSessionMutation, Types.RevokeSessionMutationVariables>;
+export declare const RevokeAllSessionsDocument: Apollo.DocumentNode;
+export type RevokeAllSessionsMutationFn = Apollo.MutationFunction<Types.RevokeAllSessionsMutation, Types.RevokeAllSessionsMutationVariables>;
+/**
+ * __useRevokeAllSessionsMutation__
+ *
+ * To run a mutation, you first call `useRevokeAllSessionsMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRevokeAllSessionsMutation` 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 [revokeAllSessionsMutation, { data, loading, error }] = useRevokeAllSessionsMutation({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useRevokeAllSessionsMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RevokeAllSessionsMutation, Types.RevokeAllSessionsMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RevokeAllSessionsMutation, any, Apollo.ApolloCache>;
+export type RevokeAllSessionsMutationHookResult = ReturnType<typeof useRevokeAllSessionsMutation>;
+export type RevokeAllSessionsMutationResult = Apollo.MutationResult<Types.RevokeAllSessionsMutation>;
+export type RevokeAllSessionsMutationOptions = Apollo.BaseMutationOptions<Types.RevokeAllSessionsMutation, Types.RevokeAllSessionsMutationVariables>;
+export declare const AuthenticateSamlDocument: Apollo.DocumentNode;
+export type AuthenticateSamlMutationFn = Apollo.MutationFunction<Types.AuthenticateSamlMutation, Types.AuthenticateSamlMutationVariables>;
+/**
+ * __useAuthenticateSamlMutation__
+ *
+ * To run a mutation, you first call `useAuthenticateSamlMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAuthenticateSamlMutation` 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 [authenticateSamlMutation, { data, loading, error }] = useAuthenticateSamlMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useAuthenticateSamlMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AuthenticateSamlMutation, Types.AuthenticateSamlMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AuthenticateSamlMutation, any, Apollo.ApolloCache>;
+export type AuthenticateSamlMutationHookResult = ReturnType<typeof useAuthenticateSamlMutation>;
+export type AuthenticateSamlMutationResult = Apollo.MutationResult<Types.AuthenticateSamlMutation>;
+export type AuthenticateSamlMutationOptions = Apollo.BaseMutationOptions<Types.AuthenticateSamlMutation, Types.AuthenticateSamlMutationVariables>;
+export declare const GenerateSamlRequestDocument: Apollo.DocumentNode;
+export type GenerateSamlRequestMutationFn = Apollo.MutationFunction<Types.GenerateSamlRequestMutation, Types.GenerateSamlRequestMutationVariables>;
+/**
+ * __useGenerateSamlRequestMutation__
+ *
+ * To run a mutation, you first call `useGenerateSamlRequestMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useGenerateSamlRequestMutation` 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 [generateSamlRequestMutation, { data, loading, error }] = useGenerateSamlRequestMutation({
+ *   variables: {
+ *      tenantId: // value for 'tenantId'
+ *      relayState: // value for 'relayState'
+ *   },
+ * });
+ */
+export declare function useGenerateSamlRequestMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.GenerateSamlRequestMutation, Types.GenerateSamlRequestMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.GenerateSamlRequestMutation, any, Apollo.ApolloCache>;
+export type GenerateSamlRequestMutationHookResult = ReturnType<typeof useGenerateSamlRequestMutation>;
+export type GenerateSamlRequestMutationResult = Apollo.MutationResult<Types.GenerateSamlRequestMutation>;
+export type GenerateSamlRequestMutationOptions = Apollo.BaseMutationOptions<Types.GenerateSamlRequestMutation, Types.GenerateSamlRequestMutationVariables>;
+export declare const SaveSsoConfigDocument: Apollo.DocumentNode;
+export type SaveSsoConfigMutationFn = Apollo.MutationFunction<Types.SaveSsoConfigMutation, Types.SaveSsoConfigMutationVariables>;
+/**
+ * __useSaveSsoConfigMutation__
+ *
+ * To run a mutation, you first call `useSaveSsoConfigMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSaveSsoConfigMutation` 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 [saveSsoConfigMutation, { data, loading, error }] = useSaveSsoConfigMutation({
+ *   variables: {
+ *      tenantId: // value for 'tenantId'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useSaveSsoConfigMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SaveSsoConfigMutation, Types.SaveSsoConfigMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.SaveSsoConfigMutation, any, Apollo.ApolloCache>;
+export type SaveSsoConfigMutationHookResult = ReturnType<typeof useSaveSsoConfigMutation>;
+export type SaveSsoConfigMutationResult = Apollo.MutationResult<Types.SaveSsoConfigMutation>;
+export type SaveSsoConfigMutationOptions = Apollo.BaseMutationOptions<Types.SaveSsoConfigMutation, Types.SaveSsoConfigMutationVariables>;
+export declare const DeleteSsoConfigDocument: Apollo.DocumentNode;
+export type DeleteSsoConfigMutationFn = Apollo.MutationFunction<Types.DeleteSsoConfigMutation, Types.DeleteSsoConfigMutationVariables>;
+/**
+ * __useDeleteSsoConfigMutation__
+ *
+ * To run a mutation, you first call `useDeleteSsoConfigMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteSsoConfigMutation` 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 [deleteSsoConfigMutation, { data, loading, error }] = useDeleteSsoConfigMutation({
+ *   variables: {
+ *      tenantId: // value for 'tenantId'
+ *   },
+ * });
+ */
+export declare function useDeleteSsoConfigMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteSsoConfigMutation, Types.DeleteSsoConfigMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteSsoConfigMutation, any, Apollo.ApolloCache>;
+export type DeleteSsoConfigMutationHookResult = ReturnType<typeof useDeleteSsoConfigMutation>;
+export type DeleteSsoConfigMutationResult = Apollo.MutationResult<Types.DeleteSsoConfigMutation>;
+export type DeleteSsoConfigMutationOptions = Apollo.BaseMutationOptions<Types.DeleteSsoConfigMutation, Types.DeleteSsoConfigMutationVariables>;
+export declare const GenerateOidcAuthUrlDocument: Apollo.DocumentNode;
+export type GenerateOidcAuthUrlMutationFn = Apollo.MutationFunction<Types.GenerateOidcAuthUrlMutation, Types.GenerateOidcAuthUrlMutationVariables>;
+/**
+ * __useGenerateOidcAuthUrlMutation__
+ *
+ * To run a mutation, you first call `useGenerateOidcAuthUrlMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useGenerateOidcAuthUrlMutation` 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 [generateOidcAuthUrlMutation, { data, loading, error }] = useGenerateOidcAuthUrlMutation({
+ *   variables: {
+ *      tenantId: // value for 'tenantId'
+ *      state: // value for 'state'
+ *   },
+ * });
+ */
+export declare function useGenerateOidcAuthUrlMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.GenerateOidcAuthUrlMutation, Types.GenerateOidcAuthUrlMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.GenerateOidcAuthUrlMutation, any, Apollo.ApolloCache>;
+export type GenerateOidcAuthUrlMutationHookResult = ReturnType<typeof useGenerateOidcAuthUrlMutation>;
+export type GenerateOidcAuthUrlMutationResult = Apollo.MutationResult<Types.GenerateOidcAuthUrlMutation>;
+export type GenerateOidcAuthUrlMutationOptions = Apollo.BaseMutationOptions<Types.GenerateOidcAuthUrlMutation, Types.GenerateOidcAuthUrlMutationVariables>;
+export declare const AuthenticateOidcDocument: Apollo.DocumentNode;
+export type AuthenticateOidcMutationFn = Apollo.MutationFunction<Types.AuthenticateOidcMutation, Types.AuthenticateOidcMutationVariables>;
+/**
+ * __useAuthenticateOidcMutation__
+ *
+ * To run a mutation, you first call `useAuthenticateOidcMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAuthenticateOidcMutation` 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 [authenticateOidcMutation, { data, loading, error }] = useAuthenticateOidcMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useAuthenticateOidcMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AuthenticateOidcMutation, Types.AuthenticateOidcMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AuthenticateOidcMutation, any, Apollo.ApolloCache>;
+export type AuthenticateOidcMutationHookResult = ReturnType<typeof useAuthenticateOidcMutation>;
+export type AuthenticateOidcMutationResult = Apollo.MutationResult<Types.AuthenticateOidcMutation>;
+export type AuthenticateOidcMutationOptions = Apollo.BaseMutationOptions<Types.AuthenticateOidcMutation, Types.AuthenticateOidcMutationVariables>;
+export declare const ValidateTokensDocument: Apollo.DocumentNode;
+export type ValidateTokensMutationFn = Apollo.MutationFunction<Types.ValidateTokensMutation, Types.ValidateTokensMutationVariables>;
+/**
+ * __useValidateTokensMutation__
+ *
+ * To run a mutation, you first call `useValidateTokensMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useValidateTokensMutation` 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 [validateTokensMutation, { data, loading, error }] = useValidateTokensMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useValidateTokensMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ValidateTokensMutation, Types.ValidateTokensMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ValidateTokensMutation, any, Apollo.ApolloCache>;
+export type ValidateTokensMutationHookResult = ReturnType<typeof useValidateTokensMutation>;
+export type ValidateTokensMutationResult = Apollo.MutationResult<Types.ValidateTokensMutation>;
+export type ValidateTokensMutationOptions = Apollo.BaseMutationOptions<Types.ValidateTokensMutation, Types.ValidateTokensMutationVariables>;
+export declare const UpdateCurrentUserProfileDocument: Apollo.DocumentNode;
+export type UpdateCurrentUserProfileMutationFn = Apollo.MutationFunction<Types.UpdateCurrentUserProfileMutation, Types.UpdateCurrentUserProfileMutationVariables>;
+/**
+ * __useUpdateCurrentUserProfileMutation__
+ *
+ * To run a mutation, you first call `useUpdateCurrentUserProfileMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateCurrentUserProfileMutation` 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 [updateCurrentUserProfileMutation, { data, loading, error }] = useUpdateCurrentUserProfileMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateCurrentUserProfileMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateCurrentUserProfileMutation, Types.UpdateCurrentUserProfileMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateCurrentUserProfileMutation, any, Apollo.ApolloCache>;
+export type UpdateCurrentUserProfileMutationHookResult = ReturnType<typeof useUpdateCurrentUserProfileMutation>;
+export type UpdateCurrentUserProfileMutationResult = Apollo.MutationResult<Types.UpdateCurrentUserProfileMutation>;
+export type UpdateCurrentUserProfileMutationOptions = Apollo.BaseMutationOptions<Types.UpdateCurrentUserProfileMutation, Types.UpdateCurrentUserProfileMutationVariables>;
+export declare const UpdateUserDocument: Apollo.DocumentNode;
+export type UpdateUserMutationFn = Apollo.MutationFunction<Types.UpdateUserMutation, Types.UpdateUserMutationVariables>;
+/**
+ * __useUpdateUserMutation__
+ *
+ * To run a mutation, you first call `useUpdateUserMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateUserMutation` 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 [updateUserMutation, { data, loading, error }] = useUpdateUserMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateUserMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateUserMutation, Types.UpdateUserMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateUserMutation, any, Apollo.ApolloCache>;
+export type UpdateUserMutationHookResult = ReturnType<typeof useUpdateUserMutation>;
+export type UpdateUserMutationResult = Apollo.MutationResult<Types.UpdateUserMutation>;
+export type UpdateUserMutationOptions = Apollo.BaseMutationOptions<Types.UpdateUserMutation, Types.UpdateUserMutationVariables>;
+export declare const DeleteUserDocument: Apollo.DocumentNode;
+export type DeleteUserMutationFn = Apollo.MutationFunction<Types.DeleteUserMutation, Types.DeleteUserMutationVariables>;
+/**
+ * __useDeleteUserMutation__
+ *
+ * To run a mutation, you first call `useDeleteUserMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDeleteUserMutation` 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 [deleteUserMutation, { data, loading, error }] = useDeleteUserMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useDeleteUserMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteUserMutation, Types.DeleteUserMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteUserMutation, any, Apollo.ApolloCache>;
+export type DeleteUserMutationHookResult = ReturnType<typeof useDeleteUserMutation>;
+export type DeleteUserMutationResult = Apollo.MutationResult<Types.DeleteUserMutation>;
+export type DeleteUserMutationOptions = Apollo.BaseMutationOptions<Types.DeleteUserMutation, Types.DeleteUserMutationVariables>;
+export declare const HardDeleteUserDocument: Apollo.DocumentNode;
+export type HardDeleteUserMutationFn = Apollo.MutationFunction<Types.HardDeleteUserMutation, Types.HardDeleteUserMutationVariables>;
+/**
+ * __useHardDeleteUserMutation__
+ *
+ * To run a mutation, you first call `useHardDeleteUserMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useHardDeleteUserMutation` 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 [hardDeleteUserMutation, { data, loading, error }] = useHardDeleteUserMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useHardDeleteUserMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.HardDeleteUserMutation, Types.HardDeleteUserMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.HardDeleteUserMutation, any, Apollo.ApolloCache>;
+export type HardDeleteUserMutationHookResult = ReturnType<typeof useHardDeleteUserMutation>;
+export type HardDeleteUserMutationResult = Apollo.MutationResult<Types.HardDeleteUserMutation>;
+export type HardDeleteUserMutationOptions = Apollo.BaseMutationOptions<Types.HardDeleteUserMutation, Types.HardDeleteUserMutationVariables>;
+export declare const CreateWorkspaceDocument: Apollo.DocumentNode;
+export type CreateWorkspaceMutationFn = Apollo.MutationFunction<Types.CreateWorkspaceMutation, Types.CreateWorkspaceMutationVariables>;
+/**
+ * __useCreateWorkspaceMutation__
+ *
+ * To run a mutation, you first call `useCreateWorkspaceMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateWorkspaceMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [createWorkspaceMutation, { data, loading, error }] = useCreateWorkspaceMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useCreateWorkspaceMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateWorkspaceMutation, Types.CreateWorkspaceMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateWorkspaceMutation, any, Apollo.ApolloCache>;
+export type CreateWorkspaceMutationHookResult = ReturnType<typeof useCreateWorkspaceMutation>;
+export type CreateWorkspaceMutationResult = Apollo.MutationResult<Types.CreateWorkspaceMutation>;
+export type CreateWorkspaceMutationOptions = Apollo.BaseMutationOptions<Types.CreateWorkspaceMutation, Types.CreateWorkspaceMutationVariables>;
+export declare const UpdateWorkspaceDocument: Apollo.DocumentNode;
+export type UpdateWorkspaceMutationFn = Apollo.MutationFunction<Types.UpdateWorkspaceMutation, Types.UpdateWorkspaceMutationVariables>;
+/**
+ * __useUpdateWorkspaceMutation__
+ *
+ * To run a mutation, you first call `useUpdateWorkspaceMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateWorkspaceMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [updateWorkspaceMutation, { data, loading, error }] = useUpdateWorkspaceMutation({
+ *   variables: {
+ *      id: // value for 'id'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateWorkspaceMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateWorkspaceMutation, Types.UpdateWorkspaceMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateWorkspaceMutation, any, Apollo.ApolloCache>;
+export type UpdateWorkspaceMutationHookResult = ReturnType<typeof useUpdateWorkspaceMutation>;
+export type UpdateWorkspaceMutationResult = Apollo.MutationResult<Types.UpdateWorkspaceMutation>;
+export type UpdateWorkspaceMutationOptions = Apollo.BaseMutationOptions<Types.UpdateWorkspaceMutation, Types.UpdateWorkspaceMutationVariables>;
+export declare const AddWorkspaceMemberDocument: Apollo.DocumentNode;
+export type AddWorkspaceMemberMutationFn = Apollo.MutationFunction<Types.AddWorkspaceMemberMutation, Types.AddWorkspaceMemberMutationVariables>;
+/**
+ * __useAddWorkspaceMemberMutation__
+ *
+ * To run a mutation, you first call `useAddWorkspaceMemberMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddWorkspaceMemberMutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [addWorkspaceMemberMutation, { data, loading, error }] = useAddWorkspaceMemberMutation({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useAddWorkspaceMemberMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AddWorkspaceMemberMutation, Types.AddWorkspaceMemberMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AddWorkspaceMemberMutation, any, Apollo.ApolloCache>;
+export type AddWorkspaceMemberMutationHookResult = ReturnType<typeof useAddWorkspaceMemberMutation>;
+export type AddWorkspaceMemberMutationResult = Apollo.MutationResult<Types.AddWorkspaceMemberMutation>;
+export type AddWorkspaceMemberMutationOptions = Apollo.BaseMutationOptions<Types.AddWorkspaceMemberMutation, Types.AddWorkspaceMemberMutationVariables>;
+export declare const UpdateWorkspaceMemberDocument: Apollo.DocumentNode;
+export type UpdateWorkspaceMemberMutationFn = Apollo.MutationFunction<Types.UpdateWorkspaceMemberMutation, Types.UpdateWorkspaceMemberMutationVariables>;
+/**
+ * __useUpdateWorkspaceMemberMutation__
+ *
+ * To run a mutation, you first call `useUpdateWorkspaceMemberMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateWorkspaceMemberMutation` 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 [updateWorkspaceMemberMutation, { data, loading, error }] = useUpdateWorkspaceMemberMutation({
+ *   variables: {
+ *      workspaceId: // value for 'workspaceId'
+ *      userId: // value for 'userId'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export declare function useUpdateWorkspaceMemberMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateWorkspaceMemberMutation, Types.UpdateWorkspaceMemberMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateWorkspaceMemberMutation, any, Apollo.ApolloCache>;
+export type UpdateWorkspaceMemberMutationHookResult = ReturnType<typeof useUpdateWorkspaceMemberMutation>;
+export type UpdateWorkspaceMemberMutationResult = Apollo.MutationResult<Types.UpdateWorkspaceMemberMutation>;
+export type UpdateWorkspaceMemberMutationOptions = Apollo.BaseMutationOptions<Types.UpdateWorkspaceMemberMutation, Types.UpdateWorkspaceMemberMutationVariables>;
+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>): ApolloReactHooks.useMutation.ResultTuple<Types.RemoveWorkspaceMemberMutation, any, Apollo.ApolloCache>;
+export type RemoveWorkspaceMemberMutationHookResult = ReturnType<typeof useRemoveWorkspaceMemberMutation>;
+export type RemoveWorkspaceMemberMutationResult = Apollo.MutationResult<Types.RemoveWorkspaceMemberMutation>;
+export type RemoveWorkspaceMemberMutationOptions = Apollo.BaseMutationOptions<Types.RemoveWorkspaceMemberMutation, Types.RemoveWorkspaceMemberMutationVariables>;
+export declare const MyApiKeysDocument: Apollo.DocumentNode;
+/**
+ * __useMyApiKeysQuery__
+ *
+ * To run a query within a React component, call `useMyApiKeysQuery` and pass it any options that fit your needs.
+ * When your component renders, `useMyApiKeysQuery` 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 } = useMyApiKeysQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useMyApiKeysQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.MyApiKeysQuery, Types.MyApiKeysQueryVariables>): ApolloReactHooks.useQuery.Result<Types.MyApiKeysQuery, Types.MyApiKeysQueryVariables, "empty" | "complete" | "streaming", Types.MyApiKeysQueryVariables>;
+export declare function useMyApiKeysLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.MyApiKeysQuery, Types.MyApiKeysQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.MyApiKeysQuery, Types.MyApiKeysQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useMyApiKeysSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.MyApiKeysQuery, Types.MyApiKeysQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.MyApiKeysQuery, Types.MyApiKeysQueryVariables>;
+export declare function useMyApiKeysSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.MyApiKeysQuery, Types.MyApiKeysQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.MyApiKeysQuery | undefined, Types.MyApiKeysQueryVariables>;
+export type MyApiKeysQueryHookResult = ReturnType<typeof useMyApiKeysQuery>;
+export type MyApiKeysLazyQueryHookResult = ReturnType<typeof useMyApiKeysLazyQuery>;
+export type MyApiKeysSuspenseQueryHookResult = ReturnType<typeof useMyApiKeysSuspenseQuery>;
+export type MyApiKeysQueryResult = Apollo.QueryResult<Types.MyApiKeysQuery, Types.MyApiKeysQueryVariables>;
+export declare const CurrentUserAppsDocument: Apollo.DocumentNode;
+/**
+ * __useCurrentUserAppsQuery__
+ *
+ * To run a query within a React component, call `useCurrentUserAppsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCurrentUserAppsQuery` 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 } = useCurrentUserAppsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useCurrentUserAppsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.CurrentUserAppsQuery, Types.CurrentUserAppsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.CurrentUserAppsQuery, Types.CurrentUserAppsQueryVariables, "empty" | "complete" | "streaming", Types.CurrentUserAppsQueryVariables>;
+export declare function useCurrentUserAppsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.CurrentUserAppsQuery, Types.CurrentUserAppsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.CurrentUserAppsQuery, Types.CurrentUserAppsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useCurrentUserAppsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.CurrentUserAppsQuery, Types.CurrentUserAppsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.CurrentUserAppsQuery, Types.CurrentUserAppsQueryVariables>;
+export declare function useCurrentUserAppsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.CurrentUserAppsQuery, Types.CurrentUserAppsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.CurrentUserAppsQuery | undefined, Types.CurrentUserAppsQueryVariables>;
+export type CurrentUserAppsQueryHookResult = ReturnType<typeof useCurrentUserAppsQuery>;
+export type CurrentUserAppsLazyQueryHookResult = ReturnType<typeof useCurrentUserAppsLazyQuery>;
+export type CurrentUserAppsSuspenseQueryHookResult = ReturnType<typeof useCurrentUserAppsSuspenseQuery>;
+export type CurrentUserAppsQueryResult = Apollo.QueryResult<Types.CurrentUserAppsQuery, Types.CurrentUserAppsQueryVariables>;
+export declare const GetAppDocument: Apollo.DocumentNode;
+/**
+ * __useGetAppQuery__
+ *
+ * To run a query within a React component, call `useGetAppQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetAppQuery` 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 } = useGetAppQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetAppQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetAppQuery, Types.GetAppQueryVariables> & ({
+    variables: Types.GetAppQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetAppQuery, Types.GetAppQueryVariables, "empty" | "complete" | "streaming", Types.GetAppQueryVariables>;
+export declare function useGetAppLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetAppQuery, Types.GetAppQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetAppQuery, Types.GetAppQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetAppSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetAppQuery, Types.GetAppQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetAppQuery, Types.GetAppQueryVariables>;
+export declare function useGetAppSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetAppQuery, Types.GetAppQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetAppQuery | undefined, Types.GetAppQueryVariables>;
+export type GetAppQueryHookResult = ReturnType<typeof useGetAppQuery>;
+export type GetAppLazyQueryHookResult = ReturnType<typeof useGetAppLazyQuery>;
+export type GetAppSuspenseQueryHookResult = ReturnType<typeof useGetAppSuspenseQuery>;
+export type GetAppQueryResult = Apollo.QueryResult<Types.GetAppQuery, Types.GetAppQueryVariables>;
+export declare const AppsActingAsCurrentUserDocument: Apollo.DocumentNode;
+/**
+ * __useAppsActingAsCurrentUserQuery__
+ *
+ * To run a query within a React component, call `useAppsActingAsCurrentUserQuery` and pass it any options that fit your needs.
+ * When your component renders, `useAppsActingAsCurrentUserQuery` 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 } = useAppsActingAsCurrentUserQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useAppsActingAsCurrentUserQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.AppsActingAsCurrentUserQuery, Types.AppsActingAsCurrentUserQueryVariables>): ApolloReactHooks.useQuery.Result<Types.AppsActingAsCurrentUserQuery, Types.AppsActingAsCurrentUserQueryVariables, "empty" | "complete" | "streaming", Types.AppsActingAsCurrentUserQueryVariables>;
+export declare function useAppsActingAsCurrentUserLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.AppsActingAsCurrentUserQuery, Types.AppsActingAsCurrentUserQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.AppsActingAsCurrentUserQuery, Types.AppsActingAsCurrentUserQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useAppsActingAsCurrentUserSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.AppsActingAsCurrentUserQuery, Types.AppsActingAsCurrentUserQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.AppsActingAsCurrentUserQuery, Types.AppsActingAsCurrentUserQueryVariables>;
+export declare function useAppsActingAsCurrentUserSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.AppsActingAsCurrentUserQuery, Types.AppsActingAsCurrentUserQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.AppsActingAsCurrentUserQuery | undefined, Types.AppsActingAsCurrentUserQueryVariables>;
+export type AppsActingAsCurrentUserQueryHookResult = ReturnType<typeof useAppsActingAsCurrentUserQuery>;
+export type AppsActingAsCurrentUserLazyQueryHookResult = ReturnType<typeof useAppsActingAsCurrentUserLazyQuery>;
+export type AppsActingAsCurrentUserSuspenseQueryHookResult = ReturnType<typeof useAppsActingAsCurrentUserSuspenseQuery>;
+export type AppsActingAsCurrentUserQueryResult = Apollo.QueryResult<Types.AppsActingAsCurrentUserQuery, Types.AppsActingAsCurrentUserQueryVariables>;
+export declare const CurrentUserDocument: Apollo.DocumentNode;
+/**
+ * __useCurrentUserQuery__
+ *
+ * To run a query within a React component, call `useCurrentUserQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCurrentUserQuery` 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 } = useCurrentUserQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useCurrentUserQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.CurrentUserQuery, Types.CurrentUserQueryVariables>): ApolloReactHooks.useQuery.Result<Types.CurrentUserQuery, Types.CurrentUserQueryVariables, "empty" | "complete" | "streaming", Types.CurrentUserQueryVariables>;
+export declare function useCurrentUserLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.CurrentUserQuery, Types.CurrentUserQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.CurrentUserQuery, Types.CurrentUserQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useCurrentUserSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.CurrentUserQuery, Types.CurrentUserQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.CurrentUserQuery, Types.CurrentUserQueryVariables>;
+export declare function useCurrentUserSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.CurrentUserQuery, Types.CurrentUserQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.CurrentUserQuery | undefined, Types.CurrentUserQueryVariables>;
+export type CurrentUserQueryHookResult = ReturnType<typeof useCurrentUserQuery>;
+export type CurrentUserLazyQueryHookResult = ReturnType<typeof useCurrentUserLazyQuery>;
+export type CurrentUserSuspenseQueryHookResult = ReturnType<typeof useCurrentUserSuspenseQuery>;
+export type CurrentUserQueryResult = Apollo.QueryResult<Types.CurrentUserQuery, Types.CurrentUserQueryVariables>;
+export declare const CurrentUserDelegationsDocument: Apollo.DocumentNode;
+/**
+ * __useCurrentUserDelegationsQuery__
+ *
+ * To run a query within a React component, call `useCurrentUserDelegationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCurrentUserDelegationsQuery` 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 } = useCurrentUserDelegationsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useCurrentUserDelegationsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.CurrentUserDelegationsQuery, Types.CurrentUserDelegationsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.CurrentUserDelegationsQuery, Types.CurrentUserDelegationsQueryVariables, "empty" | "complete" | "streaming", Types.CurrentUserDelegationsQueryVariables>;
+export declare function useCurrentUserDelegationsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.CurrentUserDelegationsQuery, Types.CurrentUserDelegationsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.CurrentUserDelegationsQuery, Types.CurrentUserDelegationsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useCurrentUserDelegationsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.CurrentUserDelegationsQuery, Types.CurrentUserDelegationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.CurrentUserDelegationsQuery, Types.CurrentUserDelegationsQueryVariables>;
+export declare function useCurrentUserDelegationsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.CurrentUserDelegationsQuery, Types.CurrentUserDelegationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.CurrentUserDelegationsQuery | undefined, Types.CurrentUserDelegationsQueryVariables>;
+export type CurrentUserDelegationsQueryHookResult = ReturnType<typeof useCurrentUserDelegationsQuery>;
+export type CurrentUserDelegationsLazyQueryHookResult = ReturnType<typeof useCurrentUserDelegationsLazyQuery>;
+export type CurrentUserDelegationsSuspenseQueryHookResult = ReturnType<typeof useCurrentUserDelegationsSuspenseQuery>;
+export type CurrentUserDelegationsQueryResult = Apollo.QueryResult<Types.CurrentUserDelegationsQuery, Types.CurrentUserDelegationsQueryVariables>;
+export declare const CurrentUserGrantedDelegationsDocument: Apollo.DocumentNode;
+/**
+ * __useCurrentUserGrantedDelegationsQuery__
+ *
+ * To run a query within a React component, call `useCurrentUserGrantedDelegationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCurrentUserGrantedDelegationsQuery` 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 } = useCurrentUserGrantedDelegationsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useCurrentUserGrantedDelegationsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.CurrentUserGrantedDelegationsQuery, Types.CurrentUserGrantedDelegationsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.CurrentUserGrantedDelegationsQuery, Types.CurrentUserGrantedDelegationsQueryVariables, "empty" | "complete" | "streaming", Types.CurrentUserGrantedDelegationsQueryVariables>;
+export declare function useCurrentUserGrantedDelegationsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.CurrentUserGrantedDelegationsQuery, Types.CurrentUserGrantedDelegationsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.CurrentUserGrantedDelegationsQuery, Types.CurrentUserGrantedDelegationsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useCurrentUserGrantedDelegationsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.CurrentUserGrantedDelegationsQuery, Types.CurrentUserGrantedDelegationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.CurrentUserGrantedDelegationsQuery, Types.CurrentUserGrantedDelegationsQueryVariables>;
+export declare function useCurrentUserGrantedDelegationsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.CurrentUserGrantedDelegationsQuery, Types.CurrentUserGrantedDelegationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.CurrentUserGrantedDelegationsQuery | undefined, Types.CurrentUserGrantedDelegationsQueryVariables>;
+export type CurrentUserGrantedDelegationsQueryHookResult = ReturnType<typeof useCurrentUserGrantedDelegationsQuery>;
+export type CurrentUserGrantedDelegationsLazyQueryHookResult = ReturnType<typeof useCurrentUserGrantedDelegationsLazyQuery>;
+export type CurrentUserGrantedDelegationsSuspenseQueryHookResult = ReturnType<typeof useCurrentUserGrantedDelegationsSuspenseQuery>;
+export type CurrentUserGrantedDelegationsQueryResult = Apollo.QueryResult<Types.CurrentUserGrantedDelegationsQuery, Types.CurrentUserGrantedDelegationsQueryVariables>;
+export declare const AvailableAuthMethodsDocument: Apollo.DocumentNode;
+/**
+ * __useAvailableAuthMethodsQuery__
+ *
+ * To run a query within a React component, call `useAvailableAuthMethodsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useAvailableAuthMethodsQuery` 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 } = useAvailableAuthMethodsQuery({
+ *   variables: {
+ *      tenantId: // value for 'tenantId'
+ *   },
+ * });
+ */
+export declare function useAvailableAuthMethodsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.AvailableAuthMethodsQuery, Types.AvailableAuthMethodsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.AvailableAuthMethodsQuery, Types.AvailableAuthMethodsQueryVariables, "empty" | "complete" | "streaming", Types.AvailableAuthMethodsQueryVariables>;
+export declare function useAvailableAuthMethodsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.AvailableAuthMethodsQuery, Types.AvailableAuthMethodsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.AvailableAuthMethodsQuery, Types.AvailableAuthMethodsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useAvailableAuthMethodsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.AvailableAuthMethodsQuery, Types.AvailableAuthMethodsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.AvailableAuthMethodsQuery, Types.AvailableAuthMethodsQueryVariables>;
+export declare function useAvailableAuthMethodsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.AvailableAuthMethodsQuery, Types.AvailableAuthMethodsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.AvailableAuthMethodsQuery | undefined, Types.AvailableAuthMethodsQueryVariables>;
+export type AvailableAuthMethodsQueryHookResult = ReturnType<typeof useAvailableAuthMethodsQuery>;
+export type AvailableAuthMethodsLazyQueryHookResult = ReturnType<typeof useAvailableAuthMethodsLazyQuery>;
+export type AvailableAuthMethodsSuspenseQueryHookResult = ReturnType<typeof useAvailableAuthMethodsSuspenseQuery>;
+export type AvailableAuthMethodsQueryResult = Apollo.QueryResult<Types.AvailableAuthMethodsQuery, Types.AvailableAuthMethodsQueryVariables>;
+export declare const AuthMethodConfigDocument: Apollo.DocumentNode;
+/**
+ * __useAuthMethodConfigQuery__
+ *
+ * To run a query within a React component, call `useAuthMethodConfigQuery` and pass it any options that fit your needs.
+ * When your component renders, `useAuthMethodConfigQuery` 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 } = useAuthMethodConfigQuery({
+ *   variables: {
+ *      tenantId: // value for 'tenantId'
+ *      authType: // value for 'authType'
+ *   },
+ * });
+ */
+export declare function useAuthMethodConfigQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.AuthMethodConfigQuery, Types.AuthMethodConfigQueryVariables> & ({
+    variables: Types.AuthMethodConfigQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.AuthMethodConfigQuery, Types.AuthMethodConfigQueryVariables, "empty" | "complete" | "streaming", Types.AuthMethodConfigQueryVariables>;
+export declare function useAuthMethodConfigLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.AuthMethodConfigQuery, Types.AuthMethodConfigQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.AuthMethodConfigQuery, Types.AuthMethodConfigQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useAuthMethodConfigSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.AuthMethodConfigQuery, Types.AuthMethodConfigQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.AuthMethodConfigQuery, Types.AuthMethodConfigQueryVariables>;
+export declare function useAuthMethodConfigSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.AuthMethodConfigQuery, Types.AuthMethodConfigQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.AuthMethodConfigQuery | undefined, Types.AuthMethodConfigQueryVariables>;
+export type AuthMethodConfigQueryHookResult = ReturnType<typeof useAuthMethodConfigQuery>;
+export type AuthMethodConfigLazyQueryHookResult = ReturnType<typeof useAuthMethodConfigLazyQuery>;
+export type AuthMethodConfigSuspenseQueryHookResult = ReturnType<typeof useAuthMethodConfigSuspenseQuery>;
+export type AuthMethodConfigQueryResult = Apollo.QueryResult<Types.AuthMethodConfigQuery, Types.AuthMethodConfigQueryVariables>;
+export declare const AuthStrategiesHealthDocument: Apollo.DocumentNode;
+/**
+ * __useAuthStrategiesHealthQuery__
+ *
+ * To run a query within a React component, call `useAuthStrategiesHealthQuery` and pass it any options that fit your needs.
+ * When your component renders, `useAuthStrategiesHealthQuery` 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 } = useAuthStrategiesHealthQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useAuthStrategiesHealthQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.AuthStrategiesHealthQuery, Types.AuthStrategiesHealthQueryVariables>): ApolloReactHooks.useQuery.Result<Types.AuthStrategiesHealthQuery, Types.AuthStrategiesHealthQueryVariables, "empty" | "complete" | "streaming", Types.AuthStrategiesHealthQueryVariables>;
+export declare function useAuthStrategiesHealthLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.AuthStrategiesHealthQuery, Types.AuthStrategiesHealthQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.AuthStrategiesHealthQuery, Types.AuthStrategiesHealthQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useAuthStrategiesHealthSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.AuthStrategiesHealthQuery, Types.AuthStrategiesHealthQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.AuthStrategiesHealthQuery, Types.AuthStrategiesHealthQueryVariables>;
+export declare function useAuthStrategiesHealthSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.AuthStrategiesHealthQuery, Types.AuthStrategiesHealthQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.AuthStrategiesHealthQuery | undefined, Types.AuthStrategiesHealthQueryVariables>;
+export type AuthStrategiesHealthQueryHookResult = ReturnType<typeof useAuthStrategiesHealthQuery>;
+export type AuthStrategiesHealthLazyQueryHookResult = ReturnType<typeof useAuthStrategiesHealthLazyQuery>;
+export type AuthStrategiesHealthSuspenseQueryHookResult = ReturnType<typeof useAuthStrategiesHealthSuspenseQuery>;
+export type AuthStrategiesHealthQueryResult = Apollo.QueryResult<Types.AuthStrategiesHealthQuery, Types.AuthStrategiesHealthQueryVariables>;
+export declare const ActiveSessionsDocument: Apollo.DocumentNode;
+/**
+ * __useActiveSessionsQuery__
+ *
+ * To run a query within a React component, call `useActiveSessionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useActiveSessionsQuery` 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 } = useActiveSessionsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useActiveSessionsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ActiveSessionsQuery, Types.ActiveSessionsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.ActiveSessionsQuery, Types.ActiveSessionsQueryVariables, "empty" | "complete" | "streaming", Types.ActiveSessionsQueryVariables>;
+export declare function useActiveSessionsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ActiveSessionsQuery, Types.ActiveSessionsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ActiveSessionsQuery, Types.ActiveSessionsQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useActiveSessionsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ActiveSessionsQuery, Types.ActiveSessionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ActiveSessionsQuery, Types.ActiveSessionsQueryVariables>;
+export declare function useActiveSessionsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ActiveSessionsQuery, Types.ActiveSessionsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ActiveSessionsQuery | undefined, Types.ActiveSessionsQueryVariables>;
+export type ActiveSessionsQueryHookResult = ReturnType<typeof useActiveSessionsQuery>;
+export type ActiveSessionsLazyQueryHookResult = ReturnType<typeof useActiveSessionsLazyQuery>;
+export type ActiveSessionsSuspenseQueryHookResult = ReturnType<typeof useActiveSessionsSuspenseQuery>;
+export type ActiveSessionsQueryResult = Apollo.QueryResult<Types.ActiveSessionsQuery, Types.ActiveSessionsQueryVariables>;
+export declare const GetSsoConfigDocument: Apollo.DocumentNode;
+/**
+ * __useGetSsoConfigQuery__
+ *
+ * To run a query within a React component, call `useGetSsoConfigQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetSsoConfigQuery` 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 } = useGetSsoConfigQuery({
+ *   variables: {
+ *      tenantId: // value for 'tenantId'
+ *   },
+ * });
+ */
+export declare function useGetSsoConfigQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetSsoConfigQuery, Types.GetSsoConfigQueryVariables> & ({
+    variables: Types.GetSsoConfigQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetSsoConfigQuery, Types.GetSsoConfigQueryVariables, "empty" | "complete" | "streaming", Types.GetSsoConfigQueryVariables>;
+export declare function useGetSsoConfigLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetSsoConfigQuery, Types.GetSsoConfigQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetSsoConfigQuery, Types.GetSsoConfigQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetSsoConfigSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSsoConfigQuery, Types.GetSsoConfigQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSsoConfigQuery, Types.GetSsoConfigQueryVariables>;
+export declare function useGetSsoConfigSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSsoConfigQuery, Types.GetSsoConfigQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSsoConfigQuery | undefined, Types.GetSsoConfigQueryVariables>;
+export type GetSsoConfigQueryHookResult = ReturnType<typeof useGetSsoConfigQuery>;
+export type GetSsoConfigLazyQueryHookResult = ReturnType<typeof useGetSsoConfigLazyQuery>;
+export type GetSsoConfigSuspenseQueryHookResult = ReturnType<typeof useGetSsoConfigSuspenseQuery>;
+export type GetSsoConfigQueryResult = Apollo.QueryResult<Types.GetSsoConfigQuery, Types.GetSsoConfigQueryVariables>;
+export declare const GetOidcConfigDocument: Apollo.DocumentNode;
+/**
+ * __useGetOidcConfigQuery__
+ *
+ * To run a query within a React component, call `useGetOidcConfigQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetOidcConfigQuery` 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 } = useGetOidcConfigQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useGetOidcConfigQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetOidcConfigQuery, Types.GetOidcConfigQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetOidcConfigQuery, Types.GetOidcConfigQueryVariables, "empty" | "complete" | "streaming", Types.GetOidcConfigQueryVariables>;
+export declare function useGetOidcConfigLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetOidcConfigQuery, Types.GetOidcConfigQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetOidcConfigQuery, Types.GetOidcConfigQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetOidcConfigSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetOidcConfigQuery, Types.GetOidcConfigQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetOidcConfigQuery, Types.GetOidcConfigQueryVariables>;
+export declare function useGetOidcConfigSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetOidcConfigQuery, Types.GetOidcConfigQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetOidcConfigQuery | undefined, Types.GetOidcConfigQueryVariables>;
+export type GetOidcConfigQueryHookResult = ReturnType<typeof useGetOidcConfigQuery>;
+export type GetOidcConfigLazyQueryHookResult = ReturnType<typeof useGetOidcConfigLazyQuery>;
+export type GetOidcConfigSuspenseQueryHookResult = ReturnType<typeof useGetOidcConfigSuspenseQuery>;
+export type GetOidcConfigQueryResult = Apollo.QueryResult<Types.GetOidcConfigQuery, Types.GetOidcConfigQueryVariables>;
+export declare const TokenInfoDocument: Apollo.DocumentNode;
+/**
+ * __useTokenInfoQuery__
+ *
+ * To run a query within a React component, call `useTokenInfoQuery` and pass it any options that fit your needs.
+ * When your component renders, `useTokenInfoQuery` 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 } = useTokenInfoQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useTokenInfoQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.TokenInfoQuery, Types.TokenInfoQueryVariables>): ApolloReactHooks.useQuery.Result<Types.TokenInfoQuery, Types.TokenInfoQueryVariables, "empty" | "complete" | "streaming", Types.TokenInfoQueryVariables>;
+export declare function useTokenInfoLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.TokenInfoQuery, Types.TokenInfoQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.TokenInfoQuery, Types.TokenInfoQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useTokenInfoSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.TokenInfoQuery, Types.TokenInfoQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.TokenInfoQuery, Types.TokenInfoQueryVariables>;
+export declare function useTokenInfoSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.TokenInfoQuery, Types.TokenInfoQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.TokenInfoQuery | undefined, Types.TokenInfoQueryVariables>;
+export type TokenInfoQueryHookResult = ReturnType<typeof useTokenInfoQuery>;
+export type TokenInfoLazyQueryHookResult = ReturnType<typeof useTokenInfoLazyQuery>;
+export type TokenInfoSuspenseQueryHookResult = ReturnType<typeof useTokenInfoSuspenseQuery>;
+export type TokenInfoQueryResult = Apollo.QueryResult<Types.TokenInfoQuery, Types.TokenInfoQueryVariables>;
+export declare const GetUserDocument: Apollo.DocumentNode;
+/**
+ * __useGetUserQuery__
+ *
+ * To run a query within a React component, call `useGetUserQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetUserQuery` 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 } = useGetUserQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useGetUserQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetUserQuery, Types.GetUserQueryVariables> & ({
+    variables: Types.GetUserQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.GetUserQuery, Types.GetUserQueryVariables, "empty" | "complete" | "streaming", Types.GetUserQueryVariables>;
+export declare function useGetUserLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetUserQuery, Types.GetUserQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetUserQuery, Types.GetUserQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useGetUserSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetUserQuery, Types.GetUserQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetUserQuery, Types.GetUserQueryVariables>;
+export declare function useGetUserSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetUserQuery, Types.GetUserQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetUserQuery | undefined, Types.GetUserQueryVariables>;
+export type GetUserQueryHookResult = ReturnType<typeof useGetUserQuery>;
+export type GetUserLazyQueryHookResult = ReturnType<typeof useGetUserLazyQuery>;
+export type GetUserSuspenseQueryHookResult = ReturnType<typeof useGetUserSuspenseQuery>;
+export type GetUserQueryResult = Apollo.QueryResult<Types.GetUserQuery, Types.GetUserQueryVariables>;
+export declare const ListUsersDocument: Apollo.DocumentNode;
+/**
+ * __useListUsersQuery__
+ *
+ * To run a query within a React component, call `useListUsersQuery` and pass it any options that fit your needs.
+ * When your component renders, `useListUsersQuery` 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 } = useListUsersQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      pagination: // value for 'pagination'
+ *   },
+ * });
+ */
+export declare function useListUsersQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.ListUsersQuery, Types.ListUsersQueryVariables>): ApolloReactHooks.useQuery.Result<Types.ListUsersQuery, Types.ListUsersQueryVariables, "empty" | "complete" | "streaming", Types.ListUsersQueryVariables>;
+export declare function useListUsersLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.ListUsersQuery, Types.ListUsersQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.ListUsersQuery, Types.ListUsersQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useListUsersSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.ListUsersQuery, Types.ListUsersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListUsersQuery, Types.ListUsersQueryVariables>;
+export declare function useListUsersSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.ListUsersQuery, Types.ListUsersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.ListUsersQuery | undefined, Types.ListUsersQueryVariables>;
+export type ListUsersQueryHookResult = ReturnType<typeof useListUsersQuery>;
+export type ListUsersLazyQueryHookResult = ReturnType<typeof useListUsersLazyQuery>;
+export type ListUsersSuspenseQueryHookResult = ReturnType<typeof useListUsersSuspenseQuery>;
+export type ListUsersQueryResult = Apollo.QueryResult<Types.ListUsersQuery, Types.ListUsersQueryVariables>;
+export declare const MyWorkspacesDocument: Apollo.DocumentNode;
+/**
+ * __useMyWorkspacesQuery__
+ *
+ * To run a query within a React component, call `useMyWorkspacesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useMyWorkspacesQuery` 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 } = useMyWorkspacesQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export declare function useMyWorkspacesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.MyWorkspacesQuery, Types.MyWorkspacesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.MyWorkspacesQuery, Types.MyWorkspacesQueryVariables, "empty" | "complete" | "streaming", Types.MyWorkspacesQueryVariables>;
+export declare function useMyWorkspacesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.MyWorkspacesQuery, Types.MyWorkspacesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.MyWorkspacesQuery, Types.MyWorkspacesQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useMyWorkspacesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.MyWorkspacesQuery, Types.MyWorkspacesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.MyWorkspacesQuery, Types.MyWorkspacesQueryVariables>;
+export declare function useMyWorkspacesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.MyWorkspacesQuery, Types.MyWorkspacesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.MyWorkspacesQuery | undefined, Types.MyWorkspacesQueryVariables>;
+export type MyWorkspacesQueryHookResult = ReturnType<typeof useMyWorkspacesQuery>;
+export type MyWorkspacesLazyQueryHookResult = ReturnType<typeof useMyWorkspacesLazyQuery>;
+export type MyWorkspacesSuspenseQueryHookResult = ReturnType<typeof useMyWorkspacesSuspenseQuery>;
+export type MyWorkspacesQueryResult = Apollo.QueryResult<Types.MyWorkspacesQuery, Types.MyWorkspacesQueryVariables>;
+export declare const WorkspaceDocument: Apollo.DocumentNode;
+/**
+ * __useWorkspaceQuery__
+ *
+ * To run a query within a React component, call `useWorkspaceQuery` and pass it any options that fit your needs.
+ * When your component renders, `useWorkspaceQuery` 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 } = useWorkspaceQuery({
+ *   variables: {
+ *      id: // value for 'id'
+ *   },
+ * });
+ */
+export declare function useWorkspaceQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.WorkspaceQuery, Types.WorkspaceQueryVariables> & ({
+    variables: Types.WorkspaceQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.WorkspaceQuery, Types.WorkspaceQueryVariables, "empty" | "complete" | "streaming", Types.WorkspaceQueryVariables>;
+export declare function useWorkspaceLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.WorkspaceQuery, Types.WorkspaceQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.WorkspaceQuery, Types.WorkspaceQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useWorkspaceSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.WorkspaceQuery, Types.WorkspaceQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.WorkspaceQuery, Types.WorkspaceQueryVariables>;
+export declare function useWorkspaceSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.WorkspaceQuery, Types.WorkspaceQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.WorkspaceQuery | undefined, Types.WorkspaceQueryVariables>;
+export type WorkspaceQueryHookResult = ReturnType<typeof useWorkspaceQuery>;
+export type WorkspaceLazyQueryHookResult = ReturnType<typeof useWorkspaceLazyQuery>;
+export type WorkspaceSuspenseQueryHookResult = ReturnType<typeof useWorkspaceSuspenseQuery>;
+export type WorkspaceQueryResult = Apollo.QueryResult<Types.WorkspaceQuery, Types.WorkspaceQueryVariables>;
+export declare const WorkspaceMembersDocument: Apollo.DocumentNode;
+/**
+ * __useWorkspaceMembersQuery__
+ *
+ * To run a query within a React component, call `useWorkspaceMembersQuery` and pass it any options that fit your needs.
+ * When your component renders, `useWorkspaceMembersQuery` 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 } = useWorkspaceMembersQuery({
+ *   variables: {
+ *      workspaceId: // value for 'workspaceId'
+ *      limit: // value for 'limit'
+ *      offset: // value for 'offset'
+ *   },
+ * });
+ */
+export declare function useWorkspaceMembersQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.WorkspaceMembersQuery, Types.WorkspaceMembersQueryVariables> & ({
+    variables: Types.WorkspaceMembersQueryVariables;
+    skip?: boolean;
+} | {
+    skip: boolean;
+})): ApolloReactHooks.useQuery.Result<Types.WorkspaceMembersQuery, Types.WorkspaceMembersQueryVariables, "empty" | "complete" | "streaming", Types.WorkspaceMembersQueryVariables>;
+export declare function useWorkspaceMembersLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.WorkspaceMembersQuery, Types.WorkspaceMembersQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.WorkspaceMembersQuery, Types.WorkspaceMembersQueryVariables, "empty" | "complete" | "streaming">;
+export declare function useWorkspaceMembersSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.WorkspaceMembersQuery, Types.WorkspaceMembersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.WorkspaceMembersQuery, Types.WorkspaceMembersQueryVariables>;
+export declare function useWorkspaceMembersSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.WorkspaceMembersQuery, Types.WorkspaceMembersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.WorkspaceMembersQuery | undefined, Types.WorkspaceMembersQueryVariables>;
+export type WorkspaceMembersQueryHookResult = ReturnType<typeof useWorkspaceMembersQuery>;
+export type WorkspaceMembersLazyQueryHookResult = ReturnType<typeof useWorkspaceMembersLazyQuery>;
+export type WorkspaceMembersSuspenseQueryHookResult = ReturnType<typeof useWorkspaceMembersSuspenseQuery>;
+export type WorkspaceMembersQueryResult = Apollo.QueryResult<Types.WorkspaceMembersQuery, Types.WorkspaceMembersQueryVariables>;
+//# sourceMappingURL=global-operations.d.ts.map