@go-mondo/identity-sdk 0.0.1 → 0.0.2-beta.12

package/dist/esm/authentication/strategies/schema/types/email.d.ts

@@ -0,0 +1,61 @@
+export declare const EmailStrategySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    status: import("arktype/internal/attributes.ts").Default<"enabled" | "disabled", "enabled">;
+    label: string;
+    createdAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
+    updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
+    deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
+    deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
+    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
+    type: "email";
+}, {}>;
+export type EmailStrategyProperties = typeof EmailStrategySchema.inferIn;
+export type EmailStrategy = typeof EmailStrategySchema.inferOut;
+export declare const EmailStrategyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    status: "enabled" | "disabled";
+    label: string;
+    createdAt: (In: string | Date) => import("arktype").Out<string>;
+    updatedAt: (In: string | Date) => import("arktype").Out<string>;
+    deletedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    deactivatedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+    type: "email";
+}, {}>;
+export type EmailStrategyPayload = typeof EmailStrategyPayloadSchema.inferOut;
+export declare const InsertEmailStrategyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    type: "email";
+    label: string;
+    status: import("arktype/internal/attributes.ts").Default<"enabled" | "disabled", "enabled">;
+    id?: string | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+}, {}>;
+export type InsertEmailStrategyInput = typeof InsertEmailStrategyPayloadSchema.inferIn;
+export type InsertEmailStrategyPayload = typeof InsertEmailStrategyPayloadSchema.inferOut;
+export declare const UpdateEmailStrategyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    type: "email";
+    label?: string | undefined;
+    status?: "enabled" | "disabled" | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+}, {}>;
+export type UpdateEmailStrategyInput = typeof UpdateEmailStrategyPayloadSchema.inferIn;
+export type UpdateEmailStrategyPayload = typeof UpdateEmailStrategyPayloadSchema.inferOut;
+export declare const VerifyEmailSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    code: string;
+    email?: string | undefined;
+}, {}>;
+export declare const SendEmailVerificationCodeSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    email?: string | undefined;
+}, {}>;
+//# sourceMappingURL=email.d.ts.map

package/dist/esm/authentication/strategies/schema/types/email.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"email.d.ts","sourceRoot":"","sources":["../../../../../../src/authentication/strategies/schema/types/email.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,mBAAmB;;;;;;;;;;MAAqC,CAAC;AACtE,MAAM,MAAM,uBAAuB,GAAG,OAAO,mBAAmB,CAAC,OAAO,CAAC;AACzE,MAAM,MAAM,aAAa,GAAG,OAAO,mBAAmB,CAAC,QAAQ,CAAC;AAEhE,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;MACI,CAAC;AAC5C,MAAM,MAAM,oBAAoB,GAAG,OAAO,0BAA0B,CAAC,QAAQ,CAAC;AAE9E,eAAO,MAAM,gCAAgC;;;;;;;;;;MAE5B,CAAC;AAClB,MAAM,MAAM,wBAAwB,GAClC,OAAO,gCAAgC,CAAC,OAAO,CAAC;AAClD,MAAM,MAAM,0BAA0B,GACpC,OAAO,gCAAgC,CAAC,QAAQ,CAAC;AAEnD,eAAO,MAAM,gCAAgC;;;;;;;;;MAE5C,CAAC;AACF,MAAM,MAAM,wBAAwB,GAClC,OAAO,gCAAgC,CAAC,OAAO,CAAC;AAClD,MAAM,MAAM,0BAA0B,GACpC,OAAO,gCAAgC,CAAC,QAAQ,CAAC;AAEnD,eAAO,MAAM,iBAAiB;;;MAK5B,CAAC;AAEH,eAAO,MAAM,+BAA+B;;MAE1C,CAAC"}

package/dist/esm/authentication/strategies/schema/types/email.js

@@ -0,0 +1,18 @@
+import { type } from 'arktype';
+import { BaseInsertStrategyPayloadSchema, BaseStrategyPayloadSchema, BaseStrategySchema, BaseUpdateStrategyPayloadSchema, } from '../base.js';
+const TypeSchema = type({
+    type: "'email'",
+});
+export const EmailStrategySchema = BaseStrategySchema.and(TypeSchema);
+export const EmailStrategyPayloadSchema = BaseStrategyPayloadSchema.and(TypeSchema);
+export const InsertEmailStrategyPayloadSchema = TypeSchema.and(BaseInsertStrategyPayloadSchema).and(TypeSchema);
+export const UpdateEmailStrategyPayloadSchema = TypeSchema.and(BaseUpdateStrategyPayloadSchema);
+export const VerifyEmailSchema = type({
+    email: type('string.email').optional(),
+    code: type('string').configure({
+        message: 'A verification code is required',
+    }),
+});
+export const SendEmailVerificationCodeSchema = type({
+    email: type('string.email').optional(),
+});

package/dist/esm/authentication/strategies/schema/types/email.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=email.test.d.ts.map

package/dist/esm/authentication/strategies/schema/types/email.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"email.test.d.ts","sourceRoot":"","sources":["../../../../../../src/authentication/strategies/schema/types/email.test.ts"],"names":[],"mappings":""}

package/dist/esm/authentication/strategies/schema/types/email.test.js

@@ -0,0 +1,203 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateStrategyId } from '../../../../authentication/utils.js';
+import { EmailStrategyPayloadSchema, EmailStrategySchema, InsertEmailStrategyPayloadSchema, SendEmailVerificationCodeSchema, UpdateEmailStrategyPayloadSchema, VerifyEmailSchema, } from './email.js';
+describe('Authentication Strategies - Email', () => {
+    describe('EmailStrategySchema', () => {
+        test('should accept complete email strategy', () => {
+            const strategy = {
+                id: generateStrategyId(),
+                type: 'email',
+                label: 'Test',
+                status: 'enabled',
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: { provider: 'sendgrid' },
+            };
+            const result = EmailStrategySchema(strategy);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid type', () => {
+            const strategy = {
+                id: generateStrategyId(),
+                type: 'password',
+                status: 'enabled',
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = EmailStrategySchema(strategy);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject missing required fields', () => {
+            const strategy = {
+                type: 'email',
+                // missing id, enabled, dates, metadata
+            };
+            const result = EmailStrategySchema(strategy);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('EmailStrategyPayloadSchema', () => {
+        test('should accept complete payload', () => {
+            const payload = {
+                id: generateStrategyId(),
+                type: 'email',
+                label: 'Test',
+                status: 'enabled',
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: { configured: true },
+            };
+            const result = EmailStrategyPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should reject invalid type', () => {
+            const payload = {
+                id: generateStrategyId(),
+                type: 'sms',
+                label: 'Test',
+                status: 'enabled',
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = EmailStrategyPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('InsertEmailStrategyPayloadSchema', () => {
+        test('should accept complete insert payload', () => {
+            const payload = {
+                id: generateStrategyId(),
+                type: 'email',
+                label: 'Test',
+                status: 'enabled',
+                metadata: { setup: 'manual' },
+            };
+            const result = InsertEmailStrategyPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept minimal insert payload', () => {
+            const payload = {
+                type: 'email',
+                label: 'Test',
+            };
+            const result = InsertEmailStrategyPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject missing type', () => {
+            const payload = {
+                status: 'enabled',
+            };
+            const result = InsertEmailStrategyPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid type', () => {
+            const payload = {
+                type: 'password',
+            };
+            const result = InsertEmailStrategyPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('UpdateEmailStrategyPayloadSchema', () => {
+        test('should accept update with type and enabled', () => {
+            const payload = {
+                type: 'email',
+                enabled: false,
+                metadata: { updated: true },
+            };
+            const result = UpdateEmailStrategyPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept minimal update', () => {
+            const payload = {
+                type: 'email',
+            };
+            const result = UpdateEmailStrategyPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid type', () => {
+            const payload = {
+                type: 'totp',
+            };
+            const result = UpdateEmailStrategyPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('VerifyEmailSchema', () => {
+        test('should accept verification with email and code', () => {
+            const verification = {
+                email: 'user@example.com',
+                code: '123456',
+            };
+            const result = VerifyEmailSchema(verification);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(verification);
+        });
+        test('should accept verification with only code', () => {
+            const verification = {
+                code: 'ABC123',
+            };
+            const result = VerifyEmailSchema(verification);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(verification);
+        });
+        test('should reject missing code', () => {
+            const verification = {
+                email: 'user@example.com',
+            };
+            const result = VerifyEmailSchema(verification);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid email format', () => {
+            const verification = {
+                email: 'invalid-email',
+                code: '123456',
+            };
+            const result = VerifyEmailSchema(verification);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject non-string code', () => {
+            const verification = {
+                email: 'user@example.com',
+                code: 123456,
+            };
+            const result = VerifyEmailSchema(verification);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('SendEmailVerificationCodeSchema', () => {
+        test('should accept valid email', () => {
+            const request = {
+                email: 'test@example.com',
+            };
+            const result = SendEmailVerificationCodeSchema(request);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(request);
+        });
+        test('should accept empty request', () => {
+            const request = {};
+            const result = SendEmailVerificationCodeSchema(request);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(request);
+        });
+        test('should reject invalid email format', () => {
+            const request = {
+                email: 'not-an-email',
+            };
+            const result = SendEmailVerificationCodeSchema(request);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject non-string email', () => {
+            const request = {
+                email: 123,
+            };
+            const result = SendEmailVerificationCodeSchema(request);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+});

package/dist/esm/authentication/strategies/schema/types/password.d.ts

@@ -0,0 +1,131 @@
+export declare const PasswordPolicyDefaults: {
+    minimumLength: number;
+    maximumLength: number;
+    minimumCapital: number;
+    minimumLower: number;
+    minimumNumber: number;
+    minimumSpecial: number;
+};
+export declare const PasswordPolicySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    minimumLength: import("arktype/internal/attributes.ts").Default<number, number>;
+    maximumLength: import("arktype/internal/attributes.ts").Default<number, number>;
+    minimumCapital: import("arktype/internal/attributes.ts").Default<number, number>;
+    minimumLower: import("arktype/internal/attributes.ts").Default<number, number>;
+    minimumNumber: import("arktype/internal/attributes.ts").Default<number, number>;
+    minimumSpecial: import("arktype/internal/attributes.ts").Default<number, number>;
+}, {}>;
+export declare const PasswordStrategySettingsPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    settings: {
+        passwordPolicy: {
+            minimumLength: import("arktype/internal/attributes.ts").Default<number, number>;
+            maximumLength: import("arktype/internal/attributes.ts").Default<number, number>;
+            minimumCapital: import("arktype/internal/attributes.ts").Default<number, number>;
+            minimumLower: import("arktype/internal/attributes.ts").Default<number, number>;
+            minimumNumber: import("arktype/internal/attributes.ts").Default<number, number>;
+            minimumSpecial: import("arktype/internal/attributes.ts").Default<number, number>;
+        };
+    };
+}, {}>;
+export declare const PasswordStrategySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    status: import("arktype/internal/attributes.ts").Default<"enabled" | "disabled", "enabled">;
+    label: string;
+    createdAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
+    updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
+    deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
+    deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
+    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
+    type: "password";
+    settings: {
+        passwordPolicy: {
+            minimumLength: import("arktype/internal/attributes.ts").Default<number, number>;
+            maximumLength: import("arktype/internal/attributes.ts").Default<number, number>;
+            minimumCapital: import("arktype/internal/attributes.ts").Default<number, number>;
+            minimumLower: import("arktype/internal/attributes.ts").Default<number, number>;
+            minimumNumber: import("arktype/internal/attributes.ts").Default<number, number>;
+            minimumSpecial: import("arktype/internal/attributes.ts").Default<number, number>;
+        };
+    };
+}, {}>;
+export type PasswordStrategyProperties = typeof PasswordStrategySchema.inferIn;
+export type PasswordStrategy = typeof PasswordStrategySchema.inferOut;
+export declare const PasswordStrategyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    status: "enabled" | "disabled";
+    label: string;
+    createdAt: (In: string | Date) => import("arktype").Out<string>;
+    updatedAt: (In: string | Date) => import("arktype").Out<string>;
+    deletedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    deactivatedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+    type: "password";
+    settings: {
+        passwordPolicy: {
+            minimumLength: import("arktype/internal/attributes.ts").Default<number, number>;
+            maximumLength: import("arktype/internal/attributes.ts").Default<number, number>;
+            minimumCapital: import("arktype/internal/attributes.ts").Default<number, number>;
+            minimumLower: import("arktype/internal/attributes.ts").Default<number, number>;
+            minimumNumber: import("arktype/internal/attributes.ts").Default<number, number>;
+            minimumSpecial: import("arktype/internal/attributes.ts").Default<number, number>;
+        };
+    };
+}, {}>;
+export type PasswordStrategyPayload = typeof PasswordStrategyPayloadSchema.inferOut;
+export declare const InsertPasswordStrategyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    type: "password";
+    label: string;
+    status: import("arktype/internal/attributes.ts").Default<"enabled" | "disabled", "enabled">;
+    id?: string | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+    settings?: {
+        passwordPolicy: {
+            minimumLength: import("arktype/internal/attributes.ts").Default<number, number>;
+            maximumLength: import("arktype/internal/attributes.ts").Default<number, number>;
+            minimumCapital: import("arktype/internal/attributes.ts").Default<number, number>;
+            minimumLower: import("arktype/internal/attributes.ts").Default<number, number>;
+            minimumNumber: import("arktype/internal/attributes.ts").Default<number, number>;
+            minimumSpecial: import("arktype/internal/attributes.ts").Default<number, number>;
+        };
+    } | undefined;
+}, {}>;
+export type InsertPasswordStrategyInput = typeof InsertPasswordStrategyPayloadSchema.inferIn;
+export type InsertPasswordStrategyPayload = typeof InsertPasswordStrategyPayloadSchema.inferOut;
+export declare const UpdatePasswordStrategyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    type: "password";
+    label?: string | undefined;
+    status?: "enabled" | "disabled" | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+    settings?: {
+        passwordPolicy: {
+            minimumLength: import("arktype/internal/attributes.ts").Default<number, number>;
+            maximumLength: import("arktype/internal/attributes.ts").Default<number, number>;
+            minimumCapital: import("arktype/internal/attributes.ts").Default<number, number>;
+            minimumLower: import("arktype/internal/attributes.ts").Default<number, number>;
+            minimumNumber: import("arktype/internal/attributes.ts").Default<number, number>;
+            minimumSpecial: import("arktype/internal/attributes.ts").Default<number, number>;
+        };
+    } | undefined;
+}, {}>;
+export type UpdatePasswordStrategyInput = typeof UpdatePasswordStrategyPayloadSchema.inferIn;
+export type UpdatePasswordStrategyPayload = typeof UpdatePasswordStrategyPayloadSchema.inferOut;
+export declare const ForgotPasswordSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    identifier?: string | undefined;
+    identifierType?: "email" | "phoneNumber" | undefined;
+}, {}>;
+export declare const VerifyPasswordSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    password: string;
+    identifier?: string | undefined;
+    identifierType?: "email" | "phoneNumber" | undefined;
+}, {}>;
+//# sourceMappingURL=password.d.ts.map

package/dist/esm/authentication/strategies/schema/types/password.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"password.d.ts","sourceRoot":"","sources":["../../../../../../src/authentication/strategies/schema/types/password.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,sBAAsB;;;;;;;CAOlC,CAAC;AAMF,eAAO,MAAM,oBAAoB;;;;;;;MAO/B,CAAC;AAMH,eAAO,MAAM,sCAAsC;;;;;;;;;;;MAEjD,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;MAEjC,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,OAAO,sBAAsB,CAAC,OAAO,CAAC;AAC/E,MAAM,MAAM,gBAAgB,GAAG,OAAO,sBAAsB,CAAC,QAAQ,CAAC;AAEtE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;MAEG,CAAC;AAC9C,MAAM,MAAM,uBAAuB,GACjC,OAAO,6BAA6B,CAAC,QAAQ,CAAC;AAEhD,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;MAM5C,CAAC;AACL,MAAM,MAAM,2BAA2B,GACrC,OAAO,mCAAmC,CAAC,OAAO,CAAC;AACrD,MAAM,MAAM,6BAA6B,GACvC,OAAO,mCAAmC,CAAC,QAAQ,CAAC;AAEtD,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;MAI9C,CAAC;AACH,MAAM,MAAM,2BAA2B,GACrC,OAAO,mCAAmC,CAAC,OAAO,CAAC;AACrD,MAAM,MAAM,6BAA6B,GACvC,OAAO,mCAAmC,CAAC,QAAQ,CAAC;AAEtD,eAAO,MAAM,oBAAoB;;;MAG/B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;MAI/B,CAAC"}

package/dist/esm/authentication/strategies/schema/types/password.js

@@ -0,0 +1,49 @@
+import { type } from 'arktype';
+import { IdentityIdentifierSchema } from '../../../../identity/schema.js';
+import { BaseInsertStrategyPayloadSchema, BaseStrategyPayloadSchema, BaseStrategySchema, BaseUpdateStrategyPayloadSchema, } from '../base.js';
+export const PasswordPolicyDefaults = {
+    minimumLength: 8,
+    maximumLength: 36,
+    minimumCapital: 1,
+    minimumLower: 1,
+    minimumNumber: 1,
+    minimumSpecial: 1,
+};
+const TypeSchema = type({
+    type: "'password'",
+});
+export const PasswordPolicySchema = type({
+    minimumLength: type.number.default(PasswordPolicyDefaults.minimumLength),
+    maximumLength: type.number.default(PasswordPolicyDefaults.maximumLength),
+    minimumCapital: type.number.default(PasswordPolicyDefaults.minimumCapital),
+    minimumLower: type.number.default(PasswordPolicyDefaults.minimumLower),
+    minimumNumber: type.number.default(PasswordPolicyDefaults.minimumNumber),
+    minimumSpecial: type.number.default(PasswordPolicyDefaults.minimumSpecial),
+});
+const SettingsSchema = type({
+    passwordPolicy: PasswordPolicySchema,
+});
+export const PasswordStrategySettingsPropertySchema = type({
+    settings: SettingsSchema,
+});
+export const PasswordStrategySchema = BaseStrategySchema.and(TypeSchema).and({
+    settings: SettingsSchema,
+});
+export const PasswordStrategyPayloadSchema = BaseStrategyPayloadSchema.and(TypeSchema).and(PasswordStrategySettingsPropertySchema);
+export const InsertPasswordStrategyPayloadSchema = TypeSchema.and(BaseInsertStrategyPayloadSchema)
+    .and(TypeSchema)
+    .and({
+    settings: SettingsSchema.optional(),
+});
+export const UpdatePasswordStrategyPayloadSchema = TypeSchema.and(BaseUpdateStrategyPayloadSchema).and({
+    settings: SettingsSchema.optional(),
+});
+export const ForgotPasswordSchema = type({
+    identifier: type('string').optional(),
+    identifierType: IdentityIdentifierSchema.optional(),
+});
+export const VerifyPasswordSchema = type({
+    password: type('string'),
+    identifier: type('string').optional(),
+    identifierType: IdentityIdentifierSchema.optional(),
+});

package/dist/esm/authentication/strategies/schema/types/totp.d.ts

@@ -0,0 +1,110 @@
+export declare const DEFAULT_DIGITS = 6;
+export declare const DEFAULT_PERIOD = 30;
+export declare const TOTPAlgorithm: {
+    DEFAULT: string;
+    SHA1: string;
+    SHA224: string;
+    SHA256: string;
+    SHA384: string;
+    SHA512: string;
+    'SHA3-224': string;
+    'SHA3-256': string;
+    'SHA3-384': string;
+    'SHA3-512': string;
+};
+export type AnyTOTPAlgorithm = (typeof TOTPAlgorithm)[keyof typeof TOTPAlgorithm];
+export declare const TOTPStrategySettingsSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    digits: import("arktype/internal/attributes.ts").Default<6 | 7 | 8, 6>;
+    period: import("arktype/internal/attributes.ts").Default<15 | 30 | 60, 30>;
+    algorithm: import("arktype/internal/attributes.ts").Default<string, string>;
+}, {}>;
+export type TOTPStrategySettings = typeof TOTPStrategySettingsSchema.inferOut;
+export declare const TOTPStrategySettingsPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    settings: {
+        digits: import("arktype/internal/attributes.ts").Default<6 | 7 | 8, 6>;
+        period: import("arktype/internal/attributes.ts").Default<15 | 30 | 60, 30>;
+        algorithm: import("arktype/internal/attributes.ts").Default<string, string>;
+    };
+}, {}>;
+export type TOTPStrategySettingsProperty = typeof TOTPStrategySettingsPropertySchema.inferOut;
+export declare const TOTPStrategySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    status: import("arktype/internal/attributes.ts").Default<"enabled" | "disabled", "enabled">;
+    label: string;
+    createdAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
+    updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
+    deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
+    deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
+    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
+    type: "totp";
+    settings: {
+        digits: import("arktype/internal/attributes.ts").Default<6 | 7 | 8, 6>;
+        period: import("arktype/internal/attributes.ts").Default<15 | 30 | 60, 30>;
+        algorithm: import("arktype/internal/attributes.ts").Default<string, string>;
+    };
+}, {}>;
+export type TOTPStrategyProperties = typeof TOTPStrategySchema.inferIn;
+export type TOTPStrategy = typeof TOTPStrategySchema.inferOut;
+export declare const TOTPStrategyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    status: "enabled" | "disabled";
+    label: string;
+    createdAt: (In: string | Date) => import("arktype").Out<string>;
+    updatedAt: (In: string | Date) => import("arktype").Out<string>;
+    deletedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    deactivatedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+    type: "totp";
+    settings: {
+        digits: import("arktype/internal/attributes.ts").Default<6 | 7 | 8, 6>;
+        period: import("arktype/internal/attributes.ts").Default<15 | 30 | 60, 30>;
+        algorithm: import("arktype/internal/attributes.ts").Default<string, string>;
+    };
+}, {}>;
+export type TOTPStrategyPayload = typeof TOTPStrategyPayloadSchema.inferOut;
+export declare const InsertTOTPStrategyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    type: "totp";
+    label: string;
+    status: import("arktype/internal/attributes.ts").Default<"enabled" | "disabled", "enabled">;
+    id?: string | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+    settings?: {
+        digits: import("arktype/internal/attributes.ts").Default<6 | 7 | 8, 6>;
+        period: import("arktype/internal/attributes.ts").Default<15 | 30 | 60, 30>;
+        algorithm: import("arktype/internal/attributes.ts").Default<string, string>;
+    } | undefined;
+}, {}>;
+export type InsertTOTPStrategyInput = typeof InsertTOTPStrategyPayloadSchema.inferIn;
+export type InsertTOTPStrategyPayload = typeof InsertTOTPStrategyPayloadSchema.inferOut;
+export declare const UpdateTOTPStrategyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    type: "totp";
+    label?: string | undefined;
+    status?: "enabled" | "disabled" | undefined;
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+    settings?: {
+        digits: import("arktype/internal/attributes.ts").Default<6 | 7 | 8, 6>;
+        period: import("arktype/internal/attributes.ts").Default<15 | 30 | 60, 30>;
+        algorithm: import("arktype/internal/attributes.ts").Default<string, string>;
+    } | undefined;
+}, {}>;
+export type UpdateTOTPStrategyInput = typeof UpdateTOTPStrategyPayloadSchema.inferIn;
+export type UpdateTOTPStrategyPayload = typeof UpdateTOTPStrategyPayloadSchema.inferOut;
+export declare const RegisterTOTPSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    uri: string;
+    token: string;
+}, {}>;
+export declare const VerifyTOTPSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    token: string;
+}, {}>;
+//# sourceMappingURL=totp.d.ts.map

package/dist/esm/authentication/strategies/schema/types/totp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"totp.d.ts","sourceRoot":"","sources":["../../../../../../src/authentication/strategies/schema/types/totp.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,cAAc,IAAI,CAAC;AAChC,eAAO,MAAM,cAAc,KAAK,CAAC;AAMjC,eAAO,MAAM,aAAa;;;;;;;;;;;CAWzB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAC1B,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAErD,eAAO,MAAM,0BAA0B;;;;MAgBrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,0BAA0B,CAAC,QAAQ,CAAC;AAE9E,eAAO,MAAM,kCAAkC;;;;;;MAE7C,CAAC;AACH,MAAM,MAAM,4BAA4B,GACtC,OAAO,kCAAkC,CAAC,QAAQ,CAAC;AAErD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;MAE7B,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,OAAO,kBAAkB,CAAC,OAAO,CAAC;AACvE,MAAM,MAAM,YAAY,GAAG,OAAO,kBAAkB,CAAC,QAAQ,CAAC;AAE9D,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;MAEG,CAAC;AAC1C,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC;AAE5E,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;MAMxC,CAAC;AACL,MAAM,MAAM,uBAAuB,GACjC,OAAO,+BAA+B,CAAC,OAAO,CAAC;AACjD,MAAM,MAAM,yBAAyB,GACnC,OAAO,+BAA+B,CAAC,QAAQ,CAAC;AAElD,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;MAI1C,CAAC;AACH,MAAM,MAAM,uBAAuB,GACjC,OAAO,+BAA+B,CAAC,OAAO,CAAC;AACjD,MAAM,MAAM,yBAAyB,GACnC,OAAO,+BAA+B,CAAC,QAAQ,CAAC;AAElD,eAAO,MAAM,kBAAkB;;;MAO7B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;MAI3B,CAAC"}

package/dist/esm/authentication/strategies/schema/types/totp.js

@@ -0,0 +1,54 @@
+import { type } from 'arktype';
+import { BaseInsertStrategyPayloadSchema, BaseStrategyPayloadSchema, BaseStrategySchema, BaseUpdateStrategyPayloadSchema, } from '../base.js';
+export const DEFAULT_DIGITS = 6;
+export const DEFAULT_PERIOD = 30;
+const TypeSchema = type({
+    type: "'totp'",
+});
+export const TOTPAlgorithm = {
+    DEFAULT: 'SHA256',
+    SHA1: 'SHA1',
+    SHA224: 'SHA224',
+    SHA256: 'SHA256',
+    SHA384: 'SHA384',
+    SHA512: 'SHA512',
+    'SHA3-224': 'SHA3-224',
+    'SHA3-256': 'SHA3-256',
+    'SHA3-384': 'SHA3-384',
+    'SHA3-512': 'SHA3-512',
+};
+export const TOTPStrategySettingsSchema = type({
+    digits: type.enumerated(6, 7, 8).default(DEFAULT_DIGITS),
+    period: type.enumerated(15, 30, 60).default(DEFAULT_PERIOD),
+    algorithm: type
+        .enumerated(TOTPAlgorithm.SHA1, TOTPAlgorithm.SHA224, TOTPAlgorithm.SHA256, TOTPAlgorithm.SHA384, TOTPAlgorithm.SHA512, TOTPAlgorithm['SHA3-224'], TOTPAlgorithm['SHA3-256'], TOTPAlgorithm['SHA3-384'], TOTPAlgorithm['SHA3-512'])
+        .default(TOTPAlgorithm.DEFAULT),
+});
+export const TOTPStrategySettingsPropertySchema = type({
+    settings: TOTPStrategySettingsSchema,
+});
+export const TOTPStrategySchema = BaseStrategySchema.and(TypeSchema).and({
+    settings: TOTPStrategySettingsSchema,
+});
+export const TOTPStrategyPayloadSchema = BaseStrategyPayloadSchema.and(TypeSchema).and(TOTPStrategySettingsPropertySchema);
+export const InsertTOTPStrategyPayloadSchema = TypeSchema.and(BaseInsertStrategyPayloadSchema)
+    .and(TypeSchema)
+    .and({
+    settings: TOTPStrategySettingsSchema.optional(),
+});
+export const UpdateTOTPStrategyPayloadSchema = TypeSchema.and(BaseUpdateStrategyPayloadSchema).and({
+    settings: TOTPStrategySettingsSchema.optional(),
+});
+export const RegisterTOTPSchema = type({
+    uri: type('string.url').configure({
+        message: 'An authenticator uri is required',
+    }),
+    token: type('string').configure({
+        message: 'An authenticator token is required',
+    }),
+});
+export const VerifyTOTPSchema = type({
+    token: type('string').configure({
+        message: 'An authenticator token is required',
+    }),
+});