@authsome/client 0.0.1

package/dist/plugins/organization.js

@@ -0,0 +1,81 @@
+"use strict";
+// Auto-generated organization plugin
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrganizationPlugin = void 0;
+exports.organizationClient = organizationClient;
+class OrganizationPlugin {
+    constructor() {
+        this.id = 'organization';
+    }
+    init(client) {
+        this.client = client;
+    }
+    async createOrganization() {
+        const path = '/createorganization';
+        return this.client.request('POST', path);
+    }
+    async updateOrganization() {
+        const path = '/:id';
+        return this.client.request('PATCH', path);
+    }
+    async deleteOrganization() {
+        const path = '/:id';
+        return this.client.request('DELETE', path);
+    }
+    async inviteMember() {
+        const path = '/invite';
+        return this.client.request('POST', path);
+    }
+    async removeMember() {
+        const path = '/:memberId';
+        return this.client.request('DELETE', path);
+    }
+    async createTeam() {
+        const path = '/createteam';
+        return this.client.request('POST', path);
+    }
+    async updateTeam() {
+        const path = '/:teamId';
+        return this.client.request('PATCH', path);
+    }
+    async deleteTeam() {
+        const path = '/:teamId';
+        return this.client.request('DELETE', path);
+    }
+    async getOrganization() {
+        const path = '/:id';
+        return this.client.request('GET', path);
+    }
+    async listOrganizations() {
+        const path = '/listorganizations';
+        return this.client.request('GET', path);
+    }
+    async getOrganizationBySlug() {
+        const path = '/slug/:slug';
+        return this.client.request('GET', path);
+    }
+    async listMembers() {
+        const path = '/listmembers';
+        return this.client.request('GET', path);
+    }
+    async updateMember() {
+        const path = '/:memberId';
+        return this.client.request('PATCH', path);
+    }
+    async acceptInvitation() {
+        const path = '/:token/accept';
+        return this.client.request('POST', path);
+    }
+    async declineInvitation() {
+        const path = '/:token/decline';
+        return this.client.request('POST', path);
+    }
+    async listTeams() {
+        const path = '/listteams';
+        return this.client.request('GET', path);
+    }
+}
+exports.OrganizationPlugin = OrganizationPlugin;
+function organizationClient() {
+    return new OrganizationPlugin();
+}

package/dist/plugins/passkey.d.ts

@@ -0,0 +1,16 @@
+import { ClientPlugin } from '../plugin';
+import { AuthsomeClient } from '../client';
+import * as types from '../types';
+export declare class PasskeyPlugin implements ClientPlugin {
+    readonly id = "passkey";
+    private client;
+    init(client: AuthsomeClient): void;
+    beginRegister(): Promise<void>;
+    finishRegister(): Promise<void>;
+    beginLogin(): Promise<void>;
+    finishLogin(): Promise<void>;
+    list(): Promise<void>;
+    update(): Promise<void>;
+    delete(): Promise<types.StatusResponse>;
+}
+export declare function passkeyClient(): PasskeyPlugin;

package/dist/plugins/passkey.js

@@ -0,0 +1,45 @@
+"use strict";
+// Auto-generated passkey plugin
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PasskeyPlugin = void 0;
+exports.passkeyClient = passkeyClient;
+class PasskeyPlugin {
+    constructor() {
+        this.id = 'passkey';
+    }
+    init(client) {
+        this.client = client;
+    }
+    async beginRegister() {
+        const path = '/register/begin';
+        return this.client.request('POST', path);
+    }
+    async finishRegister() {
+        const path = '/register/finish';
+        return this.client.request('POST', path);
+    }
+    async beginLogin() {
+        const path = '/login/begin';
+        return this.client.request('POST', path);
+    }
+    async finishLogin() {
+        const path = '/login/finish';
+        return this.client.request('POST', path);
+    }
+    async list() {
+        const path = '/list';
+        return this.client.request('GET', path);
+    }
+    async update() {
+        const path = '/:id';
+        return this.client.request('PUT', path);
+    }
+    async delete() {
+        const path = '/:id';
+        return this.client.request('DELETE', path);
+    }
+}
+exports.PasskeyPlugin = PasskeyPlugin;
+function passkeyClient() {
+    return new PasskeyPlugin();
+}

package/dist/plugins/phone.d.ts

@@ -0,0 +1,12 @@
+import { ClientPlugin } from '../plugin';
+import { AuthsomeClient } from '../client';
+import * as types from '../types';
+export declare class PhonePlugin implements ClientPlugin {
+    readonly id = "phone";
+    private client;
+    init(client: AuthsomeClient): void;
+    sendCode(request: types.SendCodeRequest): Promise<void>;
+    verify(request: types.VerifyRequest): Promise<types.PhoneVerifyResponse>;
+    signIn(request: types.VerifyRequest): Promise<types.PhoneVerifyResponse>;
+}
+export declare function phoneClient(): PhonePlugin;

package/dist/plugins/phone.js

@@ -0,0 +1,35 @@
+"use strict";
+// Auto-generated phone plugin
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhonePlugin = void 0;
+exports.phoneClient = phoneClient;
+class PhonePlugin {
+    constructor() {
+        this.id = 'phone';
+    }
+    init(client) {
+        this.client = client;
+    }
+    async sendCode(request) {
+        const path = '/phone/send-code';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async verify(request) {
+        const path = '/phone/verify';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async signIn(request) {
+        const path = '/phone/signin';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+}
+exports.PhonePlugin = PhonePlugin;
+function phoneClient() {
+    return new PhonePlugin();
+}

package/dist/plugins/social.d.ts

@@ -0,0 +1,14 @@
+import { ClientPlugin } from '../plugin';
+import { AuthsomeClient } from '../client';
+import * as types from '../types';
+export declare class SocialPlugin implements ClientPlugin {
+    readonly id = "social";
+    private client;
+    init(client: AuthsomeClient): void;
+    signIn(request: types.SignInRequest): Promise<types.AuthURLResponse>;
+    callback(): Promise<types.CallbackDataResponse>;
+    linkAccount(request: types.LinkAccountRequest): Promise<types.AuthURLResponse>;
+    unlinkAccount(): Promise<types.MessageResponse>;
+    listProviders(): Promise<types.ProvidersResponse>;
+}
+export declare function socialClient(): SocialPlugin;

package/dist/plugins/social.js

@@ -0,0 +1,41 @@
+"use strict";
+// Auto-generated social plugin
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocialPlugin = void 0;
+exports.socialClient = socialClient;
+class SocialPlugin {
+    constructor() {
+        this.id = 'social';
+    }
+    init(client) {
+        this.client = client;
+    }
+    async signIn(request) {
+        const path = '/signin/social';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async callback() {
+        const path = '/callback/:provider';
+        return this.client.request('GET', path);
+    }
+    async linkAccount(request) {
+        const path = '/account/link';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async unlinkAccount() {
+        const path = '/account/unlink/:provider';
+        return this.client.request('DELETE', path);
+    }
+    async listProviders() {
+        const path = '/providers';
+        return this.client.request('GET', path);
+    }
+}
+exports.SocialPlugin = SocialPlugin;
+function socialClient() {
+    return new SocialPlugin();
+}

package/dist/plugins/sso.d.ts

@@ -0,0 +1,15 @@
+import { ClientPlugin } from '../plugin';
+import { AuthsomeClient } from '../client';
+import * as types from '../types';
+export declare class SsoPlugin implements ClientPlugin {
+    readonly id = "sso";
+    private client;
+    init(client: AuthsomeClient): void;
+    registerProvider(request: types.RegisterProviderRequest): Promise<types.ProviderRegisteredResponse>;
+    sAMLSPMetadata(): Promise<types.MetadataResponse>;
+    sAMLLogin(request: types.SAMLLoginRequest): Promise<types.SAMLLoginResponse>;
+    sAMLCallback(): Promise<types.SSOAuthResponse>;
+    oIDCLogin(request: types.OIDCLoginRequest): Promise<types.OIDCLoginResponse>;
+    oIDCCallback(): Promise<types.SSOAuthResponse>;
+}
+export declare function ssoClient(): SsoPlugin;

package/dist/plugins/sso.js

@@ -0,0 +1,47 @@
+"use strict";
+// Auto-generated sso plugin
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SsoPlugin = void 0;
+exports.ssoClient = ssoClient;
+class SsoPlugin {
+    constructor() {
+        this.id = 'sso';
+    }
+    init(client) {
+        this.client = client;
+    }
+    async registerProvider(request) {
+        const path = '/provider/register';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async sAMLSPMetadata() {
+        const path = '/saml2/sp/metadata';
+        return this.client.request('GET', path);
+    }
+    async sAMLLogin(request) {
+        const path = '/saml2/login/:providerId';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async sAMLCallback() {
+        const path = '/saml2/callback/:providerId';
+        return this.client.request('POST', path);
+    }
+    async oIDCLogin(request) {
+        const path = '/oidc/login/:providerId';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async oIDCCallback() {
+        const path = '/oidc/callback/:providerId';
+        return this.client.request('GET', path);
+    }
+}
+exports.SsoPlugin = SsoPlugin;
+function ssoClient() {
+    return new SsoPlugin();
+}

package/dist/plugins/stepup.d.ts

@@ -0,0 +1,23 @@
+import { ClientPlugin } from '../plugin';
+import { AuthsomeClient } from '../client';
+import * as types from '../types';
+export declare class StepupPlugin implements ClientPlugin {
+    readonly id = "stepup";
+    private client;
+    init(client: AuthsomeClient): void;
+    evaluate(request: types.EvaluateRequest): Promise<void>;
+    verify(request: types.VerifyRequest): Promise<void>;
+    getRequirement(): Promise<void>;
+    listPendingRequirements(): Promise<types.RequirementsResponse>;
+    listVerifications(): Promise<void>;
+    listRememberedDevices(): Promise<types.StepUpDevicesResponse>;
+    forgetDevice(): Promise<types.ForgetDeviceResponse>;
+    createPolicy(request: types.StepUpPolicy): Promise<types.StepUpPolicy>;
+    listPolicies(): Promise<void>;
+    getPolicy(): Promise<void>;
+    updatePolicy(request: types.StepUpPolicy): Promise<types.StepUpPolicy>;
+    deletePolicy(): Promise<void>;
+    getAuditLogs(): Promise<void>;
+    status(): Promise<void>;
+}
+export declare function stepupClient(): StepupPlugin;

package/dist/plugins/stepup.js

@@ -0,0 +1,81 @@
+"use strict";
+// Auto-generated stepup plugin
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepupPlugin = void 0;
+exports.stepupClient = stepupClient;
+class StepupPlugin {
+    constructor() {
+        this.id = 'stepup';
+    }
+    init(client) {
+        this.client = client;
+    }
+    async evaluate(request) {
+        const path = '/evaluate';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async verify(request) {
+        const path = '/verify';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async getRequirement() {
+        const path = '/requirements/:id';
+        return this.client.request('GET', path);
+    }
+    async listPendingRequirements() {
+        const path = '/requirements/pending';
+        return this.client.request('GET', path);
+    }
+    async listVerifications() {
+        const path = '/verifications';
+        return this.client.request('GET', path);
+    }
+    async listRememberedDevices() {
+        const path = '/devices';
+        return this.client.request('GET', path);
+    }
+    async forgetDevice() {
+        const path = '/devices/:id';
+        return this.client.request('DELETE', path);
+    }
+    async createPolicy(request) {
+        const path = '/policies';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async listPolicies() {
+        const path = '/policies';
+        return this.client.request('GET', path);
+    }
+    async getPolicy() {
+        const path = '/policies/:id';
+        return this.client.request('GET', path);
+    }
+    async updatePolicy(request) {
+        const path = '/policies/:id';
+        return this.client.request('PUT', path, {
+            body: request,
+        });
+    }
+    async deletePolicy() {
+        const path = '/policies/:id';
+        return this.client.request('DELETE', path);
+    }
+    async getAuditLogs() {
+        const path = '/audit';
+        return this.client.request('GET', path);
+    }
+    async status() {
+        const path = '/status';
+        return this.client.request('GET', path);
+    }
+}
+exports.StepupPlugin = StepupPlugin;
+function stepupClient() {
+    return new StepupPlugin();
+}

package/dist/plugins/twofa.d.ts

@@ -0,0 +1,15 @@
+import { ClientPlugin } from '../plugin';
+import { AuthsomeClient } from '../client';
+import * as types from '../types';
+export declare class TwofaPlugin implements ClientPlugin {
+    readonly id = "twofa";
+    private client;
+    init(client: AuthsomeClient): void;
+    enable(request: types.Enable_body): Promise<void>;
+    verify(request: types.Verify_body): Promise<types.StatusResponse>;
+    disable(request: types.Disable_body): Promise<types.StatusResponse>;
+    generateBackupCodes(request: types.GenerateBackupCodes_body): Promise<types.CodesResponse>;
+    sendOTP(request: types.SendOTP_body): Promise<types.OTPSentResponse>;
+    status(request: types.Status_body): Promise<types.TwoFAStatusResponse>;
+}
+export declare function twofaClient(): TwofaPlugin;

package/dist/plugins/twofa.js

@@ -0,0 +1,53 @@
+"use strict";
+// Auto-generated twofa plugin
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TwofaPlugin = void 0;
+exports.twofaClient = twofaClient;
+class TwofaPlugin {
+    constructor() {
+        this.id = 'twofa';
+    }
+    init(client) {
+        this.client = client;
+    }
+    async enable(request) {
+        const path = '/2fa/enable';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async verify(request) {
+        const path = '/2fa/verify';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async disable(request) {
+        const path = '/2fa/disable';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async generateBackupCodes(request) {
+        const path = '/2fa/generate-backup-codes';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async sendOTP(request) {
+        const path = '/2fa/send-otp';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+    async status(request) {
+        const path = '/2fa/status';
+        return this.client.request('POST', path, {
+            body: request,
+        });
+    }
+}
+exports.TwofaPlugin = TwofaPlugin;
+function twofaClient() {
+    return new TwofaPlugin();
+}

package/dist/plugins/username.d.ts

@@ -0,0 +1,11 @@
+import { ClientPlugin } from '../plugin';
+import { AuthsomeClient } from '../client';
+import * as types from '../types';
+export declare class UsernamePlugin implements ClientPlugin {
+    readonly id = "username";
+    private client;
+    init(client: AuthsomeClient): void;
+    signUp(): Promise<types.SignUpResponse>;
+    signIn(): Promise<types.SignInResponse>;
+}
+export declare function usernameClient(): UsernamePlugin;

package/dist/plugins/username.js

@@ -0,0 +1,25 @@
+"use strict";
+// Auto-generated username plugin
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsernamePlugin = void 0;
+exports.usernameClient = usernameClient;
+class UsernamePlugin {
+    constructor() {
+        this.id = 'username';
+    }
+    init(client) {
+        this.client = client;
+    }
+    async signUp() {
+        const path = '/username/signup';
+        return this.client.request('POST', path);
+    }
+    async signIn() {
+        const path = '/username/signin';
+        return this.client.request('POST', path);
+    }
+}
+exports.UsernamePlugin = UsernamePlugin;
+function usernameClient() {
+    return new UsernamePlugin();
+}

package/dist/plugins/webhook.d.ts

@@ -0,0 +1,32 @@
+import { ClientPlugin } from '../plugin';
+import { AuthsomeClient } from '../client';
+import * as types from '../types';
+export declare class WebhookPlugin implements ClientPlugin {
+    readonly id = "webhook";
+    private client;
+    init(client: AuthsomeClient): void;
+    create(request: {
+        events: string[];
+        secret?: string;
+        url: string;
+    }): Promise<{
+        webhook: types.Webhook;
+    }>;
+    list(): Promise<{
+        webhooks: types.Webhook[];
+    }>;
+    update(request: {
+        id: string;
+        url?: string;
+        events?: string[];
+        enabled?: boolean;
+    }): Promise<{
+        webhook: types.Webhook;
+    }>;
+    delete(request: {
+        id: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+}
+export declare function webhookClient(): WebhookPlugin;

package/dist/plugins/webhook.js

@@ -0,0 +1,44 @@
+"use strict";
+// Auto-generated webhook plugin
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookPlugin = void 0;
+exports.webhookClient = webhookClient;
+class WebhookPlugin {
+    constructor() {
+        this.id = 'webhook';
+    }
+    init(client) {
+        this.client = client;
+    }
+    async create(request) {
+        const path = '/api/auth/webhooks';
+        return this.client.request('POST', path, {
+            body: request,
+            auth: true,
+        });
+    }
+    async list() {
+        const path = '/api/auth/webhooks';
+        return this.client.request('GET', path, {
+            auth: true,
+        });
+    }
+    async update(request) {
+        const path = '/api/auth/webhooks/update';
+        return this.client.request('POST', path, {
+            body: request,
+            auth: true,
+        });
+    }
+    async delete(request) {
+        const path = '/api/auth/webhooks/delete';
+        return this.client.request('POST', path, {
+            body: request,
+            auth: true,
+        });
+    }
+}
+exports.WebhookPlugin = WebhookPlugin;
+function webhookClient() {
+    return new WebhookPlugin();
+}