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

package/dist/esm/association/schema.js

@@ -1,8 +1,9 @@
-import { type } from 'arktype';
+import * as z from 'zod/v4';
 import { AppAssociationReferenceSchema } from '../app/schema.js';
+import { SessionAssociationReferenceSchema } from '../authentication/sessions/schema.js';
 import { PermissionAssociationReferenceSchema, RoleAssociationReferenceSchema, } from '../authorization/index.js';
-import { OptionalDatePayloadSchema, OptionalDateSchema, RequiredDatePayloadSchema, RequiredDateSchema, } from '../common/schema/dates.js';
-import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, } from '../common/schema/metadata.js';
+import { DeactivatedAtPropertyPayloadSchema, DeactivatedAtPropertySchema, DeletedAtPropertyPayloadSchema, DeletedAtPropertySchema, OptionalDatePayloadSchema, OptionalDateSchema, UpdatedAtPropertyPayloadSchema, UpdatedAtPropertySchema, } from '../common/schema/dates.js';
+import { MetadataMapPropertySchema, MetadataRecordPropertySchema, UpsertMetadataPropertySchema, } from '../common/schema/metadata.js';
 import { OrganizationAssociationReferenceSchema } from '../customer/organization/schema.js';
 import { UserAssociationReferenceSchema } from '../customer/users/schema.js';
 export const AssociationObjectType = {
@@ -11,40 +12,44 @@ export const AssociationObjectType = {
     ROLE: 'Role',
     APP: 'App',
     PERMISSION: 'Permission',
+    SESSION: 'Session',
 };
-export const AssociationIdReferenceSchema = type({
-    id: type('string'),
-});
-export const AssociationAttributesReferenceSchema = AssociationIdReferenceSchema.and('Record<string, unknown>');
-export const AssociationObjectSchema = UserAssociationReferenceSchema.or(OrganizationAssociationReferenceSchema)
-    .or(AppAssociationReferenceSchema)
-    .or(RoleAssociationReferenceSchema)
-    .or(PermissionAssociationReferenceSchema);
+export const AssociationObjectSchema = z.union([
+    UserAssociationReferenceSchema,
+    OrganizationAssociationReferenceSchema,
+    AppAssociationReferenceSchema,
+    RoleAssociationReferenceSchema,
+    PermissionAssociationReferenceSchema,
+    SessionAssociationReferenceSchema,
+]);
 // export type AssociationObject =
 //   | UserAssociationReference
 //   | OrganizationAssociationReference
 //   | AppAssociationReference
 //   | RoleAssociationReference
 //   | PermissionAssociationReference;
-export const ObjectPropertySchema = type({
+export const ObjectPropertySchema = z.object({
     object: AssociationObjectSchema,
 });
-export const AssociationSchema = ObjectPropertySchema.and({
-    expiresAt: RequiredDateSchema.optional(),
-    updatedAt: RequiredDateSchema,
-    deletedAt: OptionalDateSchema.optional(),
-    deactivatedAt: OptionalDateSchema.optional(),
-}).and(MetadataMapPropertySchema);
-const RootAssociationProperties = AssociationSchema.omit('object');
-const RootAssociation = AssociationSchema.omit('object');
-export const AssociationPayloadSchema = type({
-    'expiresAt?': OptionalDatePayloadSchema,
-    updatedAt: RequiredDatePayloadSchema,
-    'deletedAt?': OptionalDatePayloadSchema,
-    'deactivatedAt?': OptionalDatePayloadSchema,
-})
-    .and(ObjectPropertySchema)
-    .and(MetadataPayloadPropertySchema);
-export const UpsertAssociationPayloadSchema = type({
-    expiresAt: OptionalDatePayloadSchema.optional(),
-}).and(MetadataPayloadPropertySchema);
+export const AssociationSchema = z.object({
+    ...ObjectPropertySchema.shape,
+    expiresAt: OptionalDateSchema,
+    ...UpdatedAtPropertySchema.shape,
+    ...DeletedAtPropertySchema.shape,
+    ...DeactivatedAtPropertySchema.shape,
+    ...MetadataMapPropertySchema.shape,
+});
+const RootAssociationProperties = AssociationSchema.omit({ object: true });
+const RootAssociation = AssociationSchema.omit({ object: true });
+export const AssociationPayloadSchema = z.object({
+    ...ObjectPropertySchema.shape,
+    expiresAt: OptionalDatePayloadSchema,
+    ...UpdatedAtPropertyPayloadSchema.shape,
+    ...DeletedAtPropertyPayloadSchema.shape,
+    ...DeactivatedAtPropertyPayloadSchema.shape,
+    ...MetadataRecordPropertySchema.shape,
+});
+export const UpsertAssociationPayloadSchema = z.object({
+    expiresAt: OptionalDatePayloadSchema,
+    ...UpsertMetadataPropertySchema.shape,
+});

package/dist/esm/association/schema.test.js

@@ -1,9 +1,8 @@
-import { type } from 'arktype';
 import { describe, expect, test } from 'vitest';
 import { generateAppId } from '../app/utils.js';
 import { generatePermissionId, generateRoleId, } from '../authorization/schema.js';
 import { generateUserId } from '../customer/schema.js';
-import { AssociationObjectType, AssociationIdReferenceSchema, AssociationAttributesReferenceSchema, AssociationObjectSchema, } from './schema.js';
+import { AssociationObjectSchema, AssociationObjectType } from './schema.js';
 describe('Association - Schema', () => {
     describe('AssociationObjectType constants', () => {
         test('should have correct object type values', () => {
@@ -12,47 +11,7 @@ describe('Association - Schema', () => {
             expect(AssociationObjectType.ROLE).toBe('Role');
             expect(AssociationObjectType.APP).toBe('App');
             expect(AssociationObjectType.PERMISSION).toBe('Permission');
-        });
-    });
-    describe('AssociationIdReferenceSchema', () => {
-        test('should accept valid id reference', () => {
-            const reference = { id: 'any_string_id' };
-            const result = AssociationIdReferenceSchema(reference);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual(reference);
-        });
-        test('should reject missing id', () => {
-            const result = AssociationIdReferenceSchema({});
-            expect(result).toBeInstanceOf(type.errors);
-        });
-        test('should reject non-string id', () => {
-            const reference = { id: 123 };
-            const result = AssociationIdReferenceSchema(reference);
-            expect(result).toBeInstanceOf(type.errors);
-        });
-    });
-    describe('AssociationAttributesReferenceSchema', () => {
-        test('should accept id with additional attributes', () => {
-            const reference = {
-                id: 'test_id',
-                name: 'Test Name',
-                status: 'active',
-                metadata: { key: 'value' },
-            };
-            const result = AssociationAttributesReferenceSchema(reference);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual(reference);
-        });
-        test('should accept minimal reference with just id', () => {
-            const reference = { id: 'minimal_id' };
-            const result = AssociationAttributesReferenceSchema(reference);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual(reference);
-        });
-        test('should reject missing id', () => {
-            const reference = { name: 'Test', status: 'active' };
-            const result = AssociationAttributesReferenceSchema(reference);
-            expect(result).toBeInstanceOf(type.errors);
+            expect(AssociationObjectType.SESSION).toBe('Session');
         });
     });
     describe('AssociationObjectSchema', () => {
@@ -65,8 +24,8 @@ describe('Association - Schema', () => {
                 label: 'Test App',
                 model: 'App',
             };
-            const result = AssociationObjectSchema(appAssociation);
-            expect(result).not.toBeInstanceOf(type.errors);
+            const result = AssociationObjectSchema.safeParse(appAssociation);
+            // Parse succeeds for valid data
         });
         test('should accept Role association reference', () => {
             const roleAssociation = {
@@ -75,8 +34,8 @@ describe('Association - Schema', () => {
                 status: 'enabled',
                 model: 'Role',
             };
-            const result = AssociationObjectSchema(roleAssociation);
-            expect(result).not.toBeInstanceOf(type.errors);
+            const result = AssociationObjectSchema.safeParse(roleAssociation);
+            // Parse succeeds for valid data
         });
         test('should accept Permission association reference', () => {
             const permissionAssociation = {
@@ -85,8 +44,8 @@ describe('Association - Schema', () => {
                 status: 'enabled',
                 model: 'Permission',
             };
-            const result = AssociationObjectSchema(permissionAssociation);
-            expect(result).not.toBeInstanceOf(type.errors);
+            const result = AssociationObjectSchema.safeParse(permissionAssociation);
+            // Parse succeeds for valid data
         });
         test('should reject invalid association object', () => {
             const invalidAssociation = {
@@ -94,16 +53,16 @@ describe('Association - Schema', () => {
                 name: 'Test',
                 model: 'InvalidModel',
             };
-            const result = AssociationObjectSchema(invalidAssociation);
-            expect(result).toBeInstanceOf(type.errors);
+            const result = AssociationObjectSchema.safeParse(invalidAssociation);
+            expect(result.success).toBe(false);
         });
         test('should reject association missing required fields', () => {
             const incompleteAssociation = {
                 id: generateUserId(),
                 // missing required fields for any valid association type
             };
-            const result = AssociationObjectSchema(incompleteAssociation);
-            expect(result).toBeInstanceOf(type.errors);
+            const result = AssociationObjectSchema.safeParse(incompleteAssociation);
+            expect(result.success).toBe(false);
         });
         test('should reject association with mismatched model and data', () => {
             const mismatchedAssociation = {
@@ -112,8 +71,8 @@ describe('Association - Schema', () => {
                 status: 'enabled',
                 model: 'User', // but missing user fields
             };
-            const result = AssociationObjectSchema(mismatchedAssociation);
-            expect(result).toBeInstanceOf(type.errors);
+            const result = AssociationObjectSchema.safeParse(mismatchedAssociation);
+            expect(result.success).toBe(false);
         });
     });
 });

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

@@ -1,57 +1,47 @@
-export declare const AuthenticationFactorSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+import * as z from 'zod/v4';
+export type AuthenticationFactorType = {
     id: string;
-    nextFactors?: {
-        id: string;
-        nextFactors?: /*elided*/ any[] | null | undefined;
-    }[] | null | undefined;
-}, {}>;
-export type AuthenticationFactorProperties = typeof AuthenticationFactorPayloadSchema.inferIn;
-export type AuthenticationFactor = typeof AuthenticationFactorPayloadSchema.inferOut;
-export declare const AuthenticationFactorPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    nextFactors?: AuthenticationFactorType[] | undefined | null;
+};
+export declare const AuthenticationFactorSchema: z.ZodObject<{
+    id: z.ZodString;
+    nextFactors: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strip>>, z.ZodUndefined]>, z.ZodNull]>>;
+}, z.core.$strip>;
+export type AuthenticationFactorProperties = z.input<typeof AuthenticationFactorPayloadSchema>;
+export type AuthenticationFactor = z.output<typeof AuthenticationFactorPayloadSchema>;
+export declare const AuthenticationFactorPayloadSchema: z.ZodObject<{
+    id: z.ZodString;
+    nextFactors: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strip>>, z.ZodUndefined]>, z.ZodNull]>>;
+}, z.core.$strip>;
+export type AuthenticationFactorPayload = z.output<typeof AuthenticationFactorPayloadSchema>;
+export declare const AuthenticationFactorsSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    nextFactors: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strip>>, z.ZodUndefined]>, z.ZodNull]>>;
+}, z.core.$strip>>]>, z.ZodTransform<{
     id: string;
-    nextFactors?: {
-        id: string;
-        nextFactors?: /*elided*/ any[] | null | undefined;
-    }[] | null | undefined;
-}, {}>;
-export type AuthenticationFactorPayload = typeof AuthenticationFactorPayloadSchema.inferOut;
-export declare const AuthenticationFactorsSchema: import("arktype/internal/methods/object.ts").ObjectType<(In: {
+    nextFactors?: /*elided*/ any[] | null | undefined;
+}[] | undefined, {
     id: string;
-    nextFactors?: {
+    nextFactors?: /*elided*/ any[] | null | undefined;
+}[] | null | undefined>>;
+export type AuthenticationFactors = z.output<typeof AuthenticationFactorsSchema>;
+export declare const AuthenticationFactorsPayloadSchema: z.ZodObject<{
+    factors: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        nextFactors: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strip>>, z.ZodUndefined]>, z.ZodNull]>>;
+    }, z.core.$strip>>]>, z.ZodTransform<{
         id: string;
         nextFactors?: /*elided*/ any[] | null | undefined;
-    }[] | null | undefined;
-}[] | null | undefined) => import("arktype").Out<{
-    id: string;
-    nextFactors?: {
+    }[] | undefined, {
         id: string;
         nextFactors?: /*elided*/ any[] | null | undefined;
-    }[] | null | undefined;
-}[] | undefined>, {}>;
-export type AuthenticationFactors = typeof AuthenticationFactorsSchema.inferOut;
-export declare const AuthenticationFactorsPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    factors: (In: {
-        id: string;
-        nextFactors?: {
-            id: string;
-            nextFactors?: /*elided*/ any[] | null | undefined;
-        }[] | null | undefined;
-    }[] | null | undefined) => import("arktype").Out<{
-        id: string;
-        nextFactors?: {
-            id: string;
-            nextFactors?: /*elided*/ any[] | null | undefined;
-        }[] | null | undefined;
-    }[] | undefined>;
-}, {}>;
-export type AuthenticationFactorsPayload = typeof AuthenticationFactorsPayloadSchema.inferOut;
-export declare const UpsertAuthenticationFactorsPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    factors?: {
-        id: string;
-        nextFactors?: {
-            id: string;
-            nextFactors?: /*elided*/ any[] | null | undefined;
-        }[] | null | undefined;
-    }[] | null | undefined;
-}, {}>;
+    }[] | null | undefined>>;
+}, z.core.$strip>;
+export type AuthenticationFactorsPayload = z.output<typeof AuthenticationFactorsPayloadSchema>;
+export declare const UpsertAuthenticationFactorsPayloadSchema: z.ZodObject<{
+    factors: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        nextFactors: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strip>>, z.ZodUndefined]>, z.ZodNull]>>;
+    }, z.core.$strip>>, z.ZodUndefined, z.ZodNull]>>;
+}, z.core.$strip>;
 //# sourceMappingURL=schema.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/authentication/factors/schema.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,0BAA0B;;;;;;MAGrC,CAAC;AACH,MAAM,MAAM,8BAA8B,GACxC,OAAO,iCAAiC,CAAC,OAAO,CAAC;AACnD,MAAM,MAAM,oBAAoB,GAC9B,OAAO,iCAAiC,CAAC,QAAQ,CAAC;AAEpD,eAAO,MAAM,iCAAiC;;;;;;MAG5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GACrC,OAAO,iCAAiC,CAAC,QAAQ,CAAC;AAEpD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;qBAGK,CAAC;AAC9C,MAAM,MAAM,qBAAqB,GAAG,OAAO,2BAA2B,CAAC,QAAQ,CAAC;AAEhF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;MAE7C,CAAC;AACH,MAAM,MAAM,4BAA4B,GACtC,OAAO,kCAAkC,CAAC,QAAQ,CAAC;AAErD,eAAO,MAAM,wCAAwC;;;;;;;;MAInD,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/authentication/factors/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAI5B,MAAM,MAAM,wBAAwB,GAAG;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,CAAC,EAAE,wBAAwB,EAAE,GAAG,SAAS,GAAG,IAAI,CAAC;CAC7D,CAAC;AAoBF,eAAO,MAAM,0BAA0B;;;iBAAiC,CAAC;AACzE,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,iCAAiC,CACzC,CAAC;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CACzC,OAAO,iCAAiC,CACzC,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;iBAAiC,CAAC;AAChF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,MAAM,CAChD,OAAO,iCAAiC,CACzC,CAAC;AAEF,eAAO,MAAM,2BAA2B;;;;;;;;;wBAEgB,CAAC;AAOzD,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAC1C,OAAO,2BAA2B,CACnC,CAAC;AAEF,eAAO,MAAM,kCAAkC;;;;;;;;;;;iBAE7C,CAAC;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,MAAM,CACjD,OAAO,kCAAkC,CAC1C,CAAC;AAEF,eAAO,MAAM,wCAAwC;;;;;iBAQnD,CAAC"}

package/dist/esm/authentication/factors/schema.js

@@ -1,29 +1,35 @@
-import { scope, type } from 'arktype';
+import * as z from 'zod/v4';
 import { StrategyIdSchema } from '../strategies/schema/base.js';
-const factorScope = scope({
-    factor: {
-        id: StrategyIdSchema,
-        'nextFactors?': 'childFactors',
+const Category = z.object({
+    name: z.string(),
+    get subcategories() {
+        return z.array(Category);
     },
-    childFactors: 'factor[] | undefined | null',
-    'nextFactors?': 'factor[] | undefined | null',
 });
-export const AuthenticationFactorSchema = type({
+const AuthenticationFactorBaseSchema = z.object({
     id: StrategyIdSchema,
-    ...factorScope.export('nextFactors?'),
-});
-export const AuthenticationFactorPayloadSchema = type({
-    id: StrategyIdSchema,
-    ...factorScope.export('nextFactors?'),
+    get nextFactors() {
+        return z
+            .array(AuthenticationFactorBaseSchema)
+            .or(z.undefined())
+            .or(z.null())
+            .optional();
+    },
 });
-export const AuthenticationFactorsSchema = AuthenticationFactorPayloadSchema.array()
-    .or('undefined | null')
-    .pipe((f) => (f == null ? undefined : f));
-export const AuthenticationFactorsPayloadSchema = type({
+export const AuthenticationFactorSchema = AuthenticationFactorBaseSchema;
+export const AuthenticationFactorPayloadSchema = AuthenticationFactorBaseSchema;
+export const AuthenticationFactorsSchema = z
+    .union([z.undefined(), z.null(), z.array(AuthenticationFactorPayloadSchema)])
+    .pipe(z.transform((f) => (f == null ? undefined : f)));
+export const AuthenticationFactorsPayloadSchema = z.object({
     factors: AuthenticationFactorsSchema,
 });
-export const UpsertAuthenticationFactorsPayloadSchema = type({
-    factors: AuthenticationFactorPayloadSchema.array()
-        .or('undefined | null')
+export const UpsertAuthenticationFactorsPayloadSchema = z.object({
+    factors: z
+        .union([
+        z.array(AuthenticationFactorPayloadSchema),
+        z.undefined(),
+        z.null(),
+    ])
         .optional(),
 });

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

@@ -1,11 +1,10 @@
-import { type } from 'arktype';
 import { describe, expect, test } from 'vitest';
 import { generateStrategyId } from '../utils.js';
 import { AuthenticationFactorPayloadSchema, AuthenticationFactorsPayloadSchema, UpsertAuthenticationFactorsPayloadSchema, } from './schema.js';
 describe('Authentication - Factors', () => {
     describe('Schema', () => {
         test('should parse response payload successfully', async () => {
-            expect(AuthenticationFactorsPayloadSchema({
+            expect(AuthenticationFactorsPayloadSchema.safeParse({
                 createdAt: new Date(),
                 updatedAt: new Date(),
                 factors: [
@@ -13,62 +12,62 @@ describe('Authentication - Factors', () => {
                         id: generateStrategyId(),
                     },
                 ],
-            })).not.toBeInstanceOf(type.errors);
+            }).success).toBe(true);
             // Undefined factors
-            expect(AuthenticationFactorsPayloadSchema({
+            expect(AuthenticationFactorsPayloadSchema.safeParse({
                 createdAt: new Date(),
                 updatedAt: new Date(),
                 factors: undefined,
-            })).not.toBeInstanceOf(type.errors);
+            }).success).toBe(true);
         });
         test('should parse upsert payload successfully', async () => {
-            expect(UpsertAuthenticationFactorsPayloadSchema({
+            expect(UpsertAuthenticationFactorsPayloadSchema.safeParse({
                 factors: [
                     {
                         id: generateStrategyId(),
                     },
                 ],
-            })).not.toBeInstanceOf(type.errors);
+            }).success).toBe(true);
             // Null factors
-            expect(UpsertAuthenticationFactorsPayloadSchema({
+            expect(UpsertAuthenticationFactorsPayloadSchema.safeParse({
                 factors: null,
-            })).not.toBeInstanceOf(type.errors);
+            }).success).toBe(true);
             // Undefined factors
-            expect(UpsertAuthenticationFactorsPayloadSchema({
+            expect(UpsertAuthenticationFactorsPayloadSchema.safeParse({
                 factors: undefined,
-            })).not.toBeInstanceOf(type.errors);
+            }).success).toBe(true);
         });
         test('should throw error for invalid factors', async () => {
             // Factor object
-            expect(AuthenticationFactorsPayloadSchema({
+            expect(AuthenticationFactorsPayloadSchema.safeParse({
                 createdAt: new Date(),
                 updatedAt: new Date(),
                 factors: { id: generateStrategyId() },
-            })).toBeInstanceOf(type.errors);
+            }).success).toBe(false);
             // Factor array of string
-            expect(AuthenticationFactorsPayloadSchema({
+            expect(AuthenticationFactorsPayloadSchema.safeParse({
                 createdAt: new Date(),
                 updatedAt: new Date(),
                 factors: [generateStrategyId()],
-            })).toBeInstanceOf(type.errors);
+            }).success).toBe(false);
         });
         test('should accept various next factors types', async () => {
             // Undefined
-            expect(AuthenticationFactorPayloadSchema({
+            expect(AuthenticationFactorPayloadSchema.safeParse({
                 id: generateStrategyId(),
                 nextFactors: undefined,
-            })).not.toBeInstanceOf(type.errors);
+            }).success).toBe(true);
             // Array
-            expect(AuthenticationFactorPayloadSchema({
+            expect(AuthenticationFactorPayloadSchema.safeParse({
                 id: generateStrategyId(),
                 nextFactors: [
                     {
                         id: generateStrategyId(),
                     },
                 ],
-            })).not.toBeInstanceOf(type.errors);
+            }).success).toBe(true);
             // Deeply nested array
-            expect(AuthenticationFactorPayloadSchema({
+            expect(AuthenticationFactorPayloadSchema.safeParse({
                 id: generateStrategyId(),
                 nextFactors: [
                     {
@@ -85,38 +84,38 @@ describe('Authentication - Factors', () => {
                         ],
                     },
                 ],
-            })).not.toBeInstanceOf(type.errors);
+            }).success).toBe(true);
         });
         test('should throw error for invalid factor id', async () => {
             // Number
-            expect(AuthenticationFactorsPayloadSchema({
-                id: generateStrategyId(),
-            })).toBeInstanceOf(type.errors);
+            expect(AuthenticationFactorPayloadSchema.safeParse({
+                id: 123,
+            }).success).toBe(false);
             // Null
-            expect(AuthenticationFactorsPayloadSchema({
+            expect(AuthenticationFactorPayloadSchema.safeParse({
                 id: null,
-            })).toBeInstanceOf(type.errors);
+            }).success).toBe(false);
             // Undefined
-            expect(AuthenticationFactorsPayloadSchema({
+            expect(AuthenticationFactorPayloadSchema.safeParse({
                 id: undefined,
-            })).toBeInstanceOf(type.errors);
+            }).success).toBe(false);
         });
         test('should throw error for invalid next factors', async () => {
             // String
-            expect(AuthenticationFactorsPayloadSchema({
+            expect(AuthenticationFactorPayloadSchema.safeParse({
                 id: generateStrategyId(),
                 nextFactors: generateStrategyId(),
-            })).toBeInstanceOf(type.errors);
+            }).success).toBe(false);
             // Object
-            expect(AuthenticationFactorsPayloadSchema({
+            expect(AuthenticationFactorPayloadSchema.safeParse({
                 id: generateStrategyId(),
                 nextFactors: { id: generateStrategyId() },
-            })).toBeInstanceOf(type.errors);
+            }).success).toBe(false);
             // Array
-            expect(AuthenticationFactorsPayloadSchema({
+            expect(AuthenticationFactorPayloadSchema.safeParse({
                 id: generateStrategyId(),
                 nextFactors: [generateStrategyId()],
-            })).toBeInstanceOf(type.errors);
+            }).success).toBe(false);
         });
     });
 });

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

@@ -1,3 +1,4 @@
+export * from './utils.js';
 export * from './factors/schema.js';
 export * from './providers/schema.js';
 export * from './sessions/resources.js';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/authentication/index.ts"],"names":[],"mappings":"AACA,cAAc,qBAAqB,CAAC;AAGpC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AAGrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AAGrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/authentication/index.ts"],"names":[],"mappings":"AACA,cAAc,YAAY,CAAC;AAG3B,cAAc,qBAAqB,CAAC;AAGpC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AAGrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AAGrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC"}

package/dist/esm/authentication/index.js

@@ -1,3 +1,5 @@
+// Common
+export * from './utils.js';
 // Factors
 export * from './factors/schema.js';
 // Providers

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

@@ -1,27 +1,28 @@
+import * as z from 'zod/v4';
 export declare const ProviderType: {
     readonly MONDO: "mondo";
 };
 export type AnyProviderType = (typeof ProviderType)[keyof typeof ProviderType];
-export declare const ProviderIdSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
-export type ProviderId = typeof ProviderIdSchema.inferOut;
-export declare const ProviderIdPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    id: string;
-}, {}>;
-export type ProviderIdProperty = typeof ProviderIdPropertySchema.inferOut;
-export declare const ProviderTypeSchema: import("arktype/internal/methods/string.ts").StringType<"mondo", {}>;
-export declare const ProviderPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    id: string;
-    type: "mondo";
-    user: string;
-    strategy: 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;
-}, {}>;
-export type ProviderPayload = typeof ProviderPayloadSchema.inferOut;
+export declare const ProviderIdSchema: z.ZodString;
+export type ProviderId = z.output<typeof ProviderIdSchema>;
+export declare const ProviderIdPropertySchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type ProviderIdProperty = z.output<typeof ProviderIdPropertySchema>;
+export declare const ProviderTypeSchema: z.ZodEnum<{
+    mondo: "mondo";
+}>;
+export declare const ProviderPayloadSchema: z.ZodObject<{
+    metadata: z.ZodPipe<z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodMap<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<import("../../common/schema/metadata.js").MetadataRecord, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>, z.ZodTransform<import("../../common/schema/metadata.js").MetadataRecord | undefined, import("../../common/schema/metadata.js").MetadataRecord | 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>>;
+    type: z.ZodEnum<{
+        mondo: "mondo";
+    }>;
+    user: z.ZodString;
+    strategy: z.ZodString;
+    id: z.ZodString;
+}, z.core.$strip>;
+export type ProviderPayload = z.output<typeof ProviderPayloadSchema>;
 //# sourceMappingURL=schema.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/authentication/providers/schema.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,YAAY;;CAEf,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAE/E,eAAO,MAAM,gBAAgB,qEAAc,CAAC;AAC5C,MAAM,MAAM,UAAU,GAAG,OAAO,gBAAgB,CAAC,QAAQ,CAAC;AAE1D,eAAO,MAAM,wBAAwB;;MAEnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,wBAAwB,CAAC,QAAQ,CAAC;AAE1E,eAAO,MAAM,kBAAkB,sEAAsC,CAAC;AAEtE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;MAOG,CAAC;AACtC,MAAM,MAAM,eAAe,GAAG,OAAO,qBAAqB,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/authentication/providers/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAU5B,eAAO,MAAM,YAAY;;CAEf,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAE/E,eAAO,MAAM,gBAAgB,aAAa,CAAC;AAC3C,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,kBAAkB;;EAAwC,CAAC;AAExE,eAAO,MAAM,qBAAqB;;;;;;;;;;;iBAShC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/esm/authentication/providers/schema.js

@@ -1,21 +1,23 @@
-import { type } from 'arktype';
-import { OptionalDatePayloadSchema, RequiredDatePayloadSchema, } from '../../common/schema/dates.js';
-import { MetadataPayloadPropertySchema } from '../../common/schema/metadata.js';
+import * as z from 'zod/v4';
+import { DeactivatedAtPropertyPayloadSchema, DeletedAtPropertyPayloadSchema, UpdatedAtPropertyPayloadSchema, } from '../../common/schema/dates.js';
+import { MetadataRecordPropertySchema } from '../../common/schema/metadata.js';
 import { UserIdSchema } from '../../customer/schema.js';
 import { StrategyIdSchema } from '../strategies/schema/base.js';
 export const ProviderType = {
     MONDO: 'mondo',
 };
-export const ProviderIdSchema = type.string;
-export const ProviderIdPropertySchema = type({
+export const ProviderIdSchema = z.string();
+export const ProviderIdPropertySchema = z.object({
     id: ProviderIdSchema,
 });
-export const ProviderTypeSchema = type.enumerated(ProviderType.MONDO);
-export const ProviderPayloadSchema = ProviderIdPropertySchema.and({
+export const ProviderTypeSchema = z.enum([ProviderType.MONDO]);
+export const ProviderPayloadSchema = z.object({
+    ...ProviderIdPropertySchema.shape,
     type: ProviderTypeSchema,
     user: UserIdSchema,
     strategy: StrategyIdSchema,
-    updatedAt: RequiredDatePayloadSchema,
-    'deletedAt?': OptionalDatePayloadSchema,
-    'deactivatedAt?': OptionalDatePayloadSchema,
-}).and(MetadataPayloadPropertySchema);
+    ...UpdatedAtPropertyPayloadSchema.shape,
+    ...DeletedAtPropertyPayloadSchema.shape,
+    ...DeactivatedAtPropertyPayloadSchema.shape,
+    ...MetadataRecordPropertySchema.shape,
+});