@go-mondo/identity-sdk 0.0.2-beta.4 → 0.0.2-beta.41

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

@@ -1,60 +1,108 @@
-import { type } from 'arktype';
 import { describe, expect, test } from 'vitest';
-import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, } from './metadata.js';
+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.safeParse({
+                foo: 'bar',
+                bar: '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.safeParse(new Map([
+                ['foo', 'bar'],
+                ['bar', '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.safeParse(new Map([
+                ['1', '1'],
+                ['2', '2'],
+                ['3', '3'],
+                ['4', '4'],
+                ['5', '5'],
+                ['6', '6'],
+                ['7', '7'],
+                ['8', '8'],
+                ['9', '9'],
+                ['10', '10'],
+                ['11', '11'],
+            ]));
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('Map Property Schema', () => {
+        test('should parse map to record', async () => {
+            const result = MetadataMapPropertySchema.safeParse({
+                metadata: {
+                    foo: 'bar',
+                    bar: '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 | undefined;
-    nextToken?: string | undefined;
-}, {}>;
-export type Pagination = typeof PaginationSchema.inferOut;
+import * as z from 'zod/v4';
+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,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B,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').optional(),
-    nextToken: type('string').optional(),
+import * as z from 'zod/v4';
+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.d.ts

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

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

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

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

@@ -0,0 +1,65 @@
+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.safeParse({
+                pageSize: '10',
+                nextToken: 'token123',
+            });
+            // 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.safeParse({
+                pageSize: 20,
+                nextToken: 'token456',
+            });
+            // Parse succeeds for valid data
+            expect(result.data).toEqual({
+                pageSize: 20,
+                nextToken: 'token456',
+            });
+        });
+        test('should accept pagination with only pageSize', () => {
+            const result = PaginationSchema.safeParse({
+                pageSize: '15',
+            });
+            // Parse succeeds for valid data
+            expect(result.data).toEqual({
+                pageSize: '15',
+            });
+        });
+        test('should accept pagination with only nextToken', () => {
+            const result = PaginationSchema.safeParse({
+                nextToken: 'token789',
+            });
+            // Parse succeeds for valid data
+            expect(result.data).toEqual({
+                nextToken: 'token789',
+            });
+        });
+        test('should accept empty pagination object', () => {
+            const result = PaginationSchema.safeParse({});
+            // Parse succeeds for valid data
+            expect(result.data).toEqual({});
+        });
+        test('should reject invalid pageSize type', () => {
+            const result = PaginationSchema.safeParse({
+                pageSize: true,
+                nextToken: 'token123',
+            });
+            expect(result.success).toBe(false);
+        });
+        test('should reject invalid nextToken type', () => {
+            const result = PaginationSchema.safeParse({
+                pageSize: '10',
+                nextToken: 123,
+            });
+            expect(result.success).toBe(false);
+        });
+    });
+});

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

@@ -1,4 +1,4 @@
-import type { type } from 'arktype';
+import * as z from 'zod/v4';
 export * from './aggregate.js';
 export * from './collection.js';
 export * from './dates.js';
@@ -6,7 +6,8 @@ export * from './jwt.js';
 export * from './metadata.js';
 export * from './pagination.js';
 export * from './sets.js';
-export declare const optionallyNullishToUndefined: <t extends type.Any>(t: t) => [type<t["t"] | undefined>, "?"];
-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 * from './url.js';
+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;AAE1B,eAAO,MAAM,4BAA4B,GAAI,CAAC,SAAS,IAAI,CAAC,GAAG,EAC7D,GAAG,CAAC,KACH,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC,EAAE,GAAG,CAIT,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,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B,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 * as z from 'zod/v4';
 export * from './aggregate.js';
 export * from './collection.js';
 export * from './dates.js';
@@ -5,9 +6,10 @@ export * from './jwt.js';
 export * from './metadata.js';
 export * from './pagination.js';
 export * from './sets.js';
-export const optionallyNullishToUndefined = (t) => t
-    .or('null | undefined')
-    .pipe((v) => (v == null ? v : undefined))
+export * from './url.js';
+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.d.ts

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

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

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

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

@@ -0,0 +1,27 @@
+import { describe, expect, test } from 'vitest';
+import * as z from 'zod/v4';
+import { optionallyNullishToUndefined } from './schema.js';
+describe('Common Schema', () => {
+    describe('optionallyNullishToUndefined', () => {
+        test('should parse null string successfully', async () => {
+            const Schema = z.object({
+                foo: optionallyNullishToUndefined(z.string()),
+            });
+            const result = Schema.parse({
+                foo: null,
+            });
+            // Parse succeeds for valid data
+            expect(result.foo).toBeUndefined();
+        });
+        test('should parse undefined string successfully', async () => {
+            const Schema = z.object({
+                foo: optionallyNullishToUndefined(z.string()),
+            });
+            const result = Schema.parse({
+                foo: undefined,
+            });
+            // Parse succeeds for valid data
+            expect(result.foo).toBeUndefined();
+        });
+    });
+});

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

@@ -1,3 +1,6 @@
-export declare const UniqueStringSetPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<Set<string> | ((In: string[]) => import("arktype/internal/attributes.ts").Out<Set<string>>), {}>;
-export declare const UniqueStringPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<(In: Set<string> | string[]) => import("arktype/internal/attributes.ts").Out<string[]>, {}>;
+import * as z from 'zod/v4';
+export declare const UniqueStringArraySchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>, z.ZodSet<z.ZodString>]>, z.ZodTransform<string[] | undefined, Set<string> | string[] | undefined>>;
+export declare const UniqueStringSetSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>, z.ZodSet<z.ZodString>]>, z.ZodTransform<Set<string> | undefined, Set<string> | string[] | undefined>>;
+export declare const UniqueUrlArraySchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodPipe<z.ZodArray<z.ZodUnion<[z.ZodPipe<z.ZodURL, z.ZodTransform<URL, string>>, z.ZodCustom<URL, URL>]>>, z.ZodTransform<URL[], URL[]>>, z.ZodCustom<Set<URL>, Set<URL>>]>, z.ZodTransform<URL[] | undefined, Set<URL> | URL[] | undefined>>;
+export declare const UniqueUrlSetSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodPipe<z.ZodArray<z.ZodUnion<[z.ZodPipe<z.ZodURL, z.ZodTransform<URL, string>>, z.ZodCustom<URL, URL>]>>, z.ZodTransform<URL[], URL[]>>, z.ZodCustom<Set<URL>, Set<URL>>]>, z.ZodTransform<Set<URL> | undefined, Set<URL> | URL[] | undefined>>;
 //# sourceMappingURL=sets.d.ts.map

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

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

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

@@ -1,6 +1,23 @@
-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 * as z from 'zod/v4';
+import { UrlObjectSchema } from './url.js';
+const StringSetTypeSchema = z.set(z.string());
+// const UrlStringSchema = type('string.url[]').pipe((v) => v?.filter((i) => !!i));
+const StringArrayTypeSchema = z
+    .array(z.string())
+    .pipe(z.transform((v) => v?.filter((i) => !!i)));
+export const UniqueStringArraySchema = z
+    .union([z.undefined(), StringArrayTypeSchema, StringSetTypeSchema])
+    .pipe(z.transform((v) => (v instanceof Set ? Array.from(v.values()) : v)));
+export const UniqueStringSetSchema = z
+    .union([z.undefined(), StringArrayTypeSchema, StringSetTypeSchema])
+    .pipe(z.transform((v) => (!v || v instanceof Set ? v : new Set(v))));
+const UrlSetTypeSchema = z.instanceof((Set));
+const UrlArrayTypeScheama = z
+    .array(UrlObjectSchema)
+    .pipe(z.transform((v) => v?.filter((i) => !!i)));
+export const UniqueUrlArraySchema = z
+    .union([z.undefined(), UrlArrayTypeScheama, UrlSetTypeSchema])
+    .pipe(z.transform((v) => (v instanceof Set ? Array.from(v.values()) : v)));
+export const UniqueUrlSetSchema = z
+    .union([z.undefined(), UrlArrayTypeScheama, UrlSetTypeSchema])
+    .pipe(z.transform((v) => (!v || v instanceof Set ? v : new Set(v))));

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

@@ -0,0 +1,9 @@
+import * as z from 'zod/v4';
+export declare function appendSearchParams(path: string, params: Map<string, string | undefined | null> | URLSearchParams): string;
+export declare const UrlObjectSchema: z.ZodUnion<[z.ZodPipe<z.ZodURL, z.ZodTransform<URL, string>>, z.ZodCustom<URL, URL>]>;
+export type UrlObjectInput = z.input<typeof UrlObjectSchema>;
+export type UrlObject = z.output<typeof UrlObjectSchema>;
+export declare const UrlStringSchema: z.ZodUnion<[z.ZodPipe<z.ZodCustom<URL, URL>, z.ZodTransform<string, URL>>, z.ZodURL]>;
+export type UrlStringInput = z.input<typeof UrlStringSchema>;
+export type UrlString = z.output<typeof UrlStringSchema>;
+//# sourceMappingURL=url.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/url.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC,GAAG,eAAe,GAC/D,MAAM,CAUR;AAED,eAAO,MAAM,eAAe,uFAGJ,CAAC;AACzB,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAC7D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC;AAEzD,eAAO,MAAM,eAAe,uFAGd,CAAC;AACf,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAC7D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC"}

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

@@ -0,0 +1,18 @@
+import * as z from 'zod/v4';
+export function appendSearchParams(path, params) {
+    const vals = Array.from(params.entries()).reduce((result, [key, val]) => {
+        if (val) {
+            result.push(`${key}=${val}`);
+        }
+        return result;
+    }, []);
+    return [path, vals.filter(Boolean).join('&')].filter(Boolean).join('?');
+}
+export const UrlObjectSchema = z
+    .url()
+    .pipe(z.transform((url) => new URL(url)))
+    .or(z.instanceof(URL));
+export const UrlStringSchema = z
+    .instanceof(URL)
+    .pipe(z.transform((url) => url.toString()))
+    .or(z.url());

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

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

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

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

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

@@ -0,0 +1,72 @@
+import { describe, expect, test } from 'vitest';
+import { appendSearchParams } from './url.js';
+describe('Common Schema - URL', () => {
+    describe('appendSearchParams', () => {
+        test('should append search params from Map to path', () => {
+            const params = new Map([
+                ['key1', 'value1'],
+                ['key2', 'value2'],
+            ]);
+            const result = appendSearchParams('/api/test', params);
+            expect(result).toBe('/api/test?key1=value1&key2=value2');
+        });
+        test('should append search params from URLSearchParams to path', () => {
+            const params = new URLSearchParams();
+            params.set('foo', 'bar');
+            params.set('baz', 'qux');
+            const result = appendSearchParams('/api/endpoint', params);
+            expect(result).toBe('/api/endpoint?foo=bar&baz=qux');
+        });
+        test('should handle empty params', () => {
+            const params = new Map();
+            const result = appendSearchParams('/api/test', params);
+            expect(result).toBe('/api/test');
+        });
+        test('should skip undefined values', () => {
+            const params = new Map([
+                ['key1', 'value1'],
+                ['key2', undefined],
+                ['key3', 'value3'],
+            ]);
+            const result = appendSearchParams('/api/test', params);
+            expect(result).toBe('/api/test?key1=value1&key3=value3');
+        });
+        test('should skip null values', () => {
+            const params = new Map([
+                ['key1', 'value1'],
+                ['key2', null],
+                ['key3', 'value3'],
+            ]);
+            const result = appendSearchParams('/api/test', params);
+            expect(result).toBe('/api/test?key1=value1&key3=value3');
+        });
+        test('should skip empty string values', () => {
+            const params = new Map([
+                ['key1', 'value1'],
+                ['key2', ''],
+                ['key3', 'value3'],
+            ]);
+            const result = appendSearchParams('/api/test', params);
+            expect(result).toBe('/api/test?key1=value1&key3=value3');
+        });
+        test('should handle path without leading slash', () => {
+            const params = new Map([['param', 'value']]);
+            const result = appendSearchParams('api/test', params);
+            expect(result).toBe('api/test?param=value');
+        });
+        test('should handle single parameter', () => {
+            const params = new Map([['single', 'value']]);
+            const result = appendSearchParams('/path', params);
+            expect(result).toBe('/path?single=value');
+        });
+        test('should handle all falsy values', () => {
+            const params = new Map([
+                ['key1', undefined],
+                ['key2', null],
+                ['key3', ''],
+            ]);
+            const result = appendSearchParams('/api/test', params);
+            expect(result).toBe('/api/test');
+        });
+    });
+});

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

@@ -1,4 +1,6 @@
-export * from './schema/schema.js';
+export * from './organization/schema.js';
 export * from './users/resources.js';
 export * from './users/schema.js';
+export * from './users/utils.js';
+export * from './schema.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/customer/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AAEnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/customer/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AAEzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AAEjC,cAAc,aAAa,CAAC"}

package/dist/esm/customer/index.js

@@ -1,3 +1,5 @@
-export * from './schema/schema.js';
+export * from './organization/schema.js';
 export * from './users/resources.js';
 export * from './users/schema.js';
+export * from './users/utils.js';
+export * from './schema.js';

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

@@ -0,0 +1,68 @@
+import * as z from 'zod/v4';
+export declare const OrganizationStatus: {
+    readonly ACTIVE: "active";
+    readonly SUSPENDED: "suspended";
+};
+export type AnyOrganizationStatus = (typeof OrganizationStatus)[keyof typeof OrganizationStatus];
+export declare const OrganizationIdPropertySchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type OrganizationIdProperty = z.output<typeof OrganizationIdPropertySchema>;
+export declare const OrganizationSchema: z.ZodObject<{
+    metadata: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Map<string, string | number | boolean>, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>;
+    deactivatedAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>;
+    deletedAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>;
+    updatedAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>;
+    createdAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>;
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        suspended: "suspended";
+    }>;
+    id: z.ZodString;
+}, z.core.$strip>;
+export type OrganizationProperties = z.input<typeof OrganizationSchema>;
+export type Organization = z.output<typeof OrganizationSchema>;
+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>>>;
+    deactivatedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    deletedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    updatedAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    createdAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        suspended: "suspended";
+    }>;
+    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.ZodEnum<{
+        active: "active";
+        suspended: "suspended";
+    }>>;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type UpdateOrganizationPayload = z.output<typeof UpdateOrganizationPayloadSchema>;
+/**
+ * Association
+ */
+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

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/customer/organization/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAkB5B,eAAO,MAAM,kBAAkB;;;CAGrB,CAAC;AACX,MAAM,MAAM,qBAAqB,GAC/B,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC;AAE/D,eAAO,MAAM,4BAA4B;;iBAEvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAC3C,OAAO,4BAA4B,CACpC,CAAC;AAeF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;iBAO7B,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACxE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE/D,eAAO,MAAM,yBAAyB;;;;;;;;;;;;iBAOpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE7E,eAAO,MAAM,+BAA+B;;;;;;;;iBAK1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAC9C,OAAO,+BAA+B,CACvC,CAAC;AAEF,eAAO,MAAM,+BAA+B;;;;;;;iBAI1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAC9C,OAAO,+BAA+B,CACvC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sCAAsC;;;;iBAIjD,CAAC;AACH,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,MAAM,CACrD,OAAO,sCAAsC,CAC9C,CAAC"}