@contember/engine-tenant-api 1.3.0-alpha.8 → 1.3.0-beta.1

package/dist/src/schema/index.d.ts

@@ -1,22 +1,22 @@
 import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
-export declare type Maybe<T> = T | null;
-export declare type InputMaybe<T> = Maybe<T>;
-export declare type Exact<T extends {
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends {
     [key: string]: unknown;
 }> = {
     [K in keyof T]: T[K];
 };
-export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
     [SubKey in K]?: Maybe<T[SubKey]>;
 };
-export declare type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
     [SubKey in K]: Maybe<T[SubKey]>;
 };
-export declare type RequireFields<T, K extends keyof T> = Omit<T, K> & {
+export type RequireFields<T, K extends keyof T> = Omit<T, K> & {
     [P in K]-?: NonNullable<T[P]>;
 };
 /** All built-in and custom scalars, mapped to their actual values */
-export declare type Scalars = {
+export type Scalars = {
     ID: string;
     String: string;
     Boolean: boolean;
@@ -25,40 +25,49 @@ export declare type Scalars = {
     DateTime: any;
     Json: any;
 };
-export declare type AddIdpError = {
+export type AddGlobalIdentityRolesError = {
+    readonly __typename?: 'AddGlobalIdentityRolesError';
+    readonly code: AddGlobalIdentityRolesErrorCode;
+    readonly developerMessage: Scalars['String'];
+};
+export type AddGlobalIdentityRolesErrorCode = 'IDENTITY_NOT_FOUND' | 'INVALID_ROLE';
+export type AddGlobalIdentityRolesResponse = {
+    readonly __typename?: 'AddGlobalIdentityRolesResponse';
+    readonly error?: Maybe<AddGlobalIdentityRolesError>;
+    readonly ok: Scalars['Boolean'];
+    readonly result?: Maybe<AddGlobalIdentityRolesResult>;
+};
+export type AddGlobalIdentityRolesResult = {
+    readonly __typename?: 'AddGlobalIdentityRolesResult';
+    readonly identity: Identity;
+};
+export type AddIdpError = {
     readonly __typename?: 'AddIDPError';
     readonly code: AddIdpErrorCode;
     readonly developerMessage: Scalars['String'];
 };
-export declare enum AddIdpErrorCode {
-    AlreadyExists = "ALREADY_EXISTS",
-    InvalidConfiguration = "INVALID_CONFIGURATION",
-    UnknownType = "UNKNOWN_TYPE"
-}
-export declare type AddIdpResponse = {
+export type AddIdpErrorCode = 'ALREADY_EXISTS' | 'INVALID_CONFIGURATION' | 'UNKNOWN_TYPE';
+export type AddIdpResponse = {
     readonly __typename?: 'AddIDPResponse';
     readonly error?: Maybe<AddIdpError>;
     readonly ok: Scalars['Boolean'];
 };
-export declare type AddMailTemplateError = {
+export type AddMailTemplateError = {
     readonly __typename?: 'AddMailTemplateError';
     readonly code: AddMailTemplateErrorCode;
     readonly developerMessage: Scalars['String'];
     /** @deprecated Field no longer supported */
     readonly endUserMessage?: Maybe<Scalars['String']>;
 };
-export declare enum AddMailTemplateErrorCode {
-    MissingVariable = "MISSING_VARIABLE",
-    ProjectNotFound = "PROJECT_NOT_FOUND"
-}
-export declare type AddMailTemplateResponse = {
+export type AddMailTemplateErrorCode = 'MISSING_VARIABLE' | 'PROJECT_NOT_FOUND';
+export type AddMailTemplateResponse = {
     readonly __typename?: 'AddMailTemplateResponse';
     readonly error?: Maybe<AddMailTemplateError>;
     /** @deprecated Field no longer supported */
     readonly errors: ReadonlyArray<AddMailTemplateError>;
     readonly ok: Scalars['Boolean'];
 };
-export declare type AddProjectMemberError = {
+export type AddProjectMemberError = {
     readonly __typename?: 'AddProjectMemberError';
     readonly code: AddProjectMemberErrorCode;
     readonly developerMessage: Scalars['String'];
@@ -66,102 +75,75 @@ export declare type AddProjectMemberError = {
     readonly endUserMessage?: Maybe<Scalars['String']>;
     readonly membershipValidation?: Maybe<ReadonlyArray<MembershipValidationError>>;
 };
-export declare enum AddProjectMemberErrorCode {
-    AlreadyMember = "ALREADY_MEMBER",
-    IdentityNotFound = "IDENTITY_NOT_FOUND",
-    InvalidMembership = "INVALID_MEMBERSHIP",
-    ProjectNotFound = "PROJECT_NOT_FOUND",
-    /** @deprecated Field no longer supported */
-    RoleNotFound = "ROLE_NOT_FOUND",
-    /** @deprecated Field no longer supported */
-    VariableEmpty = "VARIABLE_EMPTY",
-    /** @deprecated Field no longer supported */
-    VariableNotFound = "VARIABLE_NOT_FOUND"
-}
-export declare type AddProjectMemberResponse = {
+export type AddProjectMemberErrorCode = 'ALREADY_MEMBER' | 'IDENTITY_NOT_FOUND' | 'INVALID_MEMBERSHIP' | 'PROJECT_NOT_FOUND' | 'ROLE_NOT_FOUND' | 'VARIABLE_EMPTY' | 'VARIABLE_NOT_FOUND';
+export type AddProjectMemberResponse = {
     readonly __typename?: 'AddProjectMemberResponse';
     readonly error?: Maybe<AddProjectMemberError>;
     readonly errors: ReadonlyArray<AddProjectMemberError>;
     readonly ok: Scalars['Boolean'];
 };
-export declare type ApiKey = {
+export type ApiKey = {
     readonly __typename?: 'ApiKey';
     readonly id: Scalars['String'];
     readonly identity: Identity;
 };
-export declare type ApiKeyWithToken = {
+export type ApiKeyWithToken = {
     readonly __typename?: 'ApiKeyWithToken';
     readonly id: Scalars['String'];
     readonly identity: Identity;
     readonly token?: Maybe<Scalars['String']>;
 };
-export declare type ChangeMyPasswordError = {
+export type ChangeMyPasswordError = {
     readonly __typename?: 'ChangeMyPasswordError';
     readonly code: ChangeMyPasswordErrorCode;
     readonly developerMessage: Scalars['String'];
 };
-export declare enum ChangeMyPasswordErrorCode {
-    InvalidPassword = "INVALID_PASSWORD",
-    NotAPerson = "NOT_A_PERSON",
-    NoPasswordSet = "NO_PASSWORD_SET",
-    TooWeak = "TOO_WEAK"
-}
-export declare type ChangeMyPasswordResponse = {
+export type ChangeMyPasswordErrorCode = 'INVALID_PASSWORD' | 'NOT_A_PERSON' | 'NO_PASSWORD_SET' | 'TOO_WEAK';
+export type ChangeMyPasswordResponse = {
     readonly __typename?: 'ChangeMyPasswordResponse';
     readonly error?: Maybe<ChangeMyPasswordError>;
     readonly ok: Scalars['Boolean'];
 };
-export declare type ChangePasswordError = {
+export type ChangePasswordError = {
     readonly __typename?: 'ChangePasswordError';
     readonly code: ChangePasswordErrorCode;
     readonly developerMessage: Scalars['String'];
     /** @deprecated Field no longer supported */
     readonly endUserMessage?: Maybe<Scalars['String']>;
 };
-export declare enum ChangePasswordErrorCode {
-    PersonNotFound = "PERSON_NOT_FOUND",
-    TooWeak = "TOO_WEAK"
-}
-export declare type ChangePasswordResponse = {
+export type ChangePasswordErrorCode = 'PERSON_NOT_FOUND' | 'TOO_WEAK';
+export type ChangePasswordResponse = {
     readonly __typename?: 'ChangePasswordResponse';
     readonly error?: Maybe<ChangePasswordError>;
     /** @deprecated Field no longer supported */
     readonly errors: ReadonlyArray<ChangePasswordError>;
     readonly ok: Scalars['Boolean'];
 };
-export declare enum CheckResetPasswordTokenCode {
-    RequestNotFound = "REQUEST_NOT_FOUND",
-    TokenExpired = "TOKEN_EXPIRED",
-    TokenNotFound = "TOKEN_NOT_FOUND",
-    TokenUsed = "TOKEN_USED"
-}
-export declare type CheckResetPasswordTokenResult = {
+export type CheckResetPasswordTokenCode = 'REQUEST_NOT_FOUND' | 'TOKEN_EXPIRED' | 'TOKEN_NOT_FOUND' | 'TOKEN_USED';
+export type CheckResetPasswordTokenResult = {
     readonly __typename?: 'CheckResetPasswordTokenResult';
     readonly code: CheckResetPasswordTokenCode;
 };
-export declare type CommonSignInResult = {
+export type CommonSignInResult = {
     readonly person: Person;
     readonly token: Scalars['String'];
 };
-export declare type ConfirmOtpError = {
+export type ConfirmOtpError = {
     readonly __typename?: 'ConfirmOtpError';
     readonly code: ConfirmOtpErrorCode;
     readonly developerMessage: Scalars['String'];
     /** @deprecated Field no longer supported */
     readonly endUserMessage?: Maybe<Scalars['String']>;
 };
-export declare enum ConfirmOtpErrorCode {
-    InvalidOtpToken = "INVALID_OTP_TOKEN",
-    NotPrepared = "NOT_PREPARED"
-}
-export declare type ConfirmOtpResponse = {
+export type ConfirmOtpErrorCode = 'INVALID_OTP_TOKEN' | 'NOT_PREPARED';
+export type ConfirmOtpResponse = {
     readonly __typename?: 'ConfirmOtpResponse';
     readonly error?: Maybe<ConfirmOtpError>;
     /** @deprecated Field no longer supported */
     readonly errors: ReadonlyArray<ConfirmOtpError>;
     readonly ok: Scalars['Boolean'];
 };
-export declare type CreateApiKeyError = {
+export type CreateApiKeyError = {
     readonly __typename?: 'CreateApiKeyError';
     readonly code: CreateApiKeyErrorCode;
     readonly developerMessage: Scalars['String'];
@@ -169,17 +151,8 @@ export declare type CreateApiKeyError = {
     readonly endUserMessage?: Maybe<Scalars['String']>;
     readonly membershipValidation?: Maybe<ReadonlyArray<MembershipValidationError>>;
 };
-export declare enum CreateApiKeyErrorCode {
-    InvalidMembership = "INVALID_MEMBERSHIP",
-    ProjectNotFound = "PROJECT_NOT_FOUND",
-    /** @deprecated Field no longer supported */
-    RoleNotFound = "ROLE_NOT_FOUND",
-    /** @deprecated Field no longer supported */
-    VariableEmpty = "VARIABLE_EMPTY",
-    /** @deprecated Field no longer supported */
-    VariableNotFound = "VARIABLE_NOT_FOUND"
-}
-export declare type CreateApiKeyResponse = {
+export type CreateApiKeyErrorCode = 'INVALID_MEMBERSHIP' | 'PROJECT_NOT_FOUND' | 'ROLE_NOT_FOUND' | 'VARIABLE_EMPTY' | 'VARIABLE_NOT_FOUND';
+export type CreateApiKeyResponse = {
     readonly __typename?: 'CreateApiKeyResponse';
     readonly error?: Maybe<CreateApiKeyError>;
     /** @deprecated Field no longer supported */
@@ -187,147 +160,142 @@ export declare type CreateApiKeyResponse = {
     readonly ok: Scalars['Boolean'];
     readonly result?: Maybe<CreateApiKeyResult>;
 };
-export declare type CreateApiKeyResult = {
+export type CreateApiKeyResult = {
     readonly __typename?: 'CreateApiKeyResult';
     readonly apiKey: ApiKeyWithToken;
 };
-export declare type CreatePasswordResetRequestError = {
+export type CreatePasswordResetRequestError = {
     readonly __typename?: 'CreatePasswordResetRequestError';
     readonly code: CreatePasswordResetRequestErrorCode;
     readonly developerMessage: Scalars['String'];
     /** @deprecated Field no longer supported */
     readonly endUserMessage?: Maybe<Scalars['String']>;
 };
-export declare enum CreatePasswordResetRequestErrorCode {
-    PersonNotFound = "PERSON_NOT_FOUND"
-}
-export declare type CreatePasswordResetRequestResponse = {
+export type CreatePasswordResetRequestErrorCode = 'PERSON_NOT_FOUND';
+export type CreatePasswordResetRequestResponse = {
     readonly __typename?: 'CreatePasswordResetRequestResponse';
     readonly error?: Maybe<CreatePasswordResetRequestError>;
     /** @deprecated Field no longer supported */
     readonly errors: ReadonlyArray<CreatePasswordResetRequestError>;
     readonly ok: Scalars['Boolean'];
 };
-export declare type CreateProjectOptions = {
+export type CreateProjectOptions = {
     readonly deployTokenHash?: InputMaybe<Scalars['String']>;
     readonly noDeployToken?: InputMaybe<Scalars['Boolean']>;
 };
-export declare type CreateProjectResponse = {
+export type CreateProjectResponse = {
     readonly __typename?: 'CreateProjectResponse';
     readonly error?: Maybe<CreateProjectResponseError>;
     readonly ok: Scalars['Boolean'];
     readonly result?: Maybe<CreateProjectResult>;
 };
-export declare type CreateProjectResponseError = {
+export type CreateProjectResponseError = {
     readonly __typename?: 'CreateProjectResponseError';
     readonly code: CreateProjectResponseErrorCode;
     readonly developerMessage: Scalars['String'];
 };
-export declare enum CreateProjectResponseErrorCode {
-    AlreadyExists = "ALREADY_EXISTS",
-    InitError = "INIT_ERROR"
-}
-export declare type CreateProjectResult = {
+export type CreateProjectResponseErrorCode = 'ALREADY_EXISTS' | 'INIT_ERROR';
+export type CreateProjectResult = {
     readonly __typename?: 'CreateProjectResult';
     readonly deployerApiKey?: Maybe<ApiKeyWithToken>;
 };
-export declare type CreateResetPasswordRequestOptions = {
+export type CreateResetPasswordRequestOptions = {
     readonly mailProject?: InputMaybe<Scalars['String']>;
     readonly mailVariant?: InputMaybe<Scalars['String']>;
 };
-export declare type CreateSessionTokenError = {
+export type CreateSessionTokenError = {
     readonly __typename?: 'CreateSessionTokenError';
     readonly code: CreateSessionTokenErrorCode;
     readonly developerMessage: Scalars['String'];
 };
-export declare enum CreateSessionTokenErrorCode {
-    UnknownEmail = "UNKNOWN_EMAIL",
-    UnknownPersonId = "UNKNOWN_PERSON_ID"
-}
-export declare type CreateSessionTokenResponse = {
+export type CreateSessionTokenErrorCode = 'UNKNOWN_EMAIL' | 'UNKNOWN_PERSON_ID' | 'PERSON_DISABLED';
+export type CreateSessionTokenResponse = {
     readonly __typename?: 'CreateSessionTokenResponse';
     readonly error?: Maybe<CreateSessionTokenError>;
     readonly ok: Scalars['Boolean'];
     readonly result?: Maybe<CreateSessionTokenResult>;
 };
-export declare type CreateSessionTokenResult = CommonSignInResult & {
+export type CreateSessionTokenResult = CommonSignInResult & {
     readonly __typename?: 'CreateSessionTokenResult';
     readonly person: Person;
     readonly token: Scalars['String'];
 };
-export declare type DisableApiKeyError = {
+export type DisableApiKeyError = {
     readonly __typename?: 'DisableApiKeyError';
     readonly code: DisableApiKeyErrorCode;
     readonly developerMessage: Scalars['String'];
     /** @deprecated Field no longer supported */
     readonly endUserMessage?: Maybe<Scalars['String']>;
 };
-export declare enum DisableApiKeyErrorCode {
-    KeyNotFound = "KEY_NOT_FOUND"
-}
-export declare type DisableApiKeyResponse = {
+export type DisableApiKeyErrorCode = 'KEY_NOT_FOUND';
+export type DisableApiKeyResponse = {
     readonly __typename?: 'DisableApiKeyResponse';
     readonly error?: Maybe<DisableApiKeyError>;
     /** @deprecated Field no longer supported */
     readonly errors: ReadonlyArray<DisableApiKeyError>;
     readonly ok: Scalars['Boolean'];
 };
-export declare type DisableIdpError = {
+export type DisableIdpError = {
     readonly __typename?: 'DisableIDPError';
     readonly code: DisableIdpErrorCode;
     readonly developerMessage: Scalars['String'];
 };
-export declare enum DisableIdpErrorCode {
-    NotFound = "NOT_FOUND"
-}
-export declare type DisableIdpResponse = {
+export type DisableIdpErrorCode = 'NOT_FOUND';
+export type DisableIdpResponse = {
     readonly __typename?: 'DisableIDPResponse';
     readonly error?: Maybe<DisableIdpError>;
     readonly ok: Scalars['Boolean'];
 };
-export declare type DisableOtpError = {
+export type DisableOtpError = {
     readonly __typename?: 'DisableOtpError';
     readonly code: DisableOtpErrorCode;
     readonly developerMessage: Scalars['String'];
     /** @deprecated Field no longer supported */
     readonly endUserMessage?: Maybe<Scalars['String']>;
 };
-export declare enum DisableOtpErrorCode {
-    OtpNotActive = "OTP_NOT_ACTIVE"
-}
-export declare type DisableOtpResponse = {
+export type DisableOtpErrorCode = 'OTP_NOT_ACTIVE';
+export type DisableOtpResponse = {
     readonly __typename?: 'DisableOtpResponse';
     readonly error?: Maybe<DisableOtpError>;
     /** @deprecated Field no longer supported */
     readonly errors: ReadonlyArray<DisableOtpError>;
     readonly ok: Scalars['Boolean'];
 };
-export declare type EnableIdpError = {
+export type DisablePersonError = {
+    readonly __typename?: 'DisablePersonError';
+    readonly code: DisablePersonErrorCode;
+    readonly developerMessage: Scalars['String'];
+};
+export type DisablePersonErrorCode = 'PERSON_ALREADY_DISABLED' | 'PERSON_NOT_FOUND';
+export type DisablePersonResponse = {
+    readonly __typename?: 'DisablePersonResponse';
+    readonly error?: Maybe<DisablePersonError>;
+    readonly ok: Scalars['Boolean'];
+};
+export type EnableIdpError = {
     readonly __typename?: 'EnableIDPError';
     readonly code: EnableIdpErrorCode;
     readonly developerMessage: Scalars['String'];
 };
-export declare enum EnableIdpErrorCode {
-    NotFound = "NOT_FOUND"
-}
-export declare type EnableIdpResponse = {
+export type EnableIdpErrorCode = 'NOT_FOUND';
+export type EnableIdpResponse = {
     readonly __typename?: 'EnableIDPResponse';
     readonly error?: Maybe<EnableIdpError>;
     readonly ok: Scalars['Boolean'];
 };
-export declare type IdpOptions = {
+export type IdpOptions = {
     readonly autoSignUp?: InputMaybe<Scalars['Boolean']>;
     readonly exclusive?: InputMaybe<Scalars['Boolean']>;
 };
-export declare type IdpOptionsOutput = {
+export type IdpOptionsOutput = {
     readonly __typename?: 'IDPOptionsOutput';
     readonly autoSignUp: Scalars['Boolean'];
     readonly exclusive: Scalars['Boolean'];
 };
-export declare type IdpResponseInput = {
+export type IdpResponseInput = {
     readonly url: Scalars['String'];
 };
-export declare type Identity = {
+export type Identity = {
     readonly __typename?: 'Identity';
     readonly apiKey?: Maybe<ApiKey>;
     readonly description?: Maybe<Scalars['String']>;
@@ -337,35 +305,32 @@ export declare type Identity = {
     readonly projects: ReadonlyArray<IdentityProjectRelation>;
     readonly roles?: Maybe<ReadonlyArray<Scalars['String']>>;
 };
-export declare type IdentityGlobalPermissions = {
+export type IdentityGlobalPermissions = {
     readonly __typename?: 'IdentityGlobalPermissions';
     readonly canCreateProject: Scalars['Boolean'];
 };
-export declare type IdentityProjectRelation = {
+export type IdentityProjectRelation = {
     readonly __typename?: 'IdentityProjectRelation';
     readonly memberships: ReadonlyArray<Membership>;
     readonly project: Project;
 };
-export declare type IdentityProvider = {
+export type IdentityProvider = {
     readonly __typename?: 'IdentityProvider';
     readonly configuration: Scalars['Json'];
-    readonly disabledAt: Scalars['DateTime'];
+    readonly disabledAt?: Maybe<Scalars['DateTime']>;
     readonly options: IdpOptionsOutput;
     readonly slug: Scalars['String'];
     readonly type: Scalars['String'];
 };
-export declare type InitSignInIdpError = {
+export type InitSignInIdpError = {
     readonly __typename?: 'InitSignInIDPError';
     readonly code: InitSignInIdpErrorCode;
     readonly developerMessage: Scalars['String'];
     /** @deprecated Field no longer supported */
     readonly endUserMessage?: Maybe<Scalars['String']>;
 };
-export declare enum InitSignInIdpErrorCode {
-    IdpValidationFailed = "IDP_VALIDATION_FAILED",
-    ProviderNotFound = "PROVIDER_NOT_FOUND"
-}
-export declare type InitSignInIdpResponse = {
+export type InitSignInIdpErrorCode = 'IDP_VALIDATION_FAILED' | 'PROVIDER_NOT_FOUND';
+export type InitSignInIdpResponse = {
     readonly __typename?: 'InitSignInIDPResponse';
     readonly error?: Maybe<InitSignInIdpError>;
     /** @deprecated Field no longer supported */
@@ -373,12 +338,12 @@ export declare type InitSignInIdpResponse = {
     readonly ok: Scalars['Boolean'];
     readonly result?: Maybe<InitSignInIdpResult>;
 };
-export declare type InitSignInIdpResult = {
+export type InitSignInIdpResult = {
     readonly __typename?: 'InitSignInIDPResult';
     readonly authUrl: Scalars['String'];
     readonly sessionData: Scalars['Json'];
 };
-export declare type InviteError = {
+export type InviteError = {
     readonly __typename?: 'InviteError';
     readonly code: InviteErrorCode;
     readonly developerMessage: Scalars['String'];
@@ -386,26 +351,13 @@ export declare type InviteError = {
     readonly endUserMessage?: Maybe<Scalars['String']>;
     readonly membershipValidation?: Maybe<ReadonlyArray<MembershipValidationError>>;
 };
-export declare enum InviteErrorCode {
-    AlreadyMember = "ALREADY_MEMBER",
-    InvalidMembership = "INVALID_MEMBERSHIP",
-    ProjectNotFound = "PROJECT_NOT_FOUND",
-    /** @deprecated Field no longer supported */
-    RoleNotFound = "ROLE_NOT_FOUND",
-    /** @deprecated Field no longer supported */
-    VariableEmpty = "VARIABLE_EMPTY",
-    /** @deprecated Field no longer supported */
-    VariableNotFound = "VARIABLE_NOT_FOUND"
-}
-export declare enum InviteMethod {
-    CreatePassword = "CREATE_PASSWORD",
-    ResetPassword = "RESET_PASSWORD"
-}
-export declare type InviteOptions = {
+export type InviteErrorCode = 'ALREADY_MEMBER' | 'INVALID_MEMBERSHIP' | 'PROJECT_NOT_FOUND' | 'ROLE_NOT_FOUND' | 'VARIABLE_EMPTY' | 'VARIABLE_NOT_FOUND';
+export type InviteMethod = 'CREATE_PASSWORD' | 'RESET_PASSWORD';
+export type InviteOptions = {
     readonly mailVariant?: InputMaybe<Scalars['String']>;
     readonly method?: InputMaybe<InviteMethod>;
 };
-export declare type InviteResponse = {
+export type InviteResponse = {
     readonly __typename?: 'InviteResponse';
     readonly error?: Maybe<InviteError>;
     /** @deprecated Field no longer supported */
@@ -413,12 +365,12 @@ export declare type InviteResponse = {
     readonly ok: Scalars['Boolean'];
     readonly result?: Maybe<InviteResult>;
 };
-export declare type InviteResult = {
+export type InviteResult = {
     readonly __typename?: 'InviteResult';
     readonly isNew: Scalars['Boolean'];
     readonly person: Person;
 };
-export declare type MailTemplate = {
+export type MailTemplate = {
     readonly content: Scalars['String'];
     readonly projectSlug?: InputMaybe<Scalars['String']>;
     readonly subject: Scalars['String'];
@@ -427,43 +379,32 @@ export declare type MailTemplate = {
     /** Custom mail variant identifier, e.g. a locale. */
     readonly variant?: InputMaybe<Scalars['String']>;
 };
-export declare type MailTemplateIdentifier = {
+export type MailTemplateIdentifier = {
     readonly projectSlug?: InputMaybe<Scalars['String']>;
     readonly type: MailType;
     readonly variant?: InputMaybe<Scalars['String']>;
 };
-export declare enum MailType {
-    ExistingUserInvited = "EXISTING_USER_INVITED",
-    NewUserInvited = "NEW_USER_INVITED",
-    ResetPasswordRequest = "RESET_PASSWORD_REQUEST"
-}
-export declare enum MemberType {
-    ApiKey = "API_KEY",
-    Person = "PERSON"
-}
-export declare type Membership = {
+export type MailType = 'EXISTING_USER_INVITED' | 'NEW_USER_INVITED' | 'RESET_PASSWORD_REQUEST';
+export type MemberType = 'API_KEY' | 'PERSON';
+export type Membership = {
     readonly __typename?: 'Membership';
     readonly role: Scalars['String'];
     readonly variables: ReadonlyArray<VariableEntry>;
 };
-export declare type MembershipInput = {
+export type MembershipInput = {
     readonly role: Scalars['String'];
     readonly variables: ReadonlyArray<VariableEntryInput>;
 };
-export declare type MembershipValidationError = {
+export type MembershipValidationError = {
     readonly __typename?: 'MembershipValidationError';
     readonly code: MembershipValidationErrorCode;
     readonly role: Scalars['String'];
     readonly variable?: Maybe<Scalars['String']>;
 };
-export declare enum MembershipValidationErrorCode {
-    RoleNotFound = "ROLE_NOT_FOUND",
-    VariableEmpty = "VARIABLE_EMPTY",
-    VariableInvalid = "VARIABLE_INVALID",
-    VariableNotFound = "VARIABLE_NOT_FOUND"
-}
-export declare type Mutation = {
+export type MembershipValidationErrorCode = 'ROLE_NOT_FOUND' | 'VARIABLE_EMPTY' | 'VARIABLE_INVALID' | 'VARIABLE_NOT_FOUND';
+export type Mutation = {
     readonly __typename?: 'Mutation';
+    readonly addGlobalIdentityRoles?: Maybe<AddGlobalIdentityRolesResponse>;
     readonly addIDP?: Maybe<AddIdpResponse>;
     readonly addMailTemplate?: Maybe<AddMailTemplateResponse>;
     /** @deprecated use addMailTemplate */
@@ -480,10 +421,12 @@ export declare type Mutation = {
     readonly disableApiKey?: Maybe<DisableApiKeyResponse>;
     readonly disableIDP?: Maybe<DisableIdpResponse>;
     readonly disableOtp?: Maybe<DisableOtpResponse>;
+    readonly disablePerson?: Maybe<DisablePersonResponse>;
     readonly enableIDP?: Maybe<EnableIdpResponse>;
     readonly initSignInIDP?: Maybe<InitSignInIdpResponse>;
     readonly invite?: Maybe<InviteResponse>;
     readonly prepareOtp?: Maybe<PrepareOtpResponse>;
+    readonly removeGlobalIdentityRoles?: Maybe<RemoveGlobalIdentityRolesResponse>;
     readonly removeMailTemplate?: Maybe<RemoveMailTemplateResponse>;
     /** @deprecated use removeMailTemplate */
     readonly removeProjectMailTemplate?: Maybe<RemoveMailTemplateResponse>;
@@ -499,46 +442,50 @@ export declare type Mutation = {
     readonly updateProject?: Maybe<UpdateProjectResponse>;
     readonly updateProjectMember?: Maybe<UpdateProjectMemberResponse>;
 };
-export declare type MutationAddIdpArgs = {
+export type MutationAddGlobalIdentityRolesArgs = {
+    identityId: Scalars['String'];
+    roles: ReadonlyArray<Scalars['String']>;
+};
+export type MutationAddIdpArgs = {
     configuration: Scalars['Json'];
     identityProvider: Scalars['String'];
     options?: InputMaybe<IdpOptions>;
     type: Scalars['String'];
 };
-export declare type MutationAddMailTemplateArgs = {
+export type MutationAddMailTemplateArgs = {
     template: MailTemplate;
 };
-export declare type MutationAddProjectMailTemplateArgs = {
+export type MutationAddProjectMailTemplateArgs = {
     template: MailTemplate;
 };
-export declare type MutationAddProjectMemberArgs = {
+export type MutationAddProjectMemberArgs = {
     identityId: Scalars['String'];
     memberships: ReadonlyArray<MembershipInput>;
     projectSlug: Scalars['String'];
 };
-export declare type MutationChangeMyPasswordArgs = {
+export type MutationChangeMyPasswordArgs = {
     currentPassword: Scalars['String'];
     newPassword: Scalars['String'];
 };
-export declare type MutationChangePasswordArgs = {
+export type MutationChangePasswordArgs = {
     password: Scalars['String'];
     personId: Scalars['String'];
 };
-export declare type MutationConfirmOtpArgs = {
+export type MutationConfirmOtpArgs = {
     otpToken: Scalars['String'];
 };
-export declare type MutationCreateApiKeyArgs = {
+export type MutationCreateApiKeyArgs = {
     description: Scalars['String'];
     memberships: ReadonlyArray<MembershipInput>;
     projectSlug: Scalars['String'];
     tokenHash?: InputMaybe<Scalars['String']>;
 };
-export declare type MutationCreateGlobalApiKeyArgs = {
+export type MutationCreateGlobalApiKeyArgs = {
     description: Scalars['String'];
     roles?: InputMaybe<ReadonlyArray<Scalars['String']>>;
     tokenHash?: InputMaybe<Scalars['String']>;
 };
-export declare type MutationCreateProjectArgs = {
+export type MutationCreateProjectArgs = {
     config?: InputMaybe<Scalars['Json']>;
     deployTokenHash?: InputMaybe<Scalars['String']>;
     name?: InputMaybe<Scalars['String']>;
@@ -546,65 +493,72 @@ export declare type MutationCreateProjectArgs = {
     projectSlug: Scalars['String'];
     secrets?: InputMaybe<ReadonlyArray<ProjectSecret>>;
 };
-export declare type MutationCreateResetPasswordRequestArgs = {
+export type MutationCreateResetPasswordRequestArgs = {
     email: Scalars['String'];
     options?: InputMaybe<CreateResetPasswordRequestOptions>;
 };
-export declare type MutationCreateSessionTokenArgs = {
+export type MutationCreateSessionTokenArgs = {
     email?: InputMaybe<Scalars['String']>;
     expiration?: InputMaybe<Scalars['Int']>;
     personId?: InputMaybe<Scalars['String']>;
 };
-export declare type MutationDisableApiKeyArgs = {
+export type MutationDisableApiKeyArgs = {
     id: Scalars['String'];
 };
-export declare type MutationDisableIdpArgs = {
+export type MutationDisableIdpArgs = {
     identityProvider: Scalars['String'];
 };
-export declare type MutationEnableIdpArgs = {
+export type MutationDisablePersonArgs = {
+    personId: Scalars['String'];
+};
+export type MutationEnableIdpArgs = {
     identityProvider: Scalars['String'];
 };
-export declare type MutationInitSignInIdpArgs = {
+export type MutationInitSignInIdpArgs = {
     data?: InputMaybe<Scalars['Json']>;
     identityProvider: Scalars['String'];
     redirectUrl?: InputMaybe<Scalars['String']>;
 };
-export declare type MutationInviteArgs = {
+export type MutationInviteArgs = {
     email: Scalars['String'];
     memberships: ReadonlyArray<MembershipInput>;
     name?: InputMaybe<Scalars['String']>;
     options?: InputMaybe<InviteOptions>;
     projectSlug: Scalars['String'];
 };
-export declare type MutationPrepareOtpArgs = {
+export type MutationPrepareOtpArgs = {
     label?: InputMaybe<Scalars['String']>;
 };
-export declare type MutationRemoveMailTemplateArgs = {
+export type MutationRemoveGlobalIdentityRolesArgs = {
+    identityId: Scalars['String'];
+    roles: ReadonlyArray<Scalars['String']>;
+};
+export type MutationRemoveMailTemplateArgs = {
     templateIdentifier: MailTemplateIdentifier;
 };
-export declare type MutationRemoveProjectMailTemplateArgs = {
+export type MutationRemoveProjectMailTemplateArgs = {
     templateIdentifier: MailTemplateIdentifier;
 };
-export declare type MutationRemoveProjectMemberArgs = {
+export type MutationRemoveProjectMemberArgs = {
     identityId: Scalars['String'];
     projectSlug: Scalars['String'];
 };
-export declare type MutationResetPasswordArgs = {
+export type MutationResetPasswordArgs = {
     password: Scalars['String'];
     token: Scalars['String'];
 };
-export declare type MutationSetProjectSecretArgs = {
+export type MutationSetProjectSecretArgs = {
     key: Scalars['String'];
     projectSlug: Scalars['String'];
     value: Scalars['String'];
 };
-export declare type MutationSignInArgs = {
+export type MutationSignInArgs = {
     email: Scalars['String'];
     expiration?: InputMaybe<Scalars['Int']>;
     otpToken?: InputMaybe<Scalars['String']>;
     password: Scalars['String'];
 };
-export declare type MutationSignInIdpArgs = {
+export type MutationSignInIdpArgs = {
     data?: InputMaybe<Scalars['Json']>;
     expiration?: InputMaybe<Scalars['Int']>;
     identityProvider: Scalars['String'];
@@ -612,17 +566,17 @@ export declare type MutationSignInIdpArgs = {
     redirectUrl?: InputMaybe<Scalars['String']>;
     sessionData?: InputMaybe<Scalars['Json']>;
 };
-export declare type MutationSignOutArgs = {
+export type MutationSignOutArgs = {
     all?: InputMaybe<Scalars['Boolean']>;
 };
-export declare type MutationSignUpArgs = {
+export type MutationSignUpArgs = {
     email: Scalars['String'];
     name?: InputMaybe<Scalars['String']>;
     password?: InputMaybe<Scalars['String']>;
     passwordHash?: InputMaybe<Scalars['String']>;
     roles?: InputMaybe<ReadonlyArray<Scalars['String']>>;
 };
-export declare type MutationUnmanagedInviteArgs = {
+export type MutationUnmanagedInviteArgs = {
     email: Scalars['String'];
     memberships: ReadonlyArray<MembershipInput>;
     name?: InputMaybe<Scalars['String']>;
@@ -630,24 +584,24 @@ export declare type MutationUnmanagedInviteArgs = {
     password?: InputMaybe<Scalars['String']>;
     projectSlug: Scalars['String'];
 };
-export declare type MutationUpdateIdpArgs = {
+export type MutationUpdateIdpArgs = {
     configuration?: InputMaybe<Scalars['Json']>;
     identityProvider: Scalars['String'];
     options?: InputMaybe<IdpOptions>;
     type?: InputMaybe<Scalars['String']>;
 };
-export declare type MutationUpdateProjectArgs = {
+export type MutationUpdateProjectArgs = {
     config?: InputMaybe<Scalars['Json']>;
     mergeConfig?: InputMaybe<Scalars['Boolean']>;
     name?: InputMaybe<Scalars['String']>;
     projectSlug: Scalars['String'];
 };
-export declare type MutationUpdateProjectMemberArgs = {
+export type MutationUpdateProjectMemberArgs = {
     identityId: Scalars['String'];
     memberships: ReadonlyArray<MembershipInput>;
     projectSlug: Scalars['String'];
 };
-export declare type Person = {
+export type Person = {
     readonly __typename?: 'Person';
     readonly email?: Maybe<Scalars['String']>;
     readonly id: Scalars['String'];
@@ -655,17 +609,17 @@ export declare type Person = {
     readonly name?: Maybe<Scalars['String']>;
     readonly otpEnabled: Scalars['Boolean'];
 };
-export declare type PrepareOtpResponse = {
+export type PrepareOtpResponse = {
     readonly __typename?: 'PrepareOtpResponse';
     readonly ok: Scalars['Boolean'];
     readonly result?: Maybe<PrepareOtpResult>;
 };
-export declare type PrepareOtpResult = {
+export type PrepareOtpResult = {
     readonly __typename?: 'PrepareOtpResult';
     readonly otpSecret: Scalars['String'];
     readonly otpUri: Scalars['String'];
 };
-export declare type Project = {
+export type Project = {
     readonly __typename?: 'Project';
     readonly config: Scalars['Json'];
     readonly id: Scalars['String'];
@@ -674,29 +628,29 @@ export declare type Project = {
     readonly roles: ReadonlyArray<RoleDefinition>;
     readonly slug: Scalars['String'];
 };
-export declare type ProjectMembersArgs = {
+export type ProjectMembersArgs = {
     input?: InputMaybe<ProjectMembersInput>;
     memberType?: InputMaybe<MemberType>;
 };
-export declare type ProjectIdentityRelation = {
+export type ProjectIdentityRelation = {
     readonly __typename?: 'ProjectIdentityRelation';
     readonly identity: Identity;
     readonly memberships: ReadonlyArray<Membership>;
 };
-export declare type ProjectMembersFilter = {
+export type ProjectMembersFilter = {
     readonly email?: InputMaybe<Scalars['String']>;
     readonly memberType?: InputMaybe<MemberType>;
 };
-export declare type ProjectMembersInput = {
+export type ProjectMembersInput = {
     readonly filter?: InputMaybe<ProjectMembersFilter>;
     readonly limit?: InputMaybe<Scalars['Int']>;
     readonly offset?: InputMaybe<Scalars['Int']>;
 };
-export declare type ProjectSecret = {
+export type ProjectSecret = {
     readonly key: Scalars['String'];
     readonly value: Scalars['String'];
 };
-export declare type Query = {
+export type Query = {
     readonly __typename?: 'Query';
     readonly checkResetPasswordToken: CheckResetPasswordTokenCode;
     readonly identityProviders: ReadonlyArray<IdentityProvider>;
@@ -705,125 +659,126 @@ export declare type Query = {
     readonly projectMemberships: ReadonlyArray<Membership>;
     readonly projects: ReadonlyArray<Project>;
 };
-export declare type QueryCheckResetPasswordTokenArgs = {
+export type QueryCheckResetPasswordTokenArgs = {
     requestId: Scalars['String'];
     token: Scalars['String'];
 };
-export declare type QueryProjectBySlugArgs = {
+export type QueryProjectBySlugArgs = {
     slug: Scalars['String'];
 };
-export declare type QueryProjectMembershipsArgs = {
+export type QueryProjectMembershipsArgs = {
     identityId: Scalars['String'];
     projectSlug: Scalars['String'];
 };
-export declare type RemoveMailTemplateError = {
+export type RemoveGlobalIdentityRolesError = {
+    readonly __typename?: 'RemoveGlobalIdentityRolesError';
+    readonly code: RemoveGlobalIdentityRolesErrorCode;
+    readonly developerMessage: Scalars['String'];
+};
+export type RemoveGlobalIdentityRolesErrorCode = 'IDENTITY_NOT_FOUND' | 'INVALID_ROLE';
+export type RemoveGlobalIdentityRolesResponse = {
+    readonly __typename?: 'RemoveGlobalIdentityRolesResponse';
+    readonly error?: Maybe<RemoveGlobalIdentityRolesError>;
+    readonly ok: Scalars['Boolean'];
+    readonly result?: Maybe<RemoveGlobalIdentityRolesResult>;
+};
+export type RemoveGlobalIdentityRolesResult = {
+    readonly __typename?: 'RemoveGlobalIdentityRolesResult';
+    readonly identity: Identity;
+};
+export type RemoveMailTemplateError = {
     readonly __typename?: 'RemoveMailTemplateError';
     readonly code: RemoveMailTemplateErrorCode;
     readonly developerMessage: Scalars['String'];
     /** @deprecated Field no longer supported */
     readonly endUserMessage?: Maybe<Scalars['String']>;
 };
-export declare enum RemoveMailTemplateErrorCode {
-    ProjectNotFound = "PROJECT_NOT_FOUND",
-    TemplateNotFound = "TEMPLATE_NOT_FOUND"
-}
-export declare type RemoveMailTemplateResponse = {
+export type RemoveMailTemplateErrorCode = 'PROJECT_NOT_FOUND' | 'TEMPLATE_NOT_FOUND';
+export type RemoveMailTemplateResponse = {
     readonly __typename?: 'RemoveMailTemplateResponse';
     readonly error?: Maybe<RemoveMailTemplateError>;
     readonly errors: ReadonlyArray<RemoveMailTemplateError>;
     readonly ok: Scalars['Boolean'];
 };
-export declare type RemoveProjectMemberError = {
+export type RemoveProjectMemberError = {
     readonly __typename?: 'RemoveProjectMemberError';
     readonly code: RemoveProjectMemberErrorCode;
     readonly developerMessage: Scalars['String'];
     /** @deprecated Field no longer supported */
     readonly endUserMessage?: Maybe<Scalars['String']>;
 };
-export declare enum RemoveProjectMemberErrorCode {
-    NotMember = "NOT_MEMBER",
-    ProjectNotFound = "PROJECT_NOT_FOUND"
-}
-export declare type RemoveProjectMemberResponse = {
+export type RemoveProjectMemberErrorCode = 'NOT_MEMBER' | 'PROJECT_NOT_FOUND';
+export type RemoveProjectMemberResponse = {
     readonly __typename?: 'RemoveProjectMemberResponse';
     readonly error?: Maybe<RemoveProjectMemberError>;
     readonly errors: ReadonlyArray<RemoveProjectMemberError>;
     readonly ok: Scalars['Boolean'];
 };
-export declare type ResetPasswordError = {
+export type ResetPasswordError = {
     readonly __typename?: 'ResetPasswordError';
     readonly code: ResetPasswordErrorCode;
     readonly developerMessage: Scalars['String'];
     /** @deprecated Field no longer supported */
     readonly endUserMessage?: Maybe<Scalars['String']>;
 };
-export declare enum ResetPasswordErrorCode {
-    PasswordTooWeak = "PASSWORD_TOO_WEAK",
-    TokenExpired = "TOKEN_EXPIRED",
-    TokenNotFound = "TOKEN_NOT_FOUND",
-    TokenUsed = "TOKEN_USED"
-}
-export declare type ResetPasswordResponse = {
+export type ResetPasswordErrorCode = 'PASSWORD_TOO_WEAK' | 'TOKEN_EXPIRED' | 'TOKEN_NOT_FOUND' | 'TOKEN_USED';
+export type ResetPasswordResponse = {
     readonly __typename?: 'ResetPasswordResponse';
     readonly error?: Maybe<ResetPasswordError>;
     /** @deprecated Field no longer supported */
     readonly errors: ReadonlyArray<ResetPasswordError>;
     readonly ok: Scalars['Boolean'];
 };
-export declare type RoleConditionVariableDefinition = RoleVariableDefinition & {
+export type RoleConditionVariableDefinition = RoleVariableDefinition & {
     readonly __typename?: 'RoleConditionVariableDefinition';
     readonly name: Scalars['String'];
 };
-export declare type RoleDefinition = {
+export type RoleDefinition = {
     readonly __typename?: 'RoleDefinition';
     readonly name: Scalars['String'];
     readonly variables: ReadonlyArray<RoleVariableDefinition>;
 };
-export declare type RoleEntityVariableDefinition = RoleVariableDefinition & {
+export type RoleEntityVariableDefinition = RoleVariableDefinition & {
     readonly __typename?: 'RoleEntityVariableDefinition';
     readonly entityName: Scalars['String'];
     readonly name: Scalars['String'];
 };
-export declare type RolePredefinedVariableDefinition = RoleVariableDefinition & {
+export type RolePredefinedVariableDefinition = RoleVariableDefinition & {
     readonly __typename?: 'RolePredefinedVariableDefinition';
     readonly name: Scalars['String'];
     readonly value: Scalars['String'];
 };
-export declare type RoleVariableDefinition = {
+export type RoleVariableDefinition = {
     readonly name: Scalars['String'];
 };
-export declare type SetProjectSecretResponse = {
+export type SetProjectSecretError = {
+    readonly __typename?: 'SetProjectSecretError';
+    readonly code: SetProjectSecretErrorCode;
+    readonly developerMessage: Scalars['String'];
+};
+export type SetProjectSecretErrorCode = 'PROJECT_NOT_FOUND';
+export type SetProjectSecretResponse = {
     readonly __typename?: 'SetProjectSecretResponse';
+    readonly error?: Maybe<SetProjectSecretError>;
     readonly ok: Scalars['Boolean'];
 };
-export declare type SignInError = {
+export type SignInError = {
     readonly __typename?: 'SignInError';
     readonly code: SignInErrorCode;
     readonly developerMessage: Scalars['String'];
     /** @deprecated Field no longer supported */
     readonly endUserMessage?: Maybe<Scalars['String']>;
 };
-export declare enum SignInErrorCode {
-    InvalidOtpToken = "INVALID_OTP_TOKEN",
-    InvalidPassword = "INVALID_PASSWORD",
-    NoPasswordSet = "NO_PASSWORD_SET",
-    OtpRequired = "OTP_REQUIRED",
-    UnknownEmail = "UNKNOWN_EMAIL"
-}
-export declare type SignInIdpError = {
+export type SignInErrorCode = 'INVALID_OTP_TOKEN' | 'INVALID_PASSWORD' | 'NO_PASSWORD_SET' | 'OTP_REQUIRED' | 'UNKNOWN_EMAIL' | 'PERSON_DISABLED';
+export type SignInIdpError = {
     readonly __typename?: 'SignInIDPError';
     readonly code: SignInIdpErrorCode;
     readonly developerMessage: Scalars['String'];
     /** @deprecated Field no longer supported */
     readonly endUserMessage?: Maybe<Scalars['String']>;
 };
-export declare enum SignInIdpErrorCode {
-    IdpValidationFailed = "IDP_VALIDATION_FAILED",
-    InvalidIdpResponse = "INVALID_IDP_RESPONSE",
-    PersonAlreadyExists = "PERSON_ALREADY_EXISTS",
-    PersonNotFound = "PERSON_NOT_FOUND"
-}
-export declare type SignInIdpResponse = {
+export type SignInIdpErrorCode = 'IDP_VALIDATION_FAILED' | 'INVALID_IDP_RESPONSE' | 'PERSON_ALREADY_EXISTS' | 'PERSON_NOT_FOUND' | 'PERSON_DISABLED';
+export type SignInIdpResponse = {
     readonly __typename?: 'SignInIDPResponse';
     readonly error?: Maybe<SignInIdpError>;
     /** @deprecated Field no longer supported */
@@ -831,12 +786,12 @@ export declare type SignInIdpResponse = {
     readonly ok: Scalars['Boolean'];
     readonly result?: Maybe<SignInIdpResult>;
 };
-export declare type SignInIdpResult = CommonSignInResult & {
+export type SignInIdpResult = CommonSignInResult & {
     readonly __typename?: 'SignInIDPResult';
     readonly person: Person;
     readonly token: Scalars['String'];
 };
-export declare type SignInResponse = {
+export type SignInResponse = {
     readonly __typename?: 'SignInResponse';
     readonly error?: Maybe<SignInError>;
     /** @deprecated Field no longer supported */
@@ -844,40 +799,35 @@ export declare type SignInResponse = {
     readonly ok: Scalars['Boolean'];
     readonly result?: Maybe<SignInResult>;
 };
-export declare type SignInResult = CommonSignInResult & {
+export type SignInResult = CommonSignInResult & {
     readonly __typename?: 'SignInResult';
     readonly person: Person;
     readonly token: Scalars['String'];
 };
-export declare type SignOutError = {
+export type SignOutError = {
     readonly __typename?: 'SignOutError';
     readonly code: SignOutErrorCode;
     readonly developerMessage: Scalars['String'];
     /** @deprecated Field no longer supported */
     readonly endUserMessage?: Maybe<Scalars['String']>;
 };
-export declare enum SignOutErrorCode {
-    NotAPerson = "NOT_A_PERSON"
-}
-export declare type SignOutResponse = {
+export type SignOutErrorCode = 'NOT_A_PERSON' | 'NOT_POSSIBLE_SIGN_OUT_WITH_PERMANENT_API_KEY';
+export type SignOutResponse = {
     readonly __typename?: 'SignOutResponse';
     readonly error?: Maybe<SignOutError>;
     /** @deprecated Field no longer supported */
     readonly errors: ReadonlyArray<SignOutError>;
     readonly ok: Scalars['Boolean'];
 };
-export declare type SignUpError = {
+export type SignUpError = {
     readonly __typename?: 'SignUpError';
     readonly code: SignUpErrorCode;
     readonly developerMessage: Scalars['String'];
     /** @deprecated Field no longer supported */
     readonly endPersonMessage?: Maybe<Scalars['String']>;
 };
-export declare enum SignUpErrorCode {
-    EmailAlreadyExists = "EMAIL_ALREADY_EXISTS",
-    TooWeak = "TOO_WEAK"
-}
-export declare type SignUpResponse = {
+export type SignUpErrorCode = 'EMAIL_ALREADY_EXISTS' | 'TOO_WEAK';
+export type SignUpResponse = {
     readonly __typename?: 'SignUpResponse';
     readonly error?: Maybe<SignUpError>;
     /** @deprecated Field no longer supported */
@@ -885,29 +835,32 @@ export declare type SignUpResponse = {
     readonly ok: Scalars['Boolean'];
     readonly result?: Maybe<SignUpResult>;
 };
-export declare type SignUpResult = {
+export type SignUpResult = {
     readonly __typename?: 'SignUpResult';
     readonly person: Person;
 };
-export declare type UnmanagedInviteOptions = {
+export type UnmanagedInviteOptions = {
     readonly password?: InputMaybe<Scalars['String']>;
     readonly resetTokenHash?: InputMaybe<Scalars['String']>;
 };
-export declare type UpdateIdpError = {
+export type UpdateIdpError = {
     readonly __typename?: 'UpdateIDPError';
     readonly code: UpdateIdpErrorCode;
     readonly developerMessage: Scalars['String'];
 };
-export declare enum UpdateIdpErrorCode {
-    InvalidConfiguration = "INVALID_CONFIGURATION",
-    NotFound = "NOT_FOUND"
-}
-export declare type UpdateIdpResponse = {
+export type UpdateIdpErrorCode = 'INVALID_CONFIGURATION' | 'NOT_FOUND';
+export type UpdateIdpResponse = {
     readonly __typename?: 'UpdateIDPResponse';
     readonly error?: Maybe<UpdateIdpError>;
     readonly ok: Scalars['Boolean'];
 };
-export declare type UpdateProjectMemberError = {
+export type UpdateProjectError = {
+    readonly __typename?: 'UpdateProjectError';
+    readonly code: UpdateProjectErrorCode;
+    readonly developerMessage: Scalars['String'];
+};
+export type UpdateProjectErrorCode = 'PROJECT_NOT_FOUND';
+export type UpdateProjectMemberError = {
     readonly __typename?: 'UpdateProjectMemberError';
     readonly code: UpdateProjectMemberErrorCode;
     readonly developerMessage: Scalars['String'];
@@ -915,45 +868,36 @@ export declare type UpdateProjectMemberError = {
     readonly endUserMessage?: Maybe<Scalars['String']>;
     readonly membershipValidation?: Maybe<ReadonlyArray<MembershipValidationError>>;
 };
-export declare enum UpdateProjectMemberErrorCode {
-    InvalidMembership = "INVALID_MEMBERSHIP",
-    NotMember = "NOT_MEMBER",
-    ProjectNotFound = "PROJECT_NOT_FOUND",
-    /** @deprecated Field no longer supported */
-    RoleNotFound = "ROLE_NOT_FOUND",
-    /** @deprecated Field no longer supported */
-    VariableEmpty = "VARIABLE_EMPTY",
-    /** @deprecated Field no longer supported */
-    VariableNotFound = "VARIABLE_NOT_FOUND"
-}
-export declare type UpdateProjectMemberResponse = {
+export type UpdateProjectMemberErrorCode = 'INVALID_MEMBERSHIP' | 'NOT_MEMBER' | 'PROJECT_NOT_FOUND' | 'ROLE_NOT_FOUND' | 'VARIABLE_EMPTY' | 'VARIABLE_NOT_FOUND';
+export type UpdateProjectMemberResponse = {
     readonly __typename?: 'UpdateProjectMemberResponse';
     readonly error?: Maybe<UpdateProjectMemberError>;
     /** @deprecated Field no longer supported */
     readonly errors: ReadonlyArray<UpdateProjectMemberError>;
     readonly ok: Scalars['Boolean'];
 };
-export declare type UpdateProjectResponse = {
+export type UpdateProjectResponse = {
     readonly __typename?: 'UpdateProjectResponse';
+    readonly error?: Maybe<UpdateProjectError>;
     readonly ok: Scalars['Boolean'];
 };
-export declare type VariableEntry = {
+export type VariableEntry = {
     readonly __typename?: 'VariableEntry';
     readonly name: Scalars['String'];
     readonly values: ReadonlyArray<Scalars['String']>;
 };
-export declare type VariableEntryInput = {
+export type VariableEntryInput = {
     readonly name: Scalars['String'];
     readonly values: ReadonlyArray<Scalars['String']>;
 };
-export declare type ResolverTypeWrapper<T> = Promise<T> | T;
-export declare type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
+export type ResolverTypeWrapper<T> = Promise<T> | T;
+export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
     resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
 };
-export declare type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = ResolverFn<TResult, TParent, TContext, TArgs> | ResolverWithResolve<TResult, TParent, TContext, TArgs>;
-export declare type ResolverFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<TResult> | TResult;
-export declare type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>;
-export declare type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
+export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = ResolverFn<TResult, TParent, TContext, TArgs> | ResolverWithResolve<TResult, TParent, TContext, TArgs>;
+export type ResolverFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<TResult> | TResult;
+export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>;
+export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
 export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
     subscribe: SubscriptionSubscribeFn<{
         [key in TKey]: TResult;
@@ -966,14 +910,18 @@ export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
     subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>;
     resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
 }
-export declare type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> = SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs> | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
-export declare type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> = ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>) | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
-export declare type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (parent: TParent, context: TContext, info: GraphQLResolveInfo) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
-export declare type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
-export declare type NextResolverFn<T> = () => Promise<T>;
-export declare type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (next: NextResolverFn<TResult>, parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
+export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> = SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs> | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
+export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> = ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>) | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
+export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (parent: TParent, context: TContext, info: GraphQLResolveInfo) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
+export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
+export type NextResolverFn<T> = () => Promise<T>;
+export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (next: NextResolverFn<TResult>, parent: TParent, args: TArgs, context: TContext, info: GraphQLResolveInfo) => TResult | Promise<TResult>;
 /** Mapping between all available schema types and the resolvers types */
-export declare type ResolversTypes = {
+export type ResolversTypes = {
+    AddGlobalIdentityRolesError: ResolverTypeWrapper<AddGlobalIdentityRolesError>;
+    AddGlobalIdentityRolesErrorCode: AddGlobalIdentityRolesErrorCode;
+    AddGlobalIdentityRolesResponse: ResolverTypeWrapper<AddGlobalIdentityRolesResponse>;
+    AddGlobalIdentityRolesResult: ResolverTypeWrapper<AddGlobalIdentityRolesResult>;
     AddIDPError: ResolverTypeWrapper<AddIdpError>;
     AddIDPErrorCode: AddIdpErrorCode;
     AddIDPResponse: ResolverTypeWrapper<AddIdpResponse>;
@@ -1025,6 +973,9 @@ export declare type ResolversTypes = {
     DisableOtpError: ResolverTypeWrapper<DisableOtpError>;
     DisableOtpErrorCode: DisableOtpErrorCode;
     DisableOtpResponse: ResolverTypeWrapper<DisableOtpResponse>;
+    DisablePersonError: ResolverTypeWrapper<DisablePersonError>;
+    DisablePersonErrorCode: DisablePersonErrorCode;
+    DisablePersonResponse: ResolverTypeWrapper<DisablePersonResponse>;
     EnableIDPError: ResolverTypeWrapper<EnableIdpError>;
     EnableIDPErrorCode: EnableIdpErrorCode;
     EnableIDPResponse: ResolverTypeWrapper<EnableIdpResponse>;
@@ -1065,6 +1016,10 @@ export declare type ResolversTypes = {
     ProjectMembersInput: ProjectMembersInput;
     ProjectSecret: ProjectSecret;
     Query: ResolverTypeWrapper<{}>;
+    RemoveGlobalIdentityRolesError: ResolverTypeWrapper<RemoveGlobalIdentityRolesError>;
+    RemoveGlobalIdentityRolesErrorCode: RemoveGlobalIdentityRolesErrorCode;
+    RemoveGlobalIdentityRolesResponse: ResolverTypeWrapper<RemoveGlobalIdentityRolesResponse>;
+    RemoveGlobalIdentityRolesResult: ResolverTypeWrapper<RemoveGlobalIdentityRolesResult>;
     RemoveMailTemplateError: ResolverTypeWrapper<RemoveMailTemplateError>;
     RemoveMailTemplateErrorCode: RemoveMailTemplateErrorCode;
     RemoveMailTemplateResponse: ResolverTypeWrapper<RemoveMailTemplateResponse>;
@@ -1079,6 +1034,8 @@ export declare type ResolversTypes = {
     RoleEntityVariableDefinition: ResolverTypeWrapper<RoleEntityVariableDefinition>;
     RolePredefinedVariableDefinition: ResolverTypeWrapper<RolePredefinedVariableDefinition>;
     RoleVariableDefinition: ResolversTypes['RoleConditionVariableDefinition'] | ResolversTypes['RoleEntityVariableDefinition'] | ResolversTypes['RolePredefinedVariableDefinition'];
+    SetProjectSecretError: ResolverTypeWrapper<SetProjectSecretError>;
+    SetProjectSecretErrorCode: SetProjectSecretErrorCode;
     SetProjectSecretResponse: ResolverTypeWrapper<SetProjectSecretResponse>;
     SignInError: ResolverTypeWrapper<SignInError>;
     SignInErrorCode: SignInErrorCode;
@@ -1100,6 +1057,8 @@ export declare type ResolversTypes = {
     UpdateIDPError: ResolverTypeWrapper<UpdateIdpError>;
     UpdateIDPErrorCode: UpdateIdpErrorCode;
     UpdateIDPResponse: ResolverTypeWrapper<UpdateIdpResponse>;
+    UpdateProjectError: ResolverTypeWrapper<UpdateProjectError>;
+    UpdateProjectErrorCode: UpdateProjectErrorCode;
     UpdateProjectMemberError: ResolverTypeWrapper<UpdateProjectMemberError>;
     UpdateProjectMemberErrorCode: UpdateProjectMemberErrorCode;
     UpdateProjectMemberResponse: ResolverTypeWrapper<UpdateProjectMemberResponse>;
@@ -1108,7 +1067,10 @@ export declare type ResolversTypes = {
     VariableEntryInput: VariableEntryInput;
 };
 /** Mapping between all available schema types and the resolvers parents */
-export declare type ResolversParentTypes = {
+export type ResolversParentTypes = {
+    AddGlobalIdentityRolesError: AddGlobalIdentityRolesError;
+    AddGlobalIdentityRolesResponse: AddGlobalIdentityRolesResponse;
+    AddGlobalIdentityRolesResult: AddGlobalIdentityRolesResult;
     AddIDPError: AddIdpError;
     AddIDPResponse: AddIdpResponse;
     AddMailTemplateError: AddMailTemplateError;
@@ -1146,6 +1108,8 @@ export declare type ResolversParentTypes = {
     DisableIDPResponse: DisableIdpResponse;
     DisableOtpError: DisableOtpError;
     DisableOtpResponse: DisableOtpResponse;
+    DisablePersonError: DisablePersonError;
+    DisablePersonResponse: DisablePersonResponse;
     EnableIDPError: EnableIdpError;
     EnableIDPResponse: EnableIdpResponse;
     IDPOptions: IdpOptions;
@@ -1179,6 +1143,9 @@ export declare type ResolversParentTypes = {
     ProjectMembersInput: ProjectMembersInput;
     ProjectSecret: ProjectSecret;
     Query: {};
+    RemoveGlobalIdentityRolesError: RemoveGlobalIdentityRolesError;
+    RemoveGlobalIdentityRolesResponse: RemoveGlobalIdentityRolesResponse;
+    RemoveGlobalIdentityRolesResult: RemoveGlobalIdentityRolesResult;
     RemoveMailTemplateError: RemoveMailTemplateError;
     RemoveMailTemplateResponse: RemoveMailTemplateResponse;
     RemoveProjectMemberError: RemoveProjectMemberError;
@@ -1190,6 +1157,7 @@ export declare type ResolversParentTypes = {
     RoleEntityVariableDefinition: RoleEntityVariableDefinition;
     RolePredefinedVariableDefinition: RolePredefinedVariableDefinition;
     RoleVariableDefinition: ResolversParentTypes['RoleConditionVariableDefinition'] | ResolversParentTypes['RoleEntityVariableDefinition'] | ResolversParentTypes['RolePredefinedVariableDefinition'];
+    SetProjectSecretError: SetProjectSecretError;
     SetProjectSecretResponse: SetProjectSecretResponse;
     SignInError: SignInError;
     SignInIDPError: SignInIdpError;
@@ -1206,158 +1174,174 @@ export declare type ResolversParentTypes = {
     UnmanagedInviteOptions: UnmanagedInviteOptions;
     UpdateIDPError: UpdateIdpError;
     UpdateIDPResponse: UpdateIdpResponse;
+    UpdateProjectError: UpdateProjectError;
     UpdateProjectMemberError: UpdateProjectMemberError;
     UpdateProjectMemberResponse: UpdateProjectMemberResponse;
     UpdateProjectResponse: UpdateProjectResponse;
     VariableEntry: VariableEntry;
     VariableEntryInput: VariableEntryInput;
 };
-export declare type AddIdpErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['AddIDPError'] = ResolversParentTypes['AddIDPError']> = {
+export type AddGlobalIdentityRolesErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['AddGlobalIdentityRolesError'] = ResolversParentTypes['AddGlobalIdentityRolesError']> = {
+    code?: Resolver<ResolversTypes['AddGlobalIdentityRolesErrorCode'], ParentType, ContextType>;
+    developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export type AddGlobalIdentityRolesResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['AddGlobalIdentityRolesResponse'] = ResolversParentTypes['AddGlobalIdentityRolesResponse']> = {
+    error?: Resolver<Maybe<ResolversTypes['AddGlobalIdentityRolesError']>, ParentType, ContextType>;
+    ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    result?: Resolver<Maybe<ResolversTypes['AddGlobalIdentityRolesResult']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export type AddGlobalIdentityRolesResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['AddGlobalIdentityRolesResult'] = ResolversParentTypes['AddGlobalIdentityRolesResult']> = {
+    identity?: Resolver<ResolversTypes['Identity'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export type AddIdpErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['AddIDPError'] = ResolversParentTypes['AddIDPError']> = {
     code?: Resolver<ResolversTypes['AddIDPErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type AddIdpResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['AddIDPResponse'] = ResolversParentTypes['AddIDPResponse']> = {
+export type AddIdpResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['AddIDPResponse'] = ResolversParentTypes['AddIDPResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['AddIDPError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type AddMailTemplateErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['AddMailTemplateError'] = ResolversParentTypes['AddMailTemplateError']> = {
+export type AddMailTemplateErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['AddMailTemplateError'] = ResolversParentTypes['AddMailTemplateError']> = {
     code?: Resolver<ResolversTypes['AddMailTemplateErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     endUserMessage?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type AddMailTemplateResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['AddMailTemplateResponse'] = ResolversParentTypes['AddMailTemplateResponse']> = {
+export type AddMailTemplateResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['AddMailTemplateResponse'] = ResolversParentTypes['AddMailTemplateResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['AddMailTemplateError']>, ParentType, ContextType>;
     errors?: Resolver<ReadonlyArray<ResolversTypes['AddMailTemplateError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type AddProjectMemberErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['AddProjectMemberError'] = ResolversParentTypes['AddProjectMemberError']> = {
+export type AddProjectMemberErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['AddProjectMemberError'] = ResolversParentTypes['AddProjectMemberError']> = {
     code?: Resolver<ResolversTypes['AddProjectMemberErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     endUserMessage?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     membershipValidation?: Resolver<Maybe<ReadonlyArray<ResolversTypes['MembershipValidationError']>>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type AddProjectMemberResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['AddProjectMemberResponse'] = ResolversParentTypes['AddProjectMemberResponse']> = {
+export type AddProjectMemberResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['AddProjectMemberResponse'] = ResolversParentTypes['AddProjectMemberResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['AddProjectMemberError']>, ParentType, ContextType>;
     errors?: Resolver<ReadonlyArray<ResolversTypes['AddProjectMemberError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type ApiKeyResolvers<ContextType = any, ParentType extends ResolversParentTypes['ApiKey'] = ResolversParentTypes['ApiKey']> = {
+export type ApiKeyResolvers<ContextType = any, ParentType extends ResolversParentTypes['ApiKey'] = ResolversParentTypes['ApiKey']> = {
     id?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     identity?: Resolver<ResolversTypes['Identity'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type ApiKeyWithTokenResolvers<ContextType = any, ParentType extends ResolversParentTypes['ApiKeyWithToken'] = ResolversParentTypes['ApiKeyWithToken']> = {
+export type ApiKeyWithTokenResolvers<ContextType = any, ParentType extends ResolversParentTypes['ApiKeyWithToken'] = ResolversParentTypes['ApiKeyWithToken']> = {
     id?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     identity?: Resolver<ResolversTypes['Identity'], ParentType, ContextType>;
     token?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type ChangeMyPasswordErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['ChangeMyPasswordError'] = ResolversParentTypes['ChangeMyPasswordError']> = {
+export type ChangeMyPasswordErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['ChangeMyPasswordError'] = ResolversParentTypes['ChangeMyPasswordError']> = {
     code?: Resolver<ResolversTypes['ChangeMyPasswordErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type ChangeMyPasswordResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['ChangeMyPasswordResponse'] = ResolversParentTypes['ChangeMyPasswordResponse']> = {
+export type ChangeMyPasswordResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['ChangeMyPasswordResponse'] = ResolversParentTypes['ChangeMyPasswordResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['ChangeMyPasswordError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type ChangePasswordErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['ChangePasswordError'] = ResolversParentTypes['ChangePasswordError']> = {
+export type ChangePasswordErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['ChangePasswordError'] = ResolversParentTypes['ChangePasswordError']> = {
     code?: Resolver<ResolversTypes['ChangePasswordErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     endUserMessage?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type ChangePasswordResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['ChangePasswordResponse'] = ResolversParentTypes['ChangePasswordResponse']> = {
+export type ChangePasswordResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['ChangePasswordResponse'] = ResolversParentTypes['ChangePasswordResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['ChangePasswordError']>, ParentType, ContextType>;
     errors?: Resolver<ReadonlyArray<ResolversTypes['ChangePasswordError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type CheckResetPasswordTokenResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['CheckResetPasswordTokenResult'] = ResolversParentTypes['CheckResetPasswordTokenResult']> = {
+export type CheckResetPasswordTokenResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['CheckResetPasswordTokenResult'] = ResolversParentTypes['CheckResetPasswordTokenResult']> = {
     code?: Resolver<ResolversTypes['CheckResetPasswordTokenCode'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type CommonSignInResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['CommonSignInResult'] = ResolversParentTypes['CommonSignInResult']> = {
+export type CommonSignInResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['CommonSignInResult'] = ResolversParentTypes['CommonSignInResult']> = {
     __resolveType: TypeResolveFn<'CreateSessionTokenResult' | 'SignInIDPResult' | 'SignInResult', ParentType, ContextType>;
     person?: Resolver<ResolversTypes['Person'], ParentType, ContextType>;
     token?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
 };
-export declare type ConfirmOtpErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['ConfirmOtpError'] = ResolversParentTypes['ConfirmOtpError']> = {
+export type ConfirmOtpErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['ConfirmOtpError'] = ResolversParentTypes['ConfirmOtpError']> = {
     code?: Resolver<ResolversTypes['ConfirmOtpErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     endUserMessage?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type ConfirmOtpResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['ConfirmOtpResponse'] = ResolversParentTypes['ConfirmOtpResponse']> = {
+export type ConfirmOtpResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['ConfirmOtpResponse'] = ResolversParentTypes['ConfirmOtpResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['ConfirmOtpError']>, ParentType, ContextType>;
     errors?: Resolver<ReadonlyArray<ResolversTypes['ConfirmOtpError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type CreateApiKeyErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreateApiKeyError'] = ResolversParentTypes['CreateApiKeyError']> = {
+export type CreateApiKeyErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreateApiKeyError'] = ResolversParentTypes['CreateApiKeyError']> = {
     code?: Resolver<ResolversTypes['CreateApiKeyErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     endUserMessage?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     membershipValidation?: Resolver<Maybe<ReadonlyArray<ResolversTypes['MembershipValidationError']>>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type CreateApiKeyResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreateApiKeyResponse'] = ResolversParentTypes['CreateApiKeyResponse']> = {
+export type CreateApiKeyResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreateApiKeyResponse'] = ResolversParentTypes['CreateApiKeyResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['CreateApiKeyError']>, ParentType, ContextType>;
     errors?: Resolver<ReadonlyArray<ResolversTypes['CreateApiKeyError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     result?: Resolver<Maybe<ResolversTypes['CreateApiKeyResult']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type CreateApiKeyResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreateApiKeyResult'] = ResolversParentTypes['CreateApiKeyResult']> = {
+export type CreateApiKeyResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreateApiKeyResult'] = ResolversParentTypes['CreateApiKeyResult']> = {
     apiKey?: Resolver<ResolversTypes['ApiKeyWithToken'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type CreatePasswordResetRequestErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreatePasswordResetRequestError'] = ResolversParentTypes['CreatePasswordResetRequestError']> = {
+export type CreatePasswordResetRequestErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreatePasswordResetRequestError'] = ResolversParentTypes['CreatePasswordResetRequestError']> = {
     code?: Resolver<ResolversTypes['CreatePasswordResetRequestErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     endUserMessage?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type CreatePasswordResetRequestResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreatePasswordResetRequestResponse'] = ResolversParentTypes['CreatePasswordResetRequestResponse']> = {
+export type CreatePasswordResetRequestResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreatePasswordResetRequestResponse'] = ResolversParentTypes['CreatePasswordResetRequestResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['CreatePasswordResetRequestError']>, ParentType, ContextType>;
     errors?: Resolver<ReadonlyArray<ResolversTypes['CreatePasswordResetRequestError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type CreateProjectResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreateProjectResponse'] = ResolversParentTypes['CreateProjectResponse']> = {
+export type CreateProjectResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreateProjectResponse'] = ResolversParentTypes['CreateProjectResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['CreateProjectResponseError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     result?: Resolver<Maybe<ResolversTypes['CreateProjectResult']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type CreateProjectResponseErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreateProjectResponseError'] = ResolversParentTypes['CreateProjectResponseError']> = {
+export type CreateProjectResponseErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreateProjectResponseError'] = ResolversParentTypes['CreateProjectResponseError']> = {
     code?: Resolver<ResolversTypes['CreateProjectResponseErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type CreateProjectResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreateProjectResult'] = ResolversParentTypes['CreateProjectResult']> = {
+export type CreateProjectResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreateProjectResult'] = ResolversParentTypes['CreateProjectResult']> = {
     deployerApiKey?: Resolver<Maybe<ResolversTypes['ApiKeyWithToken']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type CreateSessionTokenErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreateSessionTokenError'] = ResolversParentTypes['CreateSessionTokenError']> = {
+export type CreateSessionTokenErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreateSessionTokenError'] = ResolversParentTypes['CreateSessionTokenError']> = {
     code?: Resolver<ResolversTypes['CreateSessionTokenErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type CreateSessionTokenResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreateSessionTokenResponse'] = ResolversParentTypes['CreateSessionTokenResponse']> = {
+export type CreateSessionTokenResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreateSessionTokenResponse'] = ResolversParentTypes['CreateSessionTokenResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['CreateSessionTokenError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     result?: Resolver<Maybe<ResolversTypes['CreateSessionTokenResult']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type CreateSessionTokenResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreateSessionTokenResult'] = ResolversParentTypes['CreateSessionTokenResult']> = {
+export type CreateSessionTokenResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['CreateSessionTokenResult'] = ResolversParentTypes['CreateSessionTokenResult']> = {
     person?: Resolver<ResolversTypes['Person'], ParentType, ContextType>;
     token?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
@@ -1365,56 +1349,66 @@ export declare type CreateSessionTokenResultResolvers<ContextType = any, ParentT
 export interface DateTimeScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['DateTime'], any> {
     name: 'DateTime';
 }
-export declare type DisableApiKeyErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['DisableApiKeyError'] = ResolversParentTypes['DisableApiKeyError']> = {
+export type DisableApiKeyErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['DisableApiKeyError'] = ResolversParentTypes['DisableApiKeyError']> = {
     code?: Resolver<ResolversTypes['DisableApiKeyErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     endUserMessage?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type DisableApiKeyResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['DisableApiKeyResponse'] = ResolversParentTypes['DisableApiKeyResponse']> = {
+export type DisableApiKeyResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['DisableApiKeyResponse'] = ResolversParentTypes['DisableApiKeyResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['DisableApiKeyError']>, ParentType, ContextType>;
     errors?: Resolver<ReadonlyArray<ResolversTypes['DisableApiKeyError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type DisableIdpErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['DisableIDPError'] = ResolversParentTypes['DisableIDPError']> = {
+export type DisableIdpErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['DisableIDPError'] = ResolversParentTypes['DisableIDPError']> = {
     code?: Resolver<ResolversTypes['DisableIDPErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type DisableIdpResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['DisableIDPResponse'] = ResolversParentTypes['DisableIDPResponse']> = {
+export type DisableIdpResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['DisableIDPResponse'] = ResolversParentTypes['DisableIDPResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['DisableIDPError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type DisableOtpErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['DisableOtpError'] = ResolversParentTypes['DisableOtpError']> = {
+export type DisableOtpErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['DisableOtpError'] = ResolversParentTypes['DisableOtpError']> = {
     code?: Resolver<ResolversTypes['DisableOtpErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     endUserMessage?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type DisableOtpResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['DisableOtpResponse'] = ResolversParentTypes['DisableOtpResponse']> = {
+export type DisableOtpResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['DisableOtpResponse'] = ResolversParentTypes['DisableOtpResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['DisableOtpError']>, ParentType, ContextType>;
     errors?: Resolver<ReadonlyArray<ResolversTypes['DisableOtpError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type EnableIdpErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['EnableIDPError'] = ResolversParentTypes['EnableIDPError']> = {
+export type DisablePersonErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['DisablePersonError'] = ResolversParentTypes['DisablePersonError']> = {
+    code?: Resolver<ResolversTypes['DisablePersonErrorCode'], ParentType, ContextType>;
+    developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export type DisablePersonResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['DisablePersonResponse'] = ResolversParentTypes['DisablePersonResponse']> = {
+    error?: Resolver<Maybe<ResolversTypes['DisablePersonError']>, ParentType, ContextType>;
+    ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export type EnableIdpErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['EnableIDPError'] = ResolversParentTypes['EnableIDPError']> = {
     code?: Resolver<ResolversTypes['EnableIDPErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type EnableIdpResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['EnableIDPResponse'] = ResolversParentTypes['EnableIDPResponse']> = {
+export type EnableIdpResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['EnableIDPResponse'] = ResolversParentTypes['EnableIDPResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['EnableIDPError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type IdpOptionsOutputResolvers<ContextType = any, ParentType extends ResolversParentTypes['IDPOptionsOutput'] = ResolversParentTypes['IDPOptionsOutput']> = {
+export type IdpOptionsOutputResolvers<ContextType = any, ParentType extends ResolversParentTypes['IDPOptionsOutput'] = ResolversParentTypes['IDPOptionsOutput']> = {
     autoSignUp?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     exclusive?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type IdentityResolvers<ContextType = any, ParentType extends ResolversParentTypes['Identity'] = ResolversParentTypes['Identity']> = {
+export type IdentityResolvers<ContextType = any, ParentType extends ResolversParentTypes['Identity'] = ResolversParentTypes['Identity']> = {
     apiKey?: Resolver<Maybe<ResolversTypes['ApiKey']>, ParentType, ContextType>;
     description?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     id?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
@@ -1424,56 +1418,56 @@ export declare type IdentityResolvers<ContextType = any, ParentType extends Reso
     roles?: Resolver<Maybe<ReadonlyArray<ResolversTypes['String']>>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type IdentityGlobalPermissionsResolvers<ContextType = any, ParentType extends ResolversParentTypes['IdentityGlobalPermissions'] = ResolversParentTypes['IdentityGlobalPermissions']> = {
+export type IdentityGlobalPermissionsResolvers<ContextType = any, ParentType extends ResolversParentTypes['IdentityGlobalPermissions'] = ResolversParentTypes['IdentityGlobalPermissions']> = {
     canCreateProject?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type IdentityProjectRelationResolvers<ContextType = any, ParentType extends ResolversParentTypes['IdentityProjectRelation'] = ResolversParentTypes['IdentityProjectRelation']> = {
+export type IdentityProjectRelationResolvers<ContextType = any, ParentType extends ResolversParentTypes['IdentityProjectRelation'] = ResolversParentTypes['IdentityProjectRelation']> = {
     memberships?: Resolver<ReadonlyArray<ResolversTypes['Membership']>, ParentType, ContextType>;
     project?: Resolver<ResolversTypes['Project'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type IdentityProviderResolvers<ContextType = any, ParentType extends ResolversParentTypes['IdentityProvider'] = ResolversParentTypes['IdentityProvider']> = {
+export type IdentityProviderResolvers<ContextType = any, ParentType extends ResolversParentTypes['IdentityProvider'] = ResolversParentTypes['IdentityProvider']> = {
     configuration?: Resolver<ResolversTypes['Json'], ParentType, ContextType>;
-    disabledAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>;
+    disabledAt?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>;
     options?: Resolver<ResolversTypes['IDPOptionsOutput'], ParentType, ContextType>;
     slug?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     type?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type InitSignInIdpErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['InitSignInIDPError'] = ResolversParentTypes['InitSignInIDPError']> = {
+export type InitSignInIdpErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['InitSignInIDPError'] = ResolversParentTypes['InitSignInIDPError']> = {
     code?: Resolver<ResolversTypes['InitSignInIDPErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     endUserMessage?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type InitSignInIdpResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['InitSignInIDPResponse'] = ResolversParentTypes['InitSignInIDPResponse']> = {
+export type InitSignInIdpResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['InitSignInIDPResponse'] = ResolversParentTypes['InitSignInIDPResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['InitSignInIDPError']>, ParentType, ContextType>;
     errors?: Resolver<ReadonlyArray<ResolversTypes['InitSignInIDPError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     result?: Resolver<Maybe<ResolversTypes['InitSignInIDPResult']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type InitSignInIdpResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['InitSignInIDPResult'] = ResolversParentTypes['InitSignInIDPResult']> = {
+export type InitSignInIdpResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['InitSignInIDPResult'] = ResolversParentTypes['InitSignInIDPResult']> = {
     authUrl?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     sessionData?: Resolver<ResolversTypes['Json'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type InviteErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['InviteError'] = ResolversParentTypes['InviteError']> = {
+export type InviteErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['InviteError'] = ResolversParentTypes['InviteError']> = {
     code?: Resolver<ResolversTypes['InviteErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     endUserMessage?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     membershipValidation?: Resolver<Maybe<ReadonlyArray<ResolversTypes['MembershipValidationError']>>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type InviteResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['InviteResponse'] = ResolversParentTypes['InviteResponse']> = {
+export type InviteResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['InviteResponse'] = ResolversParentTypes['InviteResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['InviteError']>, ParentType, ContextType>;
     errors?: Resolver<ReadonlyArray<ResolversTypes['InviteError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     result?: Resolver<Maybe<ResolversTypes['InviteResult']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type InviteResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['InviteResult'] = ResolversParentTypes['InviteResult']> = {
+export type InviteResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['InviteResult'] = ResolversParentTypes['InviteResult']> = {
     isNew?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     person?: Resolver<ResolversTypes['Person'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
@@ -1481,18 +1475,19 @@ export declare type InviteResultResolvers<ContextType = any, ParentType extends
 export interface JsonScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['Json'], any> {
     name: 'Json';
 }
-export declare type MembershipResolvers<ContextType = any, ParentType extends ResolversParentTypes['Membership'] = ResolversParentTypes['Membership']> = {
+export type MembershipResolvers<ContextType = any, ParentType extends ResolversParentTypes['Membership'] = ResolversParentTypes['Membership']> = {
     role?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     variables?: Resolver<ReadonlyArray<ResolversTypes['VariableEntry']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type MembershipValidationErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['MembershipValidationError'] = ResolversParentTypes['MembershipValidationError']> = {
+export type MembershipValidationErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['MembershipValidationError'] = ResolversParentTypes['MembershipValidationError']> = {
     code?: Resolver<ResolversTypes['MembershipValidationErrorCode'], ParentType, ContextType>;
     role?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     variable?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type MutationResolvers<ContextType = any, ParentType extends ResolversParentTypes['Mutation'] = ResolversParentTypes['Mutation']> = {
+export type MutationResolvers<ContextType = any, ParentType extends ResolversParentTypes['Mutation'] = ResolversParentTypes['Mutation']> = {
+    addGlobalIdentityRoles?: Resolver<Maybe<ResolversTypes['AddGlobalIdentityRolesResponse']>, ParentType, ContextType, RequireFields<MutationAddGlobalIdentityRolesArgs, 'identityId' | 'roles'>>;
     addIDP?: Resolver<Maybe<ResolversTypes['AddIDPResponse']>, ParentType, ContextType, RequireFields<MutationAddIdpArgs, 'configuration' | 'identityProvider' | 'type'>>;
     addMailTemplate?: Resolver<Maybe<ResolversTypes['AddMailTemplateResponse']>, ParentType, ContextType, RequireFields<MutationAddMailTemplateArgs, 'template'>>;
     addProjectMailTemplate?: Resolver<Maybe<ResolversTypes['AddMailTemplateResponse']>, ParentType, ContextType, RequireFields<MutationAddProjectMailTemplateArgs, 'template'>>;
@@ -1508,10 +1503,12 @@ export declare type MutationResolvers<ContextType = any, ParentType extends Reso
     disableApiKey?: Resolver<Maybe<ResolversTypes['DisableApiKeyResponse']>, ParentType, ContextType, RequireFields<MutationDisableApiKeyArgs, 'id'>>;
     disableIDP?: Resolver<Maybe<ResolversTypes['DisableIDPResponse']>, ParentType, ContextType, RequireFields<MutationDisableIdpArgs, 'identityProvider'>>;
     disableOtp?: Resolver<Maybe<ResolversTypes['DisableOtpResponse']>, ParentType, ContextType>;
+    disablePerson?: Resolver<Maybe<ResolversTypes['DisablePersonResponse']>, ParentType, ContextType, RequireFields<MutationDisablePersonArgs, 'personId'>>;
     enableIDP?: Resolver<Maybe<ResolversTypes['EnableIDPResponse']>, ParentType, ContextType, RequireFields<MutationEnableIdpArgs, 'identityProvider'>>;
     initSignInIDP?: Resolver<Maybe<ResolversTypes['InitSignInIDPResponse']>, ParentType, ContextType, RequireFields<MutationInitSignInIdpArgs, 'identityProvider'>>;
     invite?: Resolver<Maybe<ResolversTypes['InviteResponse']>, ParentType, ContextType, RequireFields<MutationInviteArgs, 'email' | 'memberships' | 'projectSlug'>>;
     prepareOtp?: Resolver<Maybe<ResolversTypes['PrepareOtpResponse']>, ParentType, ContextType, Partial<MutationPrepareOtpArgs>>;
+    removeGlobalIdentityRoles?: Resolver<Maybe<ResolversTypes['RemoveGlobalIdentityRolesResponse']>, ParentType, ContextType, RequireFields<MutationRemoveGlobalIdentityRolesArgs, 'identityId' | 'roles'>>;
     removeMailTemplate?: Resolver<Maybe<ResolversTypes['RemoveMailTemplateResponse']>, ParentType, ContextType, RequireFields<MutationRemoveMailTemplateArgs, 'templateIdentifier'>>;
     removeProjectMailTemplate?: Resolver<Maybe<ResolversTypes['RemoveMailTemplateResponse']>, ParentType, ContextType, RequireFields<MutationRemoveProjectMailTemplateArgs, 'templateIdentifier'>>;
     removeProjectMember?: Resolver<Maybe<ResolversTypes['RemoveProjectMemberResponse']>, ParentType, ContextType, RequireFields<MutationRemoveProjectMemberArgs, 'identityId' | 'projectSlug'>>;
@@ -1526,7 +1523,7 @@ export declare type MutationResolvers<ContextType = any, ParentType extends Reso
     updateProject?: Resolver<Maybe<ResolversTypes['UpdateProjectResponse']>, ParentType, ContextType, RequireFields<MutationUpdateProjectArgs, 'projectSlug'>>;
     updateProjectMember?: Resolver<Maybe<ResolversTypes['UpdateProjectMemberResponse']>, ParentType, ContextType, RequireFields<MutationUpdateProjectMemberArgs, 'identityId' | 'memberships' | 'projectSlug'>>;
 };
-export declare type PersonResolvers<ContextType = any, ParentType extends ResolversParentTypes['Person'] = ResolversParentTypes['Person']> = {
+export type PersonResolvers<ContextType = any, ParentType extends ResolversParentTypes['Person'] = ResolversParentTypes['Person']> = {
     email?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     id?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     identity?: Resolver<ResolversTypes['Identity'], ParentType, ContextType>;
@@ -1534,17 +1531,17 @@ export declare type PersonResolvers<ContextType = any, ParentType extends Resolv
     otpEnabled?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type PrepareOtpResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['PrepareOtpResponse'] = ResolversParentTypes['PrepareOtpResponse']> = {
+export type PrepareOtpResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['PrepareOtpResponse'] = ResolversParentTypes['PrepareOtpResponse']> = {
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     result?: Resolver<Maybe<ResolversTypes['PrepareOtpResult']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type PrepareOtpResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['PrepareOtpResult'] = ResolversParentTypes['PrepareOtpResult']> = {
+export type PrepareOtpResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['PrepareOtpResult'] = ResolversParentTypes['PrepareOtpResult']> = {
     otpSecret?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     otpUri?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type ProjectResolvers<ContextType = any, ParentType extends ResolversParentTypes['Project'] = ResolversParentTypes['Project']> = {
+export type ProjectResolvers<ContextType = any, ParentType extends ResolversParentTypes['Project'] = ResolversParentTypes['Project']> = {
     config?: Resolver<ResolversTypes['Json'], ParentType, ContextType>;
     id?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     members?: Resolver<ReadonlyArray<ResolversTypes['ProjectIdentityRelation']>, ParentType, ContextType, Partial<ProjectMembersArgs>>;
@@ -1553,12 +1550,12 @@ export declare type ProjectResolvers<ContextType = any, ParentType extends Resol
     slug?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type ProjectIdentityRelationResolvers<ContextType = any, ParentType extends ResolversParentTypes['ProjectIdentityRelation'] = ResolversParentTypes['ProjectIdentityRelation']> = {
+export type ProjectIdentityRelationResolvers<ContextType = any, ParentType extends ResolversParentTypes['ProjectIdentityRelation'] = ResolversParentTypes['ProjectIdentityRelation']> = {
     identity?: Resolver<ResolversTypes['Identity'], ParentType, ContextType>;
     memberships?: Resolver<ReadonlyArray<ResolversTypes['Membership']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type QueryResolvers<ContextType = any, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = {
+export type QueryResolvers<ContextType = any, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = {
     checkResetPasswordToken?: Resolver<ResolversTypes['CheckResetPasswordTokenCode'], ParentType, ContextType, RequireFields<QueryCheckResetPasswordTokenArgs, 'requestId' | 'token'>>;
     identityProviders?: Resolver<ReadonlyArray<ResolversTypes['IdentityProvider']>, ParentType, ContextType>;
     me?: Resolver<ResolversTypes['Identity'], ParentType, ContextType>;
@@ -1566,167 +1563,197 @@ export declare type QueryResolvers<ContextType = any, ParentType extends Resolve
     projectMemberships?: Resolver<ReadonlyArray<ResolversTypes['Membership']>, ParentType, ContextType, RequireFields<QueryProjectMembershipsArgs, 'identityId' | 'projectSlug'>>;
     projects?: Resolver<ReadonlyArray<ResolversTypes['Project']>, ParentType, ContextType>;
 };
-export declare type RemoveMailTemplateErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['RemoveMailTemplateError'] = ResolversParentTypes['RemoveMailTemplateError']> = {
+export type RemoveGlobalIdentityRolesErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['RemoveGlobalIdentityRolesError'] = ResolversParentTypes['RemoveGlobalIdentityRolesError']> = {
+    code?: Resolver<ResolversTypes['RemoveGlobalIdentityRolesErrorCode'], ParentType, ContextType>;
+    developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export type RemoveGlobalIdentityRolesResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['RemoveGlobalIdentityRolesResponse'] = ResolversParentTypes['RemoveGlobalIdentityRolesResponse']> = {
+    error?: Resolver<Maybe<ResolversTypes['RemoveGlobalIdentityRolesError']>, ParentType, ContextType>;
+    ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+    result?: Resolver<Maybe<ResolversTypes['RemoveGlobalIdentityRolesResult']>, ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export type RemoveGlobalIdentityRolesResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['RemoveGlobalIdentityRolesResult'] = ResolversParentTypes['RemoveGlobalIdentityRolesResult']> = {
+    identity?: Resolver<ResolversTypes['Identity'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export type RemoveMailTemplateErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['RemoveMailTemplateError'] = ResolversParentTypes['RemoveMailTemplateError']> = {
     code?: Resolver<ResolversTypes['RemoveMailTemplateErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     endUserMessage?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type RemoveMailTemplateResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['RemoveMailTemplateResponse'] = ResolversParentTypes['RemoveMailTemplateResponse']> = {
+export type RemoveMailTemplateResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['RemoveMailTemplateResponse'] = ResolversParentTypes['RemoveMailTemplateResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['RemoveMailTemplateError']>, ParentType, ContextType>;
     errors?: Resolver<ReadonlyArray<ResolversTypes['RemoveMailTemplateError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type RemoveProjectMemberErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['RemoveProjectMemberError'] = ResolversParentTypes['RemoveProjectMemberError']> = {
+export type RemoveProjectMemberErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['RemoveProjectMemberError'] = ResolversParentTypes['RemoveProjectMemberError']> = {
     code?: Resolver<ResolversTypes['RemoveProjectMemberErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     endUserMessage?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type RemoveProjectMemberResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['RemoveProjectMemberResponse'] = ResolversParentTypes['RemoveProjectMemberResponse']> = {
+export type RemoveProjectMemberResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['RemoveProjectMemberResponse'] = ResolversParentTypes['RemoveProjectMemberResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['RemoveProjectMemberError']>, ParentType, ContextType>;
     errors?: Resolver<ReadonlyArray<ResolversTypes['RemoveProjectMemberError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type ResetPasswordErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['ResetPasswordError'] = ResolversParentTypes['ResetPasswordError']> = {
+export type ResetPasswordErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['ResetPasswordError'] = ResolversParentTypes['ResetPasswordError']> = {
     code?: Resolver<ResolversTypes['ResetPasswordErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     endUserMessage?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type ResetPasswordResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['ResetPasswordResponse'] = ResolversParentTypes['ResetPasswordResponse']> = {
+export type ResetPasswordResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['ResetPasswordResponse'] = ResolversParentTypes['ResetPasswordResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['ResetPasswordError']>, ParentType, ContextType>;
     errors?: Resolver<ReadonlyArray<ResolversTypes['ResetPasswordError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type RoleConditionVariableDefinitionResolvers<ContextType = any, ParentType extends ResolversParentTypes['RoleConditionVariableDefinition'] = ResolversParentTypes['RoleConditionVariableDefinition']> = {
+export type RoleConditionVariableDefinitionResolvers<ContextType = any, ParentType extends ResolversParentTypes['RoleConditionVariableDefinition'] = ResolversParentTypes['RoleConditionVariableDefinition']> = {
     name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type RoleDefinitionResolvers<ContextType = any, ParentType extends ResolversParentTypes['RoleDefinition'] = ResolversParentTypes['RoleDefinition']> = {
+export type RoleDefinitionResolvers<ContextType = any, ParentType extends ResolversParentTypes['RoleDefinition'] = ResolversParentTypes['RoleDefinition']> = {
     name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     variables?: Resolver<ReadonlyArray<ResolversTypes['RoleVariableDefinition']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type RoleEntityVariableDefinitionResolvers<ContextType = any, ParentType extends ResolversParentTypes['RoleEntityVariableDefinition'] = ResolversParentTypes['RoleEntityVariableDefinition']> = {
+export type RoleEntityVariableDefinitionResolvers<ContextType = any, ParentType extends ResolversParentTypes['RoleEntityVariableDefinition'] = ResolversParentTypes['RoleEntityVariableDefinition']> = {
     entityName?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type RolePredefinedVariableDefinitionResolvers<ContextType = any, ParentType extends ResolversParentTypes['RolePredefinedVariableDefinition'] = ResolversParentTypes['RolePredefinedVariableDefinition']> = {
+export type RolePredefinedVariableDefinitionResolvers<ContextType = any, ParentType extends ResolversParentTypes['RolePredefinedVariableDefinition'] = ResolversParentTypes['RolePredefinedVariableDefinition']> = {
     name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     value?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type RoleVariableDefinitionResolvers<ContextType = any, ParentType extends ResolversParentTypes['RoleVariableDefinition'] = ResolversParentTypes['RoleVariableDefinition']> = {
+export type RoleVariableDefinitionResolvers<ContextType = any, ParentType extends ResolversParentTypes['RoleVariableDefinition'] = ResolversParentTypes['RoleVariableDefinition']> = {
     __resolveType: TypeResolveFn<'RoleConditionVariableDefinition' | 'RoleEntityVariableDefinition' | 'RolePredefinedVariableDefinition', ParentType, ContextType>;
     name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
 };
-export declare type SetProjectSecretResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['SetProjectSecretResponse'] = ResolversParentTypes['SetProjectSecretResponse']> = {
+export type SetProjectSecretErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['SetProjectSecretError'] = ResolversParentTypes['SetProjectSecretError']> = {
+    code?: Resolver<ResolversTypes['SetProjectSecretErrorCode'], ParentType, ContextType>;
+    developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export type SetProjectSecretResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['SetProjectSecretResponse'] = ResolversParentTypes['SetProjectSecretResponse']> = {
+    error?: Resolver<Maybe<ResolversTypes['SetProjectSecretError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type SignInErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignInError'] = ResolversParentTypes['SignInError']> = {
+export type SignInErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignInError'] = ResolversParentTypes['SignInError']> = {
     code?: Resolver<ResolversTypes['SignInErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     endUserMessage?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type SignInIdpErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignInIDPError'] = ResolversParentTypes['SignInIDPError']> = {
+export type SignInIdpErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignInIDPError'] = ResolversParentTypes['SignInIDPError']> = {
     code?: Resolver<ResolversTypes['SignInIDPErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     endUserMessage?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type SignInIdpResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignInIDPResponse'] = ResolversParentTypes['SignInIDPResponse']> = {
+export type SignInIdpResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignInIDPResponse'] = ResolversParentTypes['SignInIDPResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['SignInIDPError']>, ParentType, ContextType>;
     errors?: Resolver<ReadonlyArray<ResolversTypes['SignInIDPError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     result?: Resolver<Maybe<ResolversTypes['SignInIDPResult']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type SignInIdpResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignInIDPResult'] = ResolversParentTypes['SignInIDPResult']> = {
+export type SignInIdpResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignInIDPResult'] = ResolversParentTypes['SignInIDPResult']> = {
     person?: Resolver<ResolversTypes['Person'], ParentType, ContextType>;
     token?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type SignInResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignInResponse'] = ResolversParentTypes['SignInResponse']> = {
+export type SignInResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignInResponse'] = ResolversParentTypes['SignInResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['SignInError']>, ParentType, ContextType>;
     errors?: Resolver<ReadonlyArray<ResolversTypes['SignInError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     result?: Resolver<Maybe<ResolversTypes['SignInResult']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type SignInResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignInResult'] = ResolversParentTypes['SignInResult']> = {
+export type SignInResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignInResult'] = ResolversParentTypes['SignInResult']> = {
     person?: Resolver<ResolversTypes['Person'], ParentType, ContextType>;
     token?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type SignOutErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignOutError'] = ResolversParentTypes['SignOutError']> = {
+export type SignOutErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignOutError'] = ResolversParentTypes['SignOutError']> = {
     code?: Resolver<ResolversTypes['SignOutErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     endUserMessage?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type SignOutResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignOutResponse'] = ResolversParentTypes['SignOutResponse']> = {
+export type SignOutResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignOutResponse'] = ResolversParentTypes['SignOutResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['SignOutError']>, ParentType, ContextType>;
     errors?: Resolver<ReadonlyArray<ResolversTypes['SignOutError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type SignUpErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignUpError'] = ResolversParentTypes['SignUpError']> = {
+export type SignUpErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignUpError'] = ResolversParentTypes['SignUpError']> = {
     code?: Resolver<ResolversTypes['SignUpErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     endPersonMessage?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type SignUpResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignUpResponse'] = ResolversParentTypes['SignUpResponse']> = {
+export type SignUpResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignUpResponse'] = ResolversParentTypes['SignUpResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['SignUpError']>, ParentType, ContextType>;
     errors?: Resolver<ReadonlyArray<ResolversTypes['SignUpError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     result?: Resolver<Maybe<ResolversTypes['SignUpResult']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type SignUpResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignUpResult'] = ResolversParentTypes['SignUpResult']> = {
+export type SignUpResultResolvers<ContextType = any, ParentType extends ResolversParentTypes['SignUpResult'] = ResolversParentTypes['SignUpResult']> = {
     person?: Resolver<ResolversTypes['Person'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type UpdateIdpErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['UpdateIDPError'] = ResolversParentTypes['UpdateIDPError']> = {
+export type UpdateIdpErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['UpdateIDPError'] = ResolversParentTypes['UpdateIDPError']> = {
     code?: Resolver<ResolversTypes['UpdateIDPErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type UpdateIdpResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['UpdateIDPResponse'] = ResolversParentTypes['UpdateIDPResponse']> = {
+export type UpdateIdpResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['UpdateIDPResponse'] = ResolversParentTypes['UpdateIDPResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['UpdateIDPError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type UpdateProjectMemberErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['UpdateProjectMemberError'] = ResolversParentTypes['UpdateProjectMemberError']> = {
+export type UpdateProjectErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['UpdateProjectError'] = ResolversParentTypes['UpdateProjectError']> = {
+    code?: Resolver<ResolversTypes['UpdateProjectErrorCode'], ParentType, ContextType>;
+    developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+    __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+export type UpdateProjectMemberErrorResolvers<ContextType = any, ParentType extends ResolversParentTypes['UpdateProjectMemberError'] = ResolversParentTypes['UpdateProjectMemberError']> = {
     code?: Resolver<ResolversTypes['UpdateProjectMemberErrorCode'], ParentType, ContextType>;
     developerMessage?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     endUserMessage?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
     membershipValidation?: Resolver<Maybe<ReadonlyArray<ResolversTypes['MembershipValidationError']>>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type UpdateProjectMemberResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['UpdateProjectMemberResponse'] = ResolversParentTypes['UpdateProjectMemberResponse']> = {
+export type UpdateProjectMemberResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['UpdateProjectMemberResponse'] = ResolversParentTypes['UpdateProjectMemberResponse']> = {
     error?: Resolver<Maybe<ResolversTypes['UpdateProjectMemberError']>, ParentType, ContextType>;
     errors?: Resolver<ReadonlyArray<ResolversTypes['UpdateProjectMemberError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type UpdateProjectResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['UpdateProjectResponse'] = ResolversParentTypes['UpdateProjectResponse']> = {
+export type UpdateProjectResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['UpdateProjectResponse'] = ResolversParentTypes['UpdateProjectResponse']> = {
+    error?: Resolver<Maybe<ResolversTypes['UpdateProjectError']>, ParentType, ContextType>;
     ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type VariableEntryResolvers<ContextType = any, ParentType extends ResolversParentTypes['VariableEntry'] = ResolversParentTypes['VariableEntry']> = {
+export type VariableEntryResolvers<ContextType = any, ParentType extends ResolversParentTypes['VariableEntry'] = ResolversParentTypes['VariableEntry']> = {
     name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
     values?: Resolver<ReadonlyArray<ResolversTypes['String']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
-export declare type Resolvers<ContextType = any> = {
+export type Resolvers<ContextType = any> = {
+    AddGlobalIdentityRolesError?: AddGlobalIdentityRolesErrorResolvers<ContextType>;
+    AddGlobalIdentityRolesResponse?: AddGlobalIdentityRolesResponseResolvers<ContextType>;
+    AddGlobalIdentityRolesResult?: AddGlobalIdentityRolesResultResolvers<ContextType>;
     AddIDPError?: AddIdpErrorResolvers<ContextType>;
     AddIDPResponse?: AddIdpResponseResolvers<ContextType>;
     AddMailTemplateError?: AddMailTemplateErrorResolvers<ContextType>;
@@ -1761,6 +1788,8 @@ export declare type Resolvers<ContextType = any> = {
     DisableIDPResponse?: DisableIdpResponseResolvers<ContextType>;
     DisableOtpError?: DisableOtpErrorResolvers<ContextType>;
     DisableOtpResponse?: DisableOtpResponseResolvers<ContextType>;
+    DisablePersonError?: DisablePersonErrorResolvers<ContextType>;
+    DisablePersonResponse?: DisablePersonResponseResolvers<ContextType>;
     EnableIDPError?: EnableIdpErrorResolvers<ContextType>;
     EnableIDPResponse?: EnableIdpResponseResolvers<ContextType>;
     IDPOptionsOutput?: IdpOptionsOutputResolvers<ContextType>;
@@ -1784,6 +1813,9 @@ export declare type Resolvers<ContextType = any> = {
     Project?: ProjectResolvers<ContextType>;
     ProjectIdentityRelation?: ProjectIdentityRelationResolvers<ContextType>;
     Query?: QueryResolvers<ContextType>;
+    RemoveGlobalIdentityRolesError?: RemoveGlobalIdentityRolesErrorResolvers<ContextType>;
+    RemoveGlobalIdentityRolesResponse?: RemoveGlobalIdentityRolesResponseResolvers<ContextType>;
+    RemoveGlobalIdentityRolesResult?: RemoveGlobalIdentityRolesResultResolvers<ContextType>;
     RemoveMailTemplateError?: RemoveMailTemplateErrorResolvers<ContextType>;
     RemoveMailTemplateResponse?: RemoveMailTemplateResponseResolvers<ContextType>;
     RemoveProjectMemberError?: RemoveProjectMemberErrorResolvers<ContextType>;
@@ -1795,6 +1827,7 @@ export declare type Resolvers<ContextType = any> = {
     RoleEntityVariableDefinition?: RoleEntityVariableDefinitionResolvers<ContextType>;
     RolePredefinedVariableDefinition?: RolePredefinedVariableDefinitionResolvers<ContextType>;
     RoleVariableDefinition?: RoleVariableDefinitionResolvers<ContextType>;
+    SetProjectSecretError?: SetProjectSecretErrorResolvers<ContextType>;
     SetProjectSecretResponse?: SetProjectSecretResponseResolvers<ContextType>;
     SignInError?: SignInErrorResolvers<ContextType>;
     SignInIDPError?: SignInIdpErrorResolvers<ContextType>;
@@ -1809,6 +1842,7 @@ export declare type Resolvers<ContextType = any> = {
     SignUpResult?: SignUpResultResolvers<ContextType>;
     UpdateIDPError?: UpdateIdpErrorResolvers<ContextType>;
     UpdateIDPResponse?: UpdateIdpResponseResolvers<ContextType>;
+    UpdateProjectError?: UpdateProjectErrorResolvers<ContextType>;
     UpdateProjectMemberError?: UpdateProjectMemberErrorResolvers<ContextType>;
     UpdateProjectMemberResponse?: UpdateProjectMemberResponseResolvers<ContextType>;
     UpdateProjectResponse?: UpdateProjectResponseResolvers<ContextType>;