@orbis-systems/orbis-api-clients 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2308 @@
+import { AxiosError, AxiosInstance, AxiosRequestConfig, HttpStatusCode } from "axios";
+interface BaseClientConfig<HandleError extends boolean = boolean> {
+    baseUrl: string;
+    errorHandling?: HandleError;
+    storage?: Storage;
+    defaultHeaders?: Record<string, string>;
+    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>(config: 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 ValidationError {
+    message: string;
+    meta?: Record<string, string | number>;
+}
+export interface ValidationExceptionDto {
+    errors: ValidationError[];
+    id: string;
+    message: string;
+    timestamp: string;
+}
+export interface ExceptionDto {
+    id: string;
+    message: string;
+    timestamp: string;
+}
+export interface AvatarUploadDto {
+    image: File;
+}
+export interface UserTokensDto {
+    apiToken: string;
+    accessToken: string;
+    refreshToken: string;
+    assetsToken: string;
+}
+export interface MessageDto {
+    id: number;
+    title: string;
+    content: string;
+    isRtl: boolean;
+}
+export interface ChartLayoutDto {
+    id: number;
+    symbol: string;
+    resolution: string;
+    timestamp: object;
+    name: string;
+}
+export interface ChartLayoutDetailsDto {
+    id: number;
+    symbol: string;
+    resolution: string;
+    timestamp: object;
+    name: string;
+    content: string;
+}
+export interface ChartDataDto {
+    name: string;
+}
+export interface ChartTemplateDto {
+    name: string;
+    content: string;
+}
+export interface WatchlistEntryDto {
+    type?: 'equity' | 'option' | 'crypto' | 'bond' | 'mutualFund';
+    symbol: string;
+}
+export interface WatchlistDto {
+    id: number;
+    isDefault: boolean;
+    name: string;
+    description: string;
+    color: string;
+    order: number | null;
+    entries: WatchlistEntryDto[];
+}
+export interface PersistWatchlistDto {
+    id: number;
+    isDefault?: boolean;
+    name: string;
+    description?: string;
+    color?: string;
+    order?: number | null;
+    entries?: WatchlistEntryDto[];
+}
+export interface WatchlistEntriesDto {
+    entries: WatchlistEntryDto[];
+}
+export interface WatchlistOrderDto {
+    watchlistId: number;
+    order: number;
+}
+export interface WatchlistOrdersDto {
+    orders: WatchlistOrderDto[];
+}
+export interface AppVersionDto {
+    token: string;
+    versionNumber: string;
+}
+export class AttributeApi<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    getAttributeValues(config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<Record<string, string | number | boolean>, HandleError>>;
+    getPublicAttributeValue(attributePublicId: string, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<string | number | boolean, HandleError>>;
+}
+export class AuthenticationApi<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    authenticate(headers: {
+        'Firm-Id': string;
+        'Watchmen-Token': string;
+        'Application-Name': string;
+    }, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<UserTokensDto, HandleError>>;
+    refresh(config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<UserTokensDto, HandleError>>;
+    invalidate(config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+}
+export class AvatarApi<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    getUserAvatar(userId: number, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<File, HandleError>>;
+    uploadUserAvatar(userId: number, data: AvatarUploadDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    deleteUserAvatar(userId: number, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    getAccountAvatar(accountId: number, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<File, HandleError>>;
+    uploadAccountAvatar(accountId: number, data: AvatarUploadDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    deleteAccountAvatar(accountId: number, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+}
+export class ChartApi<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    getChartLayouts(config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<ChartLayoutDto[], HandleError>>;
+    updateChartLayout(data: ChartLayoutDetailsDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<ChartLayoutDetailsDto, HandleError>>;
+    getChartLayoutDetails(chartId: number, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<ChartLayoutDetailsDto, HandleError>>;
+    deleteChartLayout(chartId: number, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    getIndicatorTemplates(config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<ChartDataDto[], HandleError>>;
+    updateIndicatorTemplate(data: ChartTemplateDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<ChartTemplateDto, HandleError>>;
+    getIndicatorTemplateDetails(templateName: string, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<ChartTemplateDto, HandleError>>;
+    deleteIndicatorTemplate(templateName: string, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    getChartTemplates(config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<ChartDataDto[], HandleError>>;
+    updateChartTemplate(data: ChartTemplateDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<ChartTemplateDto, HandleError>>;
+    getChartTemplateDetails(templateName: string, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<ChartTemplateDto, HandleError>>;
+    deleteChartTemplate(templateName: string, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+}
+export class MessageApi<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    getMessages(query?: {
+        languageCode?: string;
+    }, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<MessageDto[], HandleError>>;
+}
+export class PreferenceApi<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    getPreferences(config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<Record<string, string>, HandleError>>;
+    savePreferences(config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<Record<string, string>, HandleError>>;
+}
+export class VersioningApi<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    getAppVersion(appId: string, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<AppVersionDto, HandleError>>;
+    updateAppVersion(appId: string, data: AppVersionDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+}
+export class WatchlistApi<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    getAllWatchlists(config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<WatchlistDto[], HandleError>>;
+    createWatchlist(data: PersistWatchlistDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<WatchlistDto, HandleError>>;
+    getWatchlist(watchlistId: number, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<WatchlistDto, HandleError>>;
+    updateWatchlist(watchlistId: number, data: PersistWatchlistDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<WatchlistDto, HandleError>>;
+    deleteWatchlist(watchlistId: number, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    addWatchlistEntries(watchlistId: number, data: WatchlistEntriesDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<WatchlistDto, HandleError>>;
+    removeWatchlistEntries(watchlistId: number, data: WatchlistEntriesDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<WatchlistDto, HandleError>>;
+    updateWatchlistEntries(watchlistId: number, data: WatchlistEntriesDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<WatchlistDto, HandleError>>;
+    updateWatchlistOrders(data: WatchlistOrdersDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    importWatchmenWatchlists(config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+}
+export class MiddlewareApi<HandleError extends boolean = boolean> extends BaseApi<HandleError, JwtClient<HandleError>> {
+    attribute: AttributeApi<HandleError>;
+    authentication: AuthenticationApi<HandleError>;
+    avatar: AvatarApi<HandleError>;
+    chart: ChartApi<HandleError>;
+    message: MessageApi<HandleError>;
+    preference: PreferenceApi<HandleError>;
+    versioning: VersioningApi<HandleError>;
+    watchlist: WatchlistApi<HandleError>;
+    constructor(config: JwtClientConfig<HandleError>);
+}
+interface OrbisErrorData {
+    orbisErrorCode: string | null;
+    orbisErrorMessage: string | null;
+}
+interface OrbisClientConfig<HandleError extends boolean = boolean> extends JwtClientConfig<HandleError> {
+    onLoginTimeout?: VoidFunction;
+    onUnauthorized?: VoidFunction;
+}
+type OrbisClientResponse<Data = unknown, HandleError extends boolean = boolean> = OrbisErrorData & ClientResponse<Data, HandleError>;
+declare class OrbisClient<HandleError extends boolean = boolean> extends JwtClient<HandleError> {
+    protected readonly config: OrbisClientConfig<HandleError>;
+    request<Data = unknown, Body = unknown>(config: RequestConfig<Body>): Promise<OrbisClientResponse<Data, HandleError>>;
+}
+export class OrbisApi<HandleError extends boolean = boolean> extends BaseApi<HandleError, OrbisClient<HandleError>> {
+    constructor(config: OrbisClientConfig<HandleError>);
+    login(username: string, password: string): Promise<import("BaseClient").ClientResponse<{
+        sessionId: string;
+    }, HandleError>>;
+    sso(token: string, platform: string): Promise<import("BaseClient").ClientResponse<{
+        sessionId: string;
+    }, HandleError>>;
+    logout(): Promise<void>;
+}
+export interface ActionlogsGetActionLogsSerializer {
+    action_logs: TypesActionLogSerializer[];
+    current_page: number;
+    pages_count: number;
+    status: number;
+    total_records: number;
+}
+export interface ApikeysAPIKeysMutationSerializer {
+    api_keys: TypesAPIKeys;
+    status: number;
+}
+export interface ApikeysGetAPIKeysSerializer {
+    api_keys: TypesAPIKeys[];
+    current_page: number;
+    pages_count: number;
+    status: number;
+    total_records: number;
+}
+export interface AuthappsAuthAppResponseSerializer {
+    auth_app: TypesAuthAppSerializer;
+    status: number;
+}
+export interface AuthappsFinishTOTPRegistrationResponseSerializer {
+    backup_codes: string[];
+    status: number;
+}
+export interface AuthappsGetAuthAppsListSerializer {
+    auth_apps_list: TypesAuthAppSerializer[];
+    status: number;
+}
+export interface AuthcommonBasicLoginResultSerializer {
+    tokens: TypesTokens;
+    user: TypesUserSerializer;
+}
+export interface AuthformsAuthFormMutationSerializer {
+    form: TypesAuthFormSerializer;
+    status: number;
+}
+export interface AuthformsGetAuthFormsListSerializer {
+    current_page: number;
+    forms_list: TypesAuthFormSerializer[];
+    pages_count: number;
+    status: number;
+    total_records: number;
+}
+export interface B2BauthBasicB2BLoginResultSerializer {
+    tokens: TypesTokens;
+    user: TypesB2BUserSerializer;
+}
+export interface B2BauthBasicB2BLoginSerializer {
+    login_basic: B2BauthBasicB2BLoginResultSerializer;
+    status: number;
+}
+export interface B2BauthGetCurrentB2BUserSerializer {
+    current_user: TypesB2BUserSerializer;
+    status: number;
+}
+export interface B2BauthSimpleB2BLoginResultSerializer {
+    tokens: TypesTokens;
+}
+export interface B2BauthSimpleB2BLoginSerializer {
+    api_keys_login: B2BauthSimpleB2BLoginResultSerializer;
+    status: number;
+}
+export interface B2BusersB2BUserSerializer {
+    b2b_user: TypesAdminB2BUserSerializer;
+    status: number;
+}
+export interface B2BusersettingsB2BUploadAvatarResponseSerializer {
+    avatar: TypesB2BUploadAvatarSerializer;
+    status: number;
+}
+export interface B2BusersettingsB2BUserSettingsChangeSerializer {
+    settings: B2BusersettingsB2BUserSettingsSerializer;
+    status: number;
+}
+export interface B2BusersettingsB2BUserSettingsSerializer {
+    do_not_ask_mfa_again: boolean;
+    email: string;
+    first_name: string;
+    last_name: string;
+    mfa_enabled: boolean;
+    mode: string;
+    phone: string;
+    theme: string;
+}
+export interface B2CauthB2CLoginResultSerializer {
+    email_verification_needed: boolean;
+    login_basic: AuthcommonBasicLoginResultSerializer;
+    phone_verification_needed: boolean;
+    redirect_to: string;
+    status: number;
+}
+export interface B2CauthGetCurrentB2CUserSerializer {
+    current_user: TypesUserSerializer;
+    status: number;
+}
+export interface B2CauthRefreshResultSerializer {
+    login_basic: AuthcommonBasicLoginResultSerializer;
+    redirect_to: string;
+    status: number;
+}
+export interface B2CauthRegisterResultSerializer {
+    user: TypesUserSerializer;
+}
+export interface B2CauthRegisterSerializer {
+    register: B2CauthRegisterResultSerializer;
+    status: number;
+}
+export interface B2CusersB2CUserSerializer {
+    b2c_user: TypesAdminB2CUserSerializer;
+    status: number;
+}
+export interface B2CusersettingsAvailableB2CMfaOptionsResponse {
+    options?: MfaOption[];
+    status?: number;
+}
+export interface B2CusersettingsB2CUserSettingsChangeSerializer {
+    settings: TypesB2CUserSettingsSerializer;
+    status: number;
+}
+export interface BranchesBranchMutationSerializer {
+    branch: TypesBranchAdminSerializer;
+    status: number;
+}
+export interface BranchesGetBranchesListSerializer {
+    branches_list: TypesBranchAdminSerializer[];
+    current_page: number;
+    pages_count: number;
+    status: number;
+    total_records: number;
+}
+export enum CommontypesAuthAppType {
+    EmailCodeAuthAppType = "email_code",
+    SmsCodeAuthAppType = "sms_code",
+    YubicoOTPAuthAppType = "yubico_otp",
+    WebAuthnAuthAppType = "webauthn",
+    TOTPAuthAppType = "totp"
+}
+export enum CommontypesAuthUserType {
+    AllAuthUserType = "all",
+    B2BAuthUserType = "b2b",
+    B2CAuthUserType = "b2c"
+}
+export interface CommontypesPaginationDto {
+    page?: number;
+    size?: number;
+}
+export enum CommontypesResetPasswordType {
+    PasswordResetByContactCode = "by_contact_code",
+    PasswordResetByEmailLink = "by_email_link"
+}
+export interface CommontypesSortDto {
+    direction?: string;
+    field?: string;
+}
+export interface CountriesGetCountriesSerializer {
+    countries: TypesCountrySerializer[];
+    status: number;
+}
+export interface EndpointsEndpointMutationSerializer {
+    endpoint: TypesEndpointSerializer;
+    status: number;
+}
+export interface EndpointsGetEndpointsListSerializer {
+    current_page: number;
+    endpoints_list: TypesEndpointSerializer[];
+    pages_count: number;
+    status: number;
+    total_records: number;
+}
+export interface FirmsFirmMutationSerializer {
+    firm: TypesFirmWithCredsSerializer;
+    status: number;
+}
+export interface FirmsGetFirmsListSerializer {
+    current_page: number;
+    firms_list: TypesFirmWithCredsSerializer[];
+    pages_count: number;
+    status: number;
+    total_records: number;
+}
+export interface HttperrorsError {
+    available_options?: MfaOption[];
+    code?: HttperrorsErrorCode;
+    description?: string;
+    field?: string;
+    request_id?: string;
+}
+export enum HttperrorsErrorCode {
+    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,
+    GoneErr = 4100,
+    SecondGoneErr = 4101,
+    UnprocessableEntity = 4222,
+    TooEarlyDuplicateRequest = 4250,
+    RateLimitErr = 4291,
+    ForbiddenByFirmsStatusErr = 4292,
+    NotAcceptableError = 4600,
+    InternalServerErr = 5000,
+    InvalidRequest = 6000
+}
+export interface HttperrorsErrorsSerializer {
+    errors: HttperrorsError[];
+}
+export interface IdentityprovidersGetIdentityProvidersListSerializer {
+    current_page: number;
+    identity_providers_list: TypesIdentityProviderSerializer[];
+    pages_count: number;
+    status: number;
+    total_records: number;
+}
+export interface IdentityprovidersIdentityProviderResponseSerializer {
+    identity_provider: TypesIdentityProviderSerializer;
+    status: number;
+}
+export interface LocalesLocaleSerializer {
+    id: number;
+    locale: string;
+    name: string;
+}
+export enum MfaOption {
+    SmsMfaOption = "sms",
+    EmailMfaOption = "email",
+    VoiceMfaOption = "voice",
+    WebAuthnMfaOption = "webauthn",
+    YubicoOTPMfaOption = "yubico_otp",
+    TOTPMfaOption = "totp"
+}
+export interface MicroservicesGetMicroservicesListSerializer {
+    current_page: number;
+    microservices_list: TypesMicroserviceSerializer[];
+    pages_count: number;
+    status: number;
+    total_records: number;
+}
+export interface MicroservicesMicroserviceMutationSerializer {
+    microservice: TypesMicroserviceSerializer;
+    status: number;
+}
+export interface MigrationutilsUpsertUsersSerializer {
+    status: number;
+    users: TypesAdminUserSerializer[];
+}
+export interface PermissionsGetPermissionsListSerializer {
+    current_page: number;
+    pages_count: number;
+    permissions_list: TypesPermissionSerializer[];
+    status: number;
+    total_records: number;
+}
+export interface PermissionsPermissionMutationSerializer {
+    permission: TypesPermissionSerializer;
+    status: number;
+}
+export enum PgmodelsAuthProviderAppType {
+    GoogleOAuth2Provider = "google-oauth2",
+    AppleIDOAuth2Provider = "apple-id"
+}
+export enum PgmodelsEndpointType {
+    RegularEndpoint = "regular",
+    DisplayOnlyEndpoint = "display_only"
+}
+export enum PgmodelsEntityAccessType {
+    GranularEntityAccessType = "granular",
+    HighLevelEntityAccessType = "high-level"
+}
+export enum PgmodelsPermissionAG {
+    ChiefadminPermissionAG = "chiefadmin",
+    SuperadminPermissionAG = "superadmin",
+    B2BOnlyPermissionAG = "b2b_only",
+    RegularPermissionAG = "regular"
+}
+export interface PgmodelsPermissionMetadata {
+    entities?: Record<string, PgmodelsEntityAccessType>;
+    is_microservice_global?: boolean;
+    one_of_group?: string;
+}
+export interface PublicsettingsPublicSettingsResponseSerializer {
+    settings: TypesPublicSettingsSerializer;
+    status: number;
+}
+export interface RolesGetRolesListSerializer {
+    current_page: number;
+    pages_count: number;
+    roles_list: TypesRoleSerializer[];
+    status: number;
+    total_records: number;
+}
+export interface RolesRoleMutationSerializer {
+    role: TypesRoleSerializer;
+    status: number;
+}
+export interface RoletypesGetRoleTypesListSerializer {
+    current_page: number;
+    pages_count: number;
+    role_types_list: TypesRoleTypeSerializer[];
+    status: number;
+    total_records: number;
+}
+export interface RoletypesRoleTypeResponseSerializer {
+    role_type: TypesRoleTypeSerializer;
+    status: number;
+}
+export interface SecretnotesSecretNoteCreationSuccessSerializer {
+    secret_note_link: string;
+    status: number;
+}
+export interface SecretnotesSingleSecretNoteSerializer {
+    secret_note: TypesSecretNoteSerializer;
+    status: number;
+}
+export interface SessionsGetSessionsListSerializer {
+    sessions: TypesSessionSerializer[];
+    status: number;
+}
+export interface TablepresetsTablePresetResponseSerializer {
+    status: number;
+    table_preset: TypesTablePresetSerializer;
+}
+export interface TablepresetsTablePresetsListResponseSerializer {
+    status: number;
+    table_presets: TypesTablePresetSerializer[];
+}
+export interface TagsGetTagsListSerializer {
+    current_page: number;
+    pages_count: number;
+    status: number;
+    tags_list: TypesTagSerializer[];
+    total_records: number;
+}
+export interface TagsTagMutationSerializer {
+    status: number;
+    tag: TypesTagSerializer;
+}
+export interface TypesAPIKeys {
+    ac_same_as_for_user?: boolean;
+    api_key?: string;
+    api_secret?: string;
+    branches?: TypesBranchSerializer[];
+    created_at?: string;
+    firms?: TypesFirmAccessSerializer[];
+    id?: number;
+    microservices?: TypesMicroserviceSerializer[];
+    name?: string;
+    permissions?: TypesPermissionSerializer[];
+    roles?: TypesRoleSerializer[];
+    updated_at?: string;
+}
+export interface TypesAPIKeysB2BLoginDto {
+    api_key: string;
+    api_secret: string;
+}
+export interface TypesActionLogEntityFilterDto {
+    entity_id?: number;
+    entity_name?: string;
+}
+export interface TypesActionLogSerializer {
+    action_type: string;
+    created_at: string;
+    entity_id: number;
+    entity_name: string;
+    id: number;
+    initiator: TypesUserSerializer;
+    initiator_id: number;
+    new_state: Record<string, any>;
+    prev_state: Record<string, any>;
+    trigger_type: string;
+    updated_at: string;
+}
+export interface TypesAdminB2BUserSerializer {
+    allow_feedback: boolean;
+    big_avatar_url: string;
+    branches: TypesBranchSerializer[];
+    created_at: string;
+    do_not_ask_mfa_again: boolean;
+    email: string;
+    email_verified: boolean;
+    firms: TypesFirmAccessSerializer[];
+    first_name: string;
+    has_access_to_all_firm_branches: boolean;
+    id: number;
+    initiator_id: number;
+    last_name: string;
+    locale: TypesLocaleSerializer;
+    locale_id: number;
+    mfa_enabled: boolean;
+    microservices: TypesMicroserviceSerializer[];
+    mode: string;
+    permissions: TypesPermissionSerializer[];
+    phone: string;
+    phone_verified: boolean;
+    primary_firm_id: number;
+    rep_code: string;
+    roles: TypesRoleSerializer[];
+    should_reset_password: boolean;
+    small_avatar_url: string;
+    theme: string;
+    updated_at: string;
+    username: string;
+}
+export interface TypesAdminB2CUserSerializer {
+    allow_feedback: boolean;
+    big_avatar_url: string;
+    blocked_at: string;
+    blocking_reason: string;
+    branches: TypesBranchSerializer[];
+    created_at: string;
+    do_not_ask_mfa_again: boolean;
+    email: string;
+    email_verified: boolean;
+    firms: TypesFirmAccessSerializer[];
+    first_name: string;
+    id: number;
+    initiator_id: number;
+    is_blocked: boolean;
+    last_name: string;
+    locale: TypesLocaleSerializer;
+    locale_id: number;
+    mfa_enabled: boolean;
+    microservices: TypesMicroserviceSerializer[];
+    permissions: TypesPermissionSerializer[];
+    phone: string;
+    phone_verified: boolean;
+    primary_firm_id: number;
+    rep_code: string;
+    roles: TypesRoleSerializer[];
+    should_reset_password: boolean;
+    small_avatar_url: string;
+    updated_at: string;
+    username: string;
+}
+export interface TypesAdminUserSerializer {
+    allow_feedback: boolean;
+    big_avatar_url: string;
+    branches: TypesBranchSerializer[];
+    created_at: string;
+    do_not_ask_mfa_again: boolean;
+    email: string;
+    email_verified: boolean;
+    firms: TypesFirmAccessSerializer[];
+    first_name: string;
+    id: number;
+    initiator_id: number;
+    last_name: string;
+    locale: TypesLocaleSerializer;
+    locale_id: number;
+    mfa_enabled: boolean;
+    microservices: TypesMicroserviceSerializer[];
+    permissions: TypesPermissionSerializer[];
+    phone: string;
+    phone_verified: boolean;
+    primary_firm_id: number;
+    rep_code: string;
+    roles: TypesRoleSerializer[];
+    should_reset_password: boolean;
+    small_avatar_url: string;
+    updated_at: string;
+    username: string;
+}
+export interface TypesAuthAppSerializer {
+    created_at: string;
+    id: number;
+    last_used_at: string;
+    name: string;
+    status: string;
+    type: string;
+    updated_at: string;
+}
+export interface TypesAuthAppsLimitsSerializer {
+    totp_max_apps: number;
+    webauthn_max_apps: number;
+    yubico_otp_max_apps: number;
+}
+export interface TypesAuthFormDto {
+    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: 'by_contact_code' | 'by_email_link';
+    slug: string;
+}
+export interface TypesAuthFormSerializer {
+    branch: TypesBranchSerializer;
+    branch_id: number;
+    client_platform_slug: string;
+    created_at: string;
+    firm: TypesFirmSerializer;
+    firm_id: number;
+    id: number;
+    logo_base_url: string;
+    logo_path: string;
+    redirect_url: string;
+    reset_password_link_template: string;
+    reset_password_type: 'by_contact_code' | 'by_email_link';
+    slug: string;
+    updated_at: string;
+}
+export interface TypesAuthProviderUserBindingSerializer {
+    app_type: PgmodelsAuthProviderAppType;
+    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 TypesAuthProviderUserBindingsResponse {
+    bindings?: TypesAuthProviderUserBindingSerializer[];
+    current_page?: number;
+    pages_count?: number;
+    status?: number;
+    total_records?: number;
+}
+export interface TypesAvatarSettingsSerializer {
+    allowed_extensions: string[];
+    big_dimensions: TypesImageDimensionsSerializer;
+    max_size_in_bytes: number;
+}
+export interface TypesB2BResetPasswordDto {
+    captcha_response?: string;
+    code: string;
+    contact: string;
+    new_password: string;
+    old_password?: string;
+}
+export interface TypesB2BSendContactChangeCodeDto {
+    contact: string;
+    type: 'email' | 'voice' | 'sms';
+}
+export interface TypesB2BUploadAvatarSerializer {
+    big_avatar_path: string;
+    small_avatar_path: string;
+}
+export interface TypesB2BUserSerializer {
+    admin_of_firm_ids: number[];
+    allow_feedback: boolean;
+    big_avatar_url: string;
+    created_at: string;
+    do_not_ask_mfa_again: boolean;
+    email: string;
+    email_verified: boolean;
+    first_name: string;
+    id: number;
+    initiator_id: number;
+    is_chief_admin: boolean;
+    last_name: string;
+    locale: TypesLocaleSerializer;
+    locale_id: number;
+    mfa_enabled: boolean;
+    microservices: TypesMicroserviceAccessSerializer[];
+    mode: string;
+    phone: string;
+    phone_verified: boolean;
+    rep_code: string;
+    should_reset_password: boolean;
+    small_avatar_url: string;
+    theme: string;
+    updated_at: string;
+    username: string;
+}
+export interface TypesB2CInitOAuthResponse {
+    data?: TypesInitOAuthLoginSerializer;
+    status?: number;
+}
+export interface TypesB2CRefreshDto {
+    auth_form_slug?: string;
+    refresh_token: string;
+    send_redirect?: boolean;
+}
+export interface TypesB2CResetPasswordDto {
+    auth_form_slug: string;
+    captcha_response?: string;
+    code: string;
+    contact?: string;
+    new_password: string;
+    reset_type: 'by_contact_code' | 'by_email_link';
+}
+export interface TypesB2CSendContactChangeCodeDto {
+    contact: string;
+    type: 'email' | 'voice' | 'sms';
+}
+export interface TypesB2CSendVerificationCodeDto {
+    code_type: 'email' | 'voice' | 'sms';
+    contact: string;
+}
+export interface TypesB2CUserSettingsSerializer {
+    email: string;
+    email_verified: boolean;
+    first_name: string;
+    last_name: string;
+    mfa_enabled: boolean;
+    phone: string;
+    phone_verified: boolean;
+}
+export interface TypesBasicB2BLoginDto {
+    device_id: string;
+    email: string;
+    mfa_codes?: TypesMfaCodesDto;
+    password: string;
+    remember_me?: boolean;
+}
+export interface TypesBasicB2CLoginDto {
+    auth_form_slug?: string;
+    client_platform_slug?: string;
+    device_id: string;
+    login: string;
+    mfa_codes?: TypesMfaCodesDto;
+    password: string;
+    remember_me?: boolean;
+    send_redirect?: boolean;
+}
+export interface TypesBranchAdminSerializer {
+    branch_admins_count: number;
+    code: string;
+    created_at: string;
+    firm: TypesFirmSerializer;
+    firm_id: number;
+    id: number;
+    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;
+    slug: string;
+    updated_at: string;
+}
+export interface TypesBranchSerializer {
+    code: string;
+    firm_id: number;
+    id: number;
+    name: string;
+    slug: string;
+}
+export interface TypesCountrySerializer {
+    code: string;
+    dial_code: string;
+    id: number;
+    name: string;
+}
+export interface TypesCreateAPIKeysDto {
+    ac_same_as_for_user?: boolean;
+    branches?: number[];
+    firms?: TypesFirmInfo[];
+    mfa_codes?: TypesMfaCodesDto;
+    name: string;
+    permissions?: number[];
+    roles?: number[];
+}
+export interface TypesCreateB2BUserDto {
+    add_default_domain_permissions?: boolean;
+    allow_feedback?: boolean;
+    branches?: number[];
+    email?: string;
+    firms: TypesFirmInfo[];
+    first_name: string;
+    has_access_to_all_firm_branches?: boolean;
+    last_name: string;
+    password: string;
+    permissions?: number[];
+    phone?: string;
+    primary_firm_id?: number;
+    roles: number[];
+    should_reset_password?: boolean;
+    username?: string;
+}
+export interface TypesCreateB2CUserDto {
+    allow_feedback?: boolean;
+    blocking_reason?: string;
+    branches: number[];
+    email?: string;
+    firm_id: number;
+    first_name: string;
+    is_blocked?: boolean;
+    last_name: string;
+    password: string;
+    permissions?: number[];
+    phone?: string;
+    roles: number[];
+    username?: string;
+}
+export interface TypesCreateBranchDto {
+    code?: string;
+    firm_id: number;
+    name: string;
+    retail_available_auth_app_options?: CommontypesAuthAppType[];
+    retail_email_verification_required?: boolean;
+    retail_login_enabled?: boolean;
+    retail_mfa_enabling_required?: boolean;
+    retail_phone_verification_required?: boolean;
+    settings?: TypesTenantSettingDto[];
+    slug: string;
+}
+export interface TypesCreateEndpointDto {
+    is_active?: boolean;
+    is_public?: boolean;
+    metadata?: TypesEndpointMetadataDto;
+    method: 'POST' | 'PUT' | 'DELETE' | 'GET' | 'PATCH' | 'ALL';
+    microservice_id: number;
+    required_permissions?: number[];
+    route: string;
+    type?: 'regular' | 'display_only';
+}
+export interface TypesCreateFirmDto {
+    allow_b2c_email_notifications?: boolean;
+    firm_tags?: number[];
+    mailgun_creds?: TypesFirmMailgunCredsDto;
+    name: string;
+    slug: string;
+    twilio_creds?: TypesFirmTwilioCredsDto;
+}
+export interface TypesCreateIdentityProviderDto {
+    auth_url: string;
+    client_id: string;
+    client_secret: string;
+    company_domain: string;
+    firm_id: number;
+    priority: number;
+    redirect_url?: string;
+    type: 'okta';
+}
+export interface TypesCreateMicroserviceDto {
+    domains?: TypesMicroserviceDomainDto[];
+    is_active?: boolean;
+    is_visible_on_admin_sidebar?: boolean;
+    logo_url?: string;
+    name: string;
+    slug: string;
+}
+export interface TypesCreatePermissionDto {
+    assignment_group: 'regular' | 'superadmin' | 'b2b_only';
+    metadata?: PgmodelsPermissionMetadata;
+    microservice_id?: number;
+    permission: string;
+}
+export interface TypesCreateRoleDto {
+    assignment_group?: 'regular' | 'superadmin' | 'b2b_only';
+    firm_id?: number;
+    microservice_id: number;
+    name: string;
+    permissions: number[];
+    permissions_can_assign_role?: number[];
+    type_id: number;
+}
+export interface TypesCreateRoleTypeDto {
+    color: string;
+    type: string;
+}
+export interface TypesCreateSecretNoteDto {
+    email: string;
+    expires_in: string;
+    max_view_count: number;
+    name?: string;
+    note_params: Record<string, string>;
+    type: 'password';
+}
+export interface TypesCreateTagDto {
+    name: string;
+}
+export interface TypesCreateWatchmenInstanceDto {
+    name: string;
+    slug: string;
+    url: string;
+}
+export interface TypesCreateYubicoOTPDto {
+    name: string;
+    otp: string;
+}
+export interface TypesDeleteAPIKeysDto {
+    ids: number[];
+    mfa_codes?: TypesMfaCodesDto;
+}
+export interface TypesDeleteByIDsDtoInt {
+    ids: number[];
+}
+export interface TypesDeleteByIDsDtoInt64 {
+    ids: number[];
+}
+export interface TypesDeleteSessionsDto {
+    pair_ids: string[];
+}
+export interface TypesEndpointMetadataDto {
+    admin_ui_permission_key?: string;
+    skip_email_verification_check?: boolean;
+    skip_mfa_enabled_check?: boolean;
+    skip_phone_verification_check?: boolean;
+    user_type?: 'b2b' | 'b2c';
+}
+export interface TypesEndpointMetadataSerializer {
+    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 TypesEndpointSerializer {
+    created_at: string;
+    id: number;
+    is_active: boolean;
+    is_public: boolean;
+    metadata: TypesEndpointMetadataSerializer;
+    method: 'POST' | 'PUT' | 'DELETE' | 'GET' | 'PATCH' | 'ALL';
+    microservice: TypesMicroserviceSerializer;
+    microservice_id: number;
+    required_permissions: TypesPermissionSerializer[];
+    route: string;
+    type: PgmodelsEndpointType;
+    updated_at: string;
+}
+export interface TypesFinishOAuthLoginDto {
+    authentication_code: string;
+    state: string;
+}
+export interface TypesFinishTOTPRegistrationDto {
+    code: string;
+    name: string;
+}
+export interface TypesFirmAccessSerializer {
+    admins_count: number;
+    allow_b2c_email_notifications: boolean;
+    branches: TypesBranchSerializer[];
+    branches_count: number;
+    created_at: string;
+    have_access_to_all_firm_branches: boolean;
+    id: number;
+    last_status_change_at: string;
+    name: string;
+    slug: string;
+    status: string;
+    tags: TypesTagSerializer[];
+    updated_at: string;
+}
+export interface TypesFirmInfo {
+    firm_id: number;
+    have_access_to_all_firm_branches?: boolean;
+}
+export interface TypesFirmMailgunCredsDto {
+    domain?: string;
+    from_address?: string;
+    from_name?: string;
+    private_api_key?: string;
+}
+export interface TypesFirmSerializer {
+    admins_count: number;
+    allow_b2c_email_notifications: boolean;
+    branches: TypesBranchSerializer[];
+    branches_count: number;
+    created_at: string;
+    id: number;
+    last_status_change_at: string;
+    name: string;
+    slug: string;
+    status: string;
+    tags: TypesTagSerializer[];
+    updated_at: string;
+}
+export interface TypesFirmTwilioCredsDto {
+    account_sid?: string;
+    auth_token?: string;
+    phone_number?: string;
+    subaccount_sid?: string;
+}
+export interface TypesFirmWithCredsSerializer {
+    admins_count: number;
+    allow_b2c_email_notifications: boolean;
+    branches: TypesBranchSerializer[];
+    branches_count: number;
+    created_at: string;
+    id: number;
+    last_status_change_at: string;
+    mailgun_creds: TypesFirmMailgunCredsDto;
+    name: string;
+    slug: string;
+    status: string;
+    tags: TypesTagSerializer[];
+    twilio_creds: TypesFirmTwilioCredsDto;
+    updated_at: string;
+}
+export interface TypesGeneratedWatchmenTokenInfoSerializer {
+    expires_at: number;
+    token: string;
+}
+export interface TypesGetAPIKeysListDto {
+    pagination?: CommontypesPaginationDto;
+    search?: string;
+    sorts?: CommontypesSortDto[];
+}
+export interface TypesGetActionLogsListDto {
+    filters?: TypesGetActionLogsListFiltersDto;
+    pagination: CommontypesPaginationDto;
+    sorts?: CommontypesSortDto[];
+}
+export interface TypesGetActionLogsListFiltersDto {
+    action_types?: string[];
+    entities?: TypesActionLogEntityFilterDto[];
+    ids?: number[];
+    initiator_ids?: number[];
+    trigger_types?: string[];
+}
+export interface TypesGetAuthFormsListDto {
+    filters?: TypesGetAuthFormsListFiltersDto;
+    pagination?: CommontypesPaginationDto;
+    search?: string;
+    sorts?: CommontypesSortDto[];
+}
+export interface TypesGetAuthFormsListFiltersDto {
+    branch_ids?: number[];
+    firm_ids?: number[];
+    ids?: number[];
+}
+export interface TypesGetB2BUsersListDto {
+    filters?: TypesGetUsersListFiltersDto;
+    include_chiefadmin?: boolean;
+    pagination?: CommontypesPaginationDto;
+    search?: string;
+    sorts?: CommontypesSortDto[];
+}
+export interface TypesGetB2CUsersListDto {
+    filters?: TypesGetB2CUsersListFiltersDto;
+    pagination?: CommontypesPaginationDto;
+    search?: string;
+    sorts?: CommontypesSortDto[];
+}
+export interface TypesGetB2CUsersListFiltersDto {
+    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?: 'admin' | 'branch_admin' | 'compliance';
+}
+export interface TypesGetBranchesListDto {
+    count_branch_admins?: boolean;
+    filters?: TypesGetBranchesListFiltersDto;
+    pagination?: CommontypesPaginationDto;
+    search?: string;
+    search_fields?: string[];
+    sorts?: CommontypesSortDto[];
+}
+export interface TypesGetBranchesListFiltersDto {
+    firm_ids?: number[];
+    ids?: number[];
+    retail_email_verification_required?: boolean;
+    retail_login_enabled?: boolean;
+    retail_phone_verification_required?: boolean;
+}
+export interface TypesGetEndpointsListDto {
+    filters?: TypesGetEndpointsListFiltersDto;
+    pagination?: CommontypesPaginationDto;
+    search?: string;
+    sorts?: CommontypesSortDto[];
+}
+export interface TypesGetEndpointsListFiltersDto {
+    ids?: number[];
+    is_public?: boolean;
+    methods?: string[];
+    microservice_ids?: number[];
+}
+export interface TypesGetFirmsListDto {
+    count_admins?: boolean;
+    count_branches?: boolean;
+    filters?: TypesGetFirmsListFiltersDto;
+    pagination?: CommontypesPaginationDto;
+    search?: string;
+    sorts?: CommontypesSortDto[];
+}
+export interface TypesGetFirmsListFiltersDto {
+    ids?: number[];
+    statuses?: 'in_progress' | 'active' | 'suspended' | 'deleted';
+    tag_ids?: number[];
+}
+export interface TypesGetIdentityProvidersListDto {
+    filters?: TypesGetIdentityProvidersListFiltersDto;
+    pagination?: CommontypesPaginationDto;
+    search?: string;
+    sorts?: CommontypesSortDto[];
+}
+export interface TypesGetIdentityProvidersListFiltersDto {
+    firm_ids?: number[];
+    ids?: number[];
+    types?: 'okta'[];
+}
+export interface TypesGetMicroservicesListDto {
+    filters?: TypesGetMicroservicesListFiltersDto;
+    pagination?: CommontypesPaginationDto;
+    search?: string;
+    sorts?: CommontypesSortDto[];
+}
+export interface TypesGetMicroservicesListFiltersDto {
+    ids?: number[];
+    slugs?: string[];
+}
+export interface TypesGetOAuth2BindingsListDto {
+    pagination?: CommontypesPaginationDto;
+    search?: string;
+    sorts?: CommontypesSortDto[];
+}
+export interface TypesGetPermissionsListDto {
+    filters?: TypesGetPermissionsListFiltersDto;
+    include_chiefadmin?: boolean;
+    pagination?: TypesOptionalPaginationDto;
+    search?: string;
+    sorts?: CommontypesSortDto[];
+}
+export interface TypesGetPermissionsListFiltersDto {
+    assignment_groups?: PgmodelsPermissionAG[];
+    ids?: number[];
+    microservice_ids?: number[];
+}
+export interface TypesGetRoleTypesListDto {
+    filters?: TypesGetRoleTypesListFiltersDto;
+    pagination?: CommontypesPaginationDto;
+    search?: string;
+    sorts?: CommontypesSortDto[];
+}
+export interface TypesGetRoleTypesListFiltersDto {
+    ids?: number[];
+}
+export interface TypesGetRolesListDto {
+    filters?: TypesGetRolesListFiltersDto;
+    pagination?: CommontypesPaginationDto;
+    search?: string;
+    sorts?: CommontypesSortDto[];
+}
+export interface TypesGetRolesListFiltersDto {
+    assignment_groups?: PgmodelsPermissionAG[];
+    ids?: number[];
+    microservice_ids?: number[];
+    type_ids?: number[];
+}
+export interface TypesGetSecretNoteDto {
+    email: string;
+    email_code: string;
+    id: string;
+}
+export interface TypesGetTagsDto {
+    pagination: CommontypesPaginationDto;
+    search?: string;
+    sorts?: CommontypesSortDto[];
+}
+export interface TypesGetTotpQRDto {
+    digits: number;
+    name?: string;
+}
+export interface TypesGetUserDetailsDto {
+    access_token: string;
+}
+export interface TypesGetUsersListFiltersDto {
+    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?: 'admin' | 'branch_admin' | 'compliance';
+}
+export interface TypesGetWatchmenInstancesDto {
+    pagination: CommontypesPaginationDto;
+    search?: string;
+    sorts?: CommontypesSortDto[];
+}
+export interface TypesGetWebAuthnLoginChallengeDto {
+    email: string;
+    user_type?: 'b2b' | 'b2c';
+}
+export interface TypesIdentityProviderSerializer {
+    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: 'okta';
+    updated_at: string;
+}
+export interface TypesImageDimensionsSerializer {
+    height: number;
+    width: number;
+}
+export interface TypesInitOAuthLinkingDto {
+    password: string;
+    platform_slug: string;
+}
+export interface TypesInitOAuthLoginDto {
+    platform_slug: string;
+}
+export interface TypesInitOAuthLoginSerializer {
+    client_id: string;
+    redirect_url: string;
+    sign_in_url: string;
+    state: string;
+}
+export interface TypesLinkWatchmenUserToUmaDto {
+    uma_user_id: number;
+    uma_user_type: 'b2b' | 'b2c';
+    watchmen_instance_slug: string;
+    watchmen_user_id: number;
+    watchmen_username?: string;
+}
+export interface TypesLocaleSerializer {
+    id: number;
+    locale: string;
+    name: string;
+}
+export interface TypesLogoutDto {
+    refresh_token: string;
+}
+export interface TypesMfaCodesDto {
+    email?: string;
+    phone?: string;
+    totp?: string;
+    yubico_otp?: string;
+    yubico_webauthn?: TypesWebAuthnLoginSolutionDto;
+}
+export interface TypesMicroserviceAccessSerializer {
+    entities: Record<string, Record<string, boolean>>;
+    id: number;
+    is_active: boolean;
+    is_visible_on_admin_sidebar: boolean;
+    logo_url: string;
+    name: string;
+    slug: string;
+}
+export interface TypesMicroserviceDomainDto {
+    internal_domain: string;
+    internal_protocol: string;
+    public_path_prefix: string;
+}
+export interface TypesMicroserviceDomainSerializer {
+    internal_domain: string;
+    internal_protocol: string;
+    public_path_prefix: string;
+}
+export interface TypesMicroserviceSerializer {
+    created_at: string;
+    domains: TypesMicroserviceDomainSerializer[];
+    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 TypesOptionalPaginationDto {
+    page?: number;
+    size?: number;
+}
+export interface TypesPermissionMetadataSerializer {
+    entities: object;
+    is_microservice_global: boolean;
+}
+export interface TypesPermissionSerializer {
+    assignment_group: 'regular' | 'chiefadmin' | 'superadmin';
+    created_at: string;
+    id: number;
+    metadata: TypesPermissionMetadataSerializer;
+    microservice: TypesMicroserviceSerializer;
+    microservice_id: number;
+    permission: string;
+    updated_at: string;
+}
+export interface TypesPublicSettingsSerializer {
+    auth_apps_limits: TypesAuthAppsLimitsSerializer;
+    avatar: TypesAvatarSettingsSerializer;
+    b2c_mfa_options: MfaOption[];
+    reset_password: TypesResetPasswordSettingsSerializer;
+    totp: TypesTOTPSerializer;
+    verification: TypesVerificationSettingsSerializer;
+}
+export interface TypesRefreshDto {
+    refresh_token: string;
+}
+export interface TypesRegisterDto {
+    captcha_response?: string;
+    email?: string;
+    first_name: string;
+    last_name: string;
+    password: string;
+    phone?: string;
+    username?: string;
+}
+export interface TypesResetPasswordSettingsSerializer {
+    expires_in_minutes: number;
+}
+export interface TypesRevokeUserSessionsDto {
+    user_id: number;
+    user_type: 'b2b' | 'b2c';
+}
+export interface TypesRoleSerializer {
+    assignment_group: PgmodelsPermissionAG;
+    created_at: string;
+    firm: TypesFirmSerializer;
+    firm_id: number;
+    id: number;
+    microservice: TypesMicroserviceSerializer;
+    microservice_id: number;
+    name: string;
+    permissions: TypesPermissionSerializer[];
+    permissions_can_assign_role: TypesPermissionSerializer[];
+    type: TypesRoleTypeSerializer;
+    type_id: number;
+    updated_at: string;
+}
+export interface TypesRoleTypeSerializer {
+    color: string;
+    created_at: string;
+    id: number;
+    type: string;
+    updated_at: string;
+}
+export interface TypesSecretNoteSerializer {
+    email: string;
+    expires_at: string;
+    id: string;
+    name: string;
+    note_params: Record<string, string>;
+    type: 'password';
+    views_left: number;
+}
+export interface TypesSendB2BMfaCodeDto {
+    device_id?: string;
+    email: string;
+    type: 'email' | 'voice' | 'sms';
+}
+export interface TypesSendB2CMfaCodeDto {
+    device_id?: string;
+    login: string;
+    type: 'email' | 'voice' | 'sms';
+}
+export interface TypesSendB2CResetPasswordCodeDto {
+    auth_form_slug: string;
+    code_type?: 'email' | 'voice' | 'sms';
+    contact: string;
+    reset_type: 'by_contact_code' | 'by_email_link';
+}
+export interface TypesSendResetPasswordCodeDto {
+    contact: string;
+    type: 'email' | 'voice' | 'sms';
+}
+export interface TypesSendVerificationCodeForSecretNoteDto {
+    email: string;
+    id: string;
+}
+export interface TypesSessionSerializer {
+    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 TypesSetB2BUserSettingsDto {
+    captcha_response?: string;
+    do_not_ask_mfa_again?: boolean;
+    email: string;
+    email_change_code?: string;
+    first_name: string;
+    last_name: string;
+    mfa_enabled?: boolean;
+    mode?: string;
+    new_password?: string;
+    old_password?: string;
+    phone?: string;
+    phone_change_code?: string;
+    theme?: string;
+}
+export interface TypesSetB2CUserSettingsDto {
+    email: string;
+    email_change_code?: string;
+    enable_email_mfa?: boolean;
+    enable_phone_mfa?: boolean;
+    first_name?: string;
+    last_name?: string;
+    mfa_enabled?: boolean;
+    new_password?: string;
+    old_password?: string;
+    phone?: string;
+    phone_change_code?: string;
+}
+export interface TypesTOTPSerializer {
+    backup_codes_count: number;
+    backup_codes_length: number;
+}
+export interface TypesTablePresetSerializer {
+    b2b_user_id: number;
+    id: number;
+    presets: object;
+    table_name: string;
+}
+export interface TypesTagSerializer {
+    created_at: string;
+    id: number;
+    name: string;
+    updated_at: string;
+}
+export interface TypesTenantSettingDto {
+    label: 'store_password_history_for_days' | 'reset_password_if_user_inactive_for_days' | 'periodically_reset_password_after_days';
+    value: string;
+}
+export enum TypesTenantSettingLabel {
+    StorePasswordHistoryForDays = "store_password_history_for_days",
+    ResetPasswordIfUserInactiveForDays = "reset_password_if_user_inactive_for_days",
+    PeriodicallyResetPasswordAfterDays = "periodically_reset_password_after_days"
+}
+export interface TypesTokens {
+    access_expires_at?: number;
+    access_token?: string;
+    pair_id?: string;
+    refresh_expires_at?: number;
+    refresh_token?: string;
+}
+export interface TypesUpdateAPIKeysDto {
+    ac_same_as_for_user?: boolean;
+    branches?: number[];
+    firms?: TypesFirmInfo[];
+    mfa_codes?: TypesMfaCodesDto;
+    name: string;
+    permissions?: number[];
+    roles?: number[];
+    updated_at: string;
+}
+export interface TypesUpdateAuthAppDto {
+    name: string;
+    status: 'active' | 'disabled';
+}
+export interface TypesUpdateB2BUserDto {
+    allow_feedback?: boolean;
+    branches?: number[];
+    email?: string;
+    firms: TypesFirmInfo[];
+    first_name: string;
+    has_access_to_all_firm_branches?: boolean;
+    last_name: string;
+    password?: string;
+    permissions?: number[];
+    phone?: string;
+    primary_firm_id?: number;
+    roles: number[];
+    should_reset_password?: boolean;
+    updated_at: string;
+    username?: string;
+}
+export interface TypesUpdateB2CUserDto {
+    allow_feedback?: boolean;
+    blocking_reason?: string;
+    branches: number[];
+    email?: string;
+    firm_id: number;
+    first_name: string;
+    is_blocked?: boolean;
+    last_name: string;
+    password?: string;
+    permissions?: number[];
+    phone?: string;
+    roles: number[];
+    updated_at: string;
+    username?: string;
+}
+export interface TypesUpdateBranchDto {
+    code?: string;
+    name: string;
+    retail_available_auth_app_options?: CommontypesAuthAppType[];
+    retail_email_verification_required?: boolean;
+    retail_login_enabled?: boolean;
+    retail_mfa_enabling_required?: boolean;
+    retail_phone_verification_required?: boolean;
+    settings?: TypesTenantSettingDto[];
+    slug: string;
+    updated_at: string;
+}
+export interface TypesUpdateEndpointDto {
+    is_active?: boolean;
+    is_public?: boolean;
+    metadata?: TypesEndpointMetadataDto;
+    method: 'POST' | 'PUT' | 'DELETE' | 'GET' | 'PATCH' | 'ALL';
+    microservice_id: number;
+    required_permissions?: number[];
+    route: string;
+    type?: 'regular' | 'display_only';
+    updated_at: string;
+}
+export interface TypesUpdateFirmDto {
+    allow_b2c_email_notifications?: boolean;
+    firm_tags?: number[];
+    mailgun_creds?: TypesFirmMailgunCredsDto;
+    name: string;
+    slug: string;
+    status: 'in_progress' | 'active' | 'suspended' | 'deleted';
+    twilio_creds?: TypesFirmTwilioCredsDto;
+    updated_at: string;
+}
+export interface TypesUpdateIdentityProviderDto {
+    auth_url: string;
+    client_id: string;
+    client_secret: string;
+    company_domain: string;
+    firm_id: number;
+    priority: number;
+    redirect_url?: string;
+    type: 'okta';
+    updated_at: string;
+}
+export interface TypesUpdateMicroserviceDto {
+    domains?: TypesMicroserviceDomainDto[];
+    is_active?: boolean;
+    is_visible_on_admin_sidebar?: boolean;
+    logo_url?: string;
+    name: string;
+    slug: string;
+    updated_at: string;
+}
+export interface TypesUpdatePermissionDto {
+    assignment_group?: 'regular' | 'superadmin' | 'b2b_only';
+    metadata?: PgmodelsPermissionMetadata;
+    microservice_id?: number;
+    permission: string;
+    updated_at: string;
+}
+export interface TypesUpdateRoleDto {
+    name: string;
+    permissions: number[];
+    permissions_can_assign_role?: number[];
+    type_id: number;
+    updated_at: string;
+}
+export interface TypesUpdateRoleTypeDto {
+    color: string;
+    type: string;
+    updated_at: string;
+}
+export interface TypesUpdateTagDto {
+    name: string;
+    updated_at: string;
+}
+export interface TypesUpdateWatchmenInstanceDto {
+    name: string;
+    slug: string;
+    updated_at: string;
+    url: string;
+}
+export interface TypesUpsertTablePresetDto {
+    presets?: object;
+    table_name: string;
+}
+export interface TypesUpsertUserDto {
+    branches: number[];
+    email: string;
+    firms: number[];
+    first_name?: string;
+    initiator_id?: number;
+    last_name?: string;
+    permissions: number[];
+    phone?: string;
+    rep_code?: string;
+    roles: number[];
+    type: 'b2b' | 'b2c';
+}
+export interface TypesUpsertUsersDto {
+    users: TypesUpsertUserDto[];
+}
+export interface TypesUserSerializer {
+    allow_feedback: boolean;
+    big_avatar_url: string;
+    created_at: string;
+    do_not_ask_mfa_again: boolean;
+    email: string;
+    email_verified: boolean;
+    first_name: string;
+    id: number;
+    initiator_id: number;
+    last_name: string;
+    locale: TypesLocaleSerializer;
+    locale_id: number;
+    mfa_enabled: boolean;
+    phone: string;
+    phone_verified: boolean;
+    rep_code: string;
+    should_reset_password: boolean;
+    small_avatar_url: string;
+    updated_at: string;
+    username: string;
+}
+export interface TypesVerificationSettingsSerializer {
+    expires_in_minutes: number;
+}
+export interface TypesVerifyContactDto {
+    code: string;
+    code_type: 'email' | 'voice' | 'sms';
+    contact: string;
+}
+export interface TypesVerifyWatchmenAuthTokenDto {
+    tmp_token: string;
+}
+export interface TypesWatchmenAuthTokenDetailsSerializer {
+    expires_at: number;
+    is_valid: boolean;
+    token_id: string;
+    watchmen_instance_id: number;
+    watchmen_user_id: number;
+}
+export interface TypesWatchmenInstanceSerializer {
+    created_at: string;
+    id: number;
+    name: string;
+    slug: string;
+    updated_at: string;
+    url: string;
+}
+export interface TypesWebAuthnAssertionResponse {
+    authenticator_data?: string;
+    client_data_json?: string;
+    signature?: string;
+    user_handle?: string;
+}
+export interface TypesWebAuthnAttestationResponse {
+    attestation_object?: string;
+    client_data_json?: string;
+}
+export interface TypesWebAuthnAuthenticatorSelection {
+    authenticator_attachment?: string;
+    require_resident_key?: boolean;
+    resident_key?: string;
+    user_verification?: string;
+}
+export interface TypesWebAuthnCredentialAssertionSerializer {
+    public_key: TypesWebAuthnPublicKeyCredentialAssertionSerializer;
+}
+export interface TypesWebAuthnCredentialCreationSerializer {
+    public_key: TypesWebAuthnPublicKeyCredentialCreationSerializer;
+}
+export interface TypesWebAuthnCredentialDescriptor {
+    id?: string;
+    transports?: string[];
+    type?: string;
+}
+export interface TypesWebAuthnCredentialParameterSerializer {
+    alg: number;
+    type: string;
+}
+export interface TypesWebAuthnLoginSolutionDto {
+    client_extension_results?: object;
+    id?: string;
+    raw_id?: string;
+    response?: TypesWebAuthnAssertionResponse;
+    type?: string;
+}
+export interface TypesWebAuthnPublicKeyCredentialAssertionSerializer {
+    allow_credentials: TypesWebAuthnCredentialDescriptor[];
+    challenge: string;
+    extensions: object;
+    rp_id: string;
+    timeout: number;
+    user_verification: string;
+}
+export interface TypesWebAuthnPublicKeyCredentialCreationSerializer {
+    attestation: string;
+    authenticator_selection: TypesWebAuthnAuthenticatorSelection;
+    challenge: string;
+    exclude_credentials: TypesWebAuthnCredentialDescriptor[];
+    extensions: object;
+    pub_key_cred_params: TypesWebAuthnCredentialParameterSerializer[];
+    rp: TypesWebAuthnRelyingPartyEntitySerializer;
+    timeout: number;
+    user: TypesWebAuthnUserEntitySerializer;
+}
+export interface TypesWebAuthnRegistrationSolutionDto {
+    client_extension_results?: object;
+    id?: string;
+    name: string;
+    raw_id?: string;
+    response?: TypesWebAuthnAttestationResponse;
+    type?: string;
+}
+export interface TypesWebAuthnRelyingPartyEntitySerializer {
+    icon: string;
+    id: string;
+    name: string;
+}
+export interface TypesWebAuthnUserEntitySerializer {
+    display_name: string;
+    icon: string;
+    id: any;
+    name: string;
+}
+export interface UserdetailsGetUserDetailsSerializer {
+    b2b_user: TypesAdminUserSerializer;
+    b2c_user: TypesAdminB2CUserSerializer;
+    status: number;
+}
+export interface UserscommonGetUsersListSerializerTypesAdminB2BUserSerializer {
+    current_page: number;
+    pages_count: number;
+    status: number;
+    total_records: number;
+    users_list: TypesAdminB2BUserSerializer[];
+}
+export interface UserscommonGetUsersListSerializerTypesAdminB2CUserSerializer {
+    current_page: number;
+    pages_count: number;
+    status: number;
+    total_records: number;
+    users_list: TypesAdminB2CUserSerializer[];
+}
+export interface WatchmenauthTokenDetailsResponseSerializer {
+    data: TypesWatchmenAuthTokenDetailsSerializer;
+    status: number;
+}
+export interface WatchmenauthTokenGenerationResponseSerializer {
+    data: TypesGeneratedWatchmenTokenInfoSerializer;
+    status: number;
+}
+export interface WatchmeninstancesGetWatchmenInstancesListSerializer {
+    current_page: number;
+    pages_count: number;
+    status: number;
+    total_records: number;
+    watchmen_instances_list: TypesWatchmenInstanceSerializer[];
+}
+export interface WatchmeninstancesWatchmenInstanceMutationSerializer {
+    status: number;
+    watchmen_instance: TypesWatchmenInstanceSerializer;
+}
+export class ActionLogs<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    getActionLogs(getActionLogsDto: TypesGetActionLogsListDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<ActionlogsGetActionLogsSerializer, HandleError>>;
+}
+export class ApiKeys<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    deleteMany(deleteAPIKeys: TypesDeleteAPIKeysDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<ApikeysAPIKeysMutationSerializer, HandleError>>;
+    create(createApiKeys: TypesCreateAPIKeysDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<ApikeysAPIKeysMutationSerializer, HandleError>>;
+    get(apiKeys: TypesGetAPIKeysListDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<ApikeysGetAPIKeysSerializer, HandleError>>;
+    update(id: number, apiKeys: TypesUpdateAPIKeysDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<ApikeysAPIKeysMutationSerializer, HandleError>>;
+}
+export class AuthApps<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    get(config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<AuthappsGetAuthAppsListSerializer, HandleError>>;
+    deleteMany(deleteAuthAppsDto: TypesDeleteByIDsDtoInt64, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    getRegistrationQr(getTotpQRDto: TypesGetTotpQRDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<File, HandleError>>;
+    finishRegistration(finishTOTPRegistrationDto: TypesFinishTOTPRegistrationDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<AuthappsFinishTOTPRegistrationResponseSerializer, HandleError>>;
+    getLoginChallenge(getWebAuthnLoginChallengeDto: TypesGetWebAuthnLoginChallengeDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<TypesWebAuthnCredentialAssertionSerializer, HandleError>>;
+    getRegisterChallenge(config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<TypesWebAuthnCredentialCreationSerializer, HandleError>>;
+    finishCredentialRegistration(webAuthnRegistrationSolutionDto: TypesWebAuthnRegistrationSolutionDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    register(yubicoOTPDto: TypesCreateYubicoOTPDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    update(id: number, updateAuthAppDto: TypesUpdateAuthAppDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<AuthappsAuthAppResponseSerializer, HandleError>>;
+}
+export class AuthForms<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    create(authFormDto: TypesAuthFormDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<AuthformsAuthFormMutationSerializer, HandleError>>;
+    deleteMany(deleteAuthFormsDto: TypesDeleteByIDsDtoInt64, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    get(getAuthFormListDto: TypesGetAuthFormsListDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<AuthformsGetAuthFormsListSerializer, HandleError>>;
+    getBySlug(slug: string, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<AuthformsAuthFormMutationSerializer, HandleError>>;
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<AuthformsAuthFormMutationSerializer, HandleError>>;
+    update(id: number, authFormDto: TypesAuthFormDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<AuthformsAuthFormMutationSerializer, HandleError>>;
+}
+export class B2BAuth<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    getCurrent(config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<B2BauthGetCurrentB2BUserSerializer, HandleError>>;
+    apiKeysLogin(apiKeysLoginParams: TypesAPIKeysB2BLoginDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<B2BauthSimpleB2BLoginSerializer, HandleError>>;
+    basicLogin(basicLoginParams: TypesBasicB2BLoginDto, headers?: {
+        'Debug-Token'?: string;
+    }, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<B2BauthBasicB2BLoginSerializer, HandleError>>;
+    logout(B2BLogoutParams: TypesLogoutDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    refreshTokens(B2BRefreshParams: TypesRefreshDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<B2BauthBasicB2BLoginSerializer, HandleError>>;
+    resetPassword(B2BResetPasswordParams: TypesB2BResetPasswordDto, headers?: {
+        'Debug-Token'?: string;
+    }, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<B2BauthSimpleB2BLoginSerializer, HandleError>>;
+    sendMfaCode(SendB2BMfaCodeDto: TypesSendB2BMfaCodeDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    sendResetPasswordCode(B2BSendResetPasswordCodeParams: TypesSendResetPasswordCodeDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+}
+export class B2BUsers<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    deleteMany(deleteB2BUsers: TypesDeleteByIDsDtoInt64, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<B2BusersB2BUserSerializer, HandleError>>;
+    create(createB2BUser: TypesCreateB2BUserDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<B2BusersB2BUserSerializer, HandleError>>;
+    get(getB2BUsers: TypesGetB2BUsersListDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<UserscommonGetUsersListSerializerTypesAdminB2BUserSerializer, HandleError>>;
+    update(id: number, createB2BUserNew: TypesUpdateB2BUserDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<B2BusersB2BUserSerializer, HandleError>>;
+}
+export class B2BUserSettings<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    setUserSettings(setB2BUserSettings: TypesSetB2BUserSettingsDto, headers?: {
+        'Debug-Token'?: string;
+        BRANCH?: string;
+    }, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<B2BusersettingsB2BUserSettingsChangeSerializer, HandleError>>;
+    uploadAvatar(data: {
+        avatar?: File;
+        delete_avatar?: boolean;
+    }, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<B2BusersettingsB2BUploadAvatarResponseSerializer, HandleError>>;
+    sendContactChangeCode(b2bSendContactChangeCodeDto: TypesB2BSendContactChangeCodeDto, headers?: {
+        BRANCH?: string;
+    }, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+}
+export class B2CAuth<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    getCurrent(config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<B2CauthGetCurrentB2CUserSerializer, HandleError>>;
+    initAppleLogin(initOAuthLoginDto: TypesInitOAuthLoginDto, headers?: {
+        BRANCH?: string;
+        FIRM?: string;
+    }, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<TypesB2CInitOAuthResponse, HandleError>>;
+    finishAppleLogin(finishOAuthLoginDto: TypesFinishOAuthLoginDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<B2CauthB2CLoginResultSerializer, HandleError>>;
+    basicLogin(basicLoginParams: TypesBasicB2CLoginDto, headers?: {
+        BRANCH?: string;
+        FIRM?: string;
+    }, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<B2CauthB2CLoginResultSerializer, HandleError>>;
+    initGoogleLogin(initOAuthLoginDto: TypesInitOAuthLoginDto, headers?: {
+        BRANCH?: string;
+        FIRM?: string;
+    }, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<TypesB2CInitOAuthResponse, HandleError>>;
+    finishGoogleLogin(finishOAuthLoginDto: TypesFinishOAuthLoginDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<B2CauthB2CLoginResultSerializer, HandleError>>;
+    logout(B2CLogoutParams: TypesLogoutDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    refreshTokens(b2cRefreshDto: TypesB2CRefreshDto, headers?: {
+        Cookie?: string;
+    }, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<B2CauthRefreshResultSerializer, HandleError>>;
+    register(registrationParams: TypesRegisterDto, headers?: {
+        BRANCH?: string;
+        FIRM?: string;
+    }, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<B2CauthRegisterSerializer, HandleError>>;
+    resetPassword(B2CResetPasswordParams: TypesB2CResetPasswordDto, headers?: {
+        'Debug-Token'?: string;
+        BRANCH?: string;
+        FIRM?: string;
+    }, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    sendMfaCode(SendB2CMfaCodeDto: TypesSendB2CMfaCodeDto, headers?: {
+        BRANCH?: string;
+        FIRM?: string;
+    }, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    sendResetPasswordCode(B2CSendResetPasswordCodeParams: TypesSendB2CResetPasswordCodeDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    sendVerificationCode(B2CSendVerificationCodeDto: TypesB2CSendVerificationCodeDto, headers?: {
+        BRANCH?: string;
+        FIRM?: string;
+    }, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    verifyContact(VerifyContactDto: TypesVerifyContactDto, headers?: {
+        BRANCH?: string;
+        FIRM?: string;
+    }, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+}
+export class B2CUsers<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    create(createB2CUser: TypesCreateB2CUserDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<B2CusersB2CUserSerializer, HandleError>>;
+    deleteMany(deleteB2CUsers: TypesDeleteByIDsDtoInt64, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<B2CusersB2CUserSerializer, HandleError>>;
+    update(id: number, createB2BUser: TypesUpdateB2CUserDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<B2CusersB2CUserSerializer, HandleError>>;
+    get(getB2CUsers: TypesGetB2CUsersListDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<UserscommonGetUsersListSerializerTypesAdminB2CUserSerializer, HandleError>>;
+}
+export class B2CUserSettings<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    setUserSettings(setB2CUserSettings: TypesSetB2CUserSettingsDto, headers?: {
+        BRANCH?: string;
+    }, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<B2CusersettingsB2CUserSettingsChangeSerializer, HandleError>>;
+    sendContactChangeCode(b2cSendContactChangeCodeDto: TypesB2CSendContactChangeCodeDto, headers?: {
+        BRANCH?: string;
+    }, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    availableMfaOptions(headers?: {
+        BRANCH?: string;
+    }, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<B2CusersettingsAvailableB2CMfaOptionsResponse, HandleError>>;
+    deleteManyOAuthBindings(deleteByIDsDto: TypesDeleteByIDsDtoInt64, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    finishAppleProfileLinking(finishOAuthLoginDto: TypesFinishOAuthLoginDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    initAppleProfileLinking(initOAuthLinkingDto: TypesInitOAuthLinkingDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<TypesB2CInitOAuthResponse, HandleError>>;
+    finishGoogleProfileLinking(finishOAuthLoginDto: TypesFinishOAuthLoginDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    initGoogleProfileLinking(initOAuthLinkingDto: TypesInitOAuthLinkingDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<TypesB2CInitOAuthResponse, HandleError>>;
+    getOAuthBindings(getOAuth2BindingsListDto: TypesGetOAuth2BindingsListDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<TypesAuthProviderUserBindingsResponse, HandleError>>;
+}
+export class Branches<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    create(createBranch: TypesCreateBranchDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<BranchesBranchMutationSerializer, HandleError>>;
+    deleteMany(deleteBranches: TypesDeleteByIDsDtoInt, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    getById(id: string, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<BranchesBranchMutationSerializer, HandleError>>;
+    update(id: number, updateBranch: TypesUpdateBranchDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<BranchesBranchMutationSerializer, HandleError>>;
+    get(getBranches: TypesGetBranchesListDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<BranchesGetBranchesListSerializer, HandleError>>;
+}
+export class Countries<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    get(config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<CountriesGetCountriesSerializer, HandleError>>;
+}
+export class Endpoints<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    create(endpointDto: TypesCreateEndpointDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<EndpointsEndpointMutationSerializer, HandleError>>;
+    deleteMany(deleteEndpointsDto: TypesDeleteByIDsDtoInt, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<EndpointsEndpointMutationSerializer, HandleError>>;
+    update(id: number, endpointDto: TypesUpdateEndpointDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<EndpointsEndpointMutationSerializer, HandleError>>;
+    get(endpointDto: TypesGetEndpointsListDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<EndpointsGetEndpointsListSerializer, HandleError>>;
+}
+export class Firms<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    create(createFirm: TypesCreateFirmDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<FirmsFirmMutationSerializer, HandleError>>;
+    deleteMany(deleteFirms: TypesDeleteByIDsDtoInt, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    getById(id: string, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<FirmsFirmMutationSerializer, HandleError>>;
+    update(id: number, updateFirm: TypesUpdateFirmDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<FirmsFirmMutationSerializer, HandleError>>;
+    get(getFirms: TypesGetFirmsListDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<FirmsGetFirmsListSerializer, HandleError>>;
+}
+export class IdentityProviders<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    create(createIdentityProviderDto: TypesCreateIdentityProviderDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<IdentityprovidersIdentityProviderResponseSerializer, HandleError>>;
+    deleteMany(deleteIdentityProvidersDto: TypesDeleteByIDsDtoInt, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<IdentityprovidersIdentityProviderResponseSerializer, HandleError>>;
+    update(id: number, identityProvidersDto: TypesUpdateIdentityProviderDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<IdentityprovidersIdentityProviderResponseSerializer, HandleError>>;
+    get(identityProvidersDto: TypesGetIdentityProvidersListDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<IdentityprovidersGetIdentityProvidersListSerializer, HandleError>>;
+}
+export class Locales<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    get(config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<LocalesLocaleSerializer[], HandleError>>;
+}
+export class Microservices<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    create(microserviceDto: TypesCreateMicroserviceDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<MicroservicesMicroserviceMutationSerializer, HandleError>>;
+    deleteMany(deleteMicroservices: TypesDeleteByIDsDtoInt, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<MicroservicesMicroserviceMutationSerializer, HandleError>>;
+    update(id: number, microserviceDto: TypesUpdateMicroserviceDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<MicroservicesMicroserviceMutationSerializer, HandleError>>;
+    get(microserviceDto: TypesGetMicroservicesListDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<MicroservicesGetMicroservicesListSerializer, HandleError>>;
+}
+export class MigrationUtils<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    usersUpsertCreate(upsertUsers: TypesUpsertUsersDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<MigrationutilsUpsertUsersSerializer, HandleError>>;
+}
+export class Permissions<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    create(createPermission: TypesCreatePermissionDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<PermissionsPermissionMutationSerializer, HandleError>>;
+    deleteMany(deletePermissions: TypesDeleteByIDsDtoInt, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<PermissionsPermissionMutationSerializer, HandleError>>;
+    update(id: number, updatePermission: TypesUpdatePermissionDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<PermissionsPermissionMutationSerializer, HandleError>>;
+    get(getPermissions: TypesGetPermissionsListDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<PermissionsGetPermissionsListSerializer, HandleError>>;
+}
+export class PublicSettings<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    get(config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<PublicsettingsPublicSettingsResponseSerializer, HandleError>>;
+}
+export class Roles<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    create(createRole: TypesCreateRoleDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<RolesRoleMutationSerializer, HandleError>>;
+    deleteMany(deleteRoles: TypesDeleteByIDsDtoInt, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<RolesRoleMutationSerializer, HandleError>>;
+    update(id: number, updateRole: TypesUpdateRoleDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<RolesRoleMutationSerializer, HandleError>>;
+    get(getRoles: TypesGetRolesListDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<RolesGetRolesListSerializer, HandleError>>;
+}
+export class RoleTypes<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    create(createRoleType: TypesCreateRoleTypeDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<RoletypesRoleTypeResponseSerializer, HandleError>>;
+    deleteMany(deleteRoleTypes: TypesDeleteByIDsDtoInt, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<RoletypesRoleTypeResponseSerializer, HandleError>>;
+    update(id: number, updateRoleType: TypesUpdateRoleTypeDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<RoletypesRoleTypeResponseSerializer, HandleError>>;
+    get(getRoleTypes: TypesGetRoleTypesListDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<RoletypesGetRoleTypesListSerializer, HandleError>>;
+}
+export class SecretNotes<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    create(createSecretNote: TypesCreateSecretNoteDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<SecretnotesSecretNoteCreationSuccessSerializer, HandleError>>;
+    getOne(getSecretNote: TypesGetSecretNoteDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<SecretnotesSingleSecretNoteSerializer, HandleError>>;
+    sendVerificationCode(sendVerificationCodeForSecretNote: TypesSendVerificationCodeForSecretNoteDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+}
+export class Sessions<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    getCurrentUserSessions(config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<SessionsGetSessionsListSerializer, HandleError>>;
+    deleteCurrentUserSessions(deleteSessions: TypesDeleteSessionsDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+}
+export class TablePresets<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    getUserPresets(config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<TablepresetsTablePresetsListResponseSerializer, HandleError>>;
+    upsert(upsertTablePreset: TypesUpsertTablePresetDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<TablepresetsTablePresetResponseSerializer, HandleError>>;
+}
+export class Tags<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    create(createTagDto: TypesCreateTagDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<TagsTagMutationSerializer, HandleError>>;
+    deleteMany(deleteByIDsDto: TypesDeleteByIDsDtoInt64, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    get(getTagsDto: TypesGetTagsDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<TagsGetTagsListSerializer, HandleError>>;
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<TagsTagMutationSerializer, HandleError>>;
+    update(id: number, updateTagDto: TypesUpdateTagDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<TagsTagMutationSerializer, HandleError>>;
+}
+export class UserDetails<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    getUserDetails(getUserDetailsDto: TypesGetUserDetailsDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<UserdetailsGetUserDetailsSerializer, HandleError>>;
+    revokeSessions(revokeUserSessionsDto: TypesRevokeUserSessionsDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+}
+export class UsersCommon<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    linkWatchmenUsersToUma(linkWatchmenUserToUmaDto: TypesLinkWatchmenUserToUmaDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+}
+export class WatchmenAuth<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    generateWatchmenAuthToken(config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<WatchmenauthTokenGenerationResponseSerializer, HandleError>>;
+    verifyWatchmenAuthToken(verifyWatchmenAuthToken: TypesVerifyWatchmenAuthTokenDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<WatchmenauthTokenDetailsResponseSerializer, HandleError>>;
+}
+export class WatchmenInstances<HandleError extends boolean = boolean> {
+    protected readonly apiClient: JwtClient<HandleError>;
+    constructor(apiClient: JwtClient<HandleError>);
+    create(createWatchmenInstance: TypesCreateWatchmenInstanceDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<WatchmeninstancesWatchmenInstanceMutationSerializer, HandleError>>;
+    deleteMany(deleteWatchmenInstances: TypesDeleteByIDsDtoInt64, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<void, HandleError>>;
+    getMany(getWatchmenInstances: TypesGetWatchmenInstancesDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<WatchmeninstancesGetWatchmenInstancesListSerializer, HandleError>>;
+    getById(id: number, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<WatchmeninstancesWatchmenInstanceMutationSerializer, HandleError>>;
+    update(id: number, updateWatchmenInstance: TypesUpdateWatchmenInstanceDto, config?: RequestConfig<HandleError>): Promise<import("BaseClient").ClientResponse<WatchmeninstancesWatchmenInstanceMutationSerializer, HandleError>>;
+}
+declare class _B2BAuth1<HandleError extends boolean = boolean> extends B2BAuth<HandleError> {
+    basicLogin(basicLoginParams: TypesBasicB2BLoginDto, headers?: {
+        'Debug-Token'?: string;
+    }, config?: RequestConfig<HandleError> | undefined): Promise<ClientResponse<B2BauthBasicB2BLoginSerializer, HandleError>>;
+}
+declare class _B2CAuth1<HandleError extends boolean = boolean> extends B2CAuth<HandleError> {
+    basicLogin(basicLoginParams: TypesBasicB2CLoginDto, headers?: {
+        BRANCH?: string;
+        FIRM?: string;
+    }, config?: RequestConfig<HandleError> | undefined): Promise<ClientResponse<B2CauthB2CLoginResultSerializer, HandleError>>;
+}
+export interface UmaClientConfig<HandleError extends boolean = boolean> extends JwtClientConfig<HandleError> {
+    firmId: string;
+    authFormSlug: string;
+}
+export class UmaApi<HandleError extends boolean = boolean> 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