@opengeni/contracts 5.5.0 → 5.5.2-canary.40656248492001

package/src/preference-registry.ts

@@ -1,3 +1,5 @@
+import * as primitives from "./primitives";
+import { defineSchema } from "./define-schema";
 import { z } from "zod";
 
 export const PREFERENCE_REGISTRY_CONTENT_MAX_CHARS = 262_144;
@@ -9,239 +11,269 @@ export const PREFERENCE_REGISTRY_SOURCE_ID_MAX_CHARS = 512;
 export const PREFERENCE_REGISTRY_STABLE_KEY_MAX_CHARS = 96;
 export const PREFERENCE_REGISTRY_TITLE_MAX_CHARS = 120;
 
-export const PreferenceRegistryScope = z.enum(["organization", "workspace", "user"]);
+export const PreferenceRegistryScope = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["organization", "workspace", "user"]),
+);
 export type PreferenceRegistryScope = z.infer<typeof PreferenceRegistryScope>;
 
-export const PreferenceRegistryStatus = z.enum([
-  "proposed",
-  "active",
-  "inactive",
-  "rejected",
-  "superseded",
-  "expired",
-]);
+export const PreferenceRegistryStatus = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["proposed", "active", "inactive", "rejected", "superseded", "expired"]),
+);
 export type PreferenceRegistryStatus = z.infer<typeof PreferenceRegistryStatus>;
 
-export const PreferenceRegistryProvenanceSource = z.enum([
-  "human",
-  "onboarding",
-  "knowledge_proposal",
-  "imported_document",
-  "slack",
-  "meeting_transcript",
-  "call_transcript",
-  "agent",
-  "portable_skill",
-]);
+export const PreferenceRegistryProvenanceSource = /* @__PURE__ */ defineSchema(() =>
+  z.enum([
+    "human",
+    "onboarding",
+    "knowledge_proposal",
+    "imported_document",
+    "slack",
+    "meeting_transcript",
+    "call_transcript",
+    "agent",
+    "portable_skill",
+  ]),
+);
 export type PreferenceRegistryProvenanceSource = z.infer<typeof PreferenceRegistryProvenanceSource>;
 
-export const PreferenceRegistryTrust = z.enum([
-  "untrusted_proposal",
-  "personal",
-  "workspace_managed",
-  "organization_managed",
-]);
+export const PreferenceRegistryTrust = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["untrusted_proposal", "personal", "workspace_managed", "organization_managed"]),
+);
 export type PreferenceRegistryTrust = z.infer<typeof PreferenceRegistryTrust>;
 
-export const PreferenceRegistryConflictStrategy = z.enum(["override", "merge", "reject", "inform"]);
+export const PreferenceRegistryConflictStrategy = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["override", "merge", "reject", "inform"]),
+);
 export type PreferenceRegistryConflictStrategy = z.infer<typeof PreferenceRegistryConflictStrategy>;
 
-export const PreferenceRegistryEventType = z.enum([
-  "proposal_created",
-  "activated",
-  "corrected",
-  "rejected",
-  "deactivated",
-  "superseded",
-  "scope_changed",
-]);
+export const PreferenceRegistryEventType = /* @__PURE__ */ defineSchema(() =>
+  z.enum([
+    "proposal_created",
+    "activated",
+    "corrected",
+    "rejected",
+    "deactivated",
+    "superseded",
+    "scope_changed",
+  ]),
+);
 export type PreferenceRegistryEventType = z.infer<typeof PreferenceRegistryEventType>;
 
-export const PreferenceRegistryStableKey = z
-  .string()
-  .min(1)
-  .max(PREFERENCE_REGISTRY_STABLE_KEY_MAX_CHARS)
-  .regex(/^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/);
+export const PreferenceRegistryStableKey = /* @__PURE__ */ defineSchema(() =>
+  primitives.nonEmptyString
+    .max(PREFERENCE_REGISTRY_STABLE_KEY_MAX_CHARS)
+    .regex(/^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/),
+);
 export type PreferenceRegistryStableKey = z.infer<typeof PreferenceRegistryStableKey>;
 
 export function normalizePreferenceRegistryStableKey(value: string): string {
   return value.normalize("NFKC").trim().toLowerCase().replace(/\s+/gu, "-").replace(/-+/g, "-");
 }
 
-const RequestStableKey = z
-  .string()
-  .transform(normalizePreferenceRegistryStableKey)
-  .pipe(PreferenceRegistryStableKey);
-
-const hash = z.string().regex(/^[0-9a-f]{64}$/);
-const boundedActor = z.string().trim().min(1).max(1_024);
-const boundedReason = z.string().trim().min(1).max(PREFERENCE_REGISTRY_REASON_MAX_CHARS);
-const descriptorText = z.string().min(1).max(PREFERENCE_REGISTRY_DESCRIPTOR_DESCRIPTION_MAX_CHARS);
-
-export const PreferenceRegistryScopeTarget = z
-  .object({
-    scope: PreferenceRegistryScope,
-    workspaceId: z.string().uuid().nullable(),
-    subjectId: z.string().min(1).max(1_024).nullable(),
-  })
-  .superRefine((value, context) => {
-    if (
-      value.scope === "organization" &&
-      (value.workspaceId !== null || value.subjectId !== null)
-    ) {
-      context.addIssue({
-        code: "custom",
-        message: "organization scope has no workspace or subject",
-      });
-    }
-    if (value.scope === "workspace" && (value.workspaceId === null || value.subjectId !== null)) {
-      context.addIssue({ code: "custom", message: "workspace scope requires only a workspace" });
-    }
-    if (value.scope === "user" && (value.workspaceId !== null || value.subjectId === null)) {
-      context.addIssue({ code: "custom", message: "user scope requires only a subject" });
-    }
-  });
+const RequestStableKey = /* @__PURE__ */ defineSchema(() =>
+  primitives.string
+    .transform(normalizePreferenceRegistryStableKey)
+    .pipe(PreferenceRegistryStableKey),
+);
+
+const hash = /* @__PURE__ */ defineSchema(() => primitives.string.regex(/^[0-9a-f]{64}$/));
+const boundedActor = /* @__PURE__ */ defineSchema(() => primitives.string.trim().min(1).max(1_024));
+const boundedReason = /* @__PURE__ */ defineSchema(() =>
+  primitives.string.trim().min(1).max(PREFERENCE_REGISTRY_REASON_MAX_CHARS),
+);
+const descriptorText = /* @__PURE__ */ defineSchema(() =>
+  primitives.nonEmptyString.max(PREFERENCE_REGISTRY_DESCRIPTOR_DESCRIPTION_MAX_CHARS),
+);
+
+export const PreferenceRegistryScopeTarget = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      scope: PreferenceRegistryScope,
+      workspaceId: primitives.nullableUuid,
+      subjectId: z.string().min(1).max(1_024).nullable(),
+    })
+    .superRefine((value, context) => {
+      if (
+        value.scope === "organization" &&
+        (value.workspaceId !== null || value.subjectId !== null)
+      ) {
+        context.addIssue({
+          code: "custom",
+          message: "organization scope has no workspace or subject",
+        });
+      }
+      if (value.scope === "workspace" && (value.workspaceId === null || value.subjectId !== null)) {
+        context.addIssue({ code: "custom", message: "workspace scope requires only a workspace" });
+      }
+      if (value.scope === "user" && (value.workspaceId !== null || value.subjectId === null)) {
+        context.addIssue({ code: "custom", message: "user scope requires only a subject" });
+      }
+    }),
+);
 export type PreferenceRegistryScopeTarget = z.infer<typeof PreferenceRegistryScopeTarget>;
 
-export const PreferenceRegistryPrecedence = z.object({
-  tier: PreferenceRegistryScope,
-  rank: z.number().int().min(-1_000).max(1_000),
-  conflictStrategy: PreferenceRegistryConflictStrategy,
-  conflictsWith: z.array(PreferenceRegistryStableKey).max(32),
-});
+export const PreferenceRegistryPrecedence = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    tier: PreferenceRegistryScope,
+    rank: z.number().int().min(-1_000).max(1_000),
+    conflictStrategy: PreferenceRegistryConflictStrategy,
+    conflictsWith: z.array(PreferenceRegistryStableKey).max(32),
+  }),
+);
 export type PreferenceRegistryPrecedence = z.infer<typeof PreferenceRegistryPrecedence>;
 
-export const PreferenceRegistryProvenance = z.object({
-  source: PreferenceRegistryProvenanceSource,
-  sourceId: z.string().min(1).max(PREFERENCE_REGISTRY_SOURCE_ID_MAX_CHARS).nullable(),
-  trust: PreferenceRegistryTrust,
-});
+export const PreferenceRegistryProvenance = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    source: PreferenceRegistryProvenanceSource,
+    sourceId: primitives.nonEmptyString.max(PREFERENCE_REGISTRY_SOURCE_ID_MAX_CHARS).nullable(),
+    trust: PreferenceRegistryTrust,
+  }),
+);
 export type PreferenceRegistryProvenance = z.infer<typeof PreferenceRegistryProvenance>;
 
-export const PreferenceRegistryDescriptorProvenance = z.object({
-  source: PreferenceRegistryProvenanceSource,
-  sourceIdHash: hash.nullable(),
-  trust: PreferenceRegistryTrust,
-});
+export const PreferenceRegistryDescriptorProvenance = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    source: PreferenceRegistryProvenanceSource,
+    sourceIdHash: hash.nullable(),
+    trust: PreferenceRegistryTrust,
+  }),
+);
 export type PreferenceRegistryDescriptorProvenance = z.infer<
   typeof PreferenceRegistryDescriptorProvenance
 >;
 
-export const PreferenceRegistryRevisionSummary = z.object({
-  id: z.string().uuid(),
-  preferenceId: z.string().uuid(),
-  revision: z.number().int().positive(),
-  contentHash: hash,
-  title: z.string().min(1).max(PREFERENCE_REGISTRY_TITLE_MAX_CHARS),
-  description: descriptorText,
-  precedence: PreferenceRegistryPrecedence,
-  provenance: PreferenceRegistryProvenance,
-  expiresAt: z.string().datetime().nullable(),
-  correctsRevisionId: z.string().uuid().nullable(),
-  createdBySubjectId: boundedActor,
-  createdAt: z.string().datetime(),
-});
+export const PreferenceRegistryRevisionSummary = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    id: primitives.uuid,
+    preferenceId: primitives.uuid,
+    revision: primitives.positiveInteger,
+    contentHash: hash,
+    title: primitives.nonEmptyString.max(PREFERENCE_REGISTRY_TITLE_MAX_CHARS),
+    description: descriptorText,
+    precedence: PreferenceRegistryPrecedence,
+    provenance: PreferenceRegistryProvenance,
+    expiresAt: z.string().datetime().nullable(),
+    correctsRevisionId: primitives.nullableUuid,
+    createdBySubjectId: boundedActor,
+    createdAt: primitives.dateTime,
+  }),
+);
 export type PreferenceRegistryRevisionSummary = z.infer<typeof PreferenceRegistryRevisionSummary>;
 
-export const PreferenceRegistryRecord = z.object({
-  id: z.string().uuid(),
-  accountId: z.string().uuid(),
-  stableKey: PreferenceRegistryStableKey,
-  target: PreferenceRegistryScopeTarget,
-  status: PreferenceRegistryStatus,
-  scopeVersion: z.number().int().positive(),
-  activationVersion: z.number().int().nonnegative(),
-  activeRevision: PreferenceRegistryRevisionSummary.nullable(),
-  supersededByPreferenceId: z.string().uuid().nullable(),
-  createdBySubjectId: boundedActor,
-  createdAt: z.string().datetime(),
-  updatedAt: z.string().datetime(),
-});
+export const PreferenceRegistryRecord = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    id: primitives.uuid,
+    accountId: primitives.uuid,
+    stableKey: PreferenceRegistryStableKey,
+    target: PreferenceRegistryScopeTarget,
+    status: PreferenceRegistryStatus,
+    scopeVersion: primitives.positiveInteger,
+    activationVersion: primitives.nonnegativeInteger,
+    activeRevision: PreferenceRegistryRevisionSummary.nullable(),
+    supersededByPreferenceId: primitives.nullableUuid,
+    createdBySubjectId: boundedActor,
+    createdAt: primitives.dateTime,
+    updatedAt: primitives.dateTime,
+  }),
+);
 export type PreferenceRegistryRecord = z.infer<typeof PreferenceRegistryRecord>;
 
-export const PreferenceRegistryEvent = z.object({
-  id: z.string().uuid(),
-  accountId: z.string().uuid(),
-  preferenceId: z.string().uuid(),
-  type: PreferenceRegistryEventType,
-  version: z.number().int().positive(),
-  oldRevisionId: z.string().uuid().nullable(),
-  newRevisionId: z.string().uuid().nullable(),
-  oldTarget: PreferenceRegistryScopeTarget.nullable(),
-  newTarget: PreferenceRegistryScopeTarget.nullable(),
-  relatedPreferenceId: z.string().uuid().nullable(),
-  actorSubjectId: boundedActor,
-  reason: boundedReason,
-  createdAt: z.string().datetime(),
-});
+export const PreferenceRegistryEvent = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    id: primitives.uuid,
+    accountId: primitives.uuid,
+    preferenceId: primitives.uuid,
+    type: PreferenceRegistryEventType,
+    version: primitives.positiveInteger,
+    oldRevisionId: primitives.nullableUuid,
+    newRevisionId: primitives.nullableUuid,
+    oldTarget: PreferenceRegistryScopeTarget.nullable(),
+    newTarget: PreferenceRegistryScopeTarget.nullable(),
+    relatedPreferenceId: primitives.nullableUuid,
+    actorSubjectId: boundedActor,
+    reason: boundedReason,
+    createdAt: primitives.dateTime,
+  }),
+);
 export type PreferenceRegistryEvent = z.infer<typeof PreferenceRegistryEvent>;
 
-export const PreferenceRegistryActivationAuthority = z.enum(["human_confirmed", "automatic"]);
+export const PreferenceRegistryActivationAuthority = /* @__PURE__ */ defineSchema(() =>
+  z.enum(["human_confirmed", "automatic"]),
+);
 export type PreferenceRegistryActivationAuthority = z.infer<
   typeof PreferenceRegistryActivationAuthority
 >;
 
-export const PreferenceRegistryDescriptor = z.object({
-  id: z.string().uuid(),
-  stableKey: PreferenceRegistryStableKey,
-  title: z.string().min(1).max(PREFERENCE_REGISTRY_TITLE_MAX_CHARS),
-  description: descriptorText,
-  scope: PreferenceRegistryScope,
-  activeVersion: z.number().int().positive(),
-  revisionId: z.string().uuid(),
-  contentHash: hash,
-  precedence: PreferenceRegistryPrecedence,
-  provenance: PreferenceRegistryDescriptorProvenance,
-  // How the active revision became active, derived from the governed-learning
-  // activation receipt rather than stored on the revision. `provenance.trust`
-  // stays the frozen creation-time fact - a revision proposed by an agent is
-  // `untrusted_proposal` forever, which is correct and immutable - while this
-  // says whether a human explicitly confirmed the activation or policy
-  // activated it automatically. Null when the revision became active outside
-  // governed learning, so no receipt describes it.
-  // Defaulted, not merely nullable: snapshots written before this field
-  // existed are immutable and their stored JSON simply has no answer. Parsing
-  // those as null is the truthful reading, and it keeps their pinned
-  // descriptor hash valid because the stored text is untouched.
-  activationAuthority: PreferenceRegistryActivationAuthority.nullable().default(null),
-  expiresAt: z.string().datetime().nullable(),
-  retrievalHandle: z.string().min(1).max(512),
-});
+export const PreferenceRegistryDescriptor = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    id: primitives.uuid,
+    stableKey: PreferenceRegistryStableKey,
+    title: primitives.nonEmptyString.max(PREFERENCE_REGISTRY_TITLE_MAX_CHARS),
+    description: descriptorText,
+    scope: PreferenceRegistryScope,
+    activeVersion: primitives.positiveInteger,
+    revisionId: primitives.uuid,
+    contentHash: hash,
+    precedence: PreferenceRegistryPrecedence,
+    provenance: PreferenceRegistryDescriptorProvenance,
+    // How the active revision became active, derived from the governed-learning
+    // activation receipt rather than stored on the revision. `provenance.trust`
+    // stays the frozen creation-time fact - a revision proposed by an agent is
+    // `untrusted_proposal` forever, which is correct and immutable - while this
+    // says whether a human explicitly confirmed the activation or policy
+    // activated it automatically. Null when the revision became active outside
+    // governed learning, so no receipt describes it.
+    // Defaulted, not merely nullable: snapshots written before this field
+    // existed are immutable and their stored JSON simply has no answer. Parsing
+    // those as null is the truthful reading, and it keeps their pinned
+    // descriptor hash valid because the stored text is untouched.
+    activationAuthority: PreferenceRegistryActivationAuthority.nullable().default(null),
+    expiresAt: z.string().datetime().nullable(),
+    retrievalHandle: z.string().min(1).max(512),
+  }),
+);
 export type PreferenceRegistryDescriptor = z.infer<typeof PreferenceRegistryDescriptor>;
 
-export const PreferenceRegistrySnapshot = z.object({
-  id: z.string().uuid(),
-  workspaceId: z.string().uuid(),
-  sessionId: z.string().uuid(),
-  turnId: z.string().uuid(),
-  attemptId: z.string().uuid(),
-  executionGeneration: z.number().int().positive(),
-  initiatingHumanSubjectId: boundedActor,
-  descriptorHash: hash,
-  descriptors: z.array(PreferenceRegistryDescriptor).max(PREFERENCE_REGISTRY_DESCRIPTOR_MAX_COUNT),
-  truncated: z.boolean(),
-  createdAt: z.string().datetime(),
-});
+export const PreferenceRegistrySnapshot = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    id: primitives.uuid,
+    workspaceId: primitives.uuid,
+    sessionId: primitives.uuid,
+    turnId: primitives.uuid,
+    attemptId: primitives.uuid,
+    executionGeneration: primitives.positiveInteger,
+    initiatingHumanSubjectId: boundedActor,
+    descriptorHash: hash,
+    descriptors: z
+      .array(PreferenceRegistryDescriptor)
+      .max(PREFERENCE_REGISTRY_DESCRIPTOR_MAX_COUNT),
+    truncated: primitives.boolean,
+    createdAt: primitives.dateTime,
+  }),
+);
 export type PreferenceRegistrySnapshot = z.infer<typeof PreferenceRegistrySnapshot>;
 
-export const PreferenceRegistryFullContent = z.object({
-  descriptor: PreferenceRegistryDescriptor,
-  content: z.string().min(1).max(PREFERENCE_REGISTRY_CONTENT_MAX_CHARS),
-});
+export const PreferenceRegistryFullContent = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    descriptor: PreferenceRegistryDescriptor,
+    content: primitives.nonEmptyString.max(PREFERENCE_REGISTRY_CONTENT_MAX_CHARS),
+  }),
+);
 export type PreferenceRegistryFullContent = z.infer<typeof PreferenceRegistryFullContent>;
 
 const revisionInput = {
-  title: z.string().trim().min(1).max(PREFERENCE_REGISTRY_TITLE_MAX_CHARS),
-  description: z.string().trim().min(1).max(PREFERENCE_REGISTRY_DESCRIPTOR_DESCRIPTION_MAX_CHARS),
-  content: z
-    .string()
+  title: primitives.string.trim().min(1).max(PREFERENCE_REGISTRY_TITLE_MAX_CHARS),
+  description: primitives.string
+    .trim()
     .min(1)
+    .max(PREFERENCE_REGISTRY_DESCRIPTOR_DESCRIPTION_MAX_CHARS),
+  content: primitives.nonEmptyString
     .max(PREFERENCE_REGISTRY_CONTENT_MAX_CHARS)
     .refine((value) => value.trim().length > 0, "preference content must not be blank"),
   precedenceRank: z.number().int().min(-1_000).max(1_000).default(0),
   conflictStrategy: PreferenceRegistryConflictStrategy.default("override"),
   conflictsWith: z.array(RequestStableKey).max(32).default([]),
-  expiresAt: z.string().datetime({ offset: true }).nullable().default(null),
+  expiresAt: primitives.string.datetime({ offset: true }).nullable().default(null),
 };
 
 const importedSources = new Set<PreferenceRegistryProvenanceSource>([
@@ -252,121 +284,145 @@ const importedSources = new Set<PreferenceRegistryProvenanceSource>([
   "call_transcript",
 ]);
 
-export const CreatePreferenceRegistryProposalRequest = z
-  .object({
-    stableKey: RequestStableKey,
-    scope: PreferenceRegistryScope,
-    ...revisionInput,
-    provenanceSource: PreferenceRegistryProvenanceSource.default("human"),
-    provenanceSourceId: z
-      .string()
-      .min(1)
-      .max(PREFERENCE_REGISTRY_SOURCE_ID_MAX_CHARS)
-      .nullable()
-      .default(null),
-  })
-  .superRefine((value, context) => {
-    if (importedSources.has(value.provenanceSource) && value.provenanceSourceId === null) {
-      context.addIssue({
-        code: "custom",
-        path: ["provenanceSourceId"],
-        message: "imported preference proposals require a provenance source id",
-      });
-    }
-  });
+export const CreatePreferenceRegistryProposalRequest = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      stableKey: RequestStableKey,
+      scope: PreferenceRegistryScope,
+      ...revisionInput,
+      provenanceSource: PreferenceRegistryProvenanceSource.default("human"),
+      provenanceSourceId: primitives.nonEmptyString
+        .max(PREFERENCE_REGISTRY_SOURCE_ID_MAX_CHARS)
+        .nullable()
+        .default(null),
+    })
+    .superRefine((value, context) => {
+      if (importedSources.has(value.provenanceSource) && value.provenanceSourceId === null) {
+        context.addIssue({
+          code: "custom",
+          path: ["provenanceSourceId"],
+          message: "imported preference proposals require a provenance source id",
+        });
+      }
+    }),
+);
 export type CreatePreferenceRegistryProposalRequest = z.infer<
   typeof CreatePreferenceRegistryProposalRequest
 >;
 
-export const ActivatePreferenceRegistryRevisionRequest = z.object({
-  revisionId: z.string().uuid(),
-  expectedCurrentRevisionId: z.string().uuid().nullable(),
-  expectedScopeVersion: z.number().int().positive(),
-  reason: boundedReason,
-});
+export const ActivatePreferenceRegistryRevisionRequest = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    revisionId: primitives.uuid,
+    expectedCurrentRevisionId: primitives.nullableUuid,
+    expectedScopeVersion: primitives.positiveInteger,
+    reason: boundedReason,
+  }),
+);
 export type ActivatePreferenceRegistryRevisionRequest = z.infer<
   typeof ActivatePreferenceRegistryRevisionRequest
 >;
 
-export const CorrectPreferenceRegistryRequest = z.object({
-  expectedCurrentRevisionId: z.string().uuid(),
-  expectedScopeVersion: z.number().int().positive(),
-  ...revisionInput,
-  reason: boundedReason,
-});
+export const CorrectPreferenceRegistryRequest = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    expectedCurrentRevisionId: primitives.uuid,
+    expectedScopeVersion: primitives.positiveInteger,
+    ...revisionInput,
+    reason: boundedReason,
+  }),
+);
 export type CorrectPreferenceRegistryRequest = z.infer<typeof CorrectPreferenceRegistryRequest>;
 
-export const DeactivatePreferenceRegistryRequest = z.object({
-  expectedCurrentRevisionId: z.string().uuid(),
-  expectedScopeVersion: z.number().int().positive(),
-  reason: boundedReason,
-});
+export const DeactivatePreferenceRegistryRequest = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    expectedCurrentRevisionId: primitives.uuid,
+    expectedScopeVersion: primitives.positiveInteger,
+    reason: boundedReason,
+  }),
+);
 export type DeactivatePreferenceRegistryRequest = z.infer<
   typeof DeactivatePreferenceRegistryRequest
 >;
 
-export const ChangePreferenceRegistryScopeRequest = z.object({
-  scope: PreferenceRegistryScope,
-  expectedScopeVersion: z.number().int().positive(),
-  reason: boundedReason,
-});
+export const ChangePreferenceRegistryScopeRequest = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    scope: PreferenceRegistryScope,
+    expectedScopeVersion: primitives.positiveInteger,
+    reason: boundedReason,
+  }),
+);
 export type ChangePreferenceRegistryScopeRequest = z.infer<
   typeof ChangePreferenceRegistryScopeRequest
 >;
 
-export const SupersedePreferenceRegistryRequest = z.object({
-  replacementPreferenceId: z.string().uuid(),
-  expectedCurrentRevisionId: z.string().uuid(),
-  expectedScopeVersion: z.number().int().positive(),
-  reason: boundedReason,
-});
+export const SupersedePreferenceRegistryRequest = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    replacementPreferenceId: primitives.uuid,
+    expectedCurrentRevisionId: primitives.uuid,
+    expectedScopeVersion: primitives.positiveInteger,
+    reason: boundedReason,
+  }),
+);
 export type SupersedePreferenceRegistryRequest = z.infer<typeof SupersedePreferenceRegistryRequest>;
 
-export const RejectPreferenceRegistryProposalRequest = z.object({
-  revisionId: z.string().uuid(),
-  expectedScopeVersion: z.number().int().positive(),
-  reason: boundedReason,
-});
+export const RejectPreferenceRegistryProposalRequest = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    revisionId: primitives.uuid,
+    expectedScopeVersion: primitives.positiveInteger,
+    reason: boundedReason,
+  }),
+);
 export type RejectPreferenceRegistryProposalRequest = z.infer<
   typeof RejectPreferenceRegistryProposalRequest
 >;
 
-export const PreferenceRegistryListQuery = z.object({
-  scope: PreferenceRegistryScope.optional(),
-  status: PreferenceRegistryStatus.optional(),
-  limit: z.coerce.number().int().min(1).max(100).default(50),
-});
+export const PreferenceRegistryListQuery = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    scope: PreferenceRegistryScope.optional(),
+    status: PreferenceRegistryStatus.optional(),
+    limit: z.coerce.number().int().min(1).max(100).default(50),
+  }),
+);
 export type PreferenceRegistryListQuery = z.infer<typeof PreferenceRegistryListQuery>;
 
-export const PreferenceRegistryListResponse = z.object({
-  preferences: z.array(PreferenceRegistryRecord),
-});
+export const PreferenceRegistryListResponse = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    preferences: z.array(PreferenceRegistryRecord),
+  }),
+);
 export type PreferenceRegistryListResponse = z.infer<typeof PreferenceRegistryListResponse>;
 
-export const PreferenceRegistryDetailResponse = z.object({
-  preference: PreferenceRegistryRecord,
-  revisions: z.array(PreferenceRegistryRevisionSummary),
-  events: z.array(PreferenceRegistryEvent),
-});
+export const PreferenceRegistryDetailResponse = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    preference: PreferenceRegistryRecord,
+    revisions: z.array(PreferenceRegistryRevisionSummary),
+    events: z.array(PreferenceRegistryEvent),
+  }),
+);
 export type PreferenceRegistryDetailResponse = z.infer<typeof PreferenceRegistryDetailResponse>;
 
-export const PreferenceRegistryMutationResponse = z.object({
-  preference: PreferenceRegistryRecord,
-  event: PreferenceRegistryEvent,
-});
+export const PreferenceRegistryMutationResponse = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    preference: PreferenceRegistryRecord,
+    event: PreferenceRegistryEvent,
+  }),
+);
 export type PreferenceRegistryMutationResponse = z.infer<typeof PreferenceRegistryMutationResponse>;
 
-export const PreferenceRegistryConflictResponse = z.object({
-  code: z.literal("PREFERENCE_REGISTRY_CONFLICT"),
-  message: z.string(),
-  currentRevisionId: z.string().uuid().nullable(),
-  scopeVersion: z.number().int().positive().nullable(),
-});
+export const PreferenceRegistryConflictResponse = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    code: z.literal("PREFERENCE_REGISTRY_CONFLICT"),
+    message: primitives.string,
+    currentRevisionId: primitives.nullableUuid,
+    scopeVersion: z.number().int().positive().nullable(),
+  }),
+);
 export type PreferenceRegistryConflictResponse = z.infer<typeof PreferenceRegistryConflictResponse>;
 
-export const PreferenceRegistryFullContentRequest = z.object({
-  retrievalHandle: z.string().min(1).max(512),
-});
+export const PreferenceRegistryFullContentRequest = /* @__PURE__ */ defineSchema(() =>
+  z.object({
+    retrievalHandle: z.string().min(1).max(512),
+  }),
+);
 export type PreferenceRegistryFullContentRequest = z.infer<
   typeof PreferenceRegistryFullContentRequest
 >;