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

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

@@ -1,83 +1,82 @@
-import { type } from 'arktype';
 import { describe, expect, test } from 'vitest';
 import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, UpsertMetadataPayloadSchema, } from './metadata.js';
 describe('Common - Metadata', () => {
     describe('Map Property Schema', () => {
         test('should parse a record to a map', async () => {
-            const result = MetadataMapPropertySchema({
+            const result = MetadataMapPropertySchema.safeParse({
                 metadata: { foo: 'bar' },
             });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result?.metadata).toBeInstanceOf(Map);
+            // Parse succeeds for valid data
+            expect(result.data?.metadata).toBeInstanceOf(Map);
         });
         test('should parse undefined property to a map', async () => {
-            const result = MetadataMapPropertySchema({
+            const result = MetadataMapPropertySchema.safeParse({
                 metadata: undefined,
             });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result?.metadata).toBeInstanceOf(Map);
+            // Parse succeeds for valid data
+            expect(result.data?.metadata).toBeInstanceOf(Map);
         });
         test('should parse undefined to a map', async () => {
-            const result = MetadataMapPropertySchema({});
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result?.metadata).toBeInstanceOf(Map);
+            const result = MetadataMapPropertySchema.safeParse({});
+            // Parse succeeds for valid data
+            expect(result.data?.metadata).toBeInstanceOf(Map);
         });
         test('should parse map to a map', async () => {
-            const result = MetadataMapPropertySchema({
+            const result = MetadataMapPropertySchema.safeParse({
                 metadata: new Map([['foo', 'bar']]),
             });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result?.metadata).toBeInstanceOf(Map);
+            // Parse succeeds for valid data
+            expect(result.data?.metadata).toBeInstanceOf(Map);
         });
         test('should parse null to a map', async () => {
-            const result = MetadataMapPropertySchema({
+            const result = MetadataMapPropertySchema.safeParse({
                 metadata: null,
             });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result?.metadata).toBeInstanceOf(Map);
+            // Parse succeeds for valid data
+            expect(result.data?.metadata).toBeInstanceOf(Map);
         });
     });
     describe('Payload', () => {
         test('should parse map to record', async () => {
-            const result = MetadataPayloadPropertySchema({
+            const result = MetadataPayloadPropertySchema.safeParse({
                 metadata: new Map([
                     ['foo', 'bar'],
                     ['baz', 0],
                 ]),
             });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result?.metadata?.foo).to.equal('bar');
-            expect(result?.metadata?.baz).to.equal(0);
+            // Parse succeeds for valid data
+            expect(result.data?.metadata?.foo).to.equal('bar');
+            expect(result.data?.metadata?.baz).to.equal(0);
         });
         test('should return undefined if map is empty', async () => {
-            const result = MetadataPayloadPropertySchema({
+            const result = MetadataPayloadPropertySchema.safeParse({
                 metadata: new Map(),
             });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result?.metadata).is.undefined;
+            // Parse succeeds for valid data
+            expect(result.data?.metadata).is.undefined;
         });
     });
     describe('Upsert Metadata Payload Schema', () => {
         test('should handle incoming record', async () => {
-            const result = UpsertMetadataPayloadSchema({
+            const result = UpsertMetadataPayloadSchema.safeParse({
                 foo: 'bar',
                 bar: 'baz',
             });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result?.foo).to.equal('bar');
-            expect(result?.bar).to.equal('baz');
+            // Parse succeeds for valid data
+            expect(result.data?.foo).to.equal('bar');
+            expect(result.data?.bar).to.equal('baz');
         });
         test('should handle incoming map', async () => {
-            const result = UpsertMetadataPayloadSchema(new Map([
+            const result = UpsertMetadataPayloadSchema.safeParse(new Map([
                 ['foo', 'bar'],
                 ['bar', 'baz'],
             ]));
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result?.foo).to.equal('bar');
-            expect(result?.bar).to.equal('baz');
+            // Parse succeeds for valid data
+            expect(result.data?.foo).to.equal('bar');
+            expect(result.data?.bar).to.equal('baz');
         });
         test('should only allow 10 items', async () => {
-            const result = UpsertMetadataPayloadSchema(new Map([
+            const result = UpsertMetadataPayloadSchema.safeParse(new Map([
                 ['1', '1'],
                 ['2', '2'],
                 ['3', '3'],
@@ -90,20 +89,20 @@ describe('Common - Metadata', () => {
                 ['10', '10'],
                 ['11', '11'],
             ]));
-            expect(result).toBeInstanceOf(type.errors);
+            expect(result.success).toBe(false);
         });
     });
     describe('Map Property Schema', () => {
         test('should parse map to record', async () => {
-            const result = MetadataMapPropertySchema({
+            const result = MetadataMapPropertySchema.safeParse({
                 metadata: {
                     foo: 'bar',
                     bar: 'baz',
                 },
             });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result?.metadata?.get('foo')).to.equal('bar');
-            expect(result?.metadata?.get('bar')).to.equal('baz');
+            // Parse succeeds for valid data
+            expect(result.data?.metadata?.get('foo')).to.equal('bar');
+            expect(result.data?.metadata?.get('bar')).to.equal('baz');
         });
     });
 });

package/dist/esm/common/schema/pagination.d.ts

@@ -1,6 +1,7 @@
-export declare const PaginationSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    pageSize?: string | number | null | undefined;
-    nextToken?: string | null | undefined;
-}, {}>;
-export type Pagination = typeof PaginationSchema.inferOut;
+import { z } from 'zod';
+export declare const PaginationSchema: z.ZodObject<{
+    pageSize: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>;
+    nextToken: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+}, z.core.$strip>;
+export type Pagination = z.output<typeof PaginationSchema>;
 //# sourceMappingURL=pagination.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"pagination.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/pagination.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB;;;MAG3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,OAAO,gBAAgB,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"pagination.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/pagination.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,gBAAgB;;;iBAG3B,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

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

@@ -1,5 +1,5 @@
-import { type } from 'arktype';
-export const PaginationSchema = type({
-    pageSize: type('string | number | null').optional(),
-    nextToken: type('string | null').optional(),
+import { z } from 'zod';
+export const PaginationSchema = z.object({
+    pageSize: z.union([z.string(), z.number(), z.null()]).optional(),
+    nextToken: z.union([z.string(), z.null()]).optional(),
 });

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

@@ -1,66 +1,65 @@
-import { type } from 'arktype';
 import { describe, expect, test } from 'vitest';
 import { PaginationSchema } from './pagination.js';
 describe('Common Schema - Pagination', () => {
     describe('PaginationSchema', () => {
         test('should accept valid pagination with pageSize as string', () => {
-            const result = PaginationSchema({
+            const result = PaginationSchema.safeParse({
                 pageSize: '10',
                 nextToken: 'token123',
             });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual({
+            // Parse succeeds for valid data
+            expect(result.data).toEqual({
                 pageSize: '10',
                 nextToken: 'token123',
             });
         });
         test('should accept valid pagination with pageSize as number', () => {
-            const result = PaginationSchema({
+            const result = PaginationSchema.safeParse({
                 pageSize: 20,
                 nextToken: 'token456',
             });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual({
+            // Parse succeeds for valid data
+            expect(result.data).toEqual({
                 pageSize: 20,
                 nextToken: 'token456',
             });
         });
         test('should accept pagination with only pageSize', () => {
-            const result = PaginationSchema({
+            const result = PaginationSchema.safeParse({
                 pageSize: '15',
             });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual({
+            // Parse succeeds for valid data
+            expect(result.data).toEqual({
                 pageSize: '15',
             });
         });
         test('should accept pagination with only nextToken', () => {
-            const result = PaginationSchema({
+            const result = PaginationSchema.safeParse({
                 nextToken: 'token789',
             });
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual({
+            // Parse succeeds for valid data
+            expect(result.data).toEqual({
                 nextToken: 'token789',
             });
         });
         test('should accept empty pagination object', () => {
-            const result = PaginationSchema({});
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual({});
+            const result = PaginationSchema.safeParse({});
+            // Parse succeeds for valid data
+            expect(result.data).toEqual({});
         });
         test('should reject invalid pageSize type', () => {
-            const result = PaginationSchema({
+            const result = PaginationSchema.safeParse({
                 pageSize: true,
                 nextToken: 'token123',
             });
-            expect(result).toBeInstanceOf(type.errors);
+            expect(result.success).toBe(false);
         });
         test('should reject invalid nextToken type', () => {
-            const result = PaginationSchema({
+            const result = PaginationSchema.safeParse({
                 pageSize: '10',
                 nextToken: 123,
             });
-            expect(result).toBeInstanceOf(type.errors);
+            expect(result.success).toBe(false);
         });
     });
 });

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

@@ -1,4 +1,4 @@
-import type { type } from 'arktype';
+import { z } from 'zod';
 export * from './aggregate.js';
 export * from './collection.js';
 export * from './dates.js';
@@ -7,7 +7,7 @@ export * from './metadata.js';
 export * from './pagination.js';
 export * from './sets.js';
 export * from './url.js';
-export declare const optionallyNullishToUndefined: <t extends type.Any>(t: t) => [type<t["t"]>, "?"];
-export declare const optionallyNullish: <t extends type.Any>(t: t) => [type<t["t"] | null | undefined>, "?"];
-export declare const optionallyUndefined: <t extends type.Any>(t: t) => [type<t["t"] | undefined>, "?"];
+export declare const optionallyNullishToUndefined: <T extends z.ZodTypeAny>(t: T) => z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [T, z.ZodNull, z.ZodUndefined]>, z.ZodTransform<Awaited<NonNullable<z.core.$InferUnionOutput<T>>> | undefined, z.core.$InferUnionOutput<T> | null | undefined>>>;
+export declare const optionallyNullish: <T extends z.ZodTypeAny>(t: T) => z.ZodOptional<z.ZodUnion<readonly [T, z.ZodNull, z.ZodUndefined]>>;
+export declare const optionallyUndefined: <T extends z.ZodTypeAny>(t: T) => z.ZodOptional<z.ZodUnion<readonly [T, z.ZodUndefined]>>;
 //# sourceMappingURL=schema.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAQ,IAAI,EAAE,MAAM,SAAS,CAAC;AAE1C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AAEzB,eAAO,MAAM,4BAA4B,GAAI,CAAC,SAAS,IAAI,CAAC,GAAG,EAC7D,GAAG,CAAC,KACH,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAIG,CAAC;AAEzB,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,IAAI,CAAC,GAAG,EAClD,GAAG,CAAC,KACH,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,GAAG,CACgB,CAAC;AAEzD,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,IAAI,CAAC,GAAG,EACpD,GAAG,CAAC,KACH,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,EAAE,GAAG,CACgB,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AAEzB,eAAO,MAAM,4BAA4B,GAAI,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,GAAG,CAAC,iNAI1D,CAAC;AAEhB,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,GAAG,CAAC,uEACZ,CAAC;AAEnD,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,GAAG,CAAC,4DACxB,CAAC"}

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

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 export * from './aggregate.js';
 export * from './collection.js';
 export * from './dates.js';
@@ -6,9 +7,9 @@ export * from './metadata.js';
 export * from './pagination.js';
 export * from './sets.js';
 export * from './url.js';
-export const optionallyNullishToUndefined = (t) => t
-    .or('null | undefined')
-    .pipe((v) => (v == null ? undefined : v))
+export const optionallyNullishToUndefined = (t) => z
+    .union([t, z.null(), z.undefined()])
+    .pipe(z.transform((v) => (v == null ? undefined : v)))
     .optional();
-export const optionallyNullish = (t) => t.or('null | undefined').optional();
-export const optionallyUndefined = (t) => t.or('undefined').optional();
+export const optionallyNullish = (t) => z.union([t, z.null(), z.undefined()]).optional();
+export const optionallyUndefined = (t) => z.union([t, z.undefined()]).optional();

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

@@ -1,32 +1,26 @@
-import { type } from 'arktype';
 import { describe, expect, test } from 'vitest';
+import { z } from 'zod';
 import { optionallyNullishToUndefined } from './schema.js';
 describe('Common Schema', () => {
     describe('optionallyNullishToUndefined', () => {
         test('should parse null string successfully', async () => {
-            const Schema = type({
-                foo: optionallyNullishToUndefined(type('string')),
+            const Schema = z.object({
+                foo: optionallyNullishToUndefined(z.string()),
             });
-            const result = Schema.assert({
+            const result = Schema.parse({
                 foo: null,
             });
-            if (result instanceof type.errors) {
-                console.log(result.summary);
-            }
-            expect(result).not.toBeInstanceOf(type.errors);
+            // Parse succeeds for valid data
             expect(result.foo).toBeUndefined();
         });
         test('should parse undefined string successfully', async () => {
-            const Schema = type({
-                foo: optionallyNullishToUndefined(type('string')),
+            const Schema = z.object({
+                foo: optionallyNullishToUndefined(z.string()),
             });
-            const result = Schema.assert({
+            const result = Schema.parse({
                 foo: undefined,
             });
-            if (result instanceof type.errors) {
-                console.log(result.summary);
-            }
-            expect(result).not.toBeInstanceOf(type.errors);
+            // Parse succeeds for valid data
             expect(result.foo).toBeUndefined();
         });
     });

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

@@ -1,3 +1,4 @@
-export declare const UniqueStringSetPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<Set<string> | ((In: string[]) => import("arktype").Out<Set<string>>), {}>;
-export declare const UniqueStringPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<(In: Set<string> | string[]) => import("arktype").Out<string[]>, {}>;
+import { z } from 'zod';
+export declare const UniqueStringSetPayloadSchema: z.ZodUnion<readonly [z.ZodCustom<Set<string>, Set<string>>, z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<Set<string>, string[]>>]>;
+export declare const UniqueStringPayloadSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodCustom<Set<string>, Set<string>>, z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<Set<string>, string[]>>]>, z.ZodTransform<string[], Set<string>>>;
 //# 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":"AAMA,eAAO,MAAM,4BAA4B,mIAAiC,CAAC;AAC3E,eAAO,MAAM,yBAAyB,8HAErC,CAAC"}
+{"version":3,"file":"sets.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/sets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,4BAA4B,yIAGvC,CAAC;AACH,eAAO,MAAM,yBAAyB,2LAErC,CAAC"}

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

@@ -1,6 +1,9 @@
-import { type } from 'arktype';
-const StringArraySchema = type('string[]');
-const StringArrayToSet = StringArraySchema.pipe((s) => new Set(s));
-const StringSet = type.instanceOf((Set));
-export const UniqueStringSetPayloadSchema = StringSet.or(StringArrayToSet);
-export const UniqueStringPayloadSchema = UniqueStringSetPayloadSchema.pipe((s) => Array.from(s.values()));
+import { z } from 'zod';
+const StringArraySchema = z.array(z.string());
+const StringArrayToSet = StringArraySchema.pipe(z.transform((s) => new Set(s)));
+const StringSet = z.instanceof((Set));
+export const UniqueStringSetPayloadSchema = z.union([
+    StringSet,
+    StringArrayToSet,
+]);
+export const UniqueStringPayloadSchema = UniqueStringSetPayloadSchema.pipe(z.transform((s) => Array.from(s.values())));

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

@@ -1,82 +1,91 @@
-import { type } from 'arktype';
 import { describe, expect, test } from 'vitest';
-import { UniqueStringSetPayloadSchema, UniqueStringPayloadSchema, } from './sets.js';
+import { UniqueStringPayloadSchema, UniqueStringSetPayloadSchema, } 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']);
+            const result = UniqueStringSetPayloadSchema.safeParse(stringSet);
+            // Parse succeeds for valid data
+            expect(result.data).toBeInstanceOf(Set);
+            expect(Array.from(result.data).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']);
+            const result = UniqueStringSetPayloadSchema.safeParse(stringArray);
+            // Parse succeeds for valid data
+            expect(result.data).toBeInstanceOf(Set);
+            expect(Array.from(result.data).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']);
+            const result = UniqueStringSetPayloadSchema.safeParse(stringArray);
+            // Parse succeeds for valid data
+            expect(result.data).toBeInstanceOf(Set);
+            expect(Array.from(result.data).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);
+            const result = UniqueStringSetPayloadSchema.safeParse([]);
+            // Parse succeeds for valid data
+            expect(result.data).toBeInstanceOf(Set);
+            expect(result.data.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);
+            const result = UniqueStringSetPayloadSchema.safeParse(emptySet);
+            // Parse succeeds for valid data
+            expect(result.data).toBeInstanceOf(Set);
+            expect(result.data.size).toBe(0);
         });
         test('should reject non-string array elements', () => {
-            const result = UniqueStringSetPayloadSchema(['a', 123, 'b']);
-            expect(result).toBeInstanceOf(type.errors);
+            const result = UniqueStringSetPayloadSchema.safeParse(['a', 123, 'b']);
+            expect(result.success).toBe(false);
         });
         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);
+            expect(UniqueStringSetPayloadSchema.safeParse('string').success).toBe(false);
         });
     });
     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']);
+            const result = UniqueStringPayloadSchema.safeParse(stringSet);
+            // Parse succeeds for valid data
+            expect(Array.isArray(result.data)).toBe(true);
+            expect(result.data.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']);
+            const result = UniqueStringPayloadSchema.safeParse(stringArray);
+            // Parse succeeds for valid data
+            expect(Array.isArray(result.data)).toBe(true);
+            expect(result.data.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);
+            const setResult = UniqueStringPayloadSchema.safeParse(emptySet);
+            const arrayResult = UniqueStringPayloadSchema.safeParse(emptyArray);
+            // Parse succeeds for valid data
+            // Parse succeeds for valid data
+            expect(setResult.data.length).toBe(0);
+            expect(arrayResult.data.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']);
+            const result = UniqueStringPayloadSchema.safeParse(orderedSet);
+            // Parse succeeds for valid data
+            expect(result.data).toEqual(['first', 'second', 'third']);
         });
     });
 });

package/dist/esm/customer/organization/schema.d.ts

@@ -1,55 +1,53 @@
+import { z } from 'zod';
 export declare const OrganizationStatus: {
     readonly ACTIVE: "active";
     readonly SUSPENDED: "suspended";
 };
 export type AnyOrganizationStatus = (typeof OrganizationStatus)[keyof typeof OrganizationStatus];
-export declare const OrganizationIdPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    id: string;
-}, {}>;
-export type OrganizationIdProperty = typeof OrganizationIdPropertySchema.inferOut;
-export declare const OrganizationPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    status: import("arktype/internal/attributes.ts").Default<"active" | "suspended", "active">;
-    name: 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;
-    id: string;
-    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 OrganizationPayload = typeof OrganizationPayloadSchema.inferOut;
-export declare const InsertOrganizationPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    id: import("arktype/internal/attributes.ts").Default<string, string>;
-    name: string;
-    status?: "active" | "suspended" | undefined;
-    metadata?: ((In: {
-        [x: string]: string | number | boolean;
-    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
-        [x: string]: string | number | boolean;
-    } | null>) | undefined;
-}, {}>;
-export type InsertOrganizationPayload = typeof InsertOrganizationPayloadSchema.inferOut;
-export declare const UpdateOrganizationPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    status?: "active" | "suspended" | null | undefined;
-    name?: string | null | undefined;
-    metadata?: ((In: {
-        [x: string]: string | number | boolean;
-    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
-        [x: string]: string | number | boolean;
-    } | null>) | undefined;
-}, {}>;
-export type UpdateOrganizationPayload = typeof UpdateOrganizationPayloadSchema.inferOut;
+export declare const OrganizationIdPropertySchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type OrganizationIdProperty = z.output<typeof OrganizationIdPropertySchema>;
+export declare const OrganizationPayloadSchema: 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> | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+    status: z.ZodDefault<z.ZodEnum<{
+        active: "active";
+        suspended: "suspended";
+    }>>;
+    name: z.ZodString;
+    createdAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    updatedAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    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>>>;
+    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>>>;
+    id: z.ZodString;
+}, z.core.$strip>;
+export type OrganizationPayload = z.output<typeof OrganizationPayloadSchema>;
+export declare const InsertOrganizationPayloadSchema: 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>>>;
+    id: z.ZodDefault<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        suspended: "suspended";
+    }>>;
+    name: z.ZodString;
+}, z.core.$strip>;
+export type InsertOrganizationPayload = z.output<typeof InsertOrganizationPayloadSchema>;
+export declare const UpdateOrganizationPayloadSchema: 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>>>;
+    status: z.ZodOptional<z.ZodUnion<[z.ZodEnum<{
+        active: "active";
+        suspended: "suspended";
+    }>, z.ZodNull]>>;
+    name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+}, z.core.$strip>;
+export type UpdateOrganizationPayload = z.output<typeof UpdateOrganizationPayloadSchema>;
 /**
  * Association
  */
-export declare const OrganizationAssociationReferenceSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    id: string;
-    name: string;
-    model: "Organization";
-}, {}>;
-export type OrganizationAssociationReference = typeof OrganizationAssociationReferenceSchema.inferOut;
+export declare const OrganizationAssociationReferenceSchema: z.ZodObject<{
+    name: z.ZodString;
+    model: z.ZodLiteral<"Organization">;
+    id: z.ZodString;
+}, z.core.$strip>;
+export type OrganizationAssociationReference = z.output<typeof OrganizationAssociationReferenceSchema>;
 //# sourceMappingURL=schema.d.ts.map