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

package/dist/esm/app/oidc/schema.test.js

@@ -1,4 +1,3 @@
-import { type } from 'arktype';
 import { describe, expect, test } from 'vitest';
 import { InsertOIDCPayloadSchema, OIDCPayloadSchema, OIDCSchema, UpdateOIDCPayloadSchema, } from './schema.js';
 describe('App OIDC - Schema', () => {
@@ -10,23 +9,26 @@ describe('App OIDC - Schema', () => {
                 deactivatedAt: new Date(),
                 metadata: { provider: 'auth0' },
             };
-            const result = OIDCSchema(oidc);
-            expect(result).not.toBeInstanceOf(type.errors);
+            const result = OIDCSchema.safeParse(oidc);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
         });
         test('should accept minimal OIDC object', () => {
             const oidc = {
                 metadata: {},
             };
-            const result = OIDCSchema(oidc);
-            expect(result).not.toBeInstanceOf(type.errors);
+            const result = OIDCSchema.safeParse(oidc);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
         });
         test('should accept OIDC with only some optional dates', () => {
             const oidc = {
                 updatedAt: new Date(),
                 metadata: { configured: true },
             };
-            const result = OIDCSchema(oidc);
-            expect(result).not.toBeInstanceOf(type.errors);
+            const result = OIDCSchema.safeParse(oidc);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
         });
     });
     describe('OIDCPayloadSchema', () => {
@@ -37,25 +39,32 @@ describe('App OIDC - Schema', () => {
                 deactivatedAt: new Date().toISOString(),
                 metadata: { issuer: 'https://auth.example.com' },
             };
-            const result = OIDCPayloadSchema(payload);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual(payload);
+            const result = OIDCPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual(payload);
+            }
         });
         test('should accept minimal payload', () => {
             const payload = {
                 metadata: {},
             };
-            const result = OIDCPayloadSchema(payload);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual(payload);
+            const result = OIDCPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.metadata).toBeUndefined();
+            }
         });
         test('should accept payload with optional dates', () => {
             const payload = {
                 updatedAt: new Date().toISOString(),
                 metadata: { clientId: 'oidc_client_123' },
             };
-            const result = OIDCPayloadSchema(payload);
-            expect(result).not.toBeInstanceOf(type.errors);
+            const result = OIDCPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
         });
     });
     describe('InsertOIDCPayloadSchema', () => {
@@ -63,21 +72,28 @@ describe('App OIDC - Schema', () => {
             const payload = {
                 metadata: { setup: 'initial' },
             };
-            const result = InsertOIDCPayloadSchema(payload);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual(payload);
+            const result = InsertOIDCPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual(payload);
+            }
         });
-        test('should accept undefined', () => {
-            const result = InsertOIDCPayloadSchema(undefined);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toBeUndefined();
+        test('should accept empty object', () => {
+            const result = InsertOIDCPayloadSchema.safeParse({});
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual({});
+            }
         });
         test('should accept empty metadata', () => {
             const payload = {
                 metadata: {},
             };
-            const result = InsertOIDCPayloadSchema(payload);
-            expect(result).not.toBeInstanceOf(type.errors);
+            const result = InsertOIDCPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
         });
     });
     describe('UpdateOIDCPayloadSchema', () => {
@@ -85,9 +101,12 @@ describe('App OIDC - Schema', () => {
             const payload = {
                 metadata: { version: '2.0' },
             };
-            const result = UpdateOIDCPayloadSchema(payload);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toEqual(payload);
+            const result = UpdateOIDCPayloadSchema.safeParse(payload);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual(payload);
+            }
         });
     });
 });

package/dist/esm/app/registration/resources.d.ts

@@ -1,12 +1,12 @@
-import type { MondoIdentity } from '../../common/resources/init.js';
+import type { MondoInstance } from '../../common/resources/init.js';
 import { type Registration, type UpsertRegistrationInput } from './schema.js';
 export declare class RegistrationResources {
     private readonly instance;
-    constructor(instance: MondoIdentity);
+    constructor(instance: MondoInstance);
     static buildPath(id: string): string;
     getItem(id: string): Promise<Registration>;
     upsertItem(id: string, item: UpsertRegistrationInput): Promise<Registration>;
 }
-export declare function getRegistration(instance: MondoIdentity, id: string): Promise<Registration>;
-export declare function upsertRegistration(instance: MondoIdentity, id: string, item: UpsertRegistrationInput): Promise<Registration>;
+export declare function getRegistration(instance: MondoInstance, id: string): Promise<Registration>;
+export declare function upsertRegistration(instance: MondoInstance, id: string, item: UpsertRegistrationInput): Promise<Registration>;
 //# sourceMappingURL=resources.d.ts.map

package/dist/esm/app/registration/resources.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../../src/app/registration/resources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAOpE,OAAO,EACL,KAAK,YAAY,EAEjB,KAAK,uBAAuB,EAE7B,MAAM,aAAa,CAAC;AAIrB,qBAAa,qBAAqB;IACb,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,aAAa;IAE3D,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAQ7B,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAI1C,UAAU,CACf,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC,YAAY,CAAC;CAGzB;AAED,wBAAsB,eAAe,CACnC,QAAQ,EAAE,aAAa,EACvB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,YAAY,CAAC,CASvB;AAED,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,aAAa,EACvB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC,YAAY,CAAC,CAYvB"}
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../../src/app/registration/resources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAMpE,OAAO,EACL,KAAK,YAAY,EAEjB,KAAK,uBAAuB,EAE7B,MAAM,aAAa,CAAC;AAIrB,qBAAa,qBAAqB;IACb,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,aAAa;IAE3D,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAQ7B,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAI1C,UAAU,CACf,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC,YAAY,CAAC;CAGzB;AAED,wBAAsB,eAAe,CACnC,QAAQ,EAAE,aAAa,EACvB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,YAAY,CAAC,CAOvB;AAED,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,aAAa,EACvB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC,YAAY,CAAC,CAQvB"}

package/dist/esm/app/registration/resources.js

@@ -1,5 +1,4 @@
-import { getItemWithAuthorization, insertItemWithAuthorization, } from '../../common/resources/operations.js';
-import { parseEgressSchema } from '../../common/resources/utils.js';
+import { getItemWithAuthorization, postItemWithAuthorization, } from '../../common/resources/operations.js';
 import { PATH } from '../resources.js';
 import { RegistrationSchema, UpsertRegistrationPayloadSchema, } from './schema.js';
 const RESOURCE = 'registration';
@@ -22,8 +21,8 @@ export class RegistrationResources {
     }
 }
 export async function getRegistration(instance, id) {
-    return parseEgressSchema(RegistrationSchema(await getItemWithAuthorization(new URL(RegistrationResources.buildPath(id), instance.config.host), instance.authorizer)));
+    return RegistrationSchema.parse(await getItemWithAuthorization(new URL(RegistrationResources.buildPath(id), instance.baseUrl), instance.authorize));
 }
 export async function upsertRegistration(instance, id, item) {
-    return parseEgressSchema(RegistrationSchema(await insertItemWithAuthorization(new URL(RegistrationResources.buildPath(id), instance.config.host), instance.authorizer, parseEgressSchema(UpsertRegistrationPayloadSchema.onUndeclaredKey('delete')(item)))));
+    return RegistrationSchema.parse(await postItemWithAuthorization(new URL(RegistrationResources.buildPath(id), instance.baseUrl), instance.authorize, UpsertRegistrationPayloadSchema.parse(item)));
 }

package/dist/esm/app/registration/resources.test.js

@@ -5,18 +5,19 @@ describe('App Registration Resources', () => {
     let registrationResources;
     beforeEach(() => {
         vi.clearAllMocks();
-        // Mock MondoIdentity instance
+        // Mock MondoInstance instance
         mockInstance = {
+            baseUrl: new URL('https://api.example.com'),
             config: {
                 host: 'https://api.example.com',
                 accessToken: 'test-token',
             },
-            authorizer: vi.fn((req) => req),
+            authorize: vi.fn((req) => req),
         };
         registrationResources = new RegistrationResources(mockInstance);
     });
     describe('RegistrationResources class', () => {
-        test('should initialize with MondoIdentity instance', () => {
+        test('should initialize with MondoInstance instance', () => {
             expect(registrationResources).toBeInstanceOf(RegistrationResources);
             // biome-ignore lint/complexity/useLiteralKeys: <explanation>
             expect(registrationResources['instance']).toBe(mockInstance);
@@ -141,33 +142,33 @@ describe('App Registration Resources', () => {
             }
         });
     });
-    describe('Integration with MondoIdentity instance', () => {
-        test('should store MondoIdentity instance internally', () => {
+    describe('Integration with MondoInstance instance', () => {
+        test('should store MondoInstance instance internally', () => {
             // biome-ignore lint/complexity/useLiteralKeys: <explanation>
             const internalInstance = registrationResources['instance'];
             expect(internalInstance).toBe(mockInstance);
-            expect(internalInstance.config.host).toBe('https://api.example.com');
-            expect(internalInstance.config.accessToken).toBe('test-token');
+            expect(internalInstance.baseUrl.toString()).toBe('https://api.example.com/');
         });
-        test('should maintain reference to authorizer function', () => {
+        test('should maintain reference to authorize function', () => {
             // biome-ignore lint/complexity/useLiteralKeys: <explanation>
             const internalInstance = registrationResources['instance'];
-            expect(typeof internalInstance.authorizer).toBe('function');
-            expect(internalInstance.authorizer).toBe(mockInstance.authorizer);
+            expect(typeof internalInstance.authorize).toBe('function');
+            expect(internalInstance.authorize).toBe(mockInstance.authorize);
         });
-        test('should work with different MondoIdentity configurations', () => {
+        test('should work with different MondoInstance configurations', () => {
             const customInstance = {
+                baseUrl: new URL('https://custom-registration.api.com'),
                 config: {
                     host: 'https://custom-registration.api.com',
                     accessToken: 'custom-registration-token',
                 },
-                authorizer: vi.fn(),
+                authorize: vi.fn(),
             };
             const customResources = new RegistrationResources(customInstance);
             // biome-ignore lint/complexity/useLiteralKeys: <explanation>
             expect(customResources['instance']).toBe(customInstance);
             // biome-ignore lint/complexity/useLiteralKeys: <explanation>
-            expect(customResources['instance'].config.host).toBe('https://custom-registration.api.com');
+            expect(customResources['instance'].baseUrl.toString()).toBe('https://custom-registration.api.com/');
         });
     });
     describe('Class structure and inheritance', () => {

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

@@ -1,32 +1,25 @@
-export declare const RegistrationSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    allowSelfRegistration: import("arktype/internal/attributes.ts").Default<boolean, false>;
-    updatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
-}, {}>;
-export type RegistrationProperties = typeof RegistrationSchema.inferIn;
-export type Registration = typeof RegistrationSchema.inferOut;
-export declare const RegistrationPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    allowSelfRegistration: import("arktype/internal/attributes.ts").Default<boolean, false>;
-    updatedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
-    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 RegistrationPayload = typeof RegistrationPayloadSchema.inferOut;
-export declare const UpsertRegistrationPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    allowSelfRegistration?: boolean | 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 UpsertRegistrationInput = typeof UpsertRegistrationPayloadSchema.inferIn;
-export type UpsertRegistrationPayload = typeof UpsertRegistrationPayloadSchema.inferOut;
+import * as z from 'zod/v4';
+export declare const RegistrationSchema: 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").MetadataMap, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>, z.ZodTransform<import("../../common/schema/metadata.js").MetadataMap, import("../../common/schema/metadata.js").MetadataMap | 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.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>;
+    allowSelfRegistration: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type RegistrationProperties = z.input<typeof RegistrationSchema>;
+export type Registration = z.output<typeof RegistrationSchema>;
+export declare const RegistrationPayloadSchema: 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.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    allowSelfRegistration: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type RegistrationPayload = z.output<typeof RegistrationPayloadSchema>;
+export declare const UpsertRegistrationPayloadSchema: 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 | null | undefined, import("../../common/schema/metadata.js").MetadataRecord | undefined>>;
+    allowSelfRegistration: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodUndefined]>>;
+}, z.core.$strip>;
+export type UpsertRegistrationInput = z.input<typeof UpsertRegistrationPayloadSchema>;
+export type UpsertRegistrationPayload = z.output<typeof UpsertRegistrationPayloadSchema>;
 //# sourceMappingURL=schema.d.ts.map

package/dist/esm/app/registration/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/app/registration/schema.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,kBAAkB;;;;;;MAIE,CAAC;AAClC,MAAM,MAAM,sBAAsB,GAAG,OAAO,kBAAkB,CAAC,OAAO,CAAC;AACvE,MAAM,MAAM,YAAY,GAAG,OAAO,kBAAkB,CAAC,QAAQ,CAAC;AAE9D,eAAO,MAAM,yBAAyB;;;;;;;;;;MAID,CAAC;AACtC,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC;AAE5E,eAAO,MAAM,+BAA+B;;;;;;;MAEP,CAAC;AACtC,MAAM,MAAM,uBAAuB,GACjC,OAAO,+BAA+B,CAAC,OAAO,CAAC;AACjD,MAAM,MAAM,yBAAyB,GACnC,OAAO,+BAA+B,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/app/registration/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAqB5B,eAAO,MAAM,kBAAkB;;;;;;iBAM7B,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;;;;;;iBAMpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE7E,eAAO,MAAM,+BAA+B;;;iBAK1C,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,+BAA+B,CACvC,CAAC;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAC9C,OAAO,+BAA+B,CACvC,CAAC"}

package/dist/esm/app/registration/schema.js

@@ -1,20 +1,27 @@
-import { type } from 'arktype';
-import { OptionalDatePayloadSchema, OptionalDateSchema, } from '../../common/schema/dates.js';
-import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, } from '../../common/schema/metadata.js';
-const AllowSelfRegistrationSchema = type('boolean');
-const BaseSchema = type({
+import * as z from 'zod/v4';
+import { DeactivatedAtPropertyPayloadSchema, DeactivatedAtPropertySchema, DeletedAtPropertyPayloadSchema, DeletedAtPropertySchema, OptionalDatePayloadSchema, OptionalDateSchema, } from '../../common/schema/dates.js';
+import { MetadataMapPropertySchema, MetadataRecordPropertySchema, UpsertMetadataPropertySchema, } from '../../common/schema/metadata.js';
+const AllowSelfRegistrationSchema = z.boolean();
+const BaseSchema = z.object({
     allowSelfRegistration: AllowSelfRegistrationSchema.default(false),
 });
-export const RegistrationSchema = BaseSchema.and({
-    'updatedAt?': OptionalDateSchema,
-    'deletedAt?': OptionalDateSchema,
-    'deactivatedAt?': OptionalDateSchema,
-}).and(MetadataMapPropertySchema);
-export const RegistrationPayloadSchema = BaseSchema.and({
-    'updatedAt?': OptionalDatePayloadSchema,
-    'deletedAt?': OptionalDatePayloadSchema,
-    'deactivatedAt?': OptionalDatePayloadSchema,
-}).and(MetadataPayloadPropertySchema);
-export const UpsertRegistrationPayloadSchema = type({
-    allowSelfRegistration: AllowSelfRegistrationSchema.or('undefined').optional(),
-}).and(MetadataPayloadPropertySchema);
+export const RegistrationSchema = z.object({
+    ...BaseSchema.shape,
+    updatedAt: OptionalDateSchema,
+    ...DeletedAtPropertySchema.shape,
+    ...DeactivatedAtPropertySchema.shape,
+    ...MetadataMapPropertySchema.shape,
+});
+export const RegistrationPayloadSchema = z.object({
+    ...BaseSchema.shape,
+    updatedAt: OptionalDatePayloadSchema,
+    ...DeletedAtPropertyPayloadSchema.shape,
+    ...DeactivatedAtPropertyPayloadSchema.shape,
+    ...MetadataRecordPropertySchema.shape,
+});
+export const UpsertRegistrationPayloadSchema = z.object({
+    allowSelfRegistration: z
+        .union([AllowSelfRegistrationSchema, z.undefined()])
+        .optional(),
+    ...UpsertMetadataPropertySchema.shape,
+});