@authsome/client 0.0.1

package/dist/client.d.ts

@@ -0,0 +1,91 @@
+import { ClientPlugin } from './plugin';
+import * as types from './types';
+/**
+ * AuthSome client configuration
+ * Supports multiple authentication methods that can be used simultaneously:
+ * - Cookies: Automatically sent with every request (session-based auth)
+ * - Bearer Token: JWT tokens sent in Authorization header when auth: true
+ * - API Key: Sent with every request for server-to-server auth
+ *   - Publishable Key (pk_*): Safe for frontend, limited permissions
+ *   - Secret Key (sk_*): Backend only, full admin access
+ */
+export interface AuthsomeClientConfig {
+    /** Base URL of the AuthSome API */
+    baseURL: string;
+    /** Plugin instances to initialize */
+    plugins?: ClientPlugin[];
+    /** JWT/Bearer token for user authentication (sent only when auth: true) */
+    token?: string;
+    /** API key for server-to-server auth (pk_* or sk_*, sent with all requests) */
+    apiKey?: string;
+    /** Custom header name for API key (default: 'X-API-Key') */
+    apiKeyHeader?: string;
+    /** Custom headers to include with all requests */
+    headers?: Record<string, string>;
+}
+export declare class AuthsomeClient {
+    private baseURL;
+    private token?;
+    private apiKey?;
+    private apiKeyHeader;
+    private headers;
+    private plugins;
+    constructor(config: AuthsomeClientConfig);
+    setToken(token: string): void;
+    setApiKey(apiKey: string, header?: string): void;
+    /**
+     * Set a publishable key (pk_*) - safe for frontend use
+     * Publishable keys have limited permissions and can be exposed in client-side code
+     * Typically used for: session creation, user verification, public data reads
+     */
+    setPublishableKey(publishableKey: string): void;
+    /**
+     * Set a secret key (sk_*) - MUST be kept secret on server-side only!
+     * Secret keys have full administrative access to all operations
+     * WARNING: Never expose secret keys in client-side code (browser, mobile apps)
+     */
+    setSecretKey(secretKey: string): void;
+    getPlugin<T extends ClientPlugin>(id: string): T | undefined;
+    request<T>(method: string, path: string, options?: {
+        body?: any;
+        query?: Record<string, string>;
+        auth?: boolean;
+    }): Promise<T>;
+    signUp(request: {
+        email: string;
+        password: string;
+        name?: string;
+    }): Promise<{
+        user: types.User;
+        session: types.Session;
+    }>;
+    signIn(request: {
+        email: string;
+        password: string;
+    }): Promise<{
+        session: types.Session;
+        requiresTwoFactor: boolean;
+        user: types.User;
+    }>;
+    signOut(): Promise<{
+        success: boolean;
+    }>;
+    getSession(): Promise<{
+        session: types.Session;
+        user: types.User;
+    }>;
+    updateUser(request: {
+        name?: string;
+        email?: string;
+    }): Promise<{
+        user: types.User;
+    }>;
+    listDevices(): Promise<{
+        devices: types.Device[];
+    }>;
+    revokeDevice(request: {
+        deviceId: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/client.js

@@ -0,0 +1,129 @@
+"use strict";
+// Auto-generated AuthSome client
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthsomeClient = void 0;
+const errors_1 = require("./errors");
+class AuthsomeClient {
+    constructor(config) {
+        this.baseURL = config.baseURL;
+        this.token = config.token;
+        this.apiKey = config.apiKey;
+        this.apiKeyHeader = config.apiKeyHeader || 'X-API-Key';
+        this.headers = config.headers || {};
+        this.plugins = new Map();
+        if (config.plugins) {
+            for (const plugin of config.plugins) {
+                this.plugins.set(plugin.id, plugin);
+                plugin.init(this);
+            }
+        }
+    }
+    setToken(token) {
+        this.token = token;
+    }
+    setApiKey(apiKey, header) {
+        this.apiKey = apiKey;
+        if (header) {
+            this.apiKeyHeader = header;
+        }
+    }
+    /**
+     * Set a publishable key (pk_*) - safe for frontend use
+     * Publishable keys have limited permissions and can be exposed in client-side code
+     * Typically used for: session creation, user verification, public data reads
+     */
+    setPublishableKey(publishableKey) {
+        if (!publishableKey.startsWith('pk_')) {
+            console.warn('Warning: Publishable keys should start with pk_');
+        }
+        this.setApiKey(publishableKey);
+    }
+    /**
+     * Set a secret key (sk_*) - MUST be kept secret on server-side only!
+     * Secret keys have full administrative access to all operations
+     * WARNING: Never expose secret keys in client-side code (browser, mobile apps)
+     */
+    setSecretKey(secretKey) {
+        if (!secretKey.startsWith('sk_')) {
+            console.warn('Warning: Secret keys should start with sk_');
+        }
+        this.setApiKey(secretKey);
+    }
+    getPlugin(id) {
+        return this.plugins.get(id);
+    }
+    async request(method, path, options) {
+        const url = new URL(path, this.baseURL);
+        if (options?.query) {
+            for (const [key, value] of Object.entries(options.query)) {
+                url.searchParams.append(key, value);
+            }
+        }
+        const headers = {
+            'Content-Type': 'application/json',
+            ...this.headers,
+        };
+        if (options?.auth && this.token) {
+            headers['Authorization'] = `Bearer ${this.token}`;
+        }
+        if (this.apiKey) {
+            headers[this.apiKeyHeader] = this.apiKey;
+        }
+        const response = await fetch(url.toString(), {
+            method,
+            headers,
+            body: options?.body ? JSON.stringify(options.body) : undefined,
+            credentials: 'include',
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: response.statusText }));
+            throw (0, errors_1.createErrorFromResponse)(response.status, error.error || error.message || 'Request failed');
+        }
+        return response.json();
+    }
+    async signUp(request) {
+        const path = '/api/auth/signup';
+        return this.request('POST', path, {
+            body: request,
+        });
+    }
+    async signIn(request) {
+        const path = '/api/auth/signin';
+        return this.request('POST', path, {
+            body: request,
+        });
+    }
+    async signOut() {
+        const path = '/api/auth/signout';
+        return this.request('POST', path, {
+            auth: true,
+        });
+    }
+    async getSession() {
+        const path = '/api/auth/session';
+        return this.request('GET', path, {
+            auth: true,
+        });
+    }
+    async updateUser(request) {
+        const path = '/api/auth/user/update';
+        return this.request('POST', path, {
+            body: request,
+            auth: true,
+        });
+    }
+    async listDevices() {
+        const path = '/api/auth/devices';
+        return this.request('GET', path, {
+            auth: true,
+        });
+    }
+    async revokeDevice(request) {
+        const path = '/api/auth/devices/revoke';
+        return this.request('POST', path, {
+            body: request,
+            auth: true,
+        });
+    }
+}
+exports.AuthsomeClient = AuthsomeClient;

package/dist/errors.d.ts

@@ -0,0 +1,31 @@
+export declare class AuthsomeError extends Error {
+    statusCode: number;
+    code?: string | undefined;
+    constructor(message: string, statusCode: number, code?: string | undefined);
+}
+export declare class NetworkError extends AuthsomeError {
+    constructor(message: string);
+}
+export declare class ValidationError extends AuthsomeError {
+    fields?: Record<string, string> | undefined;
+    constructor(message: string, fields?: Record<string, string> | undefined);
+}
+export declare class UnauthorizedError extends AuthsomeError {
+    constructor(message?: string);
+}
+export declare class ForbiddenError extends AuthsomeError {
+    constructor(message?: string);
+}
+export declare class NotFoundError extends AuthsomeError {
+    constructor(message?: string);
+}
+export declare class ConflictError extends AuthsomeError {
+    constructor(message: string);
+}
+export declare class RateLimitError extends AuthsomeError {
+    constructor(message?: string);
+}
+export declare class ServerError extends AuthsomeError {
+    constructor(message?: string);
+}
+export declare function createErrorFromResponse(statusCode: number, message: string): AuthsomeError;

package/dist/errors.js

@@ -0,0 +1,94 @@
+"use strict";
+// Auto-generated error classes
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerError = exports.RateLimitError = exports.ConflictError = exports.NotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.ValidationError = exports.NetworkError = exports.AuthsomeError = void 0;
+exports.createErrorFromResponse = createErrorFromResponse;
+class AuthsomeError extends Error {
+    constructor(message, statusCode, code) {
+        super(message);
+        this.statusCode = statusCode;
+        this.code = code;
+        this.name = 'AuthsomeError';
+    }
+}
+exports.AuthsomeError = AuthsomeError;
+class NetworkError extends AuthsomeError {
+    constructor(message) {
+        super(message, 0, 'NETWORK_ERROR');
+        this.name = 'NetworkError';
+    }
+}
+exports.NetworkError = NetworkError;
+class ValidationError extends AuthsomeError {
+    constructor(message, fields) {
+        super(message, 400, 'VALIDATION_ERROR');
+        this.fields = fields;
+        this.name = 'ValidationError';
+    }
+}
+exports.ValidationError = ValidationError;
+class UnauthorizedError extends AuthsomeError {
+    constructor(message = 'Unauthorized') {
+        super(message, 401, 'UNAUTHORIZED');
+        this.name = 'UnauthorizedError';
+    }
+}
+exports.UnauthorizedError = UnauthorizedError;
+class ForbiddenError extends AuthsomeError {
+    constructor(message = 'Forbidden') {
+        super(message, 403, 'FORBIDDEN');
+        this.name = 'ForbiddenError';
+    }
+}
+exports.ForbiddenError = ForbiddenError;
+class NotFoundError extends AuthsomeError {
+    constructor(message = 'Not found') {
+        super(message, 404, 'NOT_FOUND');
+        this.name = 'NotFoundError';
+    }
+}
+exports.NotFoundError = NotFoundError;
+class ConflictError extends AuthsomeError {
+    constructor(message) {
+        super(message, 409, 'CONFLICT');
+        this.name = 'ConflictError';
+    }
+}
+exports.ConflictError = ConflictError;
+class RateLimitError extends AuthsomeError {
+    constructor(message = 'Rate limit exceeded') {
+        super(message, 429, 'RATE_LIMIT_EXCEEDED');
+        this.name = 'RateLimitError';
+    }
+}
+exports.RateLimitError = RateLimitError;
+class ServerError extends AuthsomeError {
+    constructor(message = 'Internal server error') {
+        super(message, 500, 'SERVER_ERROR');
+        this.name = 'ServerError';
+    }
+}
+exports.ServerError = ServerError;
+function createErrorFromResponse(statusCode, message) {
+    switch (statusCode) {
+        case 400:
+            return new ValidationError(message);
+        case 401:
+            return new UnauthorizedError(message);
+        case 403:
+            return new ForbiddenError(message);
+        case 404:
+            return new NotFoundError(message);
+        case 409:
+            return new ConflictError(message);
+        case 429:
+            return new RateLimitError(message);
+        case 500:
+        case 502:
+        case 503:
+        case 504:
+            return new ServerError(message);
+        default:
+            return new AuthsomeError(message, statusCode);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+export { AuthsomeClient, AuthsomeClientConfig } from './client';
+export { ClientPlugin } from './plugin';
+export * from './types';
+export * from './errors';
+export * from './plugins/consent';
+export * from './plugins/idverification';
+export * from './plugins/stepup';
+export * from './plugins/organization';
+export * from './plugins/social';
+export * from './plugins/sso';
+export * from './plugins/backupauth';
+export * from './plugins/multiapp';
+export * from './plugins/twofa';
+export * from './plugins/username';
+export * from './plugins/webhook';
+export * from './plugins/apikey';
+export * from './plugins/impersonation';
+export * from './plugins/jwt';
+export * from './plugins/magiclink';
+export * from './plugins/multisession';
+export * from './plugins/notification';
+export * from './plugins/passkey';
+export * from './plugins/phone';
+export * from './plugins/emailotp';
+export * from './plugins/compliance';
+export * from './plugins/mfa';
+export * from './plugins/oidcprovider';
+export * from './plugins/admin';
+export * from './plugins/anonymous';

package/dist/index.js

@@ -0,0 +1,47 @@
+"use strict";
+// Auto-generated exports
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthsomeClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "AuthsomeClient", { enumerable: true, get: function () { return client_1.AuthsomeClient; } });
+__exportStar(require("./types"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./plugins/consent"), exports);
+__exportStar(require("./plugins/idverification"), exports);
+__exportStar(require("./plugins/stepup"), exports);
+__exportStar(require("./plugins/organization"), exports);
+__exportStar(require("./plugins/social"), exports);
+__exportStar(require("./plugins/sso"), exports);
+__exportStar(require("./plugins/backupauth"), exports);
+__exportStar(require("./plugins/multiapp"), exports);
+__exportStar(require("./plugins/twofa"), exports);
+__exportStar(require("./plugins/username"), exports);
+__exportStar(require("./plugins/webhook"), exports);
+__exportStar(require("./plugins/apikey"), exports);
+__exportStar(require("./plugins/impersonation"), exports);
+__exportStar(require("./plugins/jwt"), exports);
+__exportStar(require("./plugins/magiclink"), exports);
+__exportStar(require("./plugins/multisession"), exports);
+__exportStar(require("./plugins/notification"), exports);
+__exportStar(require("./plugins/passkey"), exports);
+__exportStar(require("./plugins/phone"), exports);
+__exportStar(require("./plugins/emailotp"), exports);
+__exportStar(require("./plugins/compliance"), exports);
+__exportStar(require("./plugins/mfa"), exports);
+__exportStar(require("./plugins/oidcprovider"), exports);
+__exportStar(require("./plugins/admin"), exports);
+__exportStar(require("./plugins/anonymous"), exports);

package/dist/plugin.d.ts

@@ -0,0 +1,6 @@
+import { AuthsomeClient } from './client';
+export interface ClientPlugin {
+    readonly id: string;
+    init(client: AuthsomeClient): void;
+    validate?(): Promise<boolean>;
+}

package/dist/plugin.js

@@ -0,0 +1,3 @@
+"use strict";
+// Auto-generated plugin interface
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/plugins/admin.d.ts

@@ -0,0 +1,20 @@
+import { ClientPlugin } from '../plugin';
+import { AuthsomeClient } from '../client';
+import * as types from '../types';
+export declare class AdminPlugin implements ClientPlugin {
+    readonly id = "admin";
+    private client;
+    init(client: AuthsomeClient): void;
+    createUser(request: types.CreateUser_reqBody): Promise<void>;
+    listUsers(): Promise<void>;
+    deleteUser(): Promise<types.MessageResponse>;
+    banUser(request: types.BanUser_reqBody): Promise<types.MessageResponse>;
+    unbanUser(request: types.UnbanUser_reqBody): Promise<types.MessageResponse>;
+    impersonateUser(request: types.ImpersonateUser_reqBody): Promise<void>;
+    setUserRole(request: types.SetUserRole_reqBody): Promise<types.MessageResponse>;
+    listSessions(): Promise<void>;
+    revokeSession(): Promise<types.MessageResponse>;
+    getStats(): Promise<void>;
+    getAuditLogs(): Promise<void>;
+}
+export declare function adminClient(): AdminPlugin;

package/dist/plugins/admin.js

@@ -0,0 +1,71 @@
+"use strict";
+// Auto-generated admin plugin
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminPlugin = void 0;
+exports.adminClient = adminClient;
+class AdminPlugin {
+    constructor() {
+        this.id = 'admin';
+    }
+    init(client) {
+        this.client = client;
+    }
+    async createUser(request) {
+        const path = '/users';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async listUsers() {
+        const path = '/users';
+        return this.client.request('GET', path);
+    }
+    async deleteUser() {
+        const path = '/users/:id';
+        return this.client.request('DELETE', path);
+    }
+    async banUser(request) {
+        const path = '/users/:id/ban';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async unbanUser(request) {
+        const path = '/users/:id/unban';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async impersonateUser(request) {
+        const path = '/users/:id/impersonate';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async setUserRole(request) {
+        const path = '/users/:id/role';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async listSessions() {
+        const path = '/sessions';
+        return this.client.request('GET', path);
+    }
+    async revokeSession() {
+        const path = '/sessions/:id';
+        return this.client.request('DELETE', path);
+    }
+    async getStats() {
+        const path = '/stats';
+        return this.client.request('GET', path);
+    }
+    async getAuditLogs() {
+        const path = '/audit-logs';
+        return this.client.request('GET', path);
+    }
+}
+exports.AdminPlugin = AdminPlugin;
+function adminClient() {
+    return new AdminPlugin();
+}

package/dist/plugins/anonymous.d.ts

@@ -0,0 +1,11 @@
+import { ClientPlugin } from '../plugin';
+import { AuthsomeClient } from '../client';
+import * as types from '../types';
+export declare class AnonymousPlugin implements ClientPlugin {
+    readonly id = "anonymous";
+    private client;
+    init(client: AuthsomeClient): void;
+    signIn(): Promise<types.SignInResponse>;
+    link(request: types.LinkRequest): Promise<types.LinkResponse>;
+}
+export declare function anonymousClient(): AnonymousPlugin;

package/dist/plugins/anonymous.js

@@ -0,0 +1,27 @@
+"use strict";
+// Auto-generated anonymous plugin
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnonymousPlugin = void 0;
+exports.anonymousClient = anonymousClient;
+class AnonymousPlugin {
+    constructor() {
+        this.id = 'anonymous';
+    }
+    init(client) {
+        this.client = client;
+    }
+    async signIn() {
+        const path = '/anonymous/signin';
+        return this.client.request('POST', path);
+    }
+    async link(request) {
+        const path = '/anonymous/link';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+}
+exports.AnonymousPlugin = AnonymousPlugin;
+function anonymousClient() {
+    return new AnonymousPlugin();
+}

package/dist/plugins/apikey.d.ts

@@ -0,0 +1,16 @@
+import { ClientPlugin } from '../plugin';
+import { AuthsomeClient } from '../client';
+import * as types from '../types';
+export declare class ApikeyPlugin implements ClientPlugin {
+    readonly id = "apikey";
+    private client;
+    init(client: AuthsomeClient): void;
+    createAPIKey(request: types.CreateAPIKey_reqBody): Promise<types.CreateAPIKeyResponse>;
+    listAPIKeys(): Promise<void>;
+    getAPIKey(): Promise<void>;
+    updateAPIKey(): Promise<void>;
+    deleteAPIKey(): Promise<types.MessageResponse>;
+    rotateAPIKey(): Promise<types.RotateAPIKeyResponse>;
+    verifyAPIKey(): Promise<void>;
+}
+export declare function apikeyClient(): ApikeyPlugin;

package/dist/plugins/apikey.js

@@ -0,0 +1,47 @@
+"use strict";
+// Auto-generated apikey plugin
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApikeyPlugin = void 0;
+exports.apikeyClient = apikeyClient;
+class ApikeyPlugin {
+    constructor() {
+        this.id = 'apikey';
+    }
+    init(client) {
+        this.client = client;
+    }
+    async createAPIKey(request) {
+        const path = '/createapikey';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async listAPIKeys() {
+        const path = '/listapikeys';
+        return this.client.request('GET', path);
+    }
+    async getAPIKey() {
+        const path = '/:id';
+        return this.client.request('GET', path);
+    }
+    async updateAPIKey() {
+        const path = '/:id';
+        return this.client.request('PUT', path);
+    }
+    async deleteAPIKey() {
+        const path = '/:id';
+        return this.client.request('DELETE', path);
+    }
+    async rotateAPIKey() {
+        const path = '/:id/rotate';
+        return this.client.request('POST', path);
+    }
+    async verifyAPIKey() {
+        const path = '/verify';
+        return this.client.request('POST', path);
+    }
+}
+exports.ApikeyPlugin = ApikeyPlugin;
+function apikeyClient() {
+    return new ApikeyPlugin();
+}

package/dist/plugins/backupauth.d.ts

@@ -0,0 +1,38 @@
+import { ClientPlugin } from '../plugin';
+import { AuthsomeClient } from '../client';
+import * as types from '../types';
+export declare class BackupauthPlugin implements ClientPlugin {
+    readonly id = "backupauth";
+    private client;
+    init(client: AuthsomeClient): void;
+    startRecovery(request: types.StartRecoveryRequest): Promise<types.ErrorResponse>;
+    continueRecovery(request: types.ContinueRecoveryRequest): Promise<types.ErrorResponse>;
+    completeRecovery(request: types.CompleteRecoveryRequest): Promise<types.ErrorResponse>;
+    cancelRecovery(request: types.CancelRecoveryRequest): Promise<types.SuccessResponse>;
+    generateRecoveryCodes(request: types.GenerateRecoveryCodesRequest): Promise<types.ErrorResponse>;
+    verifyRecoveryCode(request: types.VerifyRecoveryCodeRequest): Promise<types.ErrorResponse>;
+    setupSecurityQuestions(request: types.SetupSecurityQuestionsRequest): Promise<types.ErrorResponse>;
+    getSecurityQuestions(request: types.GetSecurityQuestionsRequest): Promise<types.ErrorResponse>;
+    verifySecurityAnswers(request: types.VerifySecurityAnswersRequest): Promise<types.ErrorResponse>;
+    addTrustedContact(request: types.AddTrustedContactRequest): Promise<types.ErrorResponse>;
+    listTrustedContacts(): Promise<types.ErrorResponse>;
+    verifyTrustedContact(request: types.VerifyTrustedContactRequest): Promise<types.ErrorResponse>;
+    requestTrustedContactVerification(request: types.RequestTrustedContactVerificationRequest): Promise<types.ErrorResponse>;
+    removeTrustedContact(): Promise<types.SuccessResponse>;
+    sendVerificationCode(request: types.SendVerificationCodeRequest): Promise<types.ErrorResponse>;
+    verifyCode(request: types.VerifyCodeRequest): Promise<types.ErrorResponse>;
+    scheduleVideoSession(request: types.ScheduleVideoSessionRequest): Promise<types.ErrorResponse>;
+    startVideoSession(request: types.StartVideoSessionRequest): Promise<types.ErrorResponse>;
+    completeVideoSession(request: types.CompleteVideoSessionRequest): Promise<types.ErrorResponse>;
+    uploadDocument(request: types.UploadDocumentRequest): Promise<types.ErrorResponse>;
+    getDocumentVerification(): Promise<types.ErrorResponse>;
+    reviewDocument(request: types.ReviewDocumentRequest): Promise<types.SuccessResponse>;
+    listRecoverySessions(): Promise<void>;
+    approveRecovery(request: types.ApproveRecoveryRequest): Promise<types.ErrorResponse>;
+    rejectRecovery(request: types.RejectRecoveryRequest): Promise<types.ErrorResponse>;
+    getRecoveryStats(): Promise<void>;
+    getRecoveryConfig(): Promise<void>;
+    updateRecoveryConfig(request: types.UpdateRecoveryConfigRequest): Promise<types.SuccessResponse>;
+    healthCheck(): Promise<void>;
+}
+export declare function backupauthClient(): BackupauthPlugin;