@go-mondo/identity-sdk 0.0.2-beta.7 → 0.0.2-beta.71

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

@@ -1 +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"}
+{"version":3,"file":"email.d.ts","sourceRoot":"","sources":["../../../../../../src/authentication/strategies/schema/types/email.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAa5B,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;iBAG9B,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAC1E,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEjE,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;iBAGrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE/E,eAAO,MAAM,gCAAgC;;;;;;;;;iBAG3C,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,gCAAgC,CACxC,CAAC;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAC/C,OAAO,gCAAgC,CACxC,CAAC;AAEF,eAAO,MAAM,gCAAgC;;;;;;;;iBAG3C,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,gCAAgC,CACxC,CAAC;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAC/C,OAAO,gCAAgC,CACxC,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;iBAG5B,CAAC;AAEH,eAAO,MAAM,+BAA+B;;iBAE1C,CAAC"}

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

@@ -1,18 +1,28 @@
-import { type } from 'arktype';
-import { BaseInsertStrategyPayloadSchema, BaseStrategyPayloadSchema, BaseStrategySchema, BaseUpdateStrategyPayloadSchema, } from '../base.js';
-const TypeSchema = type({
-    type: "'email'",
+import * as z from 'zod/v4';
+import { BaseInsertStrategyPayloadSchema, BaseStrategyPayloadSchema, BaseStrategySchema, BaseUpdateStrategyPayloadSchema, StrategyType, } from '../base.js';
+const TypeSchema = z.object({
+    type: z.literal(StrategyType.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 EmailStrategySchema = z.object({
+    ...BaseStrategySchema.shape,
+    ...TypeSchema.shape,
 });
-export const SendEmailVerificationCodeSchema = type({
-    email: type('string.email').optional(),
+export const EmailStrategyPayloadSchema = z.object({
+    ...BaseStrategyPayloadSchema.shape,
+    ...TypeSchema.shape,
+});
+export const InsertEmailStrategyPayloadSchema = z.object({
+    ...TypeSchema.shape,
+    ...BaseInsertStrategyPayloadSchema.shape,
+});
+export const UpdateEmailStrategyPayloadSchema = z.object({
+    ...TypeSchema.shape,
+    ...BaseUpdateStrategyPayloadSchema.shape,
+});
+export const VerifyEmailSchema = z.object({
+    email: z.email().optional(),
+    code: z.string({ message: 'A verification code is required' }),
+});
+export const SendEmailVerificationCodeSchema = z.object({
+    email: z.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 { 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.safeParse(strategy);
+            // Parse succeeds for valid data
+        });
+        test('should reject invalid type', () => {
+            const strategy = {
+                id: generateStrategyId(),
+                type: 'password',
+                status: 'enabled',
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = EmailStrategySchema.safeParse(strategy);
+            expect(result.success).toBe(false);
+        });
+        test('should reject missing required fields', () => {
+            const strategy = {
+                type: 'email',
+                // missing id, enabled, dates, metadata
+            };
+            const result = EmailStrategySchema.safeParse(strategy);
+            expect(result.success).toBe(false);
+        });
+    });
+    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.safeParse(payload);
+            expect(result.success).toBe(true);
+            expect(result.data).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.safeParse(payload);
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('InsertEmailStrategyPayloadSchema', () => {
+        test('should accept complete insert payload', () => {
+            const payload = {
+                id: generateStrategyId(),
+                type: 'email',
+                label: 'Test',
+                status: 'enabled',
+                metadata: { setup: 'manual' },
+            };
+            const result = InsertEmailStrategyPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+        });
+        test('should accept minimal insert payload', () => {
+            const payload = {
+                type: 'email',
+                label: 'Test',
+            };
+            const result = InsertEmailStrategyPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+        });
+        test('should reject missing type', () => {
+            const payload = {
+                status: 'enabled',
+            };
+            const result = InsertEmailStrategyPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(false);
+        });
+        test('should reject invalid type', () => {
+            const payload = {
+                type: 'password',
+            };
+            const result = InsertEmailStrategyPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('UpdateEmailStrategyPayloadSchema', () => {
+        test('should accept update with type and enabled', () => {
+            const payload = {
+                type: 'email',
+                enabled: false,
+                metadata: { updated: true },
+            };
+            const result = UpdateEmailStrategyPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(true);
+            expect(result.data?.type).toEqual(payload.type);
+            expect(result.data?.metadata).toEqual(payload.metadata);
+        });
+        test('should accept minimal update', () => {
+            const payload = {
+                type: 'email',
+            };
+            const result = UpdateEmailStrategyPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+        });
+        test('should reject invalid type', () => {
+            const payload = {
+                type: 'totp',
+            };
+            const result = UpdateEmailStrategyPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('VerifyEmailSchema', () => {
+        test('should accept verification with email and code', () => {
+            const verification = {
+                email: 'user@example.com',
+                code: '123456',
+            };
+            const result = VerifyEmailSchema.safeParse(verification);
+            // Parse succeeds for valid data
+            expect(result.data).toEqual(verification);
+        });
+        test('should accept verification with only code', () => {
+            const verification = {
+                code: 'ABC123',
+            };
+            const result = VerifyEmailSchema.safeParse(verification);
+            // Parse succeeds for valid data
+            expect(result.data).toEqual(verification);
+        });
+        test('should reject missing code', () => {
+            const verification = {
+                email: 'user@example.com',
+            };
+            const result = VerifyEmailSchema.safeParse(verification);
+            expect(result.success).toBe(false);
+        });
+        test('should reject invalid email format', () => {
+            const verification = {
+                email: 'invalid-email',
+                code: '123456',
+            };
+            const result = VerifyEmailSchema.safeParse(verification);
+            expect(result.success).toBe(false);
+        });
+        test('should reject non-string code', () => {
+            const verification = {
+                email: 'user@example.com',
+                code: 123456,
+            };
+            const result = VerifyEmailSchema.safeParse(verification);
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('SendEmailVerificationCodeSchema', () => {
+        test('should accept valid email', () => {
+            const request = {
+                email: 'test@example.com',
+            };
+            const result = SendEmailVerificationCodeSchema.safeParse(request);
+            // Parse succeeds for valid data
+            expect(result.data).toEqual(request);
+        });
+        test('should accept empty request', () => {
+            const request = {};
+            const result = SendEmailVerificationCodeSchema.safeParse(request);
+            // Parse succeeds for valid data
+            expect(result.data).toEqual(request);
+        });
+        test('should reject invalid email format', () => {
+            const request = {
+                email: 'not-an-email',
+            };
+            const result = SendEmailVerificationCodeSchema.safeParse(request);
+            expect(result.success).toBe(false);
+        });
+        test('should reject non-string email', () => {
+            const request = {
+                email: 123,
+            };
+            const result = SendEmailVerificationCodeSchema.safeParse(request);
+            expect(result.success).toBe(false);
+        });
+    });
+});

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

@@ -1,3 +1,4 @@
+import * as z from 'zod/v4';
 export declare const DEFAULT_DIGITS = 6;
 export declare const DEFAULT_PERIOD = 30;
 export declare const TOTPAlgorithm: {
@@ -13,99 +14,111 @@ export declare const TOTPAlgorithm: {
     '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: "enabled" | "disabled";
-    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> | Map<string, any>>;
-    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<{
-    id: string;
-    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;
-}, {}>;
+export declare const TOTPStrategySettingsSchema: z.ZodObject<{
+    digits: z.ZodDefault<z.ZodNumber>;
+    period: z.ZodDefault<z.ZodNumber>;
+    algorithm: z.ZodDefault<z.ZodEnum<{
+        [x: string]: string;
+    }>>;
+}, z.core.$strip>;
+export type TOTPStrategySettings = z.output<typeof TOTPStrategySettingsSchema>;
+export declare const TOTPStrategySettingsPropertySchema: z.ZodObject<{
+    settings: z.ZodObject<{
+        digits: z.ZodDefault<z.ZodNumber>;
+        period: z.ZodDefault<z.ZodNumber>;
+        algorithm: z.ZodDefault<z.ZodEnum<{
+            [x: string]: string;
+        }>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type TOTPStrategySettingsProperty = z.output<typeof TOTPStrategySettingsPropertySchema>;
+export declare const TOTPStrategySchema: z.ZodObject<{
+    settings: z.ZodObject<{
+        digits: z.ZodDefault<z.ZodNumber>;
+        period: z.ZodDefault<z.ZodNumber>;
+        algorithm: z.ZodDefault<z.ZodEnum<{
+            [x: string]: string;
+        }>>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"totp">;
+    metadata: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Map<string, string | number | boolean>, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>;
+    deactivatedAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>;
+    deletedAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>;
+    updatedAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>;
+    createdAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>;
+    id: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<{
+        enabled: "enabled";
+        disabled: "disabled";
+    }>>;
+    label: z.ZodString;
+}, z.core.$strip>;
+export type TOTPStrategyProperties = z.input<typeof TOTPStrategySchema>;
+export type TOTPStrategy = z.output<typeof TOTPStrategySchema>;
+export declare const TOTPStrategyPayloadSchema: z.ZodObject<{
+    settings: z.ZodObject<{
+        digits: z.ZodDefault<z.ZodNumber>;
+        period: z.ZodDefault<z.ZodNumber>;
+        algorithm: z.ZodDefault<z.ZodEnum<{
+            [x: string]: string;
+        }>>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"totp">;
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+    deactivatedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    deletedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    updatedAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    createdAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        enabled: "enabled";
+        disabled: "disabled";
+    }>;
+    label: z.ZodString;
+}, z.core.$strip>;
+export type TOTPStrategyPayload = z.output<typeof TOTPStrategyPayloadSchema>;
+export declare const InsertTOTPStrategyPayloadSchema: z.ZodObject<{
+    settings: z.ZodOptional<z.ZodObject<{
+        digits: z.ZodDefault<z.ZodNumber>;
+        period: z.ZodDefault<z.ZodNumber>;
+        algorithm: z.ZodDefault<z.ZodEnum<{
+            [x: string]: string;
+        }>>;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+    id: z.ZodOptional<z.ZodString>;
+    label: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<{
+        enabled: "enabled";
+        disabled: "disabled";
+    }>>;
+    type: z.ZodLiteral<"totp">;
+}, z.core.$strip>;
+export type InsertTOTPStrategyInput = z.input<typeof InsertTOTPStrategyPayloadSchema>;
+export type InsertTOTPStrategyPayload = z.output<typeof InsertTOTPStrategyPayloadSchema>;
+export declare const UpdateTOTPStrategyPayloadSchema: z.ZodObject<{
+    settings: z.ZodOptional<z.ZodObject<{
+        digits: z.ZodDefault<z.ZodNumber>;
+        period: z.ZodDefault<z.ZodNumber>;
+        algorithm: z.ZodDefault<z.ZodEnum<{
+            [x: string]: string;
+        }>>;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+    label: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        enabled: "enabled";
+        disabled: "disabled";
+    }>>;
+    type: z.ZodLiteral<"totp">;
+}, z.core.$strip>;
+export type UpdateTOTPStrategyInput = z.input<typeof UpdateTOTPStrategyPayloadSchema>;
+export type UpdateTOTPStrategyPayload = z.output<typeof UpdateTOTPStrategyPayloadSchema>;
+export declare const RegisterTOTPSchema: z.ZodObject<{
+    uri: z.ZodURL;
+    token: z.ZodString;
+}, z.core.$strip>;
+export declare const VerifyTOTPSchema: z.ZodObject<{
+    token: z.ZodString;
+}, z.core.$strip>;
 //# sourceMappingURL=totp.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"totp.d.ts","sourceRoot":"","sources":["../../../../../../src/authentication/strategies/schema/types/totp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAS5B,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;AAKrD,eAAO,MAAM,0BAA0B;;;;;;iBA0BrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE/E,eAAO,MAAM,kCAAkC;;;;;;;;iBAE7C,CAAC;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,MAAM,CACjD,OAAO,kCAAkC,CAC1C,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;iBAI7B,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACxE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE/D,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;iBAIpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE7E,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;iBAI1C,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,+BAA+B,CACvC,CAAC;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAC9C,OAAO,+BAA+B,CACvC,CAAC;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;iBAI1C,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,+BAA+B,CACvC,CAAC;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAC9C,OAAO,+BAA+B,CACvC,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;iBAE3B,CAAC"}

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

@@ -1,9 +1,9 @@
-import { type } from 'arktype';
-import { BaseInsertStrategyPayloadSchema, BaseStrategyPayloadSchema, BaseStrategySchema, BaseUpdateStrategyPayloadSchema, } from '../base.js';
+import * as z from 'zod/v4';
+import { BaseInsertStrategyPayloadSchema, BaseStrategyPayloadSchema, BaseStrategySchema, BaseUpdateStrategyPayloadSchema, StrategyType, } from '../base.js';
 export const DEFAULT_DIGITS = 6;
 export const DEFAULT_PERIOD = 30;
-const TypeSchema = type({
-    type: "'totp'",
+const TypeSchema = z.object({
+    type: z.literal(StrategyType.TOTP),
 });
 export const TOTPAlgorithm = {
     DEFAULT: 'SHA256',
@@ -17,38 +17,62 @@ export const TOTPAlgorithm = {
     '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'])
+const allowedDigits = new Set([6, 7, 8]);
+const allowedPeriods = new Set([15, 30, 60]);
+export const TOTPStrategySettingsSchema = z.object({
+    digits: z
+        .number()
+        .default(DEFAULT_DIGITS)
+        .refine((val) => allowedDigits.has(val), {
+        message: 'Digit must be 6, 7, or 8',
+    }),
+    period: z
+        .number()
+        .default(DEFAULT_PERIOD)
+        .refine((val) => allowedPeriods.has(val), {
+        message: 'Period must be 15, 30, or 60',
+    }),
+    algorithm: z
+        .enum([
+        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({
+export const TOTPStrategySettingsPropertySchema = z.object({
     settings: TOTPStrategySettingsSchema,
 });
-export const TOTPStrategySchema = BaseStrategySchema.and(TypeSchema).and({
+export const TOTPStrategySchema = z.object({
+    ...BaseStrategySchema.shape,
+    ...TypeSchema.shape,
     settings: TOTPStrategySettingsSchema,
 });
-export const TOTPStrategyPayloadSchema = BaseStrategyPayloadSchema.and(TypeSchema).and(TOTPStrategySettingsPropertySchema);
-export const InsertTOTPStrategyPayloadSchema = TypeSchema.and(BaseInsertStrategyPayloadSchema)
-    .and(TypeSchema)
-    .and({
+export const TOTPStrategyPayloadSchema = z.object({
+    ...BaseStrategyPayloadSchema.shape,
+    ...TypeSchema.shape,
+    ...TOTPStrategySettingsPropertySchema.shape,
+});
+export const InsertTOTPStrategyPayloadSchema = z.object({
+    ...TypeSchema.shape,
+    ...BaseInsertStrategyPayloadSchema.shape,
     settings: TOTPStrategySettingsSchema.optional(),
 });
-export const UpdateTOTPStrategyPayloadSchema = TypeSchema.and(BaseUpdateStrategyPayloadSchema).and({
+export const UpdateTOTPStrategyPayloadSchema = z.object({
+    ...TypeSchema.shape,
+    ...BaseUpdateStrategyPayloadSchema.shape,
     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 RegisterTOTPSchema = z.object({
+    uri: z.url('An authenticator uri is required'),
+    token: z.string('An authenticator token is required'),
 });
-export const VerifyTOTPSchema = type({
-    token: type('string').configure({
-        message: 'An authenticator token is required',
-    }),
+export const VerifyTOTPSchema = z.object({
+    token: z.string({ message: 'An authenticator token is required' }),
 });

package/dist/esm/authentication/utils.d.ts

@@ -0,0 +1,13 @@
+export declare const Model: {
+    readonly Strategy: {
+        readonly UIDPrefix: "stg";
+        readonly TYPE: "Strategy";
+    };
+    readonly Session: {
+        readonly UIDPrefix: "ssn";
+        readonly TYPE: "Session";
+    };
+};
+export declare function generateStrategyId(): string;
+export declare function generateSessionId(): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/esm/authentication/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/authentication/utils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK;;;;;;;;;CASR,CAAC;AAEX,wBAAgB,kBAAkB,WAEjC;AAED,wBAAgB,iBAAiB,WAEhC"}

package/dist/esm/authentication/utils.js

@@ -0,0 +1,17 @@
+import KSUID from 'ksuid';
+export const Model = {
+    Strategy: {
+        UIDPrefix: 'stg',
+        TYPE: 'Strategy',
+    },
+    Session: {
+        UIDPrefix: 'ssn',
+        TYPE: 'Session',
+    },
+};
+export function generateStrategyId() {
+    return `${Model.Strategy.UIDPrefix}_${KSUID.randomSync().string}`;
+}
+export function generateSessionId() {
+    return `${Model.Session.UIDPrefix}_${KSUID.randomSync().string}`;
+}

package/dist/esm/authentication/utils.test.d.ts

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

package/dist/esm/authentication/utils.test.d.ts.map

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