@orbis-systems/orbis-api-clients 0.3.0 → 0.4.0

package/dist/uma/index.d.ts

@@ -0,0 +1,3859 @@
+import { AxiosError, AxiosInstance, AxiosRequestConfig, HttpStatusCode } from "axios";
+interface BaseClientConfig<HandleError extends boolean = boolean> {
+    baseUrl: string;
+    errorHandling?: HandleError;
+    storage?: Storage;
+    defaultHeaders?: Record<string, string>;
+    defaultSecure?: boolean;
+    authDataStorageKey?: string;
+    onAxiosError?: (error: AxiosError) => void;
+    onError?: (error: unknown) => void;
+}
+enum ContentType {
+    Json = "application/json",
+    FormData = "multipart/form-data",
+    UrlEncoded = "application/x-www-form-urlencoded",
+    Text = "text/plain"
+}
+type RequestConfig<Body = unknown> = AxiosRequestConfig<Body> & {
+    secure?: boolean;
+    contentType?: ContentType;
+};
+type ResponseStatus = {
+    status: HttpStatusCode | -1;
+    statusText: string;
+};
+type SuccessClientResponse<Data = unknown> = ResponseStatus & {
+    success: true;
+    data: Data;
+};
+type ErrorClientResponse = ResponseStatus & {
+    success: false;
+    data?: any;
+    error: unknown;
+};
+type ClientResponse<Data = unknown, HandleError extends boolean = boolean> = HandleError extends true ? SuccessClientResponse<Data> | ErrorClientResponse : SuccessClientResponse<Data>;
+declare abstract class BaseClient<HandleError extends boolean = boolean, AuthData = unknown> {
+    protected readonly config: BaseClientConfig<HandleError>;
+    protected readonly axiosInstance: AxiosInstance;
+    protected readonly storage: Storage;
+    constructor(config: BaseClientConfig<HandleError>);
+    protected stringifyFormItem(formItem: unknown): string;
+    protected createFormData(input: Record<string, unknown>): FormData;
+    request<Data = unknown, Error = unknown, Body = unknown>(requestConfig: RequestConfig<Body>): Promise<ClientResponse<Data, HandleError>>;
+    get<Data = unknown, Error = unknown, Body = unknown>(url: string, config?: RequestConfig<Body>): Promise<ClientResponse<Data, HandleError>>;
+    delete<Data = unknown, Error = unknown, Body = unknown>(url: string, config?: RequestConfig<Body>): Promise<ClientResponse<Data, HandleError>>;
+    head<Data = unknown, Error = unknown, Body = unknown>(url: string, config?: RequestConfig<Body>): Promise<ClientResponse<Data, HandleError>>;
+    options<Data = unknown, Error = unknown, Body = unknown>(url: string, config?: RequestConfig<Body>): Promise<ClientResponse<Data, HandleError>>;
+    post<Data = unknown, Error = unknown, Body = unknown>(url: string, data?: Body, config?: RequestConfig<Body>): Promise<ClientResponse<Data, HandleError>>;
+    put<Data = unknown, Error = unknown, Body = unknown>(url: string, data?: Body, config?: RequestConfig<Body>): Promise<ClientResponse<Data, HandleError>>;
+    patch<Data = unknown, Error = unknown, Body = unknown>(url: string, data?: Body, config?: RequestConfig<Body>): Promise<ClientResponse<Data, HandleError>>;
+    getAxios(): AxiosInstance;
+    setAuthData(data: AuthData | null): void;
+    getAuthData(): AuthData | null;
+    getConfig(): BaseClientConfig<HandleError>;
+    abstract prepareAuthRequestConfig(): Pick<RequestConfig<any>, 'headers' | 'data' | 'params'>;
+}
+declare class BaseApi<HandleError extends boolean = boolean, ApiClient extends BaseClient<HandleError> = BaseClient<HandleError>> {
+    protected readonly apiClient: ApiClient;
+    constructor(apiClient: ApiClient);
+    getApiClient(): ApiClient;
+}
+interface JwtClientConfig<HandleError extends boolean = boolean> extends BaseClientConfig<HandleError> {
+    authSchema?: string;
+}
+interface JwtAuthData {
+    accessToken: string;
+    refreshToken: string;
+}
+declare class JwtClient<HandleError extends boolean = boolean> extends BaseClient<HandleError, JwtAuthData> {
+    protected readonly config: JwtClientConfig<HandleError>;
+    constructor(config: JwtClientConfig<HandleError>);
+    getConfig(): JwtClientConfig<HandleError>;
+    prepareAuthRequestConfig(): Pick<RequestConfig<any>, 'headers' | 'data' | 'params'>;
+    scheduleTokenRenewal(renewTokenCallback: () => Promise<JwtAuthData>): void;
+    cancelTokenRenewal(): void;
+}
+export interface UmaGetActionLogsSerializer {
+    action_logs: UmaActionLogSerializer[];
+    current_page: number;
+    pages_count: number;
+    status: number;
+    total_records: number;
+}
+export interface UmaAPIKeysMutationSerializer {
+    api_keys: UmaAPIKeys;
+    status: number;
+}
+export interface UmaGetAPIKeysSerializer {
+    api_keys: UmaAPIKeys[];
+    current_page: number;
+    pages_count: number;
+    status: number;
+    total_records: number;
+}
+export interface UmaAuthAppResponseSerializer {
+    auth_app: UmaAuthAppSerializer;
+    status: number;
+}
+export interface UmaFinishTOTPRegistrationResponseSerializer {
+    backup_codes: string[];
+    status: number;
+}
+export interface UmaGetAuthAppsListSerializer {
+    auth_apps_list: UmaAuthAppSerializer[];
+    status: number;
+}
+export interface UmaBasicLoginResultSerializer {
+    tokens: UmaTokens;
+    user: UmaUserSerializer;
+}
+export interface UmaAuthFormMutationSerializer {
+    form: UmaAuthFormSerializer;
+    status: number;
+}
+export interface UmaGetAuthFormsListSerializer {
+    current_page: number;
+    forms_list: UmaAuthFormSerializer[];
+    pages_count: number;
+    status: number;
+    total_records: number;
+}
+export interface UmaBasicB2BLoginResultSerializer {
+    tokens: UmaTokens;
+    user: UmaB2BUserSerializer;
+}
+export interface UmaBasicB2BLoginSerializer {
+    login_basic: UmaBasicB2BLoginResultSerializer;
+    status: number;
+}
+export interface UmaGetCurrentB2BUserSerializer {
+    current_user: UmaB2BUserSerializer;
+    status: number;
+}
+export interface UmaSimpleB2BLoginResultSerializer {
+    tokens: UmaTokens;
+}
+export interface UmaSimpleB2BLoginSerializer {
+    api_keys_login: UmaSimpleB2BLoginResultSerializer;
+    status: number;
+}
+export interface UmaB2BUserSerializer {
+    b2b_user: UmaAdminB2BUserSerializer;
+    status: number;
+}
+export interface UmaB2BUploadAvatarResponseSerializer {
+    avatar: UmaB2BUploadAvatarSerializer;
+    status: number;
+}
+export interface UmaB2BUserSettingsChangeSerializer {
+    settings: UmaB2BUserSettingsSerializer;
+    status: number;
+}
+export interface UmaB2BUserSettingsSerializer {
+    do_not_ask_mfa_again: boolean;
+    /** @example "test@gmail.com" */
+    email: string;
+    first_name: string;
+    last_name: string;
+    /** @example true */
+    mfa_enabled: boolean;
+    mode: string;
+    /** @example "+1231231234" */
+    phone: string;
+    theme: string;
+}
+export interface UmaB2CLoginResultSerializer {
+    email_verification_needed: boolean;
+    login_basic: UmaBasicLoginResultSerializer;
+    phone_verification_needed: boolean;
+    redirect_to: string;
+    status: number;
+}
+export interface UmaGetCurrentB2CUserSerializer {
+    current_user: UmaUserSerializer;
+    status: number;
+}
+export interface UmaRefreshResultSerializer {
+    login_basic: UmaBasicLoginResultSerializer;
+    redirect_to: string;
+    status: number;
+}
+export interface UmaRegisterResultSerializer {
+    user: UmaUserSerializer;
+}
+export interface UmaRegisterSerializer {
+    register: UmaRegisterResultSerializer;
+    /** @example 201 */
+    status: number;
+}
+export interface UmaB2CUserSerializer {
+    b2c_user: UmaAdminB2CUserSerializer;
+    status: number;
+}
+export interface UmaAvailableB2CMfaOptionsResponse {
+    options?: UmaAuthAppType[];
+    status?: number;
+}
+export interface UmaB2CUserSettingsChangeSerializer {
+    settings: UmaB2CUserSettingsSerializer;
+    status: number;
+}
+export interface UmaBranchMutationSerializer {
+    branch: UmaBranchAdminSerializer;
+    status: number;
+}
+export interface UmaGetBranchesListSerializer {
+    branches_list: UmaBranchAdminListItemSerializer[];
+    current_page: number;
+    is_create_allowed: boolean;
+    pages_count: number;
+    status: number;
+    total_records: number;
+}
+export enum UmaAuthAppType {
+    EmailCodeAuthAppType = "email_code",
+    SmsCodeAuthAppType = "sms_code",
+    YubicoOTPAuthAppType = "yubico_otp",
+    WebAuthnAuthAppType = "webauthn",
+    TOTPAuthAppType = "totp"
+}
+export enum UmaAuthUserType {
+    AllAuthUserType = "all",
+    B2BAuthUserType = "b2b",
+    B2CAuthUserType = "b2c"
+}
+export interface UmaPaginationDto {
+    page?: number;
+    /** @max 100 */
+    size?: number;
+}
+export enum UmaResetPasswordType {
+    PasswordResetByContactCode = "by_contact_code",
+    PasswordResetByEmailLink = "by_email_link"
+}
+export interface UmaSortDto {
+    direction?: string;
+    field?: string;
+}
+export interface UmaGetCountriesSerializer {
+    countries: UmaCountrySerializer[];
+    status: number;
+}
+export interface UmaEndpointMutationSerializer {
+    endpoint: UmaEndpointSerializer;
+    status: number;
+}
+export interface UmaGetEndpointsListSerializer {
+    current_page: number;
+    endpoints_list: UmaEndpointSerializer[];
+    pages_count: number;
+    status: number;
+    total_records: number;
+}
+export interface UmaFirmMutationSerializer {
+    firm: UmaFirmWithCredsSerializer;
+    status: number;
+}
+export interface UmaGetFirmsListSerializer {
+    current_page: number;
+    firms_list: UmaFirmWithCredsSerializer[];
+    pages_count: number;
+    status: number;
+    total_records: number;
+}
+export interface UmaError {
+    /** @example ["'sms'"," 'email'"] */
+    available_options?: UmaOption[];
+    /** @example 400 */
+    code?: UmaErrorCode;
+    description?: string;
+    field?: string;
+    request_id?: string;
+}
+export enum UmaErrorCode {
+    JSONValidationErr = 4000,
+    JSONReadErr = 4001,
+    JSONParseErr = 4002,
+    ForbiddenErr = 4003,
+    ForbiddenDueLimit = 4030,
+    RecordNotFoundErr = 4004,
+    RecordAlreadyExistsErr = 4005,
+    ImageValidationErr = 4006,
+    InappropriateImageErr = 4007,
+    FaceNotFoundOnImageErr = 4008,
+    UnauthorizedErr = 4010,
+    TokenRevokedErr = 4012,
+    TokenNotActiveErr = 4013,
+    EmailNotVerifiedErr = 4015,
+    TokenParsingErr = 4016,
+    PhoneNotVerifiedErr = 4017,
+    UUIDParseErr = 4026,
+    InvalidEmailOrPasswordOrTypeErr = 4028,
+    InvalidMfaCodeErr = 4128,
+    MfaRequiredErr = 4228,
+    TokenVerificationErr = 4328,
+    InvalidAPIKeyOrSecretErr = 4428,
+    MfaAddingNotAllowedErr = 4528,
+    BranchRequestNotAllowed = 4103,
+    ForbiddenForUserTypeErr = 4203,
+    SecondForbiddenErr = 4031,
+    ThirdForbiddenErr = 4032,
+    EntitiesChoiceNotAllowed = 4303,
+    RecaptchaErr = 4403,
+    UpdateOfOldEntityStateErr = 4503,
+    ChiefadminMutationErr = 4603,
+    ChildEntitiesExistErr = 4703,
+    TenantActionForbiddenErr = 4803,
+    RBACManipulationErr = 4903,
+    YubicoMaxKeysLimitReachedErr = 4113,
+    ConflictErr = 4090,
+    SecondFieldConflictErr = 4091,
+    ThirdFieldConflictErr = 4092,
+    FourthFieldConflictErr = 4093,
+    FifthFieldConflictErr = 4094,
+    SixthFieldConflictErr = 4095,
+    SeventhFieldConflictErr = 4096,
+    GoneErr = 4100,
+    SecondGoneErr = 4101,
+    UnprocessableEntity = 4222,
+    TooEarlyDuplicateRequest = 4250,
+    RateLimitErr = 4291,
+    ForbiddenByFirmsStatusErr = 4292,
+    NotAcceptableError = 4600,
+    InternalServerErr = 5000,
+    InvalidRequest = 6000
+}
+export interface UmaErrorsSerializer {
+    errors: UmaError[];
+}
+export interface UmaGetIdentityProvidersListSerializer {
+    current_page: number;
+    identity_providers_list: UmaIdentityProviderSerializer[];
+    pages_count: number;
+    status: number;
+    total_records: number;
+}
+export interface UmaIdentityProviderResponseSerializer {
+    identity_provider: UmaIdentityProviderSerializer;
+    status: number;
+}
+export interface UmaLocaleSerializer {
+    /** @example 1 */
+    id: number;
+    /** @example "fr" */
+    locale: string;
+    /** @example "French" */
+    name: string;
+}
+export enum UmaOption {
+    SmsMfaOption = "sms",
+    EmailMfaOption = "email",
+    VoiceMfaOption = "voice",
+    WebAuthnMfaOption = "webauthn",
+    YubicoOTPMfaOption = "yubico_otp",
+    TOTPMfaOption = "totp"
+}
+export interface UmaGetMicroservicesListSerializer {
+    current_page: number;
+    microservices_list: UmaMicroserviceSerializer[];
+    pages_count: number;
+    status: number;
+    total_records: number;
+}
+export interface UmaMicroserviceMutationSerializer {
+    microservice: UmaMicroserviceSerializer;
+    status: number;
+}
+export interface UmaUpsertUsersSerializer {
+    status: number;
+    users: UmaAdminUserSerializer[];
+}
+export interface UmaGetPermissionsListSerializer {
+    current_page: number;
+    pages_count: number;
+    permissions_list: UmaPermissionSerializer[];
+    status: number;
+    total_records: number;
+}
+export interface UmaPermissionMutationSerializer {
+    permission: UmaPermissionSerializer;
+    status: number;
+}
+export enum UmaAuthProviderAppType {
+    GoogleOAuth2Provider = "google-oauth2",
+    AppleIDOAuth2Provider = "apple-id"
+}
+export enum UmaEndpointType {
+    RegularEndpoint = "regular",
+    DisplayOnlyEndpoint = "display_only"
+}
+export enum UmaEntityAccessType {
+    GranularEntityAccessType = "granular",
+    HighLevelEntityAccessType = "high-level"
+}
+export interface UmaEntityData {
+    name?: string;
+    value?: UmaEntityAccessType;
+}
+export enum UmaPermissionAG {
+    ChiefadminPermissionAG = "chiefadmin",
+    SuperadminPermissionAG = "superadmin",
+    B2BOnlyPermissionAG = "b2b_only",
+    RegularPermissionAG = "regular"
+}
+export enum UmaUserStatus {
+    ActiveUserStatus = "active",
+    BlockedUserStatus = "blocked",
+    ArchivedUserStatus = "archived"
+}
+export interface UmaPublicSettingsResponseSerializer {
+    settings: UmaPublicSettingsSerializer;
+    status: number;
+}
+export interface UmaGetRolesListSerializer {
+    current_page: number;
+    pages_count: number;
+    roles_list: UmaRoleSerializer[];
+    status: number;
+    total_records: number;
+}
+export interface UmaRoleMutationSerializer {
+    role: UmaRoleSerializer;
+    status: number;
+}
+export interface UmaGetRoleTypesListSerializer {
+    current_page: number;
+    pages_count: number;
+    role_types_list: UmaRoleTypeSerializer[];
+    status: number;
+    total_records: number;
+}
+export interface UmaRoleTypeResponseSerializer {
+    role_type: UmaRoleTypeSerializer;
+    status: number;
+}
+export interface UmaSecretNoteCreationSuccessSerializer {
+    secret_note_link: string;
+    status: number;
+}
+export interface UmaSingleSecretNoteSerializer {
+    secret_note: UmaSecretNoteSerializer;
+    status: number;
+}
+export interface UmaGetSessionsListSerializer {
+    sessions: UmaSessionSerializer[];
+    status: number;
+}
+export interface UmaTablePresetResponseSerializer {
+    status: number;
+    table_preset: UmaTablePresetSerializer;
+}
+export interface UmaTablePresetsListResponseSerializer {
+    status: number;
+    table_presets: UmaTablePresetSerializer[];
+}
+export interface UmaGetTagsListSerializer {
+    current_page: number;
+    pages_count: number;
+    status: number;
+    tags_list: UmaTagSerializer[];
+    total_records: number;
+}
+export interface UmaTagMutationSerializer {
+    status: number;
+    tag: UmaTagSerializer;
+}
+export interface UmaAPIKeys {
+    ac_same_as_for_user?: boolean;
+    api_key?: string;
+    api_secret?: string;
+    branches?: UmaBranchSerializer[];
+    created_at?: string;
+    firms?: UmaFirmAccessSerializer[];
+    id?: number;
+    microservices?: UmaMicroserviceSerializer[];
+    name?: string;
+    permissions?: UmaPermissionSerializer[];
+    roles?: UmaRoleSerializer[];
+    updated_at?: string;
+}
+export interface UmaAPIKeysB2BLoginDto {
+    /** @maxLength 255 */
+    api_key: string;
+    /** @maxLength 255 */
+    api_secret: string;
+}
+export interface UmaActionLogEntityFilterDto {
+    entity_id?: number;
+    entity_name?: string;
+}
+export interface UmaActionLogSerializer {
+    action_type: string;
+    created_at: string;
+    entity_id: number;
+    entity_name: string;
+    id: number;
+    initiator: UmaUserSerializer;
+    initiator_id: number;
+    new_state: Record<string, any>;
+    prev_state: Record<string, any>;
+    trigger_type: string;
+    updated_at: string;
+}
+export interface UmaAdminB2BUserSerializer {
+    allow_feedback: boolean;
+    big_avatar_url: string;
+    branches: UmaBranchSerializer[];
+    /** @example "2022-02-02T00:00:00Z" */
+    created_at: string;
+    /** @example true */
+    do_not_ask_mfa_again: boolean;
+    /** @example "test@email.com" */
+    email: string;
+    /** @example true */
+    email_verified: boolean;
+    firms: UmaFirmAccessSerializer[];
+    /** @example "Mike" */
+    first_name: string;
+    has_access_to_all_firm_branches: boolean;
+    /** @example 1 */
+    id: number;
+    initiator_id: number;
+    /** @example "Jenkins" */
+    last_name: string;
+    locale: UmaLocaleSerializer;
+    locale_id: number;
+    /** @example true */
+    mfa_enabled: boolean;
+    microservices: UmaMicroserviceSerializer[];
+    mode: string;
+    permissions: UmaPermissionSerializer[];
+    /** @example "+123478844" */
+    phone: string;
+    /** @example true */
+    phone_verified: boolean;
+    primary_firm_id: number;
+    rep_code: string;
+    roles: UmaRoleSerializer[];
+    should_reset_password: boolean;
+    small_avatar_url: string;
+    status: UmaUserStatus;
+    status_change_notes: string;
+    status_change_reason: UmaUserStatusChangeReasonSerializer;
+    status_change_reason_id: number;
+    status_changed_at: string;
+    theme: string;
+    /** @example "2022-02-02T00:00:00Z" */
+    updated_at: string;
+    username: string;
+    watchmen_user_links: UmaWatchmenUserLinkSerializer[];
+}
+export interface UmaAdminB2CUserSerializer {
+    allow_feedback: boolean;
+    big_avatar_url: string;
+    branches: UmaBranchSerializer[];
+    /** @example "2022-02-02T00:00:00Z" */
+    created_at: string;
+    /** @example true */
+    do_not_ask_mfa_again: boolean;
+    /** @example "test@email.com" */
+    email: string;
+    /** @example true */
+    email_verified: boolean;
+    firms: UmaFirmAccessSerializer[];
+    /** @example "Mike" */
+    first_name: string;
+    /** @example 1 */
+    id: number;
+    initiator_id: number;
+    /** @example "Jenkins" */
+    last_name: string;
+    locale: UmaLocaleSerializer;
+    locale_id: number;
+    /** @example true */
+    mfa_enabled: boolean;
+    microservices: UmaMicroserviceSerializer[];
+    permissions: UmaPermissionSerializer[];
+    /** @example "+123478844" */
+    phone: string;
+    /** @example true */
+    phone_verified: boolean;
+    primary_firm_id: number;
+    rep_code: string;
+    roles: UmaRoleSerializer[];
+    should_reset_password: boolean;
+    small_avatar_url: string;
+    status: UmaUserStatus;
+    status_change_notes: string;
+    status_change_reason: UmaUserStatusChangeReasonSerializer;
+    status_change_reason_id: number;
+    status_changed_at: string;
+    /** @example "2022-02-02T00:00:00Z" */
+    updated_at: string;
+    username: string;
+    watchmen_user_links: UmaWatchmenUserLinkSerializer[];
+}
+export interface UmaAdminUserSerializer {
+    allow_feedback: boolean;
+    big_avatar_url: string;
+    branches: UmaBranchSerializer[];
+    /** @example "2022-02-02T00:00:00Z" */
+    created_at: string;
+    /** @example true */
+    do_not_ask_mfa_again: boolean;
+    /** @example "test@email.com" */
+    email: string;
+    /** @example true */
+    email_verified: boolean;
+    firms: UmaFirmAccessSerializer[];
+    /** @example "Mike" */
+    first_name: string;
+    /** @example 1 */
+    id: number;
+    initiator_id: number;
+    /** @example "Jenkins" */
+    last_name: string;
+    locale: UmaLocaleSerializer;
+    locale_id: number;
+    /** @example true */
+    mfa_enabled: boolean;
+    microservices: UmaMicroserviceSerializer[];
+    permissions: UmaPermissionSerializer[];
+    /** @example "+123478844" */
+    phone: string;
+    /** @example true */
+    phone_verified: boolean;
+    primary_firm_id: number;
+    rep_code: string;
+    roles: UmaRoleSerializer[];
+    should_reset_password: boolean;
+    small_avatar_url: string;
+    status: UmaUserStatus;
+    status_change_notes: string;
+    status_change_reason: UmaUserStatusChangeReasonSerializer;
+    status_change_reason_id: number;
+    status_changed_at: string;
+    /** @example "2022-02-02T00:00:00Z" */
+    updated_at: string;
+    username: string;
+    watchmen_user_links: UmaWatchmenUserLinkSerializer[];
+}
+export interface UmaAuthAppSerializer {
+    created_at: string;
+    id: number;
+    last_used_at: string;
+    name: string;
+    status: string;
+    type: string;
+    updated_at: string;
+}
+export interface UmaAuthAppsLimitsSerializer {
+    totp_max_apps: number;
+    webauthn_max_apps: number;
+    yubico_otp_max_apps: number;
+}
+export interface UmaAuthFormDto {
+    branch_id?: number;
+    client_platform_slug?: string;
+    firm_id?: number;
+    logo_base_url?: string;
+    logo_path?: string;
+    redirect_url: string;
+    reset_password_link_template?: string;
+    reset_password_type: UmaAuthFormDtoResetPasswordTypeEnum;
+    slug: string;
+}
+export interface UmaAuthFormSerializer {
+    branch: UmaBranchSerializer;
+    branch_id: number;
+    client_platform_slug: string;
+    created_at: string;
+    firm: UmaFirmSerializer;
+    firm_id: number;
+    id: number;
+    logo_base_url: string;
+    logo_path: string;
+    redirect_url: string;
+    reset_password_link_template: string;
+    reset_password_type: UmaAuthFormSerializerResetPasswordTypeEnum;
+    slug: string;
+    updated_at: string;
+}
+export interface UmaAuthProviderUserBindingSerializer {
+    app_type: UmaAuthProviderAppType;
+    b2b_user_id: number;
+    b2c_user_id: number;
+    created_at: string;
+    firm_id: number;
+    id: number;
+    name: string;
+    provider_user_id: string;
+    updated_at: string;
+}
+export interface UmaAuthProviderUserBindingsResponse {
+    bindings?: UmaAuthProviderUserBindingSerializer[];
+    current_page?: number;
+    pages_count?: number;
+    status?: number;
+    total_records?: number;
+}
+export interface UmaAvatarSettingsSerializer {
+    allowed_extensions: string[];
+    big_dimensions: UmaImageDimensionsSerializer;
+    max_size_in_bytes: number;
+}
+export interface UmaB2BResetPasswordDto {
+    captcha_response?: string;
+    /** @maxLength 255 */
+    code: string;
+    /** @maxLength 255 */
+    contact: string;
+    /** @maxLength 100 */
+    new_password: string;
+    old_password?: string;
+}
+export interface UmaB2BSendContactChangeCodeDto {
+    /** @maxLength 255 */
+    contact: string;
+    type: UmaB2BSendContactChangeCodeDtoTypeEnum;
+}
+export interface UmaB2BUploadAvatarSerializer {
+    big_avatar_path: string;
+    small_avatar_path: string;
+}
+export interface UmaB2BUserSerializer {
+    admin_of_firm_ids: number[];
+    allow_feedback: boolean;
+    big_avatar_url: string;
+    /** @example "2022-02-02T00:00:00Z" */
+    created_at: string;
+    /** @example true */
+    do_not_ask_mfa_again: boolean;
+    /** @example "test@email.com" */
+    email: string;
+    /** @example true */
+    email_verified: boolean;
+    /** @example "Mike" */
+    first_name: string;
+    /** @example 1 */
+    id: number;
+    initiator_id: number;
+    is_chief_admin: boolean;
+    /** @example "Jenkins" */
+    last_name: string;
+    locale: UmaLocaleSerializer;
+    locale_id: number;
+    /** @example true */
+    mfa_enabled: boolean;
+    microservices: UmaMicroserviceAccessSerializer[];
+    mode: string;
+    /** @example "+123478844" */
+    phone: string;
+    /** @example true */
+    phone_verified: boolean;
+    rep_code: string;
+    should_reset_password: boolean;
+    small_avatar_url: string;
+    theme: string;
+    /** @example "2022-02-02T00:00:00Z" */
+    updated_at: string;
+    username: string;
+}
+export interface UmaB2CInitOAuthResponse {
+    data?: UmaInitOAuthLoginSerializer;
+    status?: number;
+}
+export interface UmaB2CRefreshDto {
+    auth_form_slug?: string;
+    refresh_token: string;
+    send_redirect?: boolean;
+}
+export interface UmaB2CResetPasswordDto {
+    auth_form_slug: string;
+    captcha_response?: string;
+    code: string;
+    /** @maxLength 255 */
+    contact?: string;
+    /** @maxLength 100 */
+    new_password: string;
+    reset_type: UmaB2CResetPasswordDtoResetTypeEnum;
+}
+export interface UmaB2CSendContactChangeCodeDto {
+    /** @maxLength 255 */
+    contact: string;
+    type: UmaB2CSendContactChangeCodeDtoTypeEnum;
+}
+export interface UmaB2CSendVerificationCodeDto {
+    code_type: UmaB2CSendVerificationCodeDtoCodeTypeEnum;
+    contact: string;
+}
+export interface UmaB2CUserSettingsSerializer {
+    email: string;
+    email_verified: boolean;
+    first_name: string;
+    last_name: string;
+    mfa_enabled: boolean;
+    phone: string;
+    phone_verified: boolean;
+}
+export interface UmaBasicB2BLoginDto {
+    /** @maxLength 255 */
+    device_id: string;
+    /**
+     * @maxLength 255
+     * @example "test@gmail.com"
+     */
+    email: string;
+    mfa_codes?: UmaMfaCodesDto;
+    /**
+     * @maxLength 100
+     * @example "TeStPaSS"
+     */
+    password: string;
+    /** @example true */
+    remember_me?: boolean;
+}
+export interface UmaBasicB2CLoginDto {
+    auth_form_slug?: string;
+    client_platform_slug?: string;
+    /** @maxLength 255 */
+    device_id: string;
+    /**
+     * @maxLength 255
+     * @example "test@gmail.com"
+     */
+    login: string;
+    mfa_codes?: UmaMfaCodesDto;
+    /**
+     * @maxLength 100
+     * @example "TeStPaSS"
+     */
+    password: string;
+    /** @example true */
+    remember_me?: boolean;
+    send_redirect?: boolean;
+}
+export interface UmaBranchAdminListItemSerializer {
+    branch_admins_count: number;
+    /** @example "1000" */
+    code: string;
+    /** @example "2022-02-02T00:00:00Z" */
+    created_at: string;
+    firm: UmaFirmSerializer;
+    /** @example 1 */
+    firm_id: number;
+    /** @example 1 */
+    id: number;
+    is_delete_allowed: boolean;
+    is_update_allowed: boolean;
+    /** @example "New York" */
+    name: string;
+    retail_available_mfa_options: string[];
+    retail_email_verification_required: boolean;
+    retail_login_enabled: boolean;
+    retail_mfa_enabling_required: boolean;
+    retail_phone_verification_required: boolean;
+    /** @example "new-york" */
+    slug: string;
+    /** @example "2022-02-02T00:00:00Z" */
+    updated_at: string;
+}
+export interface UmaBranchAdminSerializer {
+    branch_admins_count: number;
+    /** @example "1000" */
+    code: string;
+    /** @example "2022-02-02T00:00:00Z" */
+    created_at: string;
+    firm: UmaFirmSerializer;
+    /** @example 1 */
+    firm_id: number;
+    /** @example 1 */
+    id: number;
+    /** @example "New York" */
+    name: string;
+    retail_available_mfa_options: string[];
+    retail_email_verification_required: boolean;
+    retail_login_enabled: boolean;
+    retail_mfa_enabling_required: boolean;
+    retail_phone_verification_required: boolean;
+    /** @example "new-york" */
+    slug: string;
+    /** @example "2022-02-02T00:00:00Z" */
+    updated_at: string;
+}
+export interface UmaBranchSerializer {
+    /** @example "1000" */
+    code: string;
+    /** @example 1 */
+    firm_id: number;
+    /** @example 1 */
+    id: number;
+    /** @example "New York" */
+    name: string;
+    /** @example "new-york" */
+    slug: string;
+}
+export interface UmaChangeUserStatusDto {
+    new_status?: UmaUserStatus;
+    notes?: string;
+    /** @min 1 */
+    reason_id?: number;
+}
+export interface UmaCountrySerializer {
+    code: string;
+    dial_code: string;
+    id: number;
+    name: string;
+}
+export interface UmaCreateAPIKeysDto {
+    ac_same_as_for_user?: boolean;
+    branches?: number[];
+    firms?: UmaFirmInfo[];
+    mfa_codes?: UmaMfaCodesDto;
+    /** @maxLength 255 */
+    name: string;
+    permissions?: number[];
+    roles?: number[];
+}
+export interface UmaCreateB2BUserDto {
+    add_default_domain_permissions?: boolean;
+    allow_feedback?: boolean;
+    branches?: number[];
+    /**
+     * @maxLength 255
+     * @example "test@gmail.com"
+     */
+    email?: string;
+    /** @minItems 1 */
+    firms: UmaFirmInfo[];
+    /** @maxLength 255 */
+    first_name: string;
+    has_access_to_all_firm_branches?: boolean;
+    /** @maxLength 255 */
+    last_name: string;
+    /** @example "TeStPaSS" */
+    password: string;
+    permissions?: number[];
+    /**
+     * @maxLength 255
+     * @example "+1231231234"
+     */
+    phone?: string;
+    primary_firm_id?: number;
+    rep_code?: string;
+    /** @minItems 1 */
+    roles: number[];
+    should_reset_password?: boolean;
+    /** @maxLength 255 */
+    username?: string;
+    watchmen_user_links?: UmaWatchmenUserLinkDto[];
+}
+export interface UmaCreateB2CUserDto {
+    allow_feedback?: boolean;
+    /** @minItems 1 */
+    branches: number[];
+    /**
+     * @maxLength 255
+     * @example "test@gmail.com"
+     */
+    email?: string;
+    /** @min 1 */
+    firm_id: number;
+    /** @maxLength 255 */
+    first_name: string;
+    /** @maxLength 255 */
+    last_name: string;
+    /**
+     * @maxLength 100
+     * @example "TeStPaSS"
+     */
+    password: string;
+    permissions?: number[];
+    /**
+     * @maxLength 255
+     * @example "+1231231234"
+     */
+    phone?: string;
+    /** @minItems 1 */
+    roles: number[];
+    /** @maxLength 255 */
+    username?: string;
+    watchmen_user_links?: UmaWatchmenUserLinkDto[];
+}
+export interface UmaCreateBranchDto {
+    /** @maxLength 255 */
+    code?: string;
+    /** @min 1 */
+    firm_id: number;
+    /** @maxLength 255 */
+    name: string;
+    retail_available_auth_app_options?: UmaAuthAppType[];
+    retail_email_verification_required?: boolean;
+    retail_login_enabled?: boolean;
+    retail_mfa_enabling_required?: boolean;
+    retail_phone_verification_required?: boolean;
+    settings?: UmaTenantSettingDto[];
+    /** @maxLength 255 */
+    slug: string;
+}
+export interface UmaCreateEndpointDto {
+    is_active?: boolean;
+    is_public?: boolean;
+    metadata?: UmaEndpointMetadataDto;
+    method: UmaCreateEndpointDtoMethodEnum;
+    /** @min 1 */
+    microservice_id: number;
+    required_permissions?: number[];
+    /** @maxLength 255 */
+    route: string;
+    type?: UmaCreateEndpointDtoTypeEnum;
+}
+export interface UmaCreateFirmDto {
+    allow_b2c_email_notifications?: boolean;
+    firm_tags?: number[];
+    mailgun_creds?: UmaFirmMailgunCredsDto;
+    /** @maxLength 255 */
+    name: string;
+    /** @maxLength 255 */
+    slug: string;
+    twilio_creds?: UmaFirmTwilioCredsDto;
+}
+export interface UmaCreateIdentityProviderDto {
+    /** @maxLength 1000 */
+    auth_url: string;
+    /** @maxLength 255 */
+    client_id: string;
+    /** @maxLength 255 */
+    client_secret: string;
+    /** @maxLength 1000 */
+    company_domain: string;
+    /** @min 1 */
+    firm_id: number;
+    /** @min 1 */
+    priority: number;
+    /** @maxLength 1000 */
+    redirect_url?: string;
+    type: UmaCreateIdentityProviderDtoTypeEnum;
+}
+export interface UmaCreateMicroserviceDto {
+    domains?: UmaMicroserviceDomainDto[];
+    is_active?: boolean;
+    is_visible_on_admin_sidebar?: boolean;
+    /** @maxLength 1000 */
+    logo_url?: string;
+    /** @maxLength 255 */
+    name: string;
+    /** @maxLength 255 */
+    slug: string;
+}
+export interface UmaCreatePermissionDto {
+    assignment_group: UmaCreatePermissionDtoAssignmentGroupEnum;
+    metadata?: UmaPermissionMetadataDto;
+    microservice_id?: number;
+    /** @maxLength 1000 */
+    permission: string;
+}
+export interface UmaCreateRoleDto {
+    assignment_group?: UmaCreateRoleDtoAssignmentGroupEnum;
+    /** @min 0 */
+    firm_id?: number;
+    microservice_id: number;
+    /** @maxLength 255 */
+    name: string;
+    /** @minItems 1 */
+    permissions: number[];
+    permissions_can_assign_role?: number[];
+    /** @min 1 */
+    type_id: number;
+}
+export interface UmaCreateRoleTypeDto {
+    /** @maxLength 255 */
+    color: string;
+    /** @maxLength 255 */
+    type: string;
+}
+export interface UmaCreateSecretNoteDto {
+    /** @maxLength 255 */
+    email: string;
+    /**
+     * supported suffixes are h, m, s, ms. Min 15 mins, max 7 days
+     * @example "48h"
+     */
+    expires_in: string;
+    /**
+     * @min 1
+     * @max 5
+     */
+    max_view_count: number;
+    name?: string;
+    note_params: Record<string, string>;
+    type: UmaCreateSecretNoteDtoTypeEnum;
+}
+export interface UmaCreateTagDto {
+    name: string;
+}
+export interface UmaCreateWatchmenInstanceDto {
+    /**
+     * @minLength 1
+     * @maxLength 255
+     */
+    name: string;
+    /**
+     * @minLength 1
+     * @maxLength 255
+     */
+    slug: string;
+    /**
+     * @minLength 1
+     * @maxLength 1000
+     */
+    url: string;
+}
+export interface UmaCreateYubicoOTPDto {
+    /** @maxLength 255 */
+    name: string;
+    otp: string;
+}
+export interface UmaDeleteAPIKeysDto {
+    /** @minItems 1 */
+    ids: number[];
+    mfa_codes?: UmaMfaCodesDto;
+}
+export interface UmaDeleteByIDsDtoInt {
+    /** @minItems 1 */
+    ids: number[];
+}
+export interface UmaDeleteByIDsDtoInt64 {
+    /** @minItems 1 */
+    ids: number[];
+}
+export interface UmaDeleteSessionsDto {
+    /** @minItems 1 */
+    pair_ids: string[];
+}
+export interface UmaEndpointMetadataDto {
+    admin_ui_permission_key?: string;
+    skip_email_verification_check?: boolean;
+    skip_mfa_enabled_check?: boolean;
+    skip_phone_verification_check?: boolean;
+    user_type?: UmaEndpointMetadataDtoUserTypeEnum;
+}
+export interface UmaEndpointMetadataSerializer {
+    admin_ui_permission_key: string;
+    skip_email_verification_check: boolean;
+    skip_mfa_enabled_check: boolean;
+    skip_phone_verification_check: boolean;
+    user_type: string;
+}
+export interface UmaEndpointSerializer {
+    created_at: string;
+    id: number;
+    is_active: boolean;
+    is_public: boolean;
+    metadata: UmaEndpointMetadataSerializer;
+    method: UmaEndpointSerializerMethodEnum;
+    microservice: UmaMicroserviceSerializer;
+    microservice_id: number;
+    required_permissions: UmaPermissionSerializer[];
+    route: string;
+    type: UmaEndpointType;
+    updated_at: string;
+}
+export interface UmaFinishOAuthLoginDto {
+    authentication_code: string;
+    state: string;
+}
+export interface UmaFinishTOTPRegistrationDto {
+    /**
+     * @minLength 6
+     * @maxLength 8
+     */
+    code: string;
+    /** @maxLength 255 */
+    name: string;
+}
+export interface UmaFirmAccessSerializer {
+    admins_count: number;
+    allow_b2c_email_notifications: boolean;
+    branches: UmaBranchSerializer[];
+    branches_count: number;
+    /** @example "2022-02-02T00:00:00Z" */
+    created_at: string;
+    have_access_to_all_firm_branches: boolean;
+    /** @example 1 */
+    id: number;
+    last_status_change_at: string;
+    /** @example "ViewTrade" */
+    name: string;
+    /** @example "viewtrade" */
+    slug: string;
+    status: string;
+    tags: UmaTagSerializer[];
+    /** @example "2022-02-02T00:00:00Z" */
+    updated_at: string;
+}
+export interface UmaFirmInfo {
+    /** @min 1 */
+    firm_id: number;
+    have_access_to_all_firm_branches?: boolean;
+}
+export interface UmaFirmMailgunCredsDto {
+    /** @maxLength 255 */
+    domain?: string;
+    /** @maxLength 255 */
+    from_address?: string;
+    /** @maxLength 255 */
+    from_name?: string;
+    /** @maxLength 255 */
+    private_api_key?: string;
+}
+export interface UmaFirmSerializer {
+    admins_count: number;
+    allow_b2c_email_notifications: boolean;
+    branches: UmaBranchSerializer[];
+    branches_count: number;
+    /** @example "2022-02-02T00:00:00Z" */
+    created_at: string;
+    /** @example 1 */
+    id: number;
+    last_status_change_at: string;
+    /** @example "ViewTrade" */
+    name: string;
+    /** @example "viewtrade" */
+    slug: string;
+    status: string;
+    tags: UmaTagSerializer[];
+    /** @example "2022-02-02T00:00:00Z" */
+    updated_at: string;
+}
+export interface UmaFirmTwilioCredsDto {
+    /** @maxLength 255 */
+    account_sid?: string;
+    /** @maxLength 255 */
+    auth_token?: string;
+    /** @maxLength 255 */
+    phone_number?: string;
+    /** @maxLength 255 */
+    subaccount_sid?: string;
+}
+export interface UmaFirmWithCredsSerializer {
+    admins_count: number;
+    allow_b2c_email_notifications: boolean;
+    branches: UmaBranchSerializer[];
+    branches_count: number;
+    /** @example "2022-02-02T00:00:00Z" */
+    created_at: string;
+    /** @example 1 */
+    id: number;
+    last_status_change_at: string;
+    mailgun_creds: UmaFirmMailgunCredsDto;
+    /** @example "ViewTrade" */
+    name: string;
+    /** @example "viewtrade" */
+    slug: string;
+    status: string;
+    tags: UmaTagSerializer[];
+    twilio_creds: UmaFirmTwilioCredsDto;
+    /** @example "2022-02-02T00:00:00Z" */
+    updated_at: string;
+}
+export interface UmaGenerateWatchmenAuthTokenDto {
+    /** @min 1 */
+    branch_id?: number;
+}
+export interface UmaGeneratedWatchmenTokenInfoSerializer {
+    expires_at: number;
+    token: string;
+}
+export interface UmaGetAPIKeysListDto {
+    pagination?: UmaPaginationDto;
+    search?: string;
+    sorts?: UmaSortDto[];
+}
+export interface UmaGetActionLogsListDto {
+    filters?: UmaGetActionLogsListFiltersDto;
+    pagination: UmaPaginationDto;
+    sorts?: UmaSortDto[];
+}
+export interface UmaGetActionLogsListFiltersDto {
+    action_types?: string[];
+    entities?: UmaActionLogEntityFilterDto[];
+    ids?: number[];
+    initiator_ids?: number[];
+    show_only_fields_changes?: string[];
+    trigger_types?: string[];
+}
+export interface UmaGetAuthFormsListDto {
+    filters?: UmaGetAuthFormsListFiltersDto;
+    pagination?: UmaPaginationDto;
+    search?: string;
+    sorts?: UmaSortDto[];
+}
+export interface UmaGetAuthFormsListFiltersDto {
+    branch_ids?: number[];
+    firm_ids?: number[];
+    ids?: number[];
+}
+export interface UmaGetB2BUsersListDto {
+    filters?: UmaGetUsersListFiltersDto;
+    include_chiefadmin?: boolean;
+    pagination?: UmaPaginationDto;
+    search?: string;
+    sorts?: UmaSortDto[];
+}
+export interface UmaGetB2CUsersListDto {
+    filters?: UmaGetB2CUsersListFiltersDto;
+    pagination?: UmaPaginationDto;
+    search?: string;
+    sorts?: UmaSortDto[];
+}
+export interface UmaGetB2CUsersListFiltersDto {
+    branch_ids?: number[];
+    email_verified?: boolean;
+    firm_ids?: number[];
+    firm_tag_ids?: number[];
+    ids?: number[];
+    is_blocked?: boolean;
+    microservice_ids?: number[];
+    neither_verified?: boolean;
+    permission_ids?: number[];
+    permission_names?: string[];
+    phone_verified?: boolean;
+    role_ids?: number[];
+    show_only?: UmaGetB2CUsersListFiltersDtoShowOnlyEnum;
+    show_users_linked_to_watchmen?: boolean;
+    status_change_reason_ids?: number[];
+    statuses?: UmaUserStatus[];
+}
+export interface UmaGetBranchesListDto {
+    count_branch_admins?: boolean;
+    filters?: UmaGetBranchesListFiltersDto;
+    pagination?: UmaPaginationDto;
+    search?: string;
+    search_fields?: string[];
+    sorts?: UmaSortDto[];
+}
+export interface UmaGetBranchesListFiltersDto {
+    firm_ids?: number[];
+    ids?: number[];
+    retail_email_verification_required?: boolean;
+    retail_login_enabled?: boolean;
+    retail_phone_verification_required?: boolean;
+}
+export interface UmaGetEndpointsListDto {
+    filters?: UmaGetEndpointsListFiltersDto;
+    pagination?: UmaPaginationDto;
+    search?: string;
+    sorts?: UmaSortDto[];
+}
+export interface UmaGetEndpointsListFiltersDto {
+    ids?: number[];
+    is_public?: boolean;
+    methods?: string[];
+    microservice_ids?: number[];
+}
+export interface UmaGetFirmsListDto {
+    count_admins?: boolean;
+    count_branches?: boolean;
+    filters?: UmaGetFirmsListFiltersDto;
+    pagination?: UmaPaginationDto;
+    search?: string;
+    show_only_firms_accessible_in_branch_mutations?: boolean;
+    sorts?: UmaSortDto[];
+}
+export interface UmaGetFirmsListFiltersDto {
+    ids?: number[];
+    statuses?: UmaGetFirmsListFiltersDtoStatusesEnum;
+    tag_ids?: number[];
+}
+export interface UmaGetIdentityProvidersListDto {
+    filters?: UmaGetIdentityProvidersListFiltersDto;
+    pagination?: UmaPaginationDto;
+    search?: string;
+    sorts?: UmaSortDto[];
+}
+export interface UmaGetIdentityProvidersListFiltersDto {
+    firm_ids?: number[];
+    ids?: number[];
+    types?: UmaGetIdentityProvidersListFiltersDtoTypesEnum[];
+}
+export interface UmaGetMicroservicesListDto {
+    filters?: UmaGetMicroservicesListFiltersDto;
+    pagination?: UmaPaginationDto;
+    search?: string;
+    sorts?: UmaSortDto[];
+}
+export interface UmaGetMicroservicesListFiltersDto {
+    ids?: number[];
+    slugs?: string[];
+}
+export interface UmaGetOAuth2BindingsListDto {
+    pagination?: UmaPaginationDto;
+    search?: string;
+    sorts?: UmaSortDto[];
+}
+export interface UmaGetPermissionsListDto {
+    filters?: UmaGetPermissionsListFiltersDto;
+    include_chiefadmin?: boolean;
+    pagination?: UmaOptionalPaginationDto;
+    search?: string;
+    sorts?: UmaSortDto[];
+}
+export interface UmaGetPermissionsListFiltersDto {
+    assignment_groups?: UmaPermissionAG[];
+    ids?: number[];
+    microservice_ids?: number[];
+}
+export interface UmaGetRoleTypesListDto {
+    filters?: UmaGetRoleTypesListFiltersDto;
+    pagination?: UmaPaginationDto;
+    search?: string;
+    sorts?: UmaSortDto[];
+}
+export interface UmaGetRoleTypesListFiltersDto {
+    ids?: number[];
+}
+export interface UmaGetRolesListDto {
+    filters?: UmaGetRolesListFiltersDto;
+    pagination?: UmaPaginationDto;
+    search?: string;
+    sorts?: UmaSortDto[];
+}
+export interface UmaGetRolesListFiltersDto {
+    assignment_groups?: UmaPermissionAG[];
+    ids?: number[];
+    microservice_ids?: number[];
+    type_ids?: number[];
+}
+export interface UmaGetSecretNoteDto {
+    /** @maxLength 255 */
+    email: string;
+    email_code: string;
+    id: string;
+}
+export interface UmaGetTagsDto {
+    pagination: UmaPaginationDto;
+    search?: string;
+    sorts?: UmaSortDto[];
+}
+export interface UmaGetTotpQRDto {
+    /** @min 6 */
+    digits: number;
+    name?: string;
+}
+export interface UmaGetUserDetailsDto {
+    access_token: string;
+}
+export interface UmaGetUserStatusChangeReasonsDto {
+    filters?: UmaGetUserStatusChangeReasonsListFiltersDto;
+    pagination: UmaPaginationDto;
+    search?: string;
+    sorts?: UmaSortDto[];
+}
+export interface UmaGetUserStatusChangeReasonsListFiltersDto {
+    types: string[];
+}
+export interface UmaGetUsersListFiltersDto {
+    branch_ids?: number[];
+    email_verified?: boolean;
+    firm_ids?: number[];
+    firm_tag_ids?: number[];
+    ids?: number[];
+    microservice_ids?: number[];
+    neither_verified?: boolean;
+    permission_ids?: number[];
+    permission_names?: string[];
+    phone_verified?: boolean;
+    role_ids?: number[];
+    show_only?: UmaGetUsersListFiltersDtoShowOnlyEnum;
+    show_users_linked_to_watchmen?: boolean;
+    status_change_reason_ids?: number[];
+    statuses?: UmaUserStatus[];
+}
+export interface UmaGetWatchmenInstancesDto {
+    pagination: UmaPaginationDto;
+    search?: string;
+    sorts?: UmaSortDto[];
+}
+export interface UmaGetWebAuthnLoginChallengeDto {
+    /** @maxLength 255 */
+    email: string;
+    user_type?: UmaGetWebAuthnLoginChallengeDtoUserTypeEnum;
+}
+export interface UmaIdentityProviderSerializer {
+    auth_url: string;
+    client_id: string;
+    client_secret: string;
+    company_domain: string;
+    created_at: string;
+    firm_id: number;
+    id: number;
+    priority: number;
+    redirect_url: string;
+    type: UmaIdentityProviderSerializerTypeEnum;
+    updated_at: string;
+}
+export interface UmaImageDimensionsSerializer {
+    height: number;
+    width: number;
+}
+export interface UmaInitOAuthLinkingDto {
+    password: string;
+    platform_slug: string;
+}
+export interface UmaInitOAuthLoginDto {
+    platform_slug: string;
+}
+export interface UmaInitOAuthLoginSerializer {
+    client_id: string;
+    redirect_url: string;
+    sign_in_url: string;
+    state: string;
+}
+export interface UmaLinkWatchmenUserToUmaDto {
+    branch_slug_or_code: string;
+    /** @min 1 */
+    uma_user_id: number;
+    uma_user_type: UmaLinkWatchmenUserToUmaDtoUmaUserTypeEnum;
+    watchmen_instance_slug: string;
+    /** @min 1 */
+    watchmen_user_id: number;
+    watchmen_username?: string;
+}
+export interface UmaLocaleSerializer {
+    /** @example 1 */
+    id: number;
+    /** @example "en" */
+    locale: string;
+    /** @example "English" */
+    name: string;
+}
+export interface UmaLogoutDto {
+    refresh_token: string;
+}
+export interface UmaMfaCodesDto {
+    /** @example "12345" */
+    email?: string;
+    /** @example "12345" */
+    phone?: string;
+    totp?: string;
+    yubico_otp?: string;
+    yubico_webauthn?: UmaWebAuthnLoginSolutionDto;
+}
+export interface UmaMicroserviceAccessSerializer {
+    entities: Record<string, Record<string, boolean>>;
+    /** @example 1 */
+    id: number;
+    is_active: boolean;
+    is_visible_on_admin_sidebar: boolean;
+    logo_url: string;
+    name: string;
+    slug: string;
+}
+export interface UmaMicroserviceDomainDto {
+    /**
+     * @maxLength 255
+     * @example "internal.com"
+     */
+    internal_domain: string;
+    /** @maxLength 255 */
+    internal_protocol: string;
+    /**
+     * @maxLength 255
+     * @example "/insights-api"
+     */
+    public_path_prefix: string;
+}
+export interface UmaMicroserviceDomainSerializer {
+    /** @example "internal.com" */
+    internal_domain: string;
+    /** @example "https" */
+    internal_protocol: string;
+    /** @example "public.com" */
+    public_path_prefix: string;
+}
+export interface UmaMicroserviceSerializer {
+    created_at: string;
+    domains: UmaMicroserviceDomainSerializer[];
+    /** @example 1 */
+    id: number;
+    is_active: boolean;
+    is_visible_on_admin_sidebar: boolean;
+    logo_url: string;
+    name: string;
+    parent_id: number;
+    slug: string;
+    updated_at: string;
+}
+export interface UmaOptionalPaginationDto {
+    /** @min 0 */
+    page?: number;
+    /**
+     * @min 0
+     * @max 100
+     */
+    size?: number;
+}
+export interface UmaPermissionMetadataDto {
+    entities?: Record<string, UmaEntityAccessType>;
+    entities_new?: UmaEntityData[];
+    is_microservice_global?: boolean;
+    one_of_group?: string;
+}
+export interface UmaPermissionMetadataSerializer {
+    entities: object;
+    entities_new: UmaEntityData[];
+    is_microservice_global: boolean;
+}
+export interface UmaPermissionSerializer {
+    assignment_group: UmaPermissionSerializerAssignmentGroupEnum;
+    created_at: string;
+    /** @example 1 */
+    id: number;
+    metadata: UmaPermissionMetadataSerializer;
+    microservice: UmaMicroserviceSerializer;
+    microservice_id: number;
+    permission: string;
+    updated_at: string;
+}
+export interface UmaPublicSettingsSerializer {
+    auth_apps_limits: UmaAuthAppsLimitsSerializer;
+    avatar: UmaAvatarSettingsSerializer;
+    b2c_mfa_options: UmaAuthAppType[];
+    reset_password: UmaResetPasswordSettingsSerializer;
+    totp: UmaTOTPSerializer;
+    verification: UmaVerificationSettingsSerializer;
+}
+export interface UmaRefreshDto {
+    refresh_token: string;
+}
+export interface UmaRegisterDto {
+    captcha_response?: string;
+    /**
+     * @maxLength 255
+     * @example "test@gmail.com"
+     */
+    email?: string;
+    /**
+     * @maxLength 255
+     * @example "Mike"
+     */
+    first_name: string;
+    /**
+     * @maxLength 255
+     * @example "Jenkins"
+     */
+    last_name: string;
+    /**
+     * @maxLength 100
+     * @example "TeStPaSS"
+     */
+    password: string;
+    /**
+     * @maxLength 255
+     * @example "+12312312312"
+     */
+    phone?: string;
+    /** @maxLength 255 */
+    username?: string;
+}
+export interface UmaResetPasswordSettingsSerializer {
+    expires_in_minutes: number;
+}
+export interface UmaRevokeUserSessionsDto {
+    /** @min 1 */
+    user_id: number;
+    user_type: UmaRevokeUserSessionsDtoUserTypeEnum;
+}
+export interface UmaRoleSerializer {
+    assignment_group: UmaPermissionAG;
+    created_at: string;
+    firm: UmaFirmSerializer;
+    firm_id: number;
+    id: number;
+    microservice: UmaMicroserviceSerializer;
+    microservice_id: number;
+    name: string;
+    permissions: UmaPermissionSerializer[];
+    permissions_can_assign_role: UmaPermissionSerializer[];
+    type: UmaRoleTypeSerializer;
+    type_id: number;
+    updated_at: string;
+}
+export interface UmaRoleTypeSerializer {
+    color: string;
+    created_at: string;
+    id: number;
+    type: string;
+    updated_at: string;
+}
+export interface UmaSecretNoteSerializer {
+    email: string;
+    expires_at: string;
+    id: string;
+    name: string;
+    note_params: Record<string, string>;
+    type: UmaSecretNoteSerializerTypeEnum;
+    views_left: number;
+}
+export interface UmaSendB2BMfaCodeDto {
+    /** @maxLength 255 */
+    device_id?: string;
+    /**
+     * @maxLength 255
+     * @example "test@gmail.com"
+     */
+    email: string;
+    type: UmaSendB2BMfaCodeDtoTypeEnum;
+}
+export interface UmaSendB2CMfaCodeDto {
+    /** @maxLength 255 */
+    device_id?: string;
+    /**
+     * @maxLength 255
+     * @example "test@gmail.com"
+     */
+    login: string;
+    type: UmaSendB2CMfaCodeDtoTypeEnum;
+}
+export interface UmaSendB2CResetPasswordCodeDto {
+    auth_form_slug: string;
+    code_type?: UmaSendB2CResetPasswordCodeDtoCodeTypeEnum;
+    contact: string;
+    reset_type: UmaSendB2CResetPasswordCodeDtoResetTypeEnum;
+}
+export interface UmaSendResetPasswordCodeDto {
+    contact: string;
+    type: UmaSendResetPasswordCodeDtoTypeEnum;
+}
+export interface UmaSendVerificationCodeForSecretNoteDto {
+    /** @maxLength 255 */
+    email: string;
+    id: string;
+}
+export interface UmaSessionSerializer {
+    browser_name: string;
+    browser_version: string;
+    country: string;
+    device: string;
+    ip: string;
+    is_current: boolean;
+    last_used_at: string;
+    os_name: string;
+    os_version: string;
+    pair_id: string;
+    user_agent: string;
+}
+export interface UmaSetB2BUserSettingsDto {
+    captcha_response?: string;
+    do_not_ask_mfa_again?: boolean;
+    /**
+     * @maxLength 255
+     * @example "test@gmail.com"
+     */
+    email: string;
+    email_change_code?: string;
+    /** @maxLength 255 */
+    first_name: string;
+    /** @maxLength 255 */
+    last_name: string;
+    /** @example true */
+    mfa_enabled?: boolean;
+    /** @maxLength 255 */
+    mode?: string;
+    /** @maxLength 255 */
+    new_password?: string;
+    old_password?: string;
+    /**
+     * @maxLength 255
+     * @example "+1231231234"
+     */
+    phone?: string;
+    phone_change_code?: string;
+    /** @maxLength 255 */
+    theme?: string;
+}
+export interface UmaSetB2CUserSettingsDto {
+    /** @maxLength 255 */
+    email: string;
+    email_change_code?: string;
+    enable_email_mfa?: boolean;
+    enable_phone_mfa?: boolean;
+    /** @maxLength 255 */
+    first_name?: string;
+    /** @maxLength 255 */
+    last_name?: string;
+    /** @example true */
+    mfa_enabled?: boolean;
+    /** @maxLength 255 */
+    new_password?: string;
+    old_password?: string;
+    /**
+     * @maxLength 255
+     * @example "+1231231234"
+     */
+    phone?: string;
+    phone_change_code?: string;
+}
+export interface UmaTOTPSerializer {
+    backup_codes_count: number;
+    backup_codes_length: number;
+}
+export interface UmaTablePresetSerializer {
+    b2b_user_id: number;
+    id: number;
+    presets: object;
+    table_name: string;
+}
+export interface UmaTagSerializer {
+    created_at: string;
+    id: number;
+    name: string;
+    updated_at: string;
+}
+export interface UmaTenantSettingDto {
+    label: UmaTenantSettingDtoLabelEnum;
+    value: string;
+}
+export enum UmaTenantSettingLabel {
+    StorePasswordHistoryForDays = "store_password_history_for_days",
+    ResetPasswordIfUserInactiveForDays = "reset_password_if_user_inactive_for_days",
+    PeriodicallyResetPasswordAfterDays = "periodically_reset_password_after_days"
+}
+export interface UmaTokens {
+    access_expires_at?: number;
+    access_token?: string;
+    pair_id?: string;
+    refresh_expires_at?: number;
+    refresh_token?: string;
+}
+export interface UmaUpdateAPIKeysDto {
+    ac_same_as_for_user?: boolean;
+    branches?: number[];
+    firms?: UmaFirmInfo[];
+    mfa_codes?: UmaMfaCodesDto;
+    /** @maxLength 255 */
+    name: string;
+    permissions?: number[];
+    roles?: number[];
+    updated_at: string;
+}
+export interface UmaUpdateAuthAppDto {
+    /** @maxLength 255 */
+    name: string;
+    status: UmaUpdateAuthAppDtoStatusEnum;
+}
+export interface UmaUpdateB2BUserDto {
+    allow_feedback?: boolean;
+    branches?: number[];
+    /**
+     * @maxLength 255
+     * @example "test@gmail.com"
+     */
+    email?: string;
+    /** @minItems 1 */
+    firms: UmaFirmInfo[];
+    /** @maxLength 255 */
+    first_name: string;
+    has_access_to_all_firm_branches?: boolean;
+    /** @maxLength 255 */
+    last_name: string;
+    /** @example "TeStPaSS" */
+    password?: string;
+    permissions?: number[];
+    /**
+     * @maxLength 255
+     * @example "+1231231234"
+     */
+    phone?: string;
+    primary_firm_id?: number;
+    rep_code?: string;
+    /** @minItems 1 */
+    roles: number[];
+    should_reset_password?: boolean;
+    updated_at: string;
+    /** @maxLength 255 */
+    username?: string;
+    watchmen_user_links?: UmaWatchmenUserLinkDto[];
+}
+export interface UmaUpdateB2CUserDto {
+    allow_feedback?: boolean;
+    /** @minItems 1 */
+    branches: number[];
+    /**
+     * @maxLength 255
+     * @example "test@gmail.com"
+     */
+    email?: string;
+    /** @min 1 */
+    firm_id: number;
+    /** @maxLength 255 */
+    first_name: string;
+    /** @maxLength 255 */
+    last_name: string;
+    /**
+     * @maxLength 100
+     * @example "TeStPaSS"
+     */
+    password?: string;
+    permissions?: number[];
+    /**
+     * @maxLength 255
+     * @example "+1231231234"
+     */
+    phone?: string;
+    /** @minItems 1 */
+    roles: number[];
+    updated_at: string;
+    /** @maxLength 255 */
+    username?: string;
+    watchmen_user_links?: UmaWatchmenUserLinkDto[];
+}
+export interface UmaUpdateBranchDto {
+    /** @maxLength 255 */
+    code?: string;
+    /** @maxLength 255 */
+    name: string;
+    retail_available_auth_app_options?: UmaAuthAppType[];
+    retail_email_verification_required?: boolean;
+    retail_login_enabled?: boolean;
+    retail_mfa_enabling_required?: boolean;
+    retail_phone_verification_required?: boolean;
+    settings?: UmaTenantSettingDto[];
+    /** @maxLength 255 */
+    slug: string;
+    updated_at: string;
+}
+export interface UmaUpdateEndpointDto {
+    is_active?: boolean;
+    is_public?: boolean;
+    metadata?: UmaEndpointMetadataDto;
+    method: UmaUpdateEndpointDtoMethodEnum;
+    /** @min 1 */
+    microservice_id: number;
+    required_permissions?: number[];
+    /** @maxLength 255 */
+    route: string;
+    type?: UmaUpdateEndpointDtoTypeEnum;
+    updated_at: string;
+}
+export interface UmaUpdateFirmDto {
+    allow_b2c_email_notifications?: boolean;
+    firm_tags?: number[];
+    mailgun_creds?: UmaFirmMailgunCredsDto;
+    /** @maxLength 255 */
+    name: string;
+    /** @maxLength 255 */
+    slug: string;
+    status: UmaUpdateFirmDtoStatusEnum;
+    twilio_creds?: UmaFirmTwilioCredsDto;
+    updated_at: string;
+}
+export interface UmaUpdateIdentityProviderDto {
+    /** @maxLength 1000 */
+    auth_url: string;
+    /** @maxLength 255 */
+    client_id: string;
+    /** @maxLength 255 */
+    client_secret: string;
+    /** @maxLength 1000 */
+    company_domain: string;
+    /** @min 1 */
+    firm_id: number;
+    /** @min 1 */
+    priority: number;
+    /** @maxLength 1000 */
+    redirect_url?: string;
+    type: UmaUpdateIdentityProviderDtoTypeEnum;
+    updated_at: string;
+}
+export interface UmaUpdateMicroserviceDto {
+    domains?: UmaMicroserviceDomainDto[];
+    is_active?: boolean;
+    is_visible_on_admin_sidebar?: boolean;
+    /** @maxLength 1000 */
+    logo_url?: string;
+    /** @maxLength 255 */
+    name: string;
+    /** @maxLength 255 */
+    slug: string;
+    updated_at: string;
+}
+export interface UmaUpdatePermissionDto {
+    metadata?: UmaPermissionMetadataDto;
+    microservice_id?: number;
+    /** @maxLength 1000 */
+    permission: string;
+    updated_at: string;
+}
+export interface UmaUpdateRoleDto {
+    /** @maxLength 255 */
+    name: string;
+    /** @minItems 1 */
+    permissions: number[];
+    permissions_can_assign_role?: number[];
+    /** @min 1 */
+    type_id: number;
+    updated_at: string;
+}
+export interface UmaUpdateRoleTypeDto {
+    /** @maxLength 255 */
+    color: string;
+    /** @maxLength 255 */
+    type: string;
+    updated_at: string;
+}
+export interface UmaUpdateTagDto {
+    name: string;
+    updated_at: string;
+}
+export interface UmaUpdateWatchmenInstanceDto {
+    /**
+     * @minLength 1
+     * @maxLength 255
+     */
+    name: string;
+    /**
+     * @minLength 1
+     * @maxLength 255
+     */
+    slug: string;
+    updated_at: string;
+    /**
+     * @minLength 1
+     * @maxLength 1000
+     */
+    url: string;
+}
+export interface UmaUpsertTablePresetDto {
+    presets?: object;
+    /** @maxLength 255 */
+    table_name: string;
+}
+export interface UmaUpsertUserDto {
+    branches: number[];
+    /** @example "test@gmail.com" */
+    email: string;
+    firms: number[];
+    first_name?: string;
+    initiator_id?: number;
+    last_name?: string;
+    permissions: number[];
+    /** @example "+1231231234" */
+    phone?: string;
+    rep_code?: string;
+    roles: number[];
+    type: UmaUpsertUserDtoTypeEnum;
+}
+export interface UmaUpsertUsersDto {
+    /** @maxItems 100 */
+    users: UmaUpsertUserDto[];
+}
+export interface UmaUserSerializer {
+    allow_feedback: boolean;
+    big_avatar_url: string;
+    /** @example "2022-02-02T00:00:00Z" */
+    created_at: string;
+    /** @example true */
+    do_not_ask_mfa_again: boolean;
+    /** @example "test@email.com" */
+    email: string;
+    /** @example true */
+    email_verified: boolean;
+    /** @example "Mike" */
+    first_name: string;
+    /** @example 1 */
+    id: number;
+    initiator_id: number;
+    /** @example "Jenkins" */
+    last_name: string;
+    locale: UmaLocaleSerializer;
+    locale_id: number;
+    /** @example true */
+    mfa_enabled: boolean;
+    /** @example "+123478844" */
+    phone: string;
+    /** @example true */
+    phone_verified: boolean;
+    rep_code: string;
+    should_reset_password: boolean;
+    small_avatar_url: string;
+    /** @example "2022-02-02T00:00:00Z" */
+    updated_at: string;
+    username: string;
+}
+export interface UmaUserStatusChangeReasonSerializer {
+    code: string;
+    created_at: string;
+    id: number;
+    name: string;
+    type: string;
+    updated_at: string;
+}
+export interface UmaVerificationSettingsSerializer {
+    expires_in_minutes: number;
+}
+export interface UmaVerifyContactDto {
+    code: string;
+    code_type: UmaVerifyContactDtoCodeTypeEnum;
+    contact: string;
+}
+export interface UmaVerifyWatchmenAuthTokenDto {
+    tmp_token: string;
+}
+export interface UmaWatchmenAuthTokenDetailsSerializer {
+    expires_at: number;
+    is_valid: boolean;
+    token_id: string;
+    watchmen_instance_id: number;
+    watchmen_user_id: number;
+}
+export interface UmaWatchmenInstanceSerializer {
+    created_at: string;
+    id: number;
+    name: string;
+    slug: string;
+    updated_at: string;
+    url: string;
+}
+export interface UmaWatchmenUserLinkDto {
+    /** @min 1 */
+    branch_id: number;
+    /** @min 1 */
+    watchmen_instance_id: number;
+    /** @min 1 */
+    watchmen_user_id: number;
+}
+export interface UmaWatchmenUserLinkSerializer {
+    branch: UmaBranchSerializer;
+    branch_id: number;
+    created_at: string;
+    id: number;
+    updated_at: string;
+    watchmen_instance: UmaWatchmenInstanceSerializer;
+    watchmen_instance_id: number;
+    watchmen_user_id: number;
+}
+export interface UmaWebAuthnAssertionResponse {
+    authenticator_data?: string;
+    client_data_json?: string;
+    signature?: string;
+    user_handle?: string;
+}
+export interface UmaWebAuthnAttestationResponse {
+    attestation_object?: string;
+    client_data_json?: string;
+}
+export interface UmaWebAuthnAuthenticatorSelection {
+    authenticator_attachment?: string;
+    require_resident_key?: boolean;
+    resident_key?: string;
+    user_verification?: string;
+}
+export interface UmaWebAuthnCredentialAssertionSerializer {
+    public_key: UmaWebAuthnPublicKeyCredentialAssertionSerializer;
+}
+export interface UmaWebAuthnCredentialCreationSerializer {
+    public_key: UmaWebAuthnPublicKeyCredentialCreationSerializer;
+}
+export interface UmaWebAuthnCredentialDescriptor {
+    id?: string;
+    transports?: string[];
+    type?: string;
+}
+export interface UmaWebAuthnCredentialParameterSerializer {
+    alg: number;
+    type: string;
+}
+export interface UmaWebAuthnLoginSolutionDto {
+    client_extension_results?: object;
+    id?: string;
+    raw_id?: string;
+    response?: UmaWebAuthnAssertionResponse;
+    type?: string;
+}
+export interface UmaWebAuthnPublicKeyCredentialAssertionSerializer {
+    allow_credentials: UmaWebAuthnCredentialDescriptor[];
+    challenge: string;
+    extensions: object;
+    rp_id: string;
+    timeout: number;
+    user_verification: string;
+}
+export interface UmaWebAuthnPublicKeyCredentialCreationSerializer {
+    attestation: string;
+    authenticator_selection: UmaWebAuthnAuthenticatorSelection;
+    challenge: string;
+    exclude_credentials: UmaWebAuthnCredentialDescriptor[];
+    extensions: object;
+    pub_key_cred_params: UmaWebAuthnCredentialParameterSerializer[];
+    rp: UmaWebAuthnRelyingPartyEntitySerializer;
+    timeout: number;
+    user: UmaWebAuthnUserEntitySerializer;
+}
+export interface UmaWebAuthnRegistrationSolutionDto {
+    client_extension_results?: object;
+    id?: string;
+    /** @maxLength 255 */
+    name: string;
+    raw_id?: string;
+    response?: UmaWebAuthnAttestationResponse;
+    type?: string;
+}
+export interface UmaWebAuthnRelyingPartyEntitySerializer {
+    icon: string;
+    id: string;
+    name: string;
+}
+export interface UmaWebAuthnUserEntitySerializer {
+    display_name: string;
+    icon: string;
+    id: any;
+    name: string;
+}
+export interface UmaGetUserDetailsSerializer {
+    b2b_user: UmaAdminUserSerializer;
+    b2c_user: UmaAdminB2CUserSerializer;
+    status: number;
+}
+export interface UmaGetUserStatusChangeReasonsListSerializer {
+    current_page: number;
+    pages_count: number;
+    reasons_list: UmaUserStatusChangeReasonSerializer[];
+    status: number;
+    total_records: number;
+}
+export interface UmaGetUsersListSerializerTypesAdminB2BUserSerializer {
+    current_page: number;
+    pages_count: number;
+    status: number;
+    total_records: number;
+    users_list: UmaAdminB2BUserSerializer[];
+}
+export interface UmaGetUsersListSerializerTypesAdminB2CUserSerializer {
+    current_page: number;
+    pages_count: number;
+    status: number;
+    total_records: number;
+    users_list: UmaAdminB2CUserSerializer[];
+}
+export interface UmaTokenDetailsResponseSerializer {
+    data: UmaWatchmenAuthTokenDetailsSerializer;
+    status: number;
+}
+export interface UmaTokenGenerationResponseSerializer {
+    data: UmaGeneratedWatchmenTokenInfoSerializer;
+    status: number;
+}
+export interface UmaGetWatchmenInstancesListSerializer {
+    current_page: number;
+    pages_count: number;
+    status: number;
+    total_records: number;
+    watchmen_instances_list: UmaWatchmenInstanceSerializer[];
+}
+export interface UmaWatchmenInstanceMutationSerializer {
+    status: number;
+    watchmen_instance: UmaWatchmenInstanceSerializer;
+}
+export enum UmaAuthFormDtoResetPasswordTypeEnum {
+    ByContactCode = "by_contact_code",
+    ByEmailLink = "by_email_link"
+}
+export enum UmaAuthFormSerializerResetPasswordTypeEnum {
+    ByContactCode = "by_contact_code",
+    ByEmailLink = "by_email_link"
+}
+export enum UmaB2BSendContactChangeCodeDtoTypeEnum {
+    Email = "email",
+    Voice = "voice",
+    Sms = "sms"
+}
+export enum UmaB2CResetPasswordDtoResetTypeEnum {
+    ByContactCode = "by_contact_code",
+    ByEmailLink = "by_email_link"
+}
+export enum UmaB2CSendContactChangeCodeDtoTypeEnum {
+    Email = "email",
+    Voice = "voice",
+    Sms = "sms"
+}
+export enum UmaB2CSendVerificationCodeDtoCodeTypeEnum {
+    Email = "email",
+    Voice = "voice",
+    Sms = "sms"
+}
+export enum UmaCreateEndpointDtoMethodEnum {
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE",
+    GET = "GET",
+    PATCH = "PATCH",
+    ALL = "ALL"
+}
+export enum UmaCreateEndpointDtoTypeEnum {
+    Regular = "regular",
+    DisplayOnly = "display_only"
+}
+export enum UmaCreateIdentityProviderDtoTypeEnum {
+    Okta = "okta"
+}
+export enum UmaCreatePermissionDtoAssignmentGroupEnum {
+    Regular = "regular",
+    Superadmin = "superadmin",
+    B2BOnly = "b2b_only"
+}
+export enum UmaCreateRoleDtoAssignmentGroupEnum {
+    Regular = "regular",
+    Superadmin = "superadmin",
+    B2BOnly = "b2b_only"
+}
+export enum UmaCreateSecretNoteDtoTypeEnum {
+    Password = "password"
+}
+export enum UmaEndpointMetadataDtoUserTypeEnum {
+    B2B = "b2b",
+    B2C = "b2c"
+}
+export enum UmaEndpointSerializerMethodEnum {
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE",
+    GET = "GET",
+    PATCH = "PATCH",
+    ALL = "ALL"
+}
+export enum UmaGetB2CUsersListFiltersDtoShowOnlyEnum {
+    Admin = "admin",
+    BranchAdmin = "branch_admin",
+    Compliance = "compliance"
+}
+export enum UmaGetFirmsListFiltersDtoStatusesEnum {
+    InProgress = "in_progress",
+    Active = "active",
+    Suspended = "suspended",
+    Deleted = "deleted"
+}
+export enum UmaGetIdentityProvidersListFiltersDtoTypesEnum {
+    Okta = "okta"
+}
+export enum UmaGetUsersListFiltersDtoShowOnlyEnum {
+    Admin = "admin",
+    BranchAdmin = "branch_admin",
+    Compliance = "compliance"
+}
+export enum UmaGetWebAuthnLoginChallengeDtoUserTypeEnum {
+    B2B = "b2b",
+    B2C = "b2c"
+}
+export enum UmaIdentityProviderSerializerTypeEnum {
+    Okta = "okta"
+}
+export enum UmaLinkWatchmenUserToUmaDtoUmaUserTypeEnum {
+    B2B = "b2b",
+    B2C = "b2c"
+}
+export enum UmaPermissionSerializerAssignmentGroupEnum {
+    Regular = "regular",
+    Chiefadmin = "chiefadmin",
+    Superadmin = "superadmin"
+}
+export enum UmaRevokeUserSessionsDtoUserTypeEnum {
+    B2B = "b2b",
+    B2C = "b2c"
+}
+export enum UmaSecretNoteSerializerTypeEnum {
+    Password = "password"
+}
+export enum UmaSendB2BMfaCodeDtoTypeEnum {
+    Email = "email",
+    Voice = "voice",
+    Sms = "sms"
+}
+export enum UmaSendB2CMfaCodeDtoTypeEnum {
+    Email = "email",
+    Voice = "voice",
+    Sms = "sms"
+}
+export enum UmaSendB2CResetPasswordCodeDtoCodeTypeEnum {
+    Email = "email",
+    Voice = "voice",
+    Sms = "sms"
+}
+export enum UmaSendB2CResetPasswordCodeDtoResetTypeEnum {
+    ByContactCode = "by_contact_code",
+    ByEmailLink = "by_email_link"
+}
+export enum UmaSendResetPasswordCodeDtoTypeEnum {
+    Email = "email",
+    Voice = "voice",
+    Sms = "sms"
+}
+export enum UmaTenantSettingDtoLabelEnum {
+    StorePasswordHistoryForDays = "store_password_history_for_days",
+    ResetPasswordIfUserInactiveForDays = "reset_password_if_user_inactive_for_days",
+    PeriodicallyResetPasswordAfterDays = "periodically_reset_password_after_days"
+}
+export enum UmaUpdateAuthAppDtoStatusEnum {
+    Active = "active",
+    Disabled = "disabled"
+}
+export enum UmaUpdateEndpointDtoMethodEnum {
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE",
+    GET = "GET",
+    PATCH = "PATCH",
+    ALL = "ALL"
+}
+export enum UmaUpdateEndpointDtoTypeEnum {
+    Regular = "regular",
+    DisplayOnly = "display_only"
+}
+export enum UmaUpdateFirmDtoStatusEnum {
+    InProgress = "in_progress",
+    Active = "active",
+    Suspended = "suspended",
+    Deleted = "deleted"
+}
+export enum UmaUpdateIdentityProviderDtoTypeEnum {
+    Okta = "okta"
+}
+export enum UmaUpsertUserDtoTypeEnum {
+    B2B = "b2b",
+    B2C = "b2c"
+}
+export enum UmaVerifyContactDtoCodeTypeEnum {
+    Email = "email",
+    Voice = "voice",
+    Sms = "sms"
+}
+export class ActionLogs<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Get Action logs list
+     * @tags action_logs
+     * @name GetActionLogs
+     * @summary Get Action logs list
+     * @request POST:/v1/action-logs/list
+     * @secure
+     */
+    getActionLogs(getActionLogsDto: UmaGetActionLogsListDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetActionLogsSerializer, HandleError>>;
+}
+export class B2BAuth<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Get current B2B user info by access token.
+     * @tags b2b_auth
+     * @name GetCurrent
+     * @summary Get current B2B user info by access token
+     * @request GET:/v1/auth/b2b/current
+     * @secure
+     */
+    getCurrent(config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetCurrentB2BUserSerializer, HandleError>>;
+    /**
+     * @description Login B2B user by API Keys
+     * @tags b2b_auth
+     * @name ApiKeysLogin
+     * @summary Login B2B user by API Keys
+     * @request POST:/v1/auth/b2b/login/api-keys
+     */
+    apiKeysLogin(apiKeysLoginParams: UmaAPIKeysB2BLoginDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaSimpleB2BLoginSerializer, HandleError>>;
+    /**
+     * @description Login B2B user by email/password.
+     * @tags b2b_auth
+     * @name BasicLogin
+     * @summary Login B2B user by email/password
+     * @request POST:/v1/auth/b2b/login/basic
+     */
+    basicLogin(basicLoginParams: UmaBasicB2BLoginDto, headers?: {
+        /** Run endpoint in debug mode */
+        'Debug-Token'?: string;
+    }, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaBasicB2BLoginSerializer, HandleError>>;
+    /**
+     * @description logout from B2B user session
+     * @tags b2b_auth
+     * @name Logout
+     * @summary logout from B2B user session
+     * @request DELETE:/v1/auth/b2b/logout
+     */
+    logout(B2BLogoutParams: UmaLogoutDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Refresh B2B user token pair
+     * @tags b2b_auth
+     * @name RefreshTokens
+     * @summary Refresh B2B user token pair
+     * @request POST:/v1/auth/b2b/refresh
+     */
+    refreshTokens(B2BRefreshParams: UmaRefreshDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaBasicB2BLoginSerializer, HandleError>>;
+    /**
+     * @description Reset B2B user password
+     * @tags b2b_auth
+     * @name ResetPassword
+     * @summary Reset B2B user password
+     * @request PUT:/v1/auth/b2b/reset-password
+     */
+    resetPassword(B2BResetPasswordParams: UmaB2BResetPasswordDto, headers?: {
+        /** Run endpoint in debug mode */
+        'Debug-Token'?: string;
+    }, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaSimpleB2BLoginSerializer, HandleError>>;
+    /**
+     * @description Send MFA code for B2B user
+     * @tags b2b_auth
+     * @name SendMfaCode
+     * @summary Send MFA code for B2B user
+     * @request PUT:/v1/auth/b2b/send-mfa-code
+     */
+    sendMfaCode(SendB2BMfaCodeDto: UmaSendB2BMfaCodeDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Send reset password code for B2B user
+     * @tags b2b_auth
+     * @name SendResetPasswordCode
+     * @summary Send reset password code for B2B user
+     * @request PUT:/v1/auth/b2b/send-reset-password-code
+     */
+    sendResetPasswordCode(B2BSendResetPasswordCodeParams: UmaSendResetPasswordCodeDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+}
+export class B2CAuth<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Get current B2C user info by access token.
+     * @tags b2c_auth
+     * @name GetCurrent
+     * @summary Get current B2C user info by access token
+     * @request GET:/v1/auth/b2c/current
+     * @secure
+     */
+    getCurrent(config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetCurrentB2CUserSerializer, HandleError>>;
+    /**
+     * @description Initialize Apple OAuth2 Login
+     * @tags b2c_auth
+     * @name InitAppleLogin
+     * @summary Initialize Apple OAuth2 Login
+     * @request POST:/v1/auth/b2c/login/apple
+     */
+    initAppleLogin(initOAuthLoginDto: UmaInitOAuthLoginDto, headers?: {
+        /** Branch id/slug/code, with which user should work */
+        BRANCH?: string;
+        /** Firm id/slug, with which user should work */
+        FIRM?: string;
+    }, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaB2CInitOAuthResponse, HandleError>>;
+    /**
+     * @description Finish Apple OAuth2 Login
+     * @tags b2c_auth
+     * @name FinishAppleLogin
+     * @summary Finish Apple OAuth2 Login
+     * @request POST:/v1/auth/b2c/login/apple/callback
+     */
+    finishAppleLogin(finishOAuthLoginDto: UmaFinishOAuthLoginDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaB2CLoginResultSerializer, HandleError>>;
+    /**
+     * @description Login B2C user by email/password.
+     * @tags b2c_auth
+     * @name BasicLogin
+     * @summary Login B2C user by email/password
+     * @request POST:/v1/auth/b2c/login/basic
+     */
+    basicLogin(basicLoginParams: UmaBasicB2CLoginDto, headers?: {
+        /** Branch id/slug/code, with which user should work */
+        BRANCH?: string;
+        /** Firm id/slug, with which user should work */
+        FIRM?: string;
+    }, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaB2CLoginResultSerializer, HandleError>>;
+    /**
+     * @description Initialize Google OAuth2 Login
+     * @tags b2c_auth
+     * @name InitGoogleLogin
+     * @summary Initialize Google OAuth2 Login
+     * @request POST:/v1/auth/b2c/login/google
+     */
+    initGoogleLogin(initOAuthLoginDto: UmaInitOAuthLoginDto, headers?: {
+        /** Branch id/slug/code, with which user should work */
+        BRANCH?: string;
+        /** Firm id/slug, with which user should work */
+        FIRM?: string;
+    }, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaB2CInitOAuthResponse, HandleError>>;
+    /**
+     * @description Finish Google OAuth2 Login
+     * @tags b2c_auth
+     * @name FinishGoogleLogin
+     * @summary Finish Google OAuth2 Login
+     * @request POST:/v1/auth/b2c/login/google/callback
+     */
+    finishGoogleLogin(finishOAuthLoginDto: UmaFinishOAuthLoginDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaB2CLoginResultSerializer, HandleError>>;
+    /**
+     * @description logout from B2C user session
+     * @tags b2c_auth
+     * @name Logout
+     * @summary logout from B2C user session
+     * @request DELETE:/v1/auth/b2c/logout
+     */
+    logout(B2CLogoutParams: UmaLogoutDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Refresh B2C user token pair
+     * @tags b2c_auth
+     * @name RefreshTokens
+     * @summary Refresh B2C user token pair
+     * @request POST:/v1/auth/b2c/refresh
+     */
+    refreshTokens(b2cRefreshDto: UmaB2CRefreshDto, headers?: {
+        /**
+         * token
+         * @default "refresh_token=xxx"
+         */
+        Cookie?: string;
+    }, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaRefreshResultSerializer, HandleError>>;
+    /**
+     * @description Register new B2C user. This endpoint should be used for Web GUI only
+     * @tags b2c_auth
+     * @name Register
+     * @summary Register new B2C user
+     * @request POST:/v1/auth/b2c/register
+     */
+    register(registrationParams: UmaRegisterDto, headers?: {
+        /** Branch id/slug/code, with which user should work */
+        BRANCH?: string;
+        /** Firm id/slug, with which user should work */
+        FIRM?: string;
+    }, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaRegisterSerializer, HandleError>>;
+    /**
+     * @description Reset B2C user password
+     * @tags b2c_auth
+     * @name ResetPassword
+     * @summary Reset B2C user password
+     * @request PUT:/v1/auth/b2c/reset-password
+     */
+    resetPassword(B2CResetPasswordParams: UmaB2CResetPasswordDto, headers?: {
+        /** Run endpoint in debug mode */
+        'Debug-Token'?: string;
+        /** Branch id/slug/code, with which user should work */
+        BRANCH?: string;
+        /** Firm id/slug, with which user should work */
+        FIRM?: string;
+    }, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Send MFA code for B2C user
+     * @tags b2c_auth
+     * @name SendMfaCode
+     * @summary Send MFA code for B2C user
+     * @request PUT:/v1/auth/b2c/send-mfa-code
+     */
+    sendMfaCode(SendB2CMfaCodeDto: UmaSendB2CMfaCodeDto, headers?: {
+        /** Branch id/slug/code, with which user should work */
+        BRANCH?: string;
+        /** Firm id/slug, with which user should work */
+        FIRM?: string;
+    }, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Send reset password code for B2C user
+     * @tags b2c_auth
+     * @name SendResetPasswordCode
+     * @summary Send reset password code for B2C user
+     * @request PUT:/v1/auth/b2c/send-reset-password-code
+     */
+    sendResetPasswordCode(B2CSendResetPasswordCodeParams: UmaSendB2CResetPasswordCodeDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Send verification code for B2C user
+     * @tags b2c_auth
+     * @name SendVerificationCode
+     * @summary Send verification code for B2C user
+     * @request PUT:/v1/auth/b2c/send-verification-code
+     */
+    sendVerificationCode(B2CSendVerificationCodeDto: UmaB2CSendVerificationCodeDto, headers?: {
+        /** Branch id/slug/code, with which user should work */
+        BRANCH?: string;
+        /** Firm id/slug, with which user should work */
+        FIRM?: string;
+    }, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Verify contact for B2C user
+     * @tags b2c_auth
+     * @name VerifyContact
+     * @summary Verify contact for B2C user
+     * @request PUT:/v1/auth/b2c/verify
+     */
+    verifyContact(VerifyContactDto: UmaVerifyContactDto, headers?: {
+        /** Branch id/slug/code, with which user should work */
+        BRANCH?: string;
+        /** Firm id/slug, with which user should work */
+        FIRM?: string;
+    }, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+}
+export class Sessions<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description et current user sessions info
+     * @tags sessions
+     * @name GetCurrentUserSessions
+     * @summary Get current user sessions info
+     * @request GET:/v1/auth/sessions
+     * @secure
+     */
+    getCurrentUserSessions(config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetSessionsListSerializer, HandleError>>;
+    /**
+     * @description Delete current user sessions by pair id's
+     * @tags sessions
+     * @name DeleteCurrentUserSessions
+     * @summary Delete current user sessions by pair id's
+     * @request DELETE:/v1/auth/sessions
+     * @secure
+     */
+    deleteCurrentUserSessions(deleteSessions: UmaDeleteSessionsDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+}
+export class WatchmenAuth<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Generate Watchmen Auth Token
+     * @tags watchmen_auth
+     * @name GenerateWatchmenAuthToken
+     * @summary Generate Watchmen Auth Token
+     * @request POST:/v1/auth/watchmen/authentication-tokens
+     * @secure
+     */
+    generateWatchmenAuthToken(generateWatchmenAuthTokenDto: UmaGenerateWatchmenAuthTokenDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaTokenGenerationResponseSerializer, HandleError>>;
+    /**
+     * @description Verify Watchmen Auth Token
+     * @tags watchmen_auth
+     * @name VerifyWatchmenAuthToken
+     * @summary Verify Watchmen Auth Token
+     * @request PUT:/v1/auth/watchmen/authentication-tokens/verify
+     * @secure
+     */
+    verifyWatchmenAuthToken(verifyWatchmenAuthToken: UmaVerifyWatchmenAuthTokenDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaTokenDetailsResponseSerializer, HandleError>>;
+}
+export class AuthForms<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Create Auth Form
+     * @tags auth_forms
+     * @name Create
+     * @summary Create Auth Form
+     * @request POST:/v1/auth-forms
+     * @secure
+     */
+    create(authFormDto: UmaAuthFormDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaAuthFormMutationSerializer, HandleError>>;
+    /**
+     * @description Delete Auth Forms by ids
+     * @tags auth_forms
+     * @name DeleteMany
+     * @summary Delete Auth Forms by ids
+     * @request DELETE:/v1/auth-forms
+     * @secure
+     */
+    deleteMany(deleteAuthFormsDto: UmaDeleteByIDsDtoInt64, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Get Auth Forms with pagination. Available sort fields are `id, branch_id, slug, created_at, updated_at`. Search is performed by slug field
+     * @tags auth_forms
+     * @name Get
+     * @summary Get Auth Forms with pagination
+     * @request POST:/v1/auth-forms/list
+     * @secure
+     */
+    get(getAuthFormListDto: UmaGetAuthFormsListDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetAuthFormsListSerializer, HandleError>>;
+    /**
+     * @description Get Auth Forms by slug
+     * @tags auth_forms
+     * @name GetBySlug
+     * @summary Get Auth Forms by slug
+     * @request GET:/v1/auth-forms/public/{slug}
+     */
+    getBySlug(slug: string, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaAuthFormMutationSerializer, HandleError>>;
+    /**
+     * @description Get Auth Forms by id
+     * @tags auth_forms
+     * @name GetById
+     * @summary Get Auth Forms by id
+     * @request GET:/v1/auth-forms/{id}
+     * @secure
+     */
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaAuthFormMutationSerializer, HandleError>>;
+    /**
+     * @description Update Auth Form record
+     * @tags auth_forms
+     * @name Update
+     * @summary Update Auth Form record
+     * @request PUT:/v1/auth-forms/{id}
+     * @secure
+     */
+    update(id: number, authFormDto: UmaAuthFormDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaAuthFormMutationSerializer, HandleError>>;
+}
+export class ApiKeys<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Delete API Key by id (would throw 404 error if API key not found or belongs to different user)
+     * @tags api_keys
+     * @name DeleteMany
+     * @summary Delete API Key by id
+     * @request DELETE:/v1/b2b/api-keys
+     * @secure
+     */
+    deleteMany(deleteAPIKeys: UmaDeleteAPIKeysDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Get APIKey by id
+     * @tags api_keys
+     * @name GetById
+     * @summary Get APIKey by id
+     * @request GET:/v1/b2b/api-keys/{id}
+     * @secure
+     */
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaAPIKeysMutationSerializer, HandleError>>;
+    /**
+     * @description Create API Key & API Secret Pair. API Secret won't be accessible for read after that
+     * @tags api_keys
+     * @name Create
+     * @summary Create API Key & API Secret Pair
+     * @request POST:/v2/b2b/api-keys
+     * @secure
+     */
+    create(createApiKeys: UmaCreateAPIKeysDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaAPIKeysMutationSerializer, HandleError>>;
+    /**
+     * @description Get API Keys info(would return API Keys without secrets)
+     * @tags api_keys
+     * @name Get
+     * @summary Get API Keys info(would return API Keys without secrets)
+     * @request POST:/v2/b2b/api-keys/list
+     * @secure
+     */
+    get(apiKeys: UmaGetAPIKeysListDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetAPIKeysSerializer, HandleError>>;
+    /**
+     * @description Update API Key Record
+     * @tags api_keys
+     * @name Update
+     * @summary Update API Key Record
+     * @request PUT:/v2/b2b/api-keys/{id}
+     * @secure
+     */
+    update(id: number, apiKeys: UmaUpdateAPIKeysDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaAPIKeysMutationSerializer, HandleError>>;
+}
+export class AuthApps<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Get auth apps
+     * @tags auth_apps
+     * @name Get
+     * @summary Get auth apps
+     * @request GET:/v1/auth-apps
+     * @secure
+     */
+    get(config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetAuthAppsListSerializer, HandleError>>;
+    /**
+     * @description Delete auth apps
+     * @tags auth_apps
+     * @name DeleteMany
+     * @summary Delete auth apps
+     * @request DELETE:/v1/auth-apps
+     * @secure
+     */
+    deleteMany(deleteAuthAppsDto: UmaDeleteByIDsDtoInt64, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Get TOTP registration QR
+     * @tags auth_apps
+     * @name GetRegistrationQr
+     * @summary Get TOTP registration QR
+     * @request POST:/v1/auth-apps/totp/registration/qr
+     * @secure
+     */
+    getRegistrationQr(getTotpQRDto: UmaGetTotpQRDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<File, HandleError>>;
+    /**
+     * @description Finish TOTP registration
+     * @tags auth_apps
+     * @name FinishRegistration
+     * @summary Finish TOTP registration
+     * @request POST:/v1/auth-apps/totp/registration/response
+     * @secure
+     */
+    finishRegistration(finishTOTPRegistrationDto: UmaFinishTOTPRegistrationDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaFinishTOTPRegistrationResponseSerializer, HandleError>>;
+    /**
+     * @description Get WebAuthn login challenge
+     * @tags auth_apps
+     * @name GetLoginChallenge
+     * @summary Get WebAuthn login challenge
+     * @request POST:/v1/auth-apps/webauthn/login/request
+     */
+    getLoginChallenge(getWebAuthnLoginChallengeDto: UmaGetWebAuthnLoginChallengeDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaWebAuthnCredentialAssertionSerializer, HandleError>>;
+    /**
+     * @description Get WebAuthn register challenge
+     * @tags auth_apps
+     * @name GetRegisterChallenge
+     * @summary Get WebAuthn register challenge
+     * @request POST:/v1/auth-apps/webauthn/registration/request
+     * @secure
+     */
+    getRegisterChallenge(config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaWebAuthnCredentialCreationSerializer, HandleError>>;
+    /**
+     * @description Finish WebAuthn credential registration
+     * @tags auth_apps
+     * @name FinishCredentialRegistration
+     * @summary Finish WebAuthn credential registration
+     * @request POST:/v1/auth-apps/webauthn/registration/response
+     * @secure
+     */
+    finishCredentialRegistration(webAuthnRegistrationSolutionDto: UmaWebAuthnRegistrationSolutionDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Register Yubico OTP Key
+     * @tags auth_apps
+     * @name Register
+     * @summary Register Yubico OTP Key
+     * @request POST:/v1/auth-apps/yubico/otp/registration
+     * @secure
+     */
+    register(yubicoOTPDto: UmaCreateYubicoOTPDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Update auth app
+     * @tags auth_apps
+     * @name Update
+     * @summary Update auth app
+     * @request PUT:/v1/auth-apps/{id}
+     * @secure
+     */
+    update(id: number, updateAuthAppDto: UmaUpdateAuthAppDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaAuthAppResponseSerializer, HandleError>>;
+}
+export class Endpoints<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Create Endpoint
+     * @tags endpoints
+     * @name Create
+     * @summary Create Endpoint
+     * @request POST:/v1/b2b/endpoints
+     * @secure
+     */
+    create(endpointDto: UmaCreateEndpointDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaEndpointMutationSerializer, HandleError>>;
+    /**
+     * @description Delete endpoint by id
+     * @tags endpoints
+     * @name DeleteMany
+     * @summary Delete endpoint by id
+     * @request DELETE:/v1/b2b/endpoints
+     * @secure
+     */
+    deleteMany(deleteEndpointsDto: UmaDeleteByIDsDtoInt, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Get Endpoint by id
+     * @tags endpoints
+     * @name GetById
+     * @summary Get Endpoint by id
+     * @request GET:/v1/b2b/endpoints/{id}
+     * @secure
+     */
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaEndpointMutationSerializer, HandleError>>;
+    /**
+     * @description Update endpoint record
+     * @tags endpoints
+     * @name Update
+     * @summary Update endpoint record
+     * @request PUT:/v1/b2b/endpoints/{id}
+     * @secure
+     */
+    update(id: number, endpointDto: UmaUpdateEndpointDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaEndpointMutationSerializer, HandleError>>;
+    /**
+     * @description Get endpoints with pagination
+     * @tags endpoints
+     * @name Get
+     * @summary Get endpoints with pagination
+     * @request POST:/v2/b2b/endpoints/list
+     * @secure
+     */
+    get(endpointDto: UmaGetEndpointsListDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetEndpointsListSerializer, HandleError>>;
+}
+export class IdentityProviders<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Create Identity Provider
+     * @tags identity_providers
+     * @name Create
+     * @summary Create Identity Provider
+     * @request POST:/v1/b2b/identity-providers
+     * @secure
+     */
+    create(createIdentityProviderDto: UmaCreateIdentityProviderDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaIdentityProviderResponseSerializer, HandleError>>;
+    /**
+     * @description Delete Identity providers by id
+     * @tags identity_providers
+     * @name DeleteMany
+     * @summary Delete Identity providers by ids
+     * @request DELETE:/v1/b2b/identity-providers
+     * @secure
+     */
+    deleteMany(deleteIdentityProvidersDto: UmaDeleteByIDsDtoInt, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Get Identity Provider by id
+     * @tags identity_providers
+     * @name GetById
+     * @summary Get Identity Provider by id
+     * @request GET:/v1/b2b/identity-providers/{id}
+     * @secure
+     */
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaIdentityProviderResponseSerializer, HandleError>>;
+    /**
+     * @description Update identity provider record
+     * @tags identity_providers
+     * @name Update
+     * @summary Update identity provider record
+     * @request PUT:/v1/b2b/identity-providers/{id}
+     * @secure
+     */
+    update(id: number, identityProvidersDto: UmaUpdateIdentityProviderDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaIdentityProviderResponseSerializer, HandleError>>;
+    /**
+     * @description Get Identity Providers with pagination
+     * @tags identity_providers
+     * @name Get
+     * @summary Get Identity Providers with pagination
+     * @request POST:/v2/b2b/identity-providers/list
+     * @secure
+     */
+    get(identityProvidersDto: UmaGetIdentityProvidersListDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetIdentityProvidersListSerializer, HandleError>>;
+}
+export class RoleTypes<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Create Role Type
+     * @tags role_types
+     * @name Create
+     * @summary Create Role Type
+     * @request POST:/v1/b2b/role-types
+     * @secure
+     */
+    create(createRoleType: UmaCreateRoleTypeDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaRoleTypeResponseSerializer, HandleError>>;
+    /**
+     * @description Delete Role Types by ids
+     * @tags role_types
+     * @name DeleteMany
+     * @summary Delete Role Types by ids
+     * @request DELETE:/v1/b2b/role-types
+     * @secure
+     */
+    deleteMany(deleteRoleTypes: UmaDeleteByIDsDtoInt, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Get Role Type by id
+     * @tags role_types
+     * @name GetById
+     * @summary Get Role Type by id
+     * @request GET:/v1/b2b/role-types/{id}
+     * @secure
+     */
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaRoleTypeResponseSerializer, HandleError>>;
+    /**
+     * @description Update Role Type
+     * @tags role_types
+     * @name Update
+     * @summary Update Role Type
+     * @request PUT:/v1/b2b/role-types/{id}
+     * @secure
+     */
+    update(id: number, updateRoleType: UmaUpdateRoleTypeDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaRoleTypeResponseSerializer, HandleError>>;
+    /**
+     * @description Get Role Types with pagination
+     * @tags role_types
+     * @name Get
+     * @summary Get Role Types with pagination
+     * @request POST:/v2/b2b/role-types/list
+     * @secure
+     */
+    get(getRoleTypes: UmaGetRoleTypesListDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetRoleTypesListSerializer, HandleError>>;
+}
+export class Microservices<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Create Microservice with domains, used to proxy user requests from public domains to internal
+     * @tags microservices
+     * @name Create
+     * @summary Create Microservice
+     * @request POST:/v1/b2b/microservices
+     * @secure
+     */
+    create(microserviceDto: UmaCreateMicroserviceDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaMicroserviceMutationSerializer, HandleError>>;
+    /**
+     * @description Delete microservice by id
+     * @tags microservices
+     * @name DeleteMany
+     * @summary Delete microservice by id
+     * @request DELETE:/v1/b2b/microservices
+     * @secure
+     */
+    deleteMany(deleteMicroservices: UmaDeleteByIDsDtoInt, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Get Microservice by id
+     * @tags microservices
+     * @name GetById
+     * @summary Get Microservice by id
+     * @request GET:/v1/b2b/microservices/{id}
+     * @secure
+     */
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaMicroserviceMutationSerializer, HandleError>>;
+    /**
+     * @description Update microservice record
+     * @tags microservices
+     * @name Update
+     * @summary Update microservice record
+     * @request PUT:/v1/b2b/microservices/{id}
+     * @secure
+     */
+    update(id: number, microserviceDto: UmaUpdateMicroserviceDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaMicroserviceMutationSerializer, HandleError>>;
+    /**
+     * @description Get microservices with pagination
+     * @tags microservices
+     * @name Get
+     * @summary Get microservices with pagination
+     * @request POST:/v2/b2b/microservices/list
+     * @secure
+     */
+    get(microserviceDto: UmaGetMicroservicesListDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetMicroservicesListSerializer, HandleError>>;
+}
+export class B2BUserSettings<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Set B2B User Settings ReCAPTCHA code is required in following cases (if proper Debug-Token was not provided): 1. User changes email 2. User changes password 3. User changes/verifies phone number
+     * @tags b2b_user_settings
+     * @name SetUserSettings
+     * @summary Set B2B User Settings
+     * @request PUT:/v1/b2b/settings
+     * @secure
+     */
+    setUserSettings(setB2BUserSettings: UmaSetB2BUserSettingsDto, headers?: {
+        /** Run endpoint in debug mode */
+        'Debug-Token'?: string;
+        /** Branch id, with which user should work */
+        BRANCH?: string;
+    }, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaB2BUserSettingsChangeSerializer, HandleError>>;
+    /**
+     * @description Upload avatar for B2B user
+     * @tags b2b_user_settings
+     * @name UploadAvatar
+     * @summary Upload avatar for B2B user
+     * @request PUT:/v1/b2b/settings/avatar
+     * @secure
+     */
+    uploadAvatar(data: {
+        /**
+         * Avatar to upload
+         * @format binary
+         */
+        avatar?: File;
+        /** Should delete old avatar instead of uploading new one */
+        delete_avatar?: boolean;
+    }, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaB2BUploadAvatarResponseSerializer, HandleError>>;
+    /**
+     * @description Send B2B user contact change code
+     * @tags b2b_user_settings
+     * @name SendContactChangeCode
+     * @summary Send B2B user contact change code
+     * @request POST:/v1/b2b/settings/codes
+     * @secure
+     */
+    sendContactChangeCode(b2bSendContactChangeCodeDto: UmaB2BSendContactChangeCodeDto, headers?: {
+        /** Branch id, with which user should work */
+        BRANCH?: string;
+    }, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+}
+export class TablePresets<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Get user Table Presets
+     * @tags table_presets
+     * @name GetUserPresets
+     * @summary Get user Table Presets
+     * @request GET:/v1/b2b/table-presets
+     * @secure
+     */
+    getUserPresets(config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaTablePresetsListResponseSerializer, HandleError>>;
+    /**
+     * @description Upsert Table Preset
+     * @tags table_presets
+     * @name Upsert
+     * @summary Upsert Table Preset
+     * @request PUT:/v1/b2b/table-presets
+     * @secure
+     */
+    upsert(upsertTablePreset: UmaUpsertTablePresetDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaTablePresetResponseSerializer, HandleError>>;
+}
+export class B2CUserSettings<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Set B2C User Settings
+     * @tags b2c_user_settings
+     * @name SetUserSettings
+     * @summary Set B2C User Settings
+     * @request PUT:/v1/b2c/settings
+     * @secure
+     */
+    setUserSettings(setB2CUserSettings: UmaSetB2CUserSettingsDto, headers?: {
+        /** Branch id/slug/code, with which user should work */
+        BRANCH?: string;
+    }, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaB2CUserSettingsChangeSerializer, HandleError>>;
+    /**
+     * @description Send B2C user contact change code
+     * @tags b2c_user_settings
+     * @name SendContactChangeCode
+     * @summary Send B2C user contact change code
+     * @request POST:/v1/b2c/settings/codes
+     * @secure
+     */
+    sendContactChangeCode(b2cSendContactChangeCodeDto: UmaB2CSendContactChangeCodeDto, headers?: {
+        /** Branch id/slug/code, with which user should work */
+        BRANCH?: string;
+    }, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Get Available B2C Branch Mfa Options
+     * @tags b2c_user_settings
+     * @name AvailableMfaOptions
+     * @summary Get Available B2C Branch Mfa Options
+     * @request GET:/v1/b2c/settings/mfa-options
+     * @secure
+     */
+    availableMfaOptions(headers?: {
+        /** Branch id/slug/code, with which user should work */
+        BRANCH?: string;
+    }, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaAvailableB2CMfaOptionsResponse, HandleError>>;
+    /**
+     * @description Delete B2C OAuth2 Bindings
+     * @tags b2c_user_settings
+     * @name DeleteManyOAuthBindings
+     * @summary Delete B2C OAuth2 Bindings
+     * @request DELETE:/v1/b2c/settings/oauth-links
+     * @secure
+     */
+    deleteManyOAuthBindings(deleteByIDsDto: UmaDeleteByIDsDtoInt64, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Finish Apple OAuth2 Profile Linking
+     * @tags b2c_user_settings
+     * @name FinishAppleProfileLinking
+     * @summary Finish Apple OAuth2 Profile Linking
+     * @request POST:/v1/b2c/settings/oauth-links/apple/finish
+     */
+    finishAppleProfileLinking(finishOAuthLoginDto: UmaFinishOAuthLoginDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Initialize Apple OAuth2 Profile Linking
+     * @tags b2c_user_settings
+     * @name InitAppleProfileLinking
+     * @summary Initialize Apple OAuth2 Profile Linking
+     * @request POST:/v1/b2c/settings/oauth-links/apple/start
+     * @secure
+     */
+    initAppleProfileLinking(initOAuthLinkingDto: UmaInitOAuthLinkingDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaB2CInitOAuthResponse, HandleError>>;
+    /**
+     * @description Finish Google OAuth2 Profile Linking
+     * @tags b2c_user_settings
+     * @name FinishGoogleProfileLinking
+     * @summary Finish Google OAuth2 Profile Linking
+     * @request POST:/v1/b2c/settings/oauth-links/google/finish
+     */
+    finishGoogleProfileLinking(finishOAuthLoginDto: UmaFinishOAuthLoginDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Initialize Google OAuth2 Profile Linking
+     * @tags b2c_user_settings
+     * @name InitGoogleProfileLinking
+     * @summary Initialize Google OAuth2 Profile Linking
+     * @request POST:/v1/b2c/settings/oauth-links/google/start
+     * @secure
+     */
+    initGoogleProfileLinking(initOAuthLinkingDto: UmaInitOAuthLinkingDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaB2CInitOAuthResponse, HandleError>>;
+    /**
+     * @description Get B2C OAuth2 Bindings with pagination. Available sort fields are `id, name, app_type, b2b_user_id, b2c_user_id, provider_user_id, created_at, updated_at`. Search is performed by `name, app_type, provider_user_id` fields
+     * @tags b2c_user_settings
+     * @name GetOAuthBindings
+     * @summary Get B2C OAuth2 Bindings with pagination
+     * @request POST:/v1/b2c/settings/oauth-links/list
+     * @secure
+     */
+    getOAuthBindings(getOAuth2BindingsListDto: UmaGetOAuth2BindingsListDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaAuthProviderUserBindingsResponse, HandleError>>;
+}
+export class Branches<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Create Branch
+     * @tags branches
+     * @name Create
+     * @summary Create Branch
+     * @request POST:/v1/branches
+     * @secure
+     */
+    create(createBranch: UmaCreateBranchDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaBranchMutationSerializer, HandleError>>;
+    /**
+     * @description Delete Branch by id
+     * @tags branches
+     * @name DeleteMany
+     * @summary Delete Branch by id
+     * @request DELETE:/v1/branches
+     * @secure
+     */
+    deleteMany(deleteBranches: UmaDeleteByIDsDtoInt, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Get Branch by id
+     * @tags branches
+     * @name GetById
+     * @summary Get Branch by id
+     * @request GET:/v1/branches/{id}
+     * @secure
+     */
+    getById(id: string, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaBranchMutationSerializer, HandleError>>;
+    /**
+     * @description Update Branch
+     * @tags branches
+     * @name Update
+     * @summary Update Branch
+     * @request PUT:/v1/branches/{id}
+     * @secure
+     */
+    update(id: number, updateBranch: UmaUpdateBranchDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaBranchMutationSerializer, HandleError>>;
+    /**
+     * @description Get Branches with pagination
+     * @tags branches
+     * @name Get
+     * @summary Get Branches with pagination
+     * @request POST:/v2/branches/list
+     * @secure
+     */
+    get(getBranches: UmaGetBranchesListDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetBranchesListSerializer, HandleError>>;
+}
+export class Countries<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Get Countries info
+     * @tags countries
+     * @name Get
+     * @summary Get Countries info
+     * @request GET:/v1/countries/
+     */
+    get(config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetCountriesSerializer, HandleError>>;
+}
+export class Locales<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description get all language locales
+     * @tags locales
+     * @name Get
+     * @summary get all locales
+     * @request GET:/v1/locales
+     */
+    get(config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaLocaleSerializer[], HandleError>>;
+}
+export class Firms<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Create Firm
+     * @tags firms
+     * @name Create
+     * @summary Create Firm
+     * @request POST:/v1/firms
+     * @secure
+     */
+    create(createFirm: UmaCreateFirmDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaFirmMutationSerializer, HandleError>>;
+    /**
+     * @description Deletes Firm by ids
+     * @tags firms
+     * @name DeleteMany
+     * @summary Deletes Firm by ids
+     * @request DELETE:/v1/firms
+     * @secure
+     */
+    deleteMany(deleteFirms: UmaDeleteByIDsDtoInt, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Get Firm by id
+     * @tags firms
+     * @name GetById
+     * @summary Get Firm by id
+     * @request GET:/v1/firms/{id}
+     * @secure
+     */
+    getById(id: string, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaFirmMutationSerializer, HandleError>>;
+    /**
+     * @description Update Firm
+     * @tags firms
+     * @name Update
+     * @summary Update Firm
+     * @request PUT:/v1/firms/{id}
+     * @secure
+     */
+    update(id: number, updateFirm: UmaUpdateFirmDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaFirmMutationSerializer, HandleError>>;
+    /**
+     * @description Get Firms with pagination
+     * @tags firms
+     * @name Get
+     * @summary Get Firms with pagination
+     * @request POST:/v2/firms/list
+     * @secure
+     */
+    get(getFirms: UmaGetFirmsListDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetFirmsListSerializer, HandleError>>;
+}
+export class MigrationUtils<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Upsert Users from deprecated DB's
+     * @tags migration-utils
+     * @name PostUsersUpsert
+     * @summary Upsert Users
+     * @request POST:/v1/migration-utils/users/upsert
+     * @secure
+     */
+    postUsersUpsert(upsertUsers: UmaUpsertUsersDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaUpsertUsersSerializer, HandleError>>;
+}
+export class Permissions<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Create Permission
+     * @tags permissions
+     * @name Create
+     * @summary Create Permission
+     * @request POST:/v1/permissions
+     * @secure
+     */
+    create(createPermission: UmaCreatePermissionDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaPermissionMutationSerializer, HandleError>>;
+    /**
+     * @description Delete Permissions by id
+     * @tags permissions
+     * @name DeleteMany
+     * @summary Delete Permissions by id
+     * @request DELETE:/v1/permissions
+     * @secure
+     */
+    deleteMany(deletePermissions: UmaDeleteByIDsDtoInt, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Get Permission by id
+     * @tags permissions
+     * @name GetById
+     * @summary Get Permission by id
+     * @request GET:/v1/permissions/{id}
+     * @secure
+     */
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaPermissionMutationSerializer, HandleError>>;
+    /**
+     * @description Update Permission
+     * @tags permissions
+     * @name Update
+     * @summary Update Permission
+     * @request PUT:/v1/permissions/{id}
+     * @secure
+     */
+    update(id: number, updatePermission: UmaUpdatePermissionDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaPermissionMutationSerializer, HandleError>>;
+    /**
+     * @description Get Permissions with pagination
+     * @tags permissions
+     * @name Get
+     * @summary Get Permissions with pagination
+     * @request POST:/v2/permissions/list
+     * @secure
+     */
+    get(getPermissions: UmaGetPermissionsListDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetPermissionsListSerializer, HandleError>>;
+}
+export class PublicSettings<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Get public settings
+     * @tags public_settings
+     * @name Get
+     * @summary Get public settings
+     * @request GET:/v1/public-settings
+     */
+    get(config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaPublicSettingsResponseSerializer, HandleError>>;
+}
+export class Roles<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Create Role
+     * @tags roles
+     * @name Create
+     * @summary Create Role
+     * @request POST:/v1/roles
+     * @secure
+     */
+    create(createRole: UmaCreateRoleDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaRoleMutationSerializer, HandleError>>;
+    /**
+     * @description Delete Roles by ids
+     * @tags roles
+     * @name DeleteMany
+     * @summary Delete Roles by ids
+     * @request DELETE:/v1/roles
+     * @secure
+     */
+    deleteMany(deleteRoles: UmaDeleteByIDsDtoInt, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Get Role by id
+     * @tags roles
+     * @name GetById
+     * @summary Get Role by id
+     * @request GET:/v1/roles/{id}
+     * @secure
+     */
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaRoleMutationSerializer, HandleError>>;
+    /**
+     * @description Update Role
+     * @tags roles
+     * @name Update
+     * @summary Update Role
+     * @request PUT:/v1/roles/{id}
+     * @secure
+     */
+    update(id: number, updateRole: UmaUpdateRoleDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaRoleMutationSerializer, HandleError>>;
+    /**
+     * @description Get Roles with pagination
+     * @tags roles
+     * @name Get
+     * @summary Get Roles with pagination
+     * @request POST:/v2/roles/list
+     * @secure
+     */
+    get(getRoles: UmaGetRolesListDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetRolesListSerializer, HandleError>>;
+}
+export class SecretNotes<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Create Secret note. For type `password` field `note_params` should contain `password` field only.
+     * @tags secret_notes
+     * @name Create
+     * @summary Create Secret note
+     * @request POST:/v1/secret-notes
+     * @secure
+     */
+    create(createSecretNote: UmaCreateSecretNoteDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaSecretNoteCreationSuccessSerializer, HandleError>>;
+    /**
+     * @description Get Secret note
+     * @tags secret_notes
+     * @name GetOne
+     * @summary Get Secret note
+     * @request POST:/v1/secret-notes/fetch
+     */
+    getOne(getSecretNote: UmaGetSecretNoteDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaSingleSecretNoteSerializer, HandleError>>;
+    /**
+     * @description Send Secret note verification code
+     * @tags secret_notes
+     * @name SendVerificationCode
+     * @summary Send Secret note verification code
+     * @request PUT:/v1/secret-notes/verification
+     */
+    sendVerificationCode(sendVerificationCodeForSecretNote: UmaSendVerificationCodeForSecretNoteDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+}
+export class Tags<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Create Tag
+     * @tags tags
+     * @name Create
+     * @summary Create Tag
+     * @request POST:/v1/tags
+     * @secure
+     */
+    create(createTagDto: UmaCreateTagDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaTagMutationSerializer, HandleError>>;
+    /**
+     * @description Delete Tags
+     * @tags tags
+     * @name DeleteMany
+     * @summary Delete Tags
+     * @request DELETE:/v1/tags
+     * @secure
+     */
+    deleteMany(deleteByIDsDto: UmaDeleteByIDsDtoInt64, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Get Tags List. Available fields for sorting are `id, name, created_at, updated_at`. Search is performed by `name`
+     * @tags tags
+     * @name Get
+     * @summary Get Tags List
+     * @request POST:/v1/tags/list
+     * @secure
+     */
+    get(getTagsDto: UmaGetTagsDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetTagsListSerializer, HandleError>>;
+    /**
+     * @description Get Tags By ID
+     * @tags tags
+     * @name GetById
+     * @summary Get Tag By ID
+     * @request GET:/v1/tags/{id}
+     * @secure
+     */
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaTagMutationSerializer, HandleError>>;
+    /**
+     * @description Update Tag
+     * @tags tags
+     * @name Update
+     * @summary Update Tag
+     * @request PUT:/v1/tags/{id}
+     * @secure
+     */
+    update(id: number, updateTagDto: UmaUpdateTagDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaTagMutationSerializer, HandleError>>;
+}
+export class B2BUsers<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Delete B2B user by id
+     * @tags b2b_users
+     * @name DeleteMany
+     * @summary Delete B2B user by id
+     * @request DELETE:/v1/users/b2b
+     * @secure
+     */
+    deleteMany(deleteB2BUsers: UmaDeleteByIDsDtoInt64, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Get B2B User by id
+     * @tags b2b_users
+     * @name GetById
+     * @summary Get B2B User by id
+     * @request GET:/v1/users/b2b/{id}
+     * @secure
+     */
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaB2BUserSerializer, HandleError>>;
+    /**
+     * @description Change B2B User status
+     * @tags b2b_users
+     * @name ChangeStatus
+     * @summary Change B2B User status
+     * @request PATCH:/v1/users/b2b/{id}/status
+     * @secure
+     */
+    changeStatus(id: number, changeUserStatus: UmaChangeUserStatusDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Create B2B User
+     * @tags b2b_users
+     * @name Create
+     * @summary Create B2B User
+     * @request POST:/v2/users/b2b
+     * @secure
+     */
+    create(createB2BUser: UmaCreateB2BUserDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaB2BUserSerializer, HandleError>>;
+    /**
+     * @description Get B2B users with pagination
+     * @tags b2b_users
+     * @name Get
+     * @summary Get B2B users with pagination
+     * @request POST:/v2/users/b2b/list
+     * @secure
+     */
+    get(getB2BUsers: UmaGetB2BUsersListDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetUsersListSerializerTypesAdminB2BUserSerializer, HandleError>>;
+    /**
+     * @description Update B2B User
+     * @tags b2b_users
+     * @name Update
+     * @summary Update B2B User
+     * @request PUT:/v2/users/b2b/{id}
+     * @secure
+     */
+    update(id: number, createB2BUserNew: UmaUpdateB2BUserDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaB2BUserSerializer, HandleError>>;
+}
+export class UserDetails<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Get User Details by JWT-token
+     * @tags user_details
+     * @name GetUserDetails
+     * @summary Get User Details by JWT-token
+     * @request POST:/v1/users/details/show
+     * @secure
+     */
+    getUserDetails(getUserDetailsDto: UmaGetUserDetailsDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetUserDetailsSerializer, HandleError>>;
+    /**
+     * @description Revoke user sessions by JWT-token
+     * @tags user_details
+     * @name RevokeSessions
+     * @summary Revoke user sessions by JWT-token
+     * @request POST:/v1/users/revoke-sessions
+     * @secure
+     */
+    revokeSessions(revokeUserSessionsDto: UmaRevokeUserSessionsDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+}
+export class B2CUsers<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Create B2C User
+     * @tags b2c_users
+     * @name Create
+     * @summary Create B2C User
+     * @request POST:/v1/users/b2c
+     * @secure
+     */
+    create(createB2CUser: UmaCreateB2CUserDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaB2CUserSerializer, HandleError>>;
+    /**
+     * @description Delete B2C user by id
+     * @tags b2c_users
+     * @name DeleteMany
+     * @summary Delete B2C user by id
+     * @request DELETE:/v1/users/b2c
+     * @secure
+     */
+    deleteMany(deleteB2CUsers: UmaDeleteByIDsDtoInt64, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Get B2C User by id
+     * @tags b2c_users
+     * @name GetById
+     * @summary Get B2C User by id
+     * @request GET:/v1/users/b2c/{id}
+     * @secure
+     */
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaB2CUserSerializer, HandleError>>;
+    /**
+     * @description Update B2C User
+     * @tags b2c_users
+     * @name Update
+     * @summary Update B2C User
+     * @request PUT:/v1/users/b2c/{id}
+     * @secure
+     */
+    update(id: number, createB2BUser: UmaUpdateB2CUserDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaB2CUserSerializer, HandleError>>;
+    /**
+     * @description Change B2C User status
+     * @tags b2c_users
+     * @name ChangeStatus
+     * @summary Change B2C User status
+     * @request PATCH:/v1/users/b2c/{id}/status
+     * @secure
+     */
+    changeStatus(id: number, changeUserStatus: UmaChangeUserStatusDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Get B2C users with pagination
+     * @tags b2c_users
+     * @name Get
+     * @summary Get B2C users with pagination
+     * @request POST:/v2/users/b2c/list
+     * @secure
+     */
+    get(getB2CUsers: UmaGetB2CUsersListDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetUsersListSerializerTypesAdminB2CUserSerializer, HandleError>>;
+}
+export class UsersCommon<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Get user status change reasons list
+     * @tags users_common
+     * @name GetUserStatusChangeReasonsList
+     * @summary Get user status change reasons list
+     * @request POST:/v1/users/status-change-reasons/list
+     * @secure
+     */
+    getUserStatusChangeReasonsList(getUserStatusChangeReasonsDto: UmaGetUserStatusChangeReasonsDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetUserStatusChangeReasonsListSerializer, HandleError>>;
+    /**
+     * @description Link Watchmen user to UMA
+     * @tags users_common
+     * @name LinkWatchmenUsersToUma
+     * @summary Link Watchmen user to UMA
+     * @request POST:/v1/users/watchmen/link
+     * @secure
+     */
+    linkWatchmenUsersToUma(linkWatchmenUserToUmaDto: UmaLinkWatchmenUserToUmaDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+}
+export class WatchmenInstances<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    /**
+     * @description Create Watchmen Instance
+     * @tags watchmen_instances
+     * @name Create
+     * @summary Create Watchmen Instance
+     * @request POST:/v1/watchmen-instances
+     * @secure
+     */
+    create(createWatchmenInstance: UmaCreateWatchmenInstanceDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaWatchmenInstanceMutationSerializer, HandleError>>;
+    /**
+     * @description Delete Watchmen Instances
+     * @tags watchmen_instances
+     * @name DeleteMany
+     * @summary Delete Watchmen Instances
+     * @request DELETE:/v1/watchmen-instances
+     * @secure
+     */
+    deleteMany(deleteWatchmenInstances: UmaDeleteByIDsDtoInt64, config?: RequestConfig<HandleError>): Promise<ClientResponse<void, HandleError>>;
+    /**
+     * @description Get Watchmen Instances with pagination. Available sort fields are `id, name, slug, url, created_at, updated_at`. Search is performed by `name, url, slug` fields.
+     * @tags watchmen_instances
+     * @name GetMany
+     * @summary Get Watchmen Instances with pagination
+     * @request POST:/v1/watchmen-instances/list
+     * @secure
+     */
+    getMany(getWatchmenInstances: UmaGetWatchmenInstancesDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaGetWatchmenInstancesListSerializer, HandleError>>;
+    /**
+     * @description Get Watchmen Instance by id
+     * @tags watchmen_instances
+     * @name GetById
+     * @summary Get Watchmen Instance by id
+     * @request GET:/v1/watchmen-instances/{id}
+     * @secure
+     */
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaWatchmenInstanceMutationSerializer, HandleError>>;
+    /**
+     * @description Update Watchmen Instance
+     * @tags watchmen_instances
+     * @name Update
+     * @summary Update Watchmen Instance
+     * @request PUT:/v1/watchmen-instances/{id}
+     * @secure
+     */
+    update(id: number, updateWatchmenInstance: UmaUpdateWatchmenInstanceDto, config?: RequestConfig<HandleError>): Promise<ClientResponse<UmaWatchmenInstanceMutationSerializer, HandleError>>;
+}
+declare class _B2BAuth1<HandleError extends boolean = boolean> extends B2BAuth<HandleError> {
+    constructor(apiClient: JwtClient<HandleError>);
+    basicLogin(basicLoginParams: UmaBasicB2BLoginDto, headers?: {
+        'Debug-Token'?: string;
+    }, config?: RequestConfig<HandleError> | undefined): Promise<ClientResponse<UmaBasicB2BLoginSerializer, HandleError>>;
+}
+declare class _B2CAuth1<HandleError extends boolean = boolean> extends B2CAuth<HandleError> {
+    constructor(apiClient: JwtClient<HandleError>);
+    basicLogin(basicLoginParams: UmaBasicB2CLoginDto, headers?: {
+        BRANCH?: string;
+        FIRM?: string;
+    }, config?: RequestConfig<HandleError> | undefined): Promise<ClientResponse<UmaB2CLoginResultSerializer, HandleError>>;
+}
+export interface UmaClientConfig<HandleError extends boolean = boolean> extends JwtClientConfig<HandleError> {
+    firmId: string;
+    authFormSlug: string;
+}
+export class UmaApi<HandleError extends boolean = false> extends BaseApi<HandleError, JwtClient<HandleError>> {
+    actionLog: ActionLogs<HandleError>;
+    apiKeys: ApiKeys<HandleError>;
+    authApps: AuthApps<HandleError>;
+    authForms: AuthForms<HandleError>;
+    b2bAuth: _B2BAuth1<HandleError>;
+    b2bUsers: B2BUsers<HandleError>;
+    b2bUserSettings: B2BUserSettings<HandleError>;
+    b2cAuth: _B2CAuth1<HandleError>;
+    b2cUsers: B2CUsers<HandleError>;
+    b2cUserSettings: B2CUserSettings<HandleError>;
+    branches: Branches<HandleError>;
+    countries: Countries<HandleError>;
+    endpoints: Endpoints<HandleError>;
+    fims: Firms<HandleError>;
+    identityProviders: IdentityProviders<HandleError>;
+    locales: Locales<HandleError>;
+    microservices: Microservices<HandleError>;
+    migrationUtils: MigrationUtils<HandleError>;
+    permissions: Permissions<HandleError>;
+    publicSettings: PublicSettings<HandleError>;
+    roles: Roles<HandleError>;
+    roleTypes: RoleTypes<HandleError>;
+    secretNotes: SecretNotes<HandleError>;
+    sessions: Sessions<HandleError>;
+    tablePresets: TablePresets<HandleError>;
+    tags: Tags<HandleError>;
+    userDetails: UserDetails<HandleError>;
+    usersCommon: UsersCommon<HandleError>;
+    watchmenAuth: WatchmenAuth<HandleError>;
+    watchmenInstances: WatchmenInstances<HandleError>;
+    constructor(config: UmaClientConfig<HandleError>);
+}
+
+//# sourceMappingURL=index.d.ts.map