@go-mondo/identity-sdk 0.0.2-beta.37 → 0.0.2-beta.39

package/dist/cjs/common/schema/url.js

@@ -1,6 +1,41 @@
 "use strict";
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.UrlStringSchema = exports.UrlObjectSchema = void 0;
 exports.appendSearchParams = appendSearchParams;
+const z = __importStar(require("zod/v4"));
 function appendSearchParams(path, params) {
     const vals = Array.from(params.entries()).reduce((result, [key, val]) => {
         if (val) {
@@ -10,3 +45,11 @@ function appendSearchParams(path, params) {
     }, []);
     return [path, vals.filter(Boolean).join('&')].filter(Boolean).join('?');
 }
+exports.UrlObjectSchema = z
+    .url()
+    .pipe(z.transform((url) => new URL(url)))
+    .or(z.instanceof(URL));
+exports.UrlStringSchema = z
+    .instanceof(URL)
+    .pipe(z.transform((url) => url.toString()))
+    .or(z.url());

package/dist/esm/app/authorization/schema.d.ts

@@ -5,7 +5,7 @@ export declare const AuthorizationSchema: z.ZodObject<{
     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>>]>>;
     loginUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodUndefined]>>;
-    callbackUrls: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodPipe<z.ZodUnion<[z.ZodArray<z.ZodPipe<z.ZodURL, z.ZodTransform<URL, string>>>, z.ZodArray<z.ZodCustom<URL, URL>>]>, z.ZodTransform<URL[], URL[]>>, z.ZodCustom<Set<URL>, Set<URL>>]>, z.ZodTransform<Set<URL> | undefined, Set<URL> | URL[] | undefined>>>;
+    callbackUrls: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodPipe<z.ZodArray<z.ZodUnion<[z.ZodPipe<z.ZodURL, z.ZodTransform<URL, string>>, z.ZodCustom<URL, URL>]>>, z.ZodTransform<URL[], URL[]>>, z.ZodCustom<Set<URL>, Set<URL>>]>, z.ZodTransform<Set<URL> | undefined, Set<URL> | URL[] | undefined>>>;
     availableAudiences: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>, z.ZodSet<z.ZodString>]>, z.ZodTransform<Set<string> | undefined, Set<string> | string[] | undefined>>>;
     availableGrants: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodArray<z.ZodEnum<{
         client_credentials: "client_credentials";
@@ -39,7 +39,7 @@ export declare const AuthorizationPayloadSchema: z.ZodObject<{
     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>>>;
     loginUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodUndefined]>>;
-    callbackUrls: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodPipe<z.ZodUnion<[z.ZodArray<z.ZodPipe<z.ZodURL, z.ZodTransform<URL, string>>>, z.ZodArray<z.ZodCustom<URL, URL>>]>, z.ZodTransform<URL[], URL[]>>, z.ZodCustom<Set<URL>, Set<URL>>]>, z.ZodTransform<URL[] | undefined, Set<URL> | URL[] | undefined>>>;
+    callbackUrls: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodPipe<z.ZodArray<z.ZodUnion<[z.ZodPipe<z.ZodURL, z.ZodTransform<URL, string>>, z.ZodCustom<URL, URL>]>>, z.ZodTransform<URL[], URL[]>>, z.ZodCustom<Set<URL>, Set<URL>>]>, z.ZodTransform<URL[] | undefined, Set<URL> | URL[] | undefined>>>;
     availableAudiences: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>, z.ZodSet<z.ZodString>]>, z.ZodTransform<string[] | undefined, Set<string> | string[] | undefined>>>;
     availableGrants: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodArray<z.ZodEnum<{
         client_credentials: "client_credentials";
@@ -70,7 +70,7 @@ export type AuthorizationPayload = z.output<typeof AuthorizationPayloadSchema>;
 export declare const UpsertAuthorizationPayloadSchema: z.ZodObject<{
     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> | null | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
     loginUri: z.ZodOptional<z.ZodUnion<readonly [z.ZodURL, z.ZodUndefined]>>;
-    callbackUrls: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodPipe<z.ZodUnion<[z.ZodArray<z.ZodPipe<z.ZodURL, z.ZodTransform<URL, string>>>, z.ZodArray<z.ZodCustom<URL, URL>>]>, z.ZodTransform<URL[], URL[]>>, z.ZodCustom<Set<URL>, Set<URL>>]>, z.ZodTransform<URL[] | undefined, Set<URL> | URL[] | undefined>>>;
+    callbackUrls: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodPipe<z.ZodArray<z.ZodUnion<[z.ZodPipe<z.ZodURL, z.ZodTransform<URL, string>>, z.ZodCustom<URL, URL>]>>, z.ZodTransform<URL[], URL[]>>, z.ZodCustom<Set<URL>, Set<URL>>]>, z.ZodTransform<URL[] | undefined, Set<URL> | URL[] | undefined>>>;
     availableAudiences: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>, z.ZodSet<z.ZodString>]>, z.ZodTransform<string[] | undefined, Set<string> | string[] | undefined>>>;
     availableGrants: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodArray<z.ZodEnum<{
         client_credentials: "client_credentials";

package/dist/esm/authentication/settings/schema.test.js

@@ -1,4 +1,5 @@
 import { describe, expect, test } from 'vitest';
+import { generateStrategyId } from '../utils.js';
 import { SettingsSchema, SettingsPayloadSchema, UpsertSettingsPayloadSchema, } from './schema.js';
 describe('Authentication Settings - Schema', () => {
     describe('SettingsSchema', () => {
@@ -20,6 +21,156 @@ describe('Authentication Settings - Schema', () => {
             const result = SettingsSchema.safeParse(settings);
             expect(result.success).toBe(false);
         });
+        test('should accept settings with factors', () => {
+            const settings = {
+                factors: [
+                    {
+                        id: generateStrategyId(),
+                    },
+                ],
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = SettingsSchema.safeParse(settings);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.factors).toHaveLength(1);
+                expect(result.data.factors?.[0].id).toMatch(/^stg_[A-Za-z0-9]+$/);
+            }
+        });
+        test('should accept settings with nested factors', () => {
+            const settings = {
+                factors: [
+                    {
+                        id: generateStrategyId(),
+                        nextFactors: [
+                            {
+                                id: generateStrategyId(),
+                            },
+                        ],
+                    },
+                ],
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = SettingsSchema.safeParse(settings);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.factors?.[0].nextFactors).toHaveLength(1);
+            }
+        });
+        test('should accept settings with undefined factors', () => {
+            const settings = {
+                factors: undefined,
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = SettingsSchema.safeParse(settings);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.factors).toBeUndefined();
+            }
+        });
+        test('should accept settings with null factors (transforms to undefined)', () => {
+            const settings = {
+                factors: null,
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = SettingsSchema.safeParse(settings);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.factors).toBeUndefined();
+            }
+        });
+        test('should accept settings with multiple factors', () => {
+            const settings = {
+                factors: [
+                    { id: generateStrategyId() },
+                    { id: generateStrategyId() },
+                    { id: generateStrategyId() },
+                ],
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = SettingsSchema.safeParse(settings);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.factors).toHaveLength(3);
+            }
+        });
+        test('should accept settings with deeply nested factors', () => {
+            const settings = {
+                factors: [
+                    {
+                        id: generateStrategyId(),
+                        nextFactors: [
+                            {
+                                id: generateStrategyId(),
+                                nextFactors: [
+                                    {
+                                        id: generateStrategyId(),
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = SettingsSchema.safeParse(settings);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.factors?.[0].nextFactors?.[0].nextFactors).toHaveLength(1);
+            }
+        });
+        test('should reject settings with invalid factor id', () => {
+            const settings = {
+                factors: [
+                    {
+                        id: 'invalid-id',
+                    },
+                ],
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = SettingsSchema.safeParse(settings);
+            expect(result.success).toBe(false);
+        });
+        test('should reject settings with factors as object instead of array', () => {
+            const settings = {
+                factors: { id: generateStrategyId() },
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = SettingsSchema.safeParse(settings);
+            expect(result.success).toBe(false);
+        });
+        test('should accept settings with deletedAt', () => {
+            const settings = {
+                updatedAt: new Date(),
+                deletedAt: new Date(),
+                metadata: {},
+            };
+            const result = SettingsSchema.safeParse(settings);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.deletedAt).toBeDefined();
+            }
+        });
+        test('should accept settings with deactivatedAt', () => {
+            const settings = {
+                updatedAt: new Date(),
+                deactivatedAt: new Date(),
+                metadata: {},
+            };
+            const result = SettingsSchema.safeParse(settings);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.deactivatedAt).toBeDefined();
+            }
+        });
     });
     describe('SettingsPayloadSchema', () => {
         test('should accept minimal payload', () => {
@@ -50,6 +201,90 @@ describe('Authentication Settings - Schema', () => {
             // Parse succeeds for valid data
             expect(result.success).toBe(true);
         });
+        test('should accept payload with factors', () => {
+            const payload = {
+                factors: [
+                    {
+                        id: generateStrategyId(),
+                    },
+                ],
+                metadata: {},
+            };
+            const result = SettingsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.factors).toHaveLength(1);
+            }
+        });
+        test('should accept payload with nested factors', () => {
+            const payload = {
+                factors: [
+                    {
+                        id: generateStrategyId(),
+                        nextFactors: [
+                            {
+                                id: generateStrategyId(),
+                                nextFactors: [
+                                    {
+                                        id: generateStrategyId(),
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+                metadata: {},
+            };
+            const result = SettingsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.factors?.[0].nextFactors).toBeDefined();
+            }
+        });
+        test('should accept payload with null factors (transforms to undefined)', () => {
+            const payload = {
+                factors: null,
+                metadata: {},
+            };
+            const result = SettingsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.factors).toBeUndefined();
+            }
+        });
+        test('should accept payload with undefined factors', () => {
+            const payload = {
+                factors: undefined,
+                metadata: {},
+            };
+            const result = SettingsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.factors).toBeUndefined();
+            }
+        });
+        test('should reject payload with invalid factor structure', () => {
+            const payload = {
+                factors: [{ id: 123 }],
+                metadata: {},
+            };
+            const result = SettingsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(false);
+        });
+        test('should accept payload with deletedAt and deactivatedAt', () => {
+            const payload = {
+                updatedAt: new Date().toISOString(),
+                deletedAt: new Date().toISOString(),
+                deactivatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = SettingsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.deletedAt).toBeDefined();
+                expect(result.data.deactivatedAt).toBeDefined();
+            }
+        });
     });
     describe('UpsertSettingsPayloadSchema', () => {
         test('should accept empty upsert payload', () => {
@@ -76,5 +311,150 @@ describe('Authentication Settings - Schema', () => {
             const result = UpsertSettingsPayloadSchema.safeParse(payload);
             expect(result.success).toBe(false);
         });
+        test('should accept upsert with factors array', () => {
+            const payload = {
+                factors: [
+                    {
+                        id: generateStrategyId(),
+                    },
+                ],
+            };
+            const result = UpsertSettingsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.factors).toHaveLength(1);
+            }
+        });
+        test('should accept upsert with nested factors', () => {
+            const payload = {
+                factors: [
+                    {
+                        id: generateStrategyId(),
+                        nextFactors: [
+                            {
+                                id: generateStrategyId(),
+                            },
+                        ],
+                    },
+                ],
+            };
+            const result = UpsertSettingsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.factors?.[0].nextFactors).toHaveLength(1);
+            }
+        });
+        test('should accept upsert with multiple top-level factors', () => {
+            const payload = {
+                factors: [{ id: generateStrategyId() }, { id: generateStrategyId() }],
+            };
+            const result = UpsertSettingsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.factors).toHaveLength(2);
+            }
+        });
+        test('should accept upsert with null factors', () => {
+            const payload = {
+                factors: null,
+            };
+            const result = UpsertSettingsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(true);
+        });
+        test('should accept upsert with undefined factors', () => {
+            const payload = {
+                factors: undefined,
+            };
+            const result = UpsertSettingsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(true);
+        });
+        test('should accept upsert with deeply nested factors', () => {
+            const payload = {
+                factors: [
+                    {
+                        id: generateStrategyId(),
+                        nextFactors: [
+                            {
+                                id: generateStrategyId(),
+                                nextFactors: [
+                                    {
+                                        id: generateStrategyId(),
+                                        nextFactors: [
+                                            {
+                                                id: generateStrategyId(),
+                                            },
+                                        ],
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            };
+            const result = UpsertSettingsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                const firstFactor = result.data.factors?.[0];
+                expect(firstFactor?.nextFactors?.[0].nextFactors?.[0].nextFactors).toHaveLength(1);
+            }
+        });
+        test('should reject upsert with invalid factor id type', () => {
+            const payload = {
+                factors: [
+                    {
+                        id: 12345,
+                    },
+                ],
+            };
+            const result = UpsertSettingsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(false);
+        });
+        test('should reject upsert with factors as single object', () => {
+            const payload = {
+                factors: {
+                    id: generateStrategyId(),
+                },
+            };
+            const result = UpsertSettingsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(false);
+        });
+        test('should reject upsert with invalid nextFactors type', () => {
+            const payload = {
+                factors: [
+                    {
+                        id: generateStrategyId(),
+                        nextFactors: 'invalid',
+                    },
+                ],
+            };
+            const result = UpsertSettingsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(false);
+        });
+        test('should accept upsert with factors and metadata together', () => {
+            const payload = {
+                factors: [
+                    {
+                        id: generateStrategyId(),
+                    },
+                ],
+                metadata: { key: 'value' },
+            };
+            const result = UpsertSettingsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.factors).toHaveLength(1);
+                expect(result.data.metadata).toEqual({ key: 'value' });
+            }
+        });
+        test('should accept upsert with empty factors array', () => {
+            const payload = {
+                factors: [],
+            };
+            const result = UpsertSettingsPayloadSchema.safeParse(payload);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.factors).toHaveLength(0);
+            }
+        });
     });
 });

package/dist/esm/authentication/strategies/schema/base.d.ts

@@ -45,6 +45,7 @@ export declare const BaseStrategyPayloadSchema: z.ZodObject<{
     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";

package/dist/esm/authentication/strategies/schema/base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../../src/authentication/strategies/schema/base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAkB5B,eAAO,MAAM,YAAY;;;;CAIf,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAE/E,eAAO,MAAM,cAAc;;;CAGjB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAC3B,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,OAAO,cAAc,CAAC,CAAC;AAEvD,eAAO,MAAM,gBAAgB,aAAwC,CAAC;AACtE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE3D,eAAO,MAAM,wBAAwB;;iBAEnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE3E,eAAO,MAAM,oBAAoB;;;EAGtB,CAAC;AACZ,eAAO,MAAM,kBAAkB;;;;EAIpB,CAAC;AACZ,eAAO,MAAM,mBAAmB,aAAa,CAAC;AAE9C,eAAO,MAAM,kBAAkB;;;;;;;;;;;;iBAS7B,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;iBAQpC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;;;iBAK1C,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;;iBAI1C,CAAC"}
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../../src/authentication/strategies/schema/base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAkB5B,eAAO,MAAM,YAAY;;;;CAIf,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAE/E,eAAO,MAAM,cAAc;;;CAGjB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAC3B,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,OAAO,cAAc,CAAC,CAAC;AAEvD,eAAO,MAAM,gBAAgB,aAAwC,CAAC;AACtE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE3D,eAAO,MAAM,wBAAwB;;iBAEnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE3E,eAAO,MAAM,oBAAoB;;;EAGtB,CAAC;AACZ,eAAO,MAAM,kBAAkB;;;;EAIpB,CAAC;AACZ,eAAO,MAAM,mBAAmB,aAAa,CAAC;AAE9C,eAAO,MAAM,kBAAkB;;;;;;;;;;;;iBAS7B,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;iBASpC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;;;iBAK1C,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;;iBAI1C,CAAC"}

package/dist/esm/authentication/strategies/schema/base.js

@@ -37,6 +37,7 @@ export const BaseStrategySchema = z.object({
     ...MetadataMapPropertySchema.shape,
 });
 export const BaseStrategyPayloadSchema = z.object({
+    id: StrategyIdSchema,
     status: StrategyStatusSchema,
     label: StrategyLabelSchema,
     ...CreatedAtPropertyPayloadSchema.shape,

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

@@ -110,6 +110,7 @@ export declare const StrategyPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject
     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";
@@ -122,6 +123,7 @@ export declare const StrategyPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject
     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";
@@ -141,6 +143,7 @@ export declare const StrategyPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject
     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";

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

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../../src/authentication/strategies/schema/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAqB5B;;GAEG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAItC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAC9E,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAC1C,OAAO,2BAA2B,CACnC,CAAC;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAItC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAC9E,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAC1C,OAAO,2BAA2B,CACnC,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAIhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAIzB,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAChE,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,cAAc,CAAC,CAAC;AAEvD,OAAO,EACL,+BAA+B,EAC/B,yBAAyB,EACzB,+BAA+B,EAC/B,wBAAwB,EACxB,gBAAgB,EAChB,mBAAmB,EACnB,cAAc,EACd,oBAAoB,EACpB,YAAY,EACZ,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,UAAU,EACf,KAAK,kBAAkB,GACxB,MAAM,WAAW,CAAC;AACnB,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../../src/authentication/strategies/schema/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAqB5B;;GAEG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAItC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAC9E,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAC1C,OAAO,2BAA2B,CACnC,CAAC;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAItC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAC9E,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAC1C,OAAO,2BAA2B,CACnC,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAIhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAIzB,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAChE,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,cAAc,CAAC,CAAC;AAEvD,OAAO,EACL,+BAA+B,EAC/B,yBAAyB,EACzB,+BAA+B,EAC/B,wBAAwB,EACxB,gBAAgB,EAChB,mBAAmB,EACnB,cAAc,EACd,oBAAoB,EACpB,YAAY,EACZ,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,UAAU,EACf,KAAK,kBAAkB,GACxB,MAAM,WAAW,CAAC;AACnB,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC"}

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

@@ -22,6 +22,7 @@ export declare const EmailStrategyPayloadSchema: z.ZodObject<{
     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";

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":"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"}
+{"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.test.js

@@ -40,6 +40,7 @@ describe('Authentication Strategies - Email', () => {
     describe('EmailStrategyPayloadSchema', () => {
         test('should accept complete payload', () => {
             const payload = {
+                id: generateStrategyId(),
                 type: 'email',
                 label: 'Test',
                 status: 'enabled',

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

@@ -70,6 +70,7 @@ export declare const PasswordStrategyPayloadSchema: z.ZodObject<{
     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";

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

@@ -1 +1 @@
-{"version":3,"file":"password.d.ts","sourceRoot":"","sources":["../../../../../../src/authentication/strategies/schema/types/password.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAU5B,eAAO,MAAM,sBAAsB;;;;;;;CAOlC,CAAC;AAMF,eAAO,MAAM,oBAAoB;;;;;;;iBAO/B,CAAC;AAMH,eAAO,MAAM,sCAAsC;;;;;;;;;;;iBAEjD,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;iBAIjC,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAChF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEvE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;iBAIxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAC5C,OAAO,6BAA6B,CACrC,CAAC;AAEF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;iBAI9C,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,mCAAmC,CAC3C,CAAC;AACF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,MAAM,CAClD,OAAO,mCAAmC,CAC3C,CAAC;AAEF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;iBAI9C,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,mCAAmC,CAC3C,CAAC;AACF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,MAAM,CAClD,OAAO,mCAAmC,CAC3C,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;iBAG/B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;iBAI/B,CAAC"}
+{"version":3,"file":"password.d.ts","sourceRoot":"","sources":["../../../../../../src/authentication/strategies/schema/types/password.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAU5B,eAAO,MAAM,sBAAsB;;;;;;;CAOlC,CAAC;AAMF,eAAO,MAAM,oBAAoB;;;;;;;iBAO/B,CAAC;AAMH,eAAO,MAAM,sCAAsC;;;;;;;;;;;iBAEjD,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;iBAIjC,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAChF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEvE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;iBAIxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAC5C,OAAO,6BAA6B,CACrC,CAAC;AAEF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;iBAI9C,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,mCAAmC,CAC3C,CAAC;AACF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,MAAM,CAClD,OAAO,mCAAmC,CAC3C,CAAC;AAEF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;iBAI9C,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,mCAAmC,CAC3C,CAAC;AACF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,MAAM,CAClD,OAAO,mCAAmC,CAC3C,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;;;;iBAG/B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;iBAI/B,CAAC"}

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

@@ -69,6 +69,7 @@ export declare const TOTPStrategyPayloadSchema: z.ZodObject<{
     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";

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":"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"}
+{"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/common/schema/sets.d.ts

@@ -1,6 +1,6 @@
 import * as z from 'zod/v4';
 export declare const UniqueStringArraySchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>, z.ZodSet<z.ZodString>]>, z.ZodTransform<string[] | undefined, Set<string> | string[] | undefined>>;
 export declare const UniqueStringSetSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>, z.ZodSet<z.ZodString>]>, z.ZodTransform<Set<string> | undefined, Set<string> | string[] | undefined>>;
-export declare const UniqueUrlArraySchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodPipe<z.ZodUnion<[z.ZodArray<z.ZodPipe<z.ZodURL, z.ZodTransform<URL, string>>>, z.ZodArray<z.ZodCustom<URL, URL>>]>, z.ZodTransform<URL[], URL[]>>, z.ZodCustom<Set<URL>, Set<URL>>]>, z.ZodTransform<URL[] | undefined, Set<URL> | URL[] | undefined>>;
-export declare const UniqueUrlSetSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodPipe<z.ZodUnion<[z.ZodArray<z.ZodPipe<z.ZodURL, z.ZodTransform<URL, string>>>, z.ZodArray<z.ZodCustom<URL, URL>>]>, z.ZodTransform<URL[], URL[]>>, z.ZodCustom<Set<URL>, Set<URL>>]>, z.ZodTransform<Set<URL> | undefined, Set<URL> | URL[] | undefined>>;
+export declare const UniqueUrlArraySchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodPipe<z.ZodArray<z.ZodUnion<[z.ZodPipe<z.ZodURL, z.ZodTransform<URL, string>>, z.ZodCustom<URL, URL>]>>, z.ZodTransform<URL[], URL[]>>, z.ZodCustom<Set<URL>, Set<URL>>]>, z.ZodTransform<URL[] | undefined, Set<URL> | URL[] | undefined>>;
+export declare const UniqueUrlSetSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodPipe<z.ZodArray<z.ZodUnion<[z.ZodPipe<z.ZodURL, z.ZodTransform<URL, string>>, z.ZodCustom<URL, URL>]>>, z.ZodTransform<URL[], URL[]>>, z.ZodCustom<Set<URL>, Set<URL>>]>, z.ZodTransform<Set<URL> | undefined, Set<URL> | URL[] | undefined>>;
 //# sourceMappingURL=sets.d.ts.map

package/dist/esm/common/schema/sets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sets.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/sets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAQ5B,eAAO,MAAM,uBAAuB,2NAEwC,CAAC;AAE7E,eAAO,MAAM,qBAAqB,8NAEoC,CAAC;AAQvE,eAAO,MAAM,oBAAoB,4SAE2C,CAAC;AAE7E,eAAO,MAAM,kBAAkB,+SAEuC,CAAC"}
+{"version":3,"file":"sets.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/sets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAU5B,eAAO,MAAM,uBAAuB,2NAEwC,CAAC;AAE7E,eAAO,MAAM,qBAAqB,8NAEoC,CAAC;AAOvE,eAAO,MAAM,oBAAoB,gSAE2C,CAAC;AAE7E,eAAO,MAAM,kBAAkB,mSAEuC,CAAC"}

package/dist/esm/common/schema/sets.js

@@ -1,4 +1,5 @@
 import * as z from 'zod/v4';
+import { UrlObjectSchema } from './url.js';
 const StringSetTypeSchema = z.set(z.string());
 // const UrlStringSchema = type('string.url[]').pipe((v) => v?.filter((i) => !!i));
 const StringArrayTypeSchema = z
@@ -12,8 +13,7 @@ export const UniqueStringSetSchema = z
     .pipe(z.transform((v) => (!v || v instanceof Set ? v : new Set(v))));
 const UrlSetTypeSchema = z.instanceof((Set));
 const UrlArrayTypeScheama = z
-    .array(z.url().pipe(z.transform((url) => new URL(url))))
-    .or(z.array(z.instanceof(URL)))
+    .array(UrlObjectSchema)
     .pipe(z.transform((v) => v?.filter((i) => !!i)));
 export const UniqueUrlArraySchema = z
     .union([z.undefined(), UrlArrayTypeScheama, UrlSetTypeSchema])