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

package/dist/esm/authentication/sessions/resources.d.ts

@@ -1,4 +1,4 @@
-import type { MondoIdentity } from '../../common/resources/init.js';
+import type { MondoInstance } from '../../common/resources/init.js';
 import { type PaginationCollection } from '../../common/schema/collection.js';
 import type { Pagination } from '../../common/schema/pagination.js';
 import { type Session } from './schema.js';
@@ -10,12 +10,12 @@ export type SessionListingOptions = {
 };
 export declare class SessionResources {
     private readonly instance;
-    constructor(instance: MondoIdentity);
+    constructor(instance: MondoInstance);
     static buildPath(id: string): string;
     static buildListingPath(options?: SessionListingOptions): string;
     listItems(options?: SessionListingOptions, pagination?: Pagination): Promise<PaginationCollection<Session>>;
     deleteItem(id: string): Promise<Session>;
 }
-export declare function listSessions(instance: MondoIdentity, options?: SessionListingOptions, pagination?: Pagination): Promise<PaginationCollection<Session>>;
-export declare function deleteSession(instance: MondoIdentity, id: string): Promise<Session>;
+export declare function listSessions(instance: MondoInstance, options?: SessionListingOptions, pagination?: Pagination): Promise<PaginationCollection<Session>>;
+export declare function deleteSession(instance: MondoInstance, id: string): Promise<Session>;
 //# sourceMappingURL=resources.d.ts.map

package/dist/esm/authentication/sessions/resources.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../../src/authentication/sessions/resources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AASpE,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAGpE,OAAO,EAAE,KAAK,OAAO,EAAiB,MAAM,aAAa,CAAC;AAI1D,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,CAAC,EAAE;QACP,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,GAAG,CAAC,EAAE,MAAM,CAAC;KACd,CAAC;CACH,CAAC;AAEF,qBAAa,gBAAgB;IACR,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,aAAa;IAE3D,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAQpC,MAAM,CAAC,gBAAgB,CAAC,OAAO,CAAC,EAAE,qBAAqB,GAAG,MAAM;IAYzD,SAAS,CACd,OAAO,CAAC,EAAE,qBAAqB,EAC/B,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;IAIlC,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAGhD;AAED,wBAAsB,YAAY,CAChC,QAAQ,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,qBAAqB,EAC/B,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAWxC;AAED,wBAAsB,aAAa,CACjC,QAAQ,EAAE,aAAa,EACvB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,OAAO,CAAC,CASlB"}
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../../src/authentication/sessions/resources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAMpE,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAGpE,OAAO,EAAE,KAAK,OAAO,EAAiB,MAAM,aAAa,CAAC;AAI1D,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,CAAC,EAAE;QACP,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,GAAG,CAAC,EAAE,MAAM,CAAC;KACd,CAAC;CACH,CAAC;AAEF,qBAAa,gBAAgB;IACR,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,aAAa;IAE3D,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAQpC,MAAM,CAAC,gBAAgB,CAAC,OAAO,CAAC,EAAE,qBAAqB,GAAG,MAAM;IAYzD,SAAS,CACd,OAAO,CAAC,EAAE,qBAAqB,EAC/B,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;IAIlC,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAGhD;AAED,wBAAsB,YAAY,CAChC,QAAQ,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,qBAAqB,EAC/B,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC,CASxC;AAED,wBAAsB,aAAa,CACjC,QAAQ,EAAE,aAAa,EACvB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,OAAO,CAAC,CAOlB"}

package/dist/esm/authentication/sessions/resources.js

@@ -1,5 +1,5 @@
-import { deleteItemWithAuthorization, getItemWithAuthorization, } from '../../common/resources/operations.js';
-import { addPaginationToURL, parseEgressSchema, } from '../../common/resources/utils.js';
+import { deleteItemWithAuthorization, listItemsWithAuthorization, } from '../../common/resources/operations.js';
+import { addPaginationToURL } from '../../common/resources/utils.js';
 import { PaginationCollectionSchema, } from '../../common/schema/collection.js';
 import { appendSearchParams } from '../../common/schema/url.js';
 import { PATH } from '../resources.js';
@@ -29,9 +29,9 @@ export class SessionResources {
     }
 }
 export async function listSessions(instance, options, pagination) {
-    const url = addPaginationToURL(new URL(SessionResources.buildListingPath(options), instance.config.host), pagination);
-    return parseEgressSchema(PaginationCollectionSchema(SessionSchema)(await getItemWithAuthorization(url, instance.authorizer)));
+    const url = addPaginationToURL(new URL(SessionResources.buildListingPath(options), instance.baseUrl), pagination);
+    return PaginationCollectionSchema(SessionSchema).parse(await listItemsWithAuthorization(url, instance.authorize));
 }
 export async function deleteSession(instance, id) {
-    return parseEgressSchema(SessionSchema(await deleteItemWithAuthorization(new URL(SessionResources.buildPath(id), instance.config.host), instance.authorizer)));
+    return SessionSchema.parse(await deleteItemWithAuthorization(new URL(SessionResources.buildPath(id), instance.baseUrl), instance.authorize));
 }

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

@@ -1,81 +1,103 @@
+import * as z from 'zod/v4';
 export declare const SessionStatus: {
     readonly INITIATED: "initiated";
     readonly AUTHENTICATED: "authenticated";
     readonly PENDING: "pending";
 };
 export type AnySessionStatus = (typeof SessionStatus)[keyof typeof SessionStatus];
-export declare const SessionIdSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
-export type SessionId = typeof SessionIdSchema.inferOut;
-export declare const SessionIdPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    id: string;
-}, {}>;
-export type SessionIdProperty = typeof SessionIdPropertySchema.inferOut;
-export declare const SessionStatusSchema: import("arktype/internal/methods/string.ts").StringType<"pending" | "initiated" | "authenticated", {}>;
-export declare const SessionAuthenticationFactorSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    id: string;
-    type: "email" | "password" | "totp";
-    settings?: Record<string, unknown> | undefined;
-    state?: string | undefined;
-}, {}>;
-export type SessionAuthenticationFactor = typeof SessionAuthenticationFactorSchema.inferOut;
-export declare const SessionAuthenticationFactorHistorySchema: import("arktype/internal/methods/object.ts").ObjectType<(In: string[] | Set<string> | undefined) => import("arktype").Out<string[] | Set<string> | undefined>, {}>;
-export type SessionAuthenticationFactorHistory = typeof SessionAuthenticationFactorHistorySchema.inferOut;
-export declare const SessionSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    id: string;
-    status: "pending" | "initiated" | "authenticated";
-    user?: string | undefined;
-    userAgent?: string | undefined;
-    sourceIp?: string | undefined;
-    factors?: {
-        id: string;
-        type: "email" | "password" | "totp";
-        settings?: Record<string, unknown> | undefined;
-        state?: string | undefined;
-    }[] | undefined;
-    factorHistory?: ((In: string[] | Set<string> | undefined) => import("arktype").Out<string[] | Set<string> | undefined>) | undefined;
-    expiresAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
-    createdAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
-    updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
-    deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
-}, {}>;
-export type SessionProperties = typeof SessionSchema.inferIn;
-export type Session = typeof SessionSchema.inferOut;
-export declare const SessionPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    id: string;
-    status: "pending" | "initiated" | "authenticated";
-    user?: string | undefined;
-    userAgent?: string | undefined;
-    sourceIp?: string | undefined;
-    factors?: {
-        id: string;
-        type: "email" | "password" | "totp";
-        settings?: Record<string, unknown> | undefined;
-        state?: string | undefined;
-    }[] | undefined;
-    factorHistory?: ((In: string[] | Set<string> | undefined) => import("arktype").Out<string[] | Set<string> | undefined>) | undefined;
-    expiresAt: (In: string | Date) => import("arktype").Out<string>;
-    createdAt: (In: string | Date) => import("arktype").Out<string>;
-    updatedAt: (In: string | Date) => import("arktype").Out<string>;
-    deletedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
-    deactivatedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
-    metadata?: ((In: {
-        [x: string]: string | number | boolean;
-    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
-        [x: string]: string | number | boolean;
-    } | undefined>) | undefined;
-}, {}>;
-export type SessionPayload = typeof SessionPayloadSchema.inferOut;
-export declare const SessionAssociationReferenceSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    id: string;
-    status: "pending" | "initiated" | "authenticated";
-    user?: string | undefined;
-    userAgent?: string | undefined;
-    sourceIp?: string | undefined;
-    expiresAt: (In: string | Date) => import("arktype").Out<string>;
-    createdAt: (In: string | Date) => import("arktype").Out<string>;
-    model: "Session";
-}, {}>;
-export type SessionAssociationReference = typeof SessionAssociationReferenceSchema.inferOut;
+export declare const SessionIdSchema: z.ZodString;
+export type SessionId = z.output<typeof SessionIdSchema>;
+export declare const SessionIdPropertySchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type SessionIdProperty = z.output<typeof SessionIdPropertySchema>;
+export declare const SessionStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    initiated: "initiated";
+    authenticated: "authenticated";
+}>;
+export declare const SessionAuthenticationFactorSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        email: "email";
+        totp: "totp";
+    }>;
+    settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    state: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SessionAuthenticationFactor = z.output<typeof SessionAuthenticationFactorSchema>;
+export declare const SessionSchema: 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>>]>>;
+    factorHistory: z.ZodPipe<z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodArray<z.ZodString>, z.ZodCustom<Set<string>, Set<string>>]>, z.ZodTransform<Set<string>, Set<string> | string[] | undefined>>>, z.ZodTransform<Set<unknown>, Set<string> | undefined>>;
+    redirectPath: z.ZodDefault<z.ZodString>;
+    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>>]>;
+    expiresAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        initiated: "initiated";
+        authenticated: "authenticated";
+    }>;
+    user: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodUndefined]>>;
+    userAgent: z.ZodOptional<z.ZodString>;
+    sourceIp: z.ZodOptional<z.ZodUnion<readonly [z.ZodIPv4, z.ZodIPv6, z.ZodUndefined]>>;
+    factors: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            email: "email";
+            totp: "totp";
+        }>;
+        settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        state: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>, z.ZodUndefined]>>;
+    id: z.ZodString;
+}, z.core.$strip>;
+export type SessionProperties = z.input<typeof SessionSchema>;
+export type Session = z.output<typeof SessionSchema>;
+export declare const SessionPayloadSchema: 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>>>;
+    redirectPath: z.ZodDefault<z.ZodString>;
+    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>>;
+    expiresAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        initiated: "initiated";
+        authenticated: "authenticated";
+    }>;
+    user: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodUndefined]>>;
+    userAgent: z.ZodOptional<z.ZodString>;
+    sourceIp: z.ZodOptional<z.ZodUnion<readonly [z.ZodIPv4, z.ZodIPv6, z.ZodUndefined]>>;
+    factors: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            email: "email";
+            totp: "totp";
+        }>;
+        settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        state: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>, z.ZodUndefined]>>;
+    factorHistory: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodArray<z.ZodString>, z.ZodCustom<Set<string>, Set<string>>]>, z.ZodTransform<Set<string> | string[] | undefined, Set<string> | string[] | undefined>>>;
+    id: z.ZodString;
+}, z.core.$strip>;
+export type SessionPayload = z.output<typeof SessionPayloadSchema>;
+export declare const SessionAssociationReferenceSchema: z.ZodObject<{
+    model: z.ZodLiteral<"Session">;
+    createdAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    id: z.ZodString;
+    expiresAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    user: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodUndefined]>>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        initiated: "initiated";
+        authenticated: "authenticated";
+    }>;
+    userAgent: z.ZodOptional<z.ZodString>;
+    sourceIp: z.ZodOptional<z.ZodUnion<readonly [z.ZodIPv4, z.ZodIPv6, z.ZodUndefined]>>;
+}, z.core.$strip>;
+export type SessionAssociationReference = z.output<typeof SessionAssociationReferenceSchema>;
 //# sourceMappingURL=schema.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/authentication/sessions/schema.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,aAAa;;;;CAIhB,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAC1B,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAErD,eAAO,MAAM,eAAe,qEAAuC,CAAC;AACpE,MAAM,MAAM,SAAS,GAAG,OAAO,eAAe,CAAC,QAAQ,CAAC;AAExD,eAAO,MAAM,uBAAuB;;MAElC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC;AAExE,eAAO,MAAM,mBAAmB,wGAI/B,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;;;MAK5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GACrC,OAAO,iCAAiC,CAAC,QAAQ,CAAC;AAMpD,eAAO,MAAM,wCAAwC,oKAKlD,CAAC;AACJ,MAAM,MAAM,kCAAkC,GAC5C,OAAO,wCAAwC,CAAC,QAAQ,CAAC;AAW3D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;MAMO,CAAC;AAClC,MAAM,MAAM,iBAAiB,GAAG,OAAO,aAAa,CAAC,OAAO,CAAC;AAC7D,MAAM,MAAM,OAAO,GAAG,OAAO,aAAa,CAAC,QAAQ,CAAC;AAEpD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;MAMI,CAAC;AACtC,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,CAAC,QAAQ,CAAC;AAElE,eAAO,MAAM,iCAAiC;;;;;;;;;MAU5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GACrC,OAAO,iCAAiC,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/authentication/sessions/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AA0B5B,eAAO,MAAM,aAAa;;;;CAIhB,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAC1B,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAErD,eAAO,MAAM,eAAe,aAAuC,CAAC;AACpE,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC;AAEzD,eAAO,MAAM,uBAAuB;;iBAElC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAEzE,eAAO,MAAM,mBAAmB;;;;EAIrB,CAAC;AAEZ,eAAO,MAAM,iCAAiC;;;;;;;;iBAK5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,MAAM,CAChD,OAAO,iCAAiC,CACzC,CAAC;AA0CF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAaxB,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC9D,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,aAAa,CAAC,CAAC;AAErD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAS/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEnE,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;iBAW5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,MAAM,CAChD,OAAO,iCAAiC,CACzC,CAAC"}

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

@@ -1,7 +1,8 @@
-import { type } from 'arktype';
-import { OptionalDatePayloadSchema, OptionalDateSchema, RequiredDatePayloadSchema, RequiredDateSchema, } from '../../common/schema/dates.js';
+import * as z from 'zod/v4';
+import { CreatedAtPropertyPayloadSchema, CreatedAtPropertySchema, DeactivatedAtPropertyPayloadSchema, DeactivatedAtPropertySchema, DeletedAtPropertyPayloadSchema, DeletedAtPropertySchema, RequiredDatePayloadSchema, RequiredDateSchema, UpdatedAtPropertyPayloadSchema, UpdatedAtPropertySchema, } from '../../common/schema/dates.js';
 import { KSUIDSchema } from '../../common/schema/id.js';
-import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, } from '../../common/schema/metadata.js';
+import { MetadataMapPropertySchema, MetadataRecordPropertySchema, } from '../../common/schema/metadata.js';
+import { RelativeUrlPathSchema } from '../../common/schema/url.js';
 import { UserIdSchema } from '../../customer/schema.js';
 import { StrategyIdSchema, StrategyTypeSchema, } from '../strategies/schema/base.js';
 import { Model } from '../utils.js';
@@ -11,44 +12,76 @@ export const SessionStatus = {
     PENDING: 'pending', // Session is in the process of authenticating
 };
 export const SessionIdSchema = KSUIDSchema(Model.Session.UIDPrefix);
-export const SessionIdPropertySchema = type({
+export const SessionIdPropertySchema = z.object({
     id: SessionIdSchema,
 });
-export const SessionStatusSchema = type.enumerated(SessionStatus.INITIATED, SessionStatus.AUTHENTICATED, SessionStatus.PENDING);
-export const SessionAuthenticationFactorSchema = type({
+export const SessionStatusSchema = z.enum([
+    SessionStatus.INITIATED,
+    SessionStatus.AUTHENTICATED,
+    SessionStatus.PENDING,
+]);
+export const SessionAuthenticationFactorSchema = z.object({
     id: StrategyIdSchema,
     type: StrategyTypeSchema,
-    settings: type('Record<string, unknown> | undefined').optional(),
-    state: type('string | undefined').optional(),
+    settings: z.record(z.string(), z.unknown()).optional(),
+    state: z.string().optional(),
 });
-const AuthenticationFactorHistoryArraySchema = StrategyIdSchema.array();
-const AuthenticationFactorHistorySetSchema = type.instanceOf((Set));
-export const SessionAuthenticationFactorHistorySchema = type('undefined')
-    .or(AuthenticationFactorHistoryArraySchema)
-    .or(AuthenticationFactorHistorySetSchema)
-    .pipe((s) => (s instanceof Set ? Array.from(s) : s)?.length ? s : undefined);
-const BaseSchema = SessionIdPropertySchema.and({
+const AuthenticationFactorHistoryArraySchema = z.array(StrategyIdSchema);
+const AuthenticationFactorHistorySetSchema = z.instanceof((Set));
+const SessionAuthenticationFactorHistoryInput = z.union([
+    z.undefined(),
+    AuthenticationFactorHistoryArraySchema,
+    AuthenticationFactorHistorySetSchema,
+]);
+const SessionAuthenticationFactorHistoryArraySchema = SessionAuthenticationFactorHistoryInput.pipe(z.transform((s) => (s instanceof Set ? Array.from(s) : s)?.length ? s : undefined));
+// type SessionAuthenticationFactorArrayHistory = z.output<
+//   typeof SessionAuthenticationFactorHistoryArraySchema
+// >;
+const SessionAuthenticationFactorHistorySetSchema = SessionAuthenticationFactorHistoryInput.pipe(z.transform((s) => (s instanceof Set ? s : new Set(s))));
+// type SessionAuthenticationFactorSetHistory = z.output<
+//   typeof SessionAuthenticationFactorHistorySetSchema
+// >;
+const BaseSchema = z.object({
+    ...SessionIdPropertySchema.shape,
     status: SessionStatusSchema,
-    user: UserIdSchema.or('undefined').optional(),
-    userAgent: type('string | undefined').optional(),
-    sourceIp: type('string.ip.v4 | string.ip.v6	| undefined').optional(),
-    factors: SessionAuthenticationFactorSchema.array().or('undefined').optional(),
-    factorHistory: SessionAuthenticationFactorHistorySchema.optional(),
+    user: z.union([UserIdSchema, z.undefined()]).optional(),
+    userAgent: z.string().optional(),
+    sourceIp: z.union([z.ipv4(), z.ipv6(), z.undefined()]).optional(),
+    factors: z
+        .union([z.array(SessionAuthenticationFactorSchema), z.undefined()])
+        .optional(),
+    factorHistory: SessionAuthenticationFactorHistoryArraySchema.optional(),
 });
-export const SessionSchema = BaseSchema.and({
+export const SessionSchema = z.object({
+    ...BaseSchema.shape,
     expiresAt: RequiredDateSchema,
-    createdAt: RequiredDateSchema,
-    updatedAt: RequiredDateSchema,
-    deletedAt: OptionalDateSchema.optional(),
-    deactivatedAt: OptionalDateSchema.optional(),
-}).and(MetadataMapPropertySchema);
-export const SessionPayloadSchema = BaseSchema.and({
+    ...CreatedAtPropertySchema.shape,
+    ...UpdatedAtPropertySchema.shape,
+    factorHistory: SessionAuthenticationFactorHistorySetSchema.optional().transform((factorHistory) => factorHistory ?? new Set()),
+    redirectPath: RelativeUrlPathSchema.default('/'),
+    ...DeletedAtPropertySchema.shape,
+    ...DeactivatedAtPropertySchema.shape,
+    ...MetadataMapPropertySchema.shape,
+});
+export const SessionPayloadSchema = z.object({
+    ...BaseSchema.shape,
     expiresAt: RequiredDatePayloadSchema,
-    createdAt: RequiredDatePayloadSchema,
-    updatedAt: RequiredDatePayloadSchema,
-    'deletedAt?': OptionalDatePayloadSchema,
-    'deactivatedAt?': OptionalDatePayloadSchema,
-}).and(MetadataPayloadPropertySchema);
-export const SessionAssociationReferenceSchema = SessionPayloadSchema.pick('id', 'status', 'user', 'userAgent', 'sourceIp', 'createdAt', 'expiresAt').and({
-    model: "'Session'",
+    ...CreatedAtPropertyPayloadSchema.shape,
+    ...UpdatedAtPropertyPayloadSchema.shape,
+    redirectPath: RelativeUrlPathSchema.default('/'),
+    ...DeletedAtPropertyPayloadSchema.shape,
+    ...DeactivatedAtPropertyPayloadSchema.shape,
+    ...MetadataRecordPropertySchema.shape,
+});
+export const SessionAssociationReferenceSchema = z.object({
+    ...SessionPayloadSchema.pick({
+        id: true,
+        status: true,
+        user: true,
+        userAgent: true,
+        sourceIp: true,
+        createdAt: true,
+        expiresAt: true,
+    }).shape,
+    model: z.literal('Session'),
 });

package/dist/esm/authentication/sessions/schema.test.d.ts

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

package/dist/esm/authentication/sessions/schema.test.d.ts.map

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

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

@@ -0,0 +1,63 @@
+import { describe, expect, test } from 'vitest';
+import { generateSessionId } from '../utils.js';
+import { SessionPayloadSchema, SessionSchema, SessionStatus, } from './schema.js';
+describe('Authentication Sessions - Schema', () => {
+    const baseSession = {
+        id: generateSessionId(),
+        status: SessionStatus.INITIATED,
+        expiresAt: new Date('2026-01-01T00:00:00.000Z'),
+        createdAt: new Date('2025-01-01T00:00:00.000Z'),
+        updatedAt: new Date('2025-01-01T00:00:00.000Z'),
+        metadata: {},
+    };
+    describe('redirectPath', () => {
+        test('should accept a relative path with query parameters', () => {
+            const result = SessionSchema.safeParse({
+                ...baseSession,
+                redirectPath: '/oauth/authorize?client_id=123',
+            });
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.redirectPath).toBe('/oauth/authorize?client_id=123');
+            }
+        });
+        test('should accept a payload relative path with query parameters', () => {
+            const result = SessionPayloadSchema.safeParse({
+                ...baseSession,
+                redirectPath: '/oauth/authorize?client_id=123',
+            });
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.redirectPath).toBe('/oauth/authorize?client_id=123');
+            }
+        });
+        test('should default to root when omitted', () => {
+            const result = SessionSchema.safeParse(baseSession);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.redirectPath).toBe('/');
+            }
+        });
+        test('should reject absolute URLs', () => {
+            const result = SessionSchema.safeParse({
+                ...baseSession,
+                redirectPath: 'https://example.com/oauth/authorize?client_id=123',
+            });
+            expect(result.success).toBe(false);
+        });
+        test('should reject paths that start with a double slash', () => {
+            const result = SessionSchema.safeParse({
+                ...baseSession,
+                redirectPath: '//example.com/oauth/authorize?client_id=123',
+            });
+            expect(result.success).toBe(false);
+        });
+        test('should reject paths that do not start with slash', () => {
+            const result = SessionSchema.safeParse({
+                ...baseSession,
+                redirectPath: 'oauth/authorize?client_id=123',
+            });
+            expect(result.success).toBe(false);
+        });
+    });
+});

package/dist/esm/authentication/settings/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 Settings, type UpsertSettingsInput } from './schema.js';
 export declare class SettingsResources {
     private readonly instance;
-    constructor(instance: MondoIdentity);
+    constructor(instance: MondoInstance);
     static buildPath(): string;
     getItem(): Promise<Settings>;
     upsertItem(item: UpsertSettingsInput): Promise<Settings>;
 }
-export declare function getSettings(instance: MondoIdentity): Promise<Settings>;
-export declare function upsertSettings(instance: MondoIdentity, item: UpsertSettingsInput): Promise<Settings>;
+export declare function getSettings(instance: MondoInstance): Promise<Settings>;
+export declare function upsertSettings(instance: MondoInstance, item: UpsertSettingsInput): Promise<Settings>;
 //# sourceMappingURL=resources.d.ts.map

package/dist/esm/authentication/settings/resources.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../../src/authentication/settings/resources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAOpE,OAAO,EACL,KAAK,QAAQ,EAEb,KAAK,mBAAmB,EAEzB,MAAM,aAAa,CAAC;AAIrB,qBAAa,iBAAiB;IACT,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,aAAa;IAE3D,MAAM,CAAC,SAAS,IAAI,MAAM;IAInB,OAAO,IAAI,OAAO,CAAC,QAAQ,CAAC;IAI5B,UAAU,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,QAAQ,CAAC;CAGhE;AAED,wBAAsB,WAAW,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,QAAQ,CAAC,CAS5E;AAED,wBAAsB,cAAc,CAClC,QAAQ,EAAE,aAAa,EACvB,IAAI,EAAE,mBAAmB,GACxB,OAAO,CAAC,QAAQ,CAAC,CAYnB"}
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../../src/authentication/settings/resources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAMpE,OAAO,EACL,KAAK,QAAQ,EAEb,KAAK,mBAAmB,EAEzB,MAAM,aAAa,CAAC;AAIrB,qBAAa,iBAAiB;IACT,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,aAAa;IAE3D,MAAM,CAAC,SAAS,IAAI,MAAM;IAInB,OAAO,IAAI,OAAO,CAAC,QAAQ,CAAC;IAI5B,UAAU,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,QAAQ,CAAC;CAGhE;AAED,wBAAsB,WAAW,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,QAAQ,CAAC,CAO5E;AAED,wBAAsB,cAAc,CAClC,QAAQ,EAAE,aAAa,EACvB,IAAI,EAAE,mBAAmB,GACxB,OAAO,CAAC,QAAQ,CAAC,CAQnB"}

package/dist/esm/authentication/settings/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 { SettingsSchema, UpsertSettingsPayloadSchema, } from './schema.js';
 const RESOURCE = 'settings';
@@ -19,8 +18,8 @@ export class SettingsResources {
     }
 }
 export async function getSettings(instance) {
-    return parseEgressSchema(SettingsSchema(await getItemWithAuthorization(new URL(SettingsResources.buildPath(), instance.config.host), instance.authorizer)));
+    return SettingsSchema.parse(await getItemWithAuthorization(new URL(SettingsResources.buildPath(), instance.baseUrl), instance.authorize));
 }
 export async function upsertSettings(instance, item) {
-    return parseEgressSchema(SettingsSchema(await insertItemWithAuthorization(new URL(SettingsResources.buildPath(), instance.config.host), instance.authorizer, parseEgressSchema(UpsertSettingsPayloadSchema.onUndeclaredKey('delete')(item)))));
+    return SettingsSchema.parse(await postItemWithAuthorization(new URL(SettingsResources.buildPath(), instance.baseUrl), instance.authorize, UpsertSettingsPayloadSchema.parse(item)));
 }

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

@@ -1,69 +1,52 @@
-export declare const SettingsSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    createdAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
-    updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
-    factors?: ((In: {
+import * as z from 'zod/v4';
+export declare const SettingsSchema: 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>>]>>;
+    factors: z.ZodOptional<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;
-    }[] | null | undefined) => import("arktype").Out<{
+        nextFactors?: /*elided*/ any[] | null | undefined;
+    }[] | undefined, {
         id: string;
-        nextFactors?: {
-            id: string;
-            nextFactors?: /*elided*/ any[] | null | undefined;
-        }[] | null | undefined;
-    }[] | undefined>) | 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 SettingsProperties = typeof SettingsSchema.inferIn;
-export type Settings = typeof SettingsSchema.inferOut;
-export declare const SettingsPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    factors?: ((In: {
+        nextFactors?: /*elided*/ any[] | null | undefined;
+    }[] | null | undefined>>>;
+    updatedAt: z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>;
+}, z.core.$strip>;
+export type SettingsProperties = z.input<typeof SettingsSchema>;
+export type Settings = z.output<typeof SettingsSchema>;
+export declare const SettingsPayloadSchema: 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>>>;
+    factors: z.ZodOptional<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;
-    }[] | null | undefined) => import("arktype").Out<{
+        nextFactors?: /*elided*/ any[] | null | undefined;
+    }[] | undefined, {
         id: string;
-        nextFactors?: {
-            id: string;
-            nextFactors?: /*elided*/ any[] | null | undefined;
-        }[] | null | undefined;
-    }[] | undefined>) | undefined;
-    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 SettingsPayload = typeof SettingsPayloadSchema.inferOut;
-export declare const UpsertSettingsPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    factors?: ((In: {
+        nextFactors?: /*elided*/ any[] | null | undefined;
+    }[] | null | 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>>>;
+}, z.core.$strip>;
+export type SettingsPayload = z.output<typeof SettingsPayloadSchema>;
+export declare const UpsertSettingsPayloadSchema: 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>>;
+    factors: z.ZodOptional<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;
-    }[] | null | undefined) => import("arktype").Out<{
+        nextFactors?: /*elided*/ any[] | null | undefined;
+    }[] | undefined, {
         id: string;
-        nextFactors?: {
-            id: string;
-            nextFactors?: /*elided*/ any[] | null | undefined;
-        }[] | null | undefined;
-    }[] | undefined>) | 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 UpsertSettingsInput = typeof UpsertSettingsPayloadSchema.inferIn;
-export type UpsertSettingsPayload = typeof UpsertSettingsPayloadSchema.inferOut;
+        nextFactors?: /*elided*/ any[] | null | undefined;
+    }[] | null | undefined>>>;
+}, z.core.$strip>;
+export type UpsertSettingsInput = z.input<typeof UpsertSettingsPayloadSchema>;
+export type UpsertSettingsPayload = z.output<typeof UpsertSettingsPayloadSchema>;
 //# sourceMappingURL=schema.d.ts.map