@go-mondo/identity-sdk 0.0.2-beta.9 → 0.0.2-beta.91

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

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VerifyPasswordSchema = exports.ForgotPasswordSchema = exports.UpdatePasswordStrategyPayloadSchema = exports.InsertPasswordStrategyPayloadSchema = exports.PasswordStrategyPayloadSchema = exports.PasswordStrategySchema = exports.PasswordStrategySettingsPropertySchema = exports.PasswordPolicySchema = exports.PasswordPolicyDefaults = void 0;
-const arktype_1 = require("arktype");
-const schema_js_1 = require("../../../../identity/schema.js");
-const base_js_1 = require("../base.js");
-exports.PasswordPolicyDefaults = {
-    minimumLength: 8,
-    maximumLength: 36,
-    minimumCapital: 1,
-    minimumLower: 1,
-    minimumNumber: 1,
-    minimumSpecial: 1,
-};
-const TypeSchema = (0, arktype_1.type)({
-    type: "'password'",
-});
-exports.PasswordPolicySchema = (0, arktype_1.type)({
-    minimumLength: arktype_1.type.number.default(exports.PasswordPolicyDefaults.minimumLength),
-    maximumLength: arktype_1.type.number.default(exports.PasswordPolicyDefaults.maximumLength),
-    minimumCapital: arktype_1.type.number.default(exports.PasswordPolicyDefaults.minimumCapital),
-    minimumLower: arktype_1.type.number.default(exports.PasswordPolicyDefaults.minimumLower),
-    minimumNumber: arktype_1.type.number.default(exports.PasswordPolicyDefaults.minimumNumber),
-    minimumSpecial: arktype_1.type.number.default(exports.PasswordPolicyDefaults.minimumSpecial),
-});
-const SettingsSchema = (0, arktype_1.type)({
-    passwordPolicy: exports.PasswordPolicySchema,
-});
-exports.PasswordStrategySettingsPropertySchema = (0, arktype_1.type)({
-    settings: SettingsSchema,
-});
-exports.PasswordStrategySchema = base_js_1.BaseStrategySchema.and(TypeSchema).and({
-    settings: SettingsSchema,
-});
-exports.PasswordStrategyPayloadSchema = base_js_1.BaseStrategyPayloadSchema.and(TypeSchema).and(exports.PasswordStrategySettingsPropertySchema);
-exports.InsertPasswordStrategyPayloadSchema = TypeSchema.and(base_js_1.BaseInsertStrategyPayloadSchema)
-    .and(TypeSchema)
-    .and({
-    settings: SettingsSchema.optional(),
-});
-exports.UpdatePasswordStrategyPayloadSchema = TypeSchema.and(base_js_1.BaseUpdateStrategyPayloadSchema).and({
-    settings: SettingsSchema.optional(),
-});
-exports.ForgotPasswordSchema = (0, arktype_1.type)({
-    identifier: (0, arktype_1.type)('string').optional(),
-    identifierType: schema_js_1.IdentityIdentifierSchema.optional(),
-});
-exports.VerifyPasswordSchema = (0, arktype_1.type)({
-    password: (0, arktype_1.type)('string'),
-    identifier: (0, arktype_1.type)('string').optional(),
-    identifierType: schema_js_1.IdentityIdentifierSchema.optional(),
-});

package/dist/cjs/common/schema/sets.test.d.ts

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

package/dist/cjs/common/schema/sets.test.d.ts.map

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

package/dist/cjs/common/schema/sets.test.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const arktype_1 = require("arktype");
-const vitest_1 = require("vitest");
-const sets_js_1 = require("./sets.js");
-(0, vitest_1.describe)('Common Schema - Sets', () => {
-    (0, vitest_1.describe)('UniqueStringSetPayloadSchema', () => {
-        (0, vitest_1.test)('should accept Set of strings', () => {
-            const stringSet = new Set(['a', 'b', 'c']);
-            const result = (0, sets_js_1.UniqueStringSetPayloadSchema)(stringSet);
-            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
-            (0, vitest_1.expect)(result).toBeInstanceOf(Set);
-            (0, vitest_1.expect)(Array.from(result).sort()).toEqual(['a', 'b', 'c']);
-        });
-        (0, vitest_1.test)('should accept array of strings and convert to Set', () => {
-            const stringArray = ['x', 'y', 'z'];
-            const result = (0, sets_js_1.UniqueStringSetPayloadSchema)(stringArray);
-            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
-            (0, vitest_1.expect)(result).toBeInstanceOf(Set);
-            (0, vitest_1.expect)(Array.from(result).sort()).toEqual(['x', 'y', 'z']);
-        });
-        (0, vitest_1.test)('should handle duplicate strings in array', () => {
-            const stringArray = ['a', 'b', 'a', 'c', 'b'];
-            const result = (0, sets_js_1.UniqueStringSetPayloadSchema)(stringArray);
-            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
-            (0, vitest_1.expect)(result).toBeInstanceOf(Set);
-            (0, vitest_1.expect)(Array.from(result).sort()).toEqual(['a', 'b', 'c']);
-        });
-        (0, vitest_1.test)('should accept empty array', () => {
-            const result = (0, sets_js_1.UniqueStringSetPayloadSchema)([]);
-            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
-            (0, vitest_1.expect)(result).toBeInstanceOf(Set);
-            (0, vitest_1.expect)(result.size).toBe(0);
-        });
-        (0, vitest_1.test)('should accept empty Set', () => {
-            const emptySet = new Set();
-            const result = (0, sets_js_1.UniqueStringSetPayloadSchema)(emptySet);
-            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
-            (0, vitest_1.expect)(result).toBeInstanceOf(Set);
-            (0, vitest_1.expect)(result.size).toBe(0);
-        });
-        (0, vitest_1.test)('should reject non-string array elements', () => {
-            const result = (0, sets_js_1.UniqueStringSetPayloadSchema)(['a', 123, 'b']);
-            (0, vitest_1.expect)(result).toBeInstanceOf(arktype_1.type.errors);
-        });
-        (0, vitest_1.test)('should reject non-array, non-Set values', () => {
-            (0, vitest_1.expect)((0, sets_js_1.UniqueStringSetPayloadSchema)('string')).toBeInstanceOf(arktype_1.type.errors);
-            (0, vitest_1.expect)((0, sets_js_1.UniqueStringSetPayloadSchema)(123)).toBeInstanceOf(arktype_1.type.errors);
-            (0, vitest_1.expect)((0, sets_js_1.UniqueStringSetPayloadSchema)({})).toBeInstanceOf(arktype_1.type.errors);
-        });
-    });
-    (0, vitest_1.describe)('UniqueStringPayloadSchema', () => {
-        (0, vitest_1.test)('should convert Set to array', () => {
-            const stringSet = new Set(['x', 'y', 'z']);
-            const result = (0, sets_js_1.UniqueStringPayloadSchema)(stringSet);
-            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
-            (0, vitest_1.expect)(Array.isArray(result)).toBe(true);
-            (0, vitest_1.expect)(result.sort()).toEqual(['x', 'y', 'z']);
-        });
-        (0, vitest_1.test)('should convert array to unique array', () => {
-            const stringArray = ['a', 'b', 'a', 'c', 'b'];
-            const result = (0, sets_js_1.UniqueStringPayloadSchema)(stringArray);
-            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
-            (0, vitest_1.expect)(Array.isArray(result)).toBe(true);
-            (0, vitest_1.expect)(result.sort()).toEqual(['a', 'b', 'c']);
-        });
-        (0, vitest_1.test)('should handle empty inputs', () => {
-            const emptySet = new Set();
-            const emptyArray = [];
-            const setResult = (0, sets_js_1.UniqueStringPayloadSchema)(emptySet);
-            const arrayResult = (0, sets_js_1.UniqueStringPayloadSchema)(emptyArray);
-            (0, vitest_1.expect)(setResult).not.toBeInstanceOf(arktype_1.type.errors);
-            (0, vitest_1.expect)(arrayResult).not.toBeInstanceOf(arktype_1.type.errors);
-            (0, vitest_1.expect)(setResult.length).toBe(0);
-            (0, vitest_1.expect)(arrayResult.length).toBe(0);
-        });
-        (0, vitest_1.test)('should maintain order from original Set', () => {
-            const orderedSet = new Set(['first', 'second', 'third']);
-            const result = (0, sets_js_1.UniqueStringPayloadSchema)(orderedSet);
-            (0, vitest_1.expect)(result).not.toBeInstanceOf(arktype_1.type.errors);
-            (0, vitest_1.expect)(result).toEqual(['first', 'second', 'third']);
-        });
-    });
-});

package/dist/esm/action/schema/operations/set-password.d.ts

@@ -1,31 +0,0 @@
-export declare const SetPasswordActionPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    id: string;
-    attempt: number;
-    expiresAt: (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;
-    operation: "set-password";
-    user: string;
-    identifier: "email" | "phoneNumber";
-    policy: {
-        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 SetPasswordActionPayload = typeof SetPasswordActionPayloadSchema.inferOut;
-export declare const SetPasswordActionRequestSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    code: string;
-    password: string;
-}, {}>;
-export type SetPasswordActionRequest = typeof SetPasswordActionRequestSchema.inferOut;
-//# sourceMappingURL=set-password.d.ts.map

package/dist/esm/action/schema/operations/set-password.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"set-password.d.ts","sourceRoot":"","sources":["../../../../../src/action/schema/operations/set-password.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;MAKf,CAAC;AAC7B,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC;AAEjD,eAAO,MAAM,8BAA8B;;;MAGf,CAAC;AAC7B,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC"}

package/dist/esm/action/schema/operations/set-password.js

@@ -1,15 +0,0 @@
-import { type } from 'arktype';
-import { PasswordPolicySchema } from '../../../authentication/strategies/schema/schema.js';
-import { UserIdSchema } from '../../../customer/schema.js';
-import { IdentityIdentifierSchema } from '../../../identity/schema.js';
-import { BasePayloadSchema } from '../base.js';
-export const SetPasswordActionPayloadSchema = BasePayloadSchema.and({
-    operation: type("'set-password'"),
-    user: UserIdSchema,
-    identifier: IdentityIdentifierSchema,
-    policy: PasswordPolicySchema,
-}).onUndeclaredKey('delete');
-export const SetPasswordActionRequestSchema = type({
-    code: type('string'),
-    password: type('string'),
-}).onUndeclaredKey('delete');

package/dist/esm/action/schema/operations/set-password.test.d.ts

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

package/dist/esm/action/schema/operations/set-password.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"set-password.test.d.ts","sourceRoot":"","sources":["../../../../../src/action/schema/operations/set-password.test.ts"],"names":[],"mappings":""}

package/dist/esm/action/schema/operations/set-password.test.js

@@ -1,165 +0,0 @@
-import { type } from 'arktype';
-import { describe, expect, test } from 'vitest';
-import { generateUserId } from '../../../customer/schema.js';
-import { generateActionId } from '../utils.js';
-import { SetPasswordActionPayloadSchema, SetPasswordActionRequestSchema, } from './set-password.js';
-describe('Action Schema Operations - Set Password', () => {
-    describe('SetPasswordActionPayloadSchema', () => {
-        test('should accept complete payload with email identifier', () => {
-            const payload = {
-                id: generateActionId(),
-                operation: 'set-password',
-                user: generateUserId(),
-                identifier: 'email',
-                policy: {},
-                attempt: 1,
-                expiresAt: new Date().toISOString(),
-                updatedAt: new Date().toISOString(),
-                metadata: { key: 'value' },
-            };
-            const result = SetPasswordActionPayloadSchema(payload);
-            expect(result).not.toBeInstanceOf(type.errors);
-            // Policy defaults are applied, so we don't compare exact equality
-        });
-        test('should accept payload with phoneNumber identifier', () => {
-            const payload = {
-                id: generateActionId(),
-                operation: 'set-password',
-                user: generateUserId(),
-                identifier: 'phoneNumber',
-                policy: {},
-                attempt: 1,
-                expiresAt: new Date().toISOString(),
-                updatedAt: new Date().toISOString(),
-                metadata: {},
-            };
-            const result = SetPasswordActionPayloadSchema(payload);
-            expect(result).not.toBeInstanceOf(type.errors);
-            // Policy defaults are applied, so we don't compare exact equality
-        });
-        test('should accept payload with optional dates', () => {
-            const payload = {
-                id: generateActionId(),
-                operation: 'set-password',
-                user: generateUserId(),
-                identifier: 'email',
-                policy: {},
-                attempt: 2,
-                expiresAt: new Date().toISOString(),
-                updatedAt: new Date().toISOString(),
-                deletedAt: new Date().toISOString(),
-                deactivatedAt: new Date().toISOString(),
-                metadata: {},
-            };
-            const result = SetPasswordActionPayloadSchema(payload);
-            expect(result).not.toBeInstanceOf(type.errors);
-        });
-        test('should reject invalid operation', () => {
-            const payload = {
-                id: generateActionId(),
-                operation: 'invalid-operation',
-                user: generateUserId(),
-                identifier: 'email',
-                policy: {},
-                attempt: 1,
-                expiresAt: new Date().toISOString(),
-                updatedAt: new Date().toISOString(),
-                metadata: {},
-            };
-            const result = SetPasswordActionPayloadSchema(payload);
-            expect(result).toBeInstanceOf(type.errors);
-        });
-        test('should reject invalid identifier', () => {
-            const payload = {
-                id: generateActionId(),
-                operation: 'set-password',
-                user: generateUserId(),
-                identifier: 'username',
-                policy: {},
-                attempt: 1,
-                expiresAt: new Date().toISOString(),
-                updatedAt: new Date().toISOString(),
-                metadata: {},
-            };
-            const result = SetPasswordActionPayloadSchema(payload);
-            expect(result).toBeInstanceOf(type.errors);
-        });
-        test('should reject missing required fields', () => {
-            const payload = {
-                id: generateActionId(),
-                operation: 'set-password',
-                // missing user, identifier, policy, etc.
-            };
-            const result = SetPasswordActionPayloadSchema(payload);
-            expect(result).toBeInstanceOf(type.errors);
-        });
-        test('should delete undeclared keys', () => {
-            const payload = {
-                id: generateActionId(),
-                operation: 'set-password',
-                user: generateUserId(),
-                identifier: 'email',
-                policy: {},
-                attempt: 1,
-                expiresAt: new Date().toISOString(),
-                updatedAt: new Date().toISOString(),
-                metadata: {},
-                extraField: 'should be removed',
-            };
-            const result = SetPasswordActionPayloadSchema(payload);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).not.toHaveProperty('extraField');
-        });
-    });
-    describe('SetPasswordActionRequestSchema', () => {
-        test('should accept valid request', () => {
-            const request = {
-                code: 'reset_code_123',
-                password: 'NewPassword123!',
-            };
-            const result = SetPasswordActionRequestSchema(request);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual(request);
-        });
-        test('should reject missing code', () => {
-            const request = {
-                password: 'NewPassword123!',
-            };
-            const result = SetPasswordActionRequestSchema(request);
-            expect(result).toBeInstanceOf(type.errors);
-        });
-        test('should reject missing password', () => {
-            const request = {
-                code: 'reset_code_123',
-            };
-            const result = SetPasswordActionRequestSchema(request);
-            expect(result).toBeInstanceOf(type.errors);
-        });
-        test('should reject non-string values', () => {
-            const request1 = {
-                code: 123456,
-                password: 'NewPassword123!',
-            };
-            const request2 = {
-                code: 'reset_code_123',
-                password: 123456,
-            };
-            expect(SetPasswordActionRequestSchema(request1)).toBeInstanceOf(type.errors);
-            expect(SetPasswordActionRequestSchema(request2)).toBeInstanceOf(type.errors);
-        });
-        test('should delete undeclared keys', () => {
-            const request = {
-                code: 'reset_code_123',
-                password: 'NewPassword123!',
-                extraField: 'should be removed',
-            };
-            const result = SetPasswordActionRequestSchema(request);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).not.toHaveProperty('extraField');
-            expect(result).toEqual({
-                code: 'reset_code_123',
-                password: 'NewPassword123!',
-            });
-        });
-    });
-});

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

@@ -1,132 +0,0 @@
-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: "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>>;
-    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<{
-    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: "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

@@ -1 +0,0 @@
-{"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

@@ -1,49 +0,0 @@
-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/common/schema/sets.test.d.ts

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

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

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

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

@@ -1,82 +0,0 @@
-import { type } from 'arktype';
-import { describe, expect, test } from 'vitest';
-import { UniqueStringSetPayloadSchema, UniqueStringPayloadSchema, } from './sets.js';
-describe('Common Schema - Sets', () => {
-    describe('UniqueStringSetPayloadSchema', () => {
-        test('should accept Set of strings', () => {
-            const stringSet = new Set(['a', 'b', 'c']);
-            const result = UniqueStringSetPayloadSchema(stringSet);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toBeInstanceOf(Set);
-            expect(Array.from(result).sort()).toEqual(['a', 'b', 'c']);
-        });
-        test('should accept array of strings and convert to Set', () => {
-            const stringArray = ['x', 'y', 'z'];
-            const result = UniqueStringSetPayloadSchema(stringArray);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toBeInstanceOf(Set);
-            expect(Array.from(result).sort()).toEqual(['x', 'y', 'z']);
-        });
-        test('should handle duplicate strings in array', () => {
-            const stringArray = ['a', 'b', 'a', 'c', 'b'];
-            const result = UniqueStringSetPayloadSchema(stringArray);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toBeInstanceOf(Set);
-            expect(Array.from(result).sort()).toEqual(['a', 'b', 'c']);
-        });
-        test('should accept empty array', () => {
-            const result = UniqueStringSetPayloadSchema([]);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toBeInstanceOf(Set);
-            expect(result.size).toBe(0);
-        });
-        test('should accept empty Set', () => {
-            const emptySet = new Set();
-            const result = UniqueStringSetPayloadSchema(emptySet);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toBeInstanceOf(Set);
-            expect(result.size).toBe(0);
-        });
-        test('should reject non-string array elements', () => {
-            const result = UniqueStringSetPayloadSchema(['a', 123, 'b']);
-            expect(result).toBeInstanceOf(type.errors);
-        });
-        test('should reject non-array, non-Set values', () => {
-            expect(UniqueStringSetPayloadSchema('string')).toBeInstanceOf(type.errors);
-            expect(UniqueStringSetPayloadSchema(123)).toBeInstanceOf(type.errors);
-            expect(UniqueStringSetPayloadSchema({})).toBeInstanceOf(type.errors);
-        });
-    });
-    describe('UniqueStringPayloadSchema', () => {
-        test('should convert Set to array', () => {
-            const stringSet = new Set(['x', 'y', 'z']);
-            const result = UniqueStringPayloadSchema(stringSet);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(Array.isArray(result)).toBe(true);
-            expect(result.sort()).toEqual(['x', 'y', 'z']);
-        });
-        test('should convert array to unique array', () => {
-            const stringArray = ['a', 'b', 'a', 'c', 'b'];
-            const result = UniqueStringPayloadSchema(stringArray);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(Array.isArray(result)).toBe(true);
-            expect(result.sort()).toEqual(['a', 'b', 'c']);
-        });
-        test('should handle empty inputs', () => {
-            const emptySet = new Set();
-            const emptyArray = [];
-            const setResult = UniqueStringPayloadSchema(emptySet);
-            const arrayResult = UniqueStringPayloadSchema(emptyArray);
-            expect(setResult).not.toBeInstanceOf(type.errors);
-            expect(arrayResult).not.toBeInstanceOf(type.errors);
-            expect(setResult.length).toBe(0);
-            expect(arrayResult.length).toBe(0);
-        });
-        test('should maintain order from original Set', () => {
-            const orderedSet = new Set(['first', 'second', 'third']);
-            const result = UniqueStringPayloadSchema(orderedSet);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual(['first', 'second', 'third']);
-        });
-    });
-});