@aventurevc/api-schemas 0.8.176 → 0.8.178

package/dist/agent/help-question.d.ts

@@ -1,6 +1,5 @@
 import { z } from "zod/v4";
 declare const AgentHelpQuestionSchemaDefinition: z.ZodObject<{
-    includePrivate: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
     model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     question: z.ZodString;
     resolve: z.ZodOptional<z.ZodBoolean>;

package/dist/agent/help-question.js

@@ -2,12 +2,10 @@
 import { z } from "zod/v4";
 import { HelpScopeSchema } from "../help/scope.js";
 const AgentHelpQuestionSchemaDefinition = z.object({
-    /** False limits answers to operations every account can run; omit it to match your account's access. */
-    includePrivate: z.boolean().nullish(),
     /** Optional supported model for the answer. Omit it to use the default; an unsupported model answers 422. */
     model: z.string().nullish(),
     /** The question to answer, in natural language. */
-    question: z.string().max(2000),
+    question: z.string().min(1),
     /** True recommends the operation or workflow that does what the question asks, or asks a clarifying question, instead of writing an answer. It ignores model and has its own per-account limit. */
     resolve: z.boolean().optional(),
     /** Optional scope restricting which operations the answer may recommend; null means all. */

package/dist/agent/help.d.ts

@@ -39,8 +39,8 @@ declare const AgentHelpSchemaDefinition: z.ZodObject<{
         probability: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         taskKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         taskPlan: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-            catalogRevision: z.ZodInt;
-            gateId: z.ZodArray<z.ZodString>;
+            catalogRevision: z.ZodOptional<z.ZodInt>;
+            gateId: z.ZodOptional<z.ZodArray<z.ZodString>>;
             input: z.ZodArray<z.ZodType<{
                 description: string;
                 key: string;
@@ -56,7 +56,7 @@ declare const AgentHelpSchemaDefinition: z.ZodObject<{
                 step: {
                     instruction: string;
                     operationId: string;
-                    stepKey: string;
+                    stepKey?: string | undefined;
                 };
                 writeGuidance?: {
                     body: string;
@@ -72,7 +72,7 @@ declare const AgentHelpSchemaDefinition: z.ZodObject<{
                 step: {
                     instruction: string;
                     operationId: string;
-                    stepKey: string;
+                    stepKey?: string | undefined;
                 };
                 writeGuidance?: {
                     body: string;
@@ -83,7 +83,7 @@ declare const AgentHelpSchemaDefinition: z.ZodObject<{
                     typeCatalog: string;
                 } | null | undefined;
             }, import("../harness/task-plan-step.ts").HarnessTaskPlanStepSchemaInput>>>;
-            taskKey: z.ZodString;
+            taskKey: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;

package/dist/agent/task-preset-catalog.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod/v4";
+declare const AgentTaskPresetCatalogSchemaDefinition: z.ZodObject<{
+    taskPreset: z.ZodArray<z.ZodType<{
+        execution: "FULL" | "MICRO";
+        key: string;
+        name: string;
+        phase: "FINAL" | "PRIMARY";
+    }, import("./task-preset.ts").AgentTaskPresetSchemaInput, z.core.$ZodTypeInternals<{
+        execution: "FULL" | "MICRO";
+        key: string;
+        name: string;
+        phase: "FINAL" | "PRIMARY";
+    }, import("./task-preset.ts").AgentTaskPresetSchemaInput>>>;
+}, z.core.$strip>;
+type AgentTaskPresetCatalogDefinition = z.infer<typeof AgentTaskPresetCatalogSchemaDefinition>;
+export interface AgentTaskPresetCatalogSchemaInput extends z.input<typeof AgentTaskPresetCatalogSchemaDefinition> {
+}
+/**
+ * Research presets available to the caller.
+ *
+ * @openapiSchema AgentTaskPresetCatalog
+ * @endpoint GET /v1/research-runs/presets
+ * @contractShape agent.task-preset-catalog
+ * @contractRole canonical
+ */
+export declare const AgentTaskPresetCatalogSchema: z.ZodType<AgentTaskPresetCatalogDefinition, AgentTaskPresetCatalogSchemaInput>;
+export type AgentTaskPresetCatalog = z.infer<typeof AgentTaskPresetCatalogSchema>;
+export {};
+//# sourceMappingURL=task-preset-catalog.d.ts.map

package/dist/agent/task-preset-catalog.js

@@ -0,0 +1,17 @@
+// LLM AGENTS MAY NOT EDIT THIS FILE UNDER ANY CIRCUMSTANCES. DO NOT EDIT - generated from Kotlin data classes via OpenAPI. Edit the backend owner and run: make docs-openapi && make docs-zod
+import { z } from "zod/v4";
+import { AgentTaskPresetSchema } from "./task-preset.js";
+const AgentTaskPresetCatalogSchemaDefinition = z.object({
+    /** Available task presets. Field name is singular by repository convention even though the value is a collection. */
+    taskPreset: z.array(AgentTaskPresetSchema),
+});
+/**
+ * Research presets available to the caller.
+ *
+ * @openapiSchema AgentTaskPresetCatalog
+ * @endpoint GET /v1/research-runs/presets
+ * @contractShape agent.task-preset-catalog
+ * @contractRole canonical
+ */
+export const AgentTaskPresetCatalogSchema = AgentTaskPresetCatalogSchemaDefinition;
+//# sourceMappingURL=task-preset-catalog.js.map

package/dist/agent/task-preset-phase.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod/v4";
+/**
+ * Dispatch phase governing intra-job ordering when presets are multi-selected.
+ *
+ * @openapiSchema AgentTaskPresetPhase
+ * @endpoint GET /v1/research-runs/presets
+ * @usedBySchema AgentTaskPresetSchema
+ * @contractShape agent.task-preset-phase
+ * @contractRole canonical
+ */
+export declare const AgentTaskPresetPhaseSchema: z.ZodEnum<{
+    FINAL: "FINAL";
+    PRIMARY: "PRIMARY";
+}>;
+export type AgentTaskPresetPhase = z.infer<typeof AgentTaskPresetPhaseSchema>;
+//# sourceMappingURL=task-preset-phase.d.ts.map

package/dist/agent/task-preset-phase.js

@@ -0,0 +1,13 @@
+// LLM AGENTS MAY NOT EDIT THIS FILE UNDER ANY CIRCUMSTANCES. DO NOT EDIT - generated from Kotlin data classes via OpenAPI. Edit the backend owner and run: make docs-openapi && make docs-zod
+import { z } from "zod/v4";
+/**
+ * Dispatch phase governing intra-job ordering when presets are multi-selected.
+ *
+ * @openapiSchema AgentTaskPresetPhase
+ * @endpoint GET /v1/research-runs/presets
+ * @usedBySchema AgentTaskPresetSchema
+ * @contractShape agent.task-preset-phase
+ * @contractRole canonical
+ */
+export const AgentTaskPresetPhaseSchema = z.enum(["PRIMARY", "FINAL"]);
+//# sourceMappingURL=task-preset-phase.js.map

package/dist/agent/task-preset.d.ts

@@ -0,0 +1,29 @@
+import { z } from "zod/v4";
+declare const AgentTaskPresetSchemaDefinition: z.ZodObject<{
+    execution: z.ZodEnum<{
+        FULL: "FULL";
+        MICRO: "MICRO";
+    }>;
+    key: z.ZodString;
+    name: z.ZodString;
+    phase: z.ZodEnum<{
+        FINAL: "FINAL";
+        PRIMARY: "PRIMARY";
+    }>;
+}, z.core.$strip>;
+type AgentTaskPresetDefinition = z.infer<typeof AgentTaskPresetSchemaDefinition>;
+export interface AgentTaskPresetSchemaInput extends z.input<typeof AgentTaskPresetSchemaDefinition> {
+}
+/**
+ * A research preset: one named topic a research run can focus on.
+ *
+ * @openapiSchema AgentTaskPreset
+ * @endpoint GET /v1/research-runs/presets
+ * @usedBySchema AgentTaskPresetCatalogSchema
+ * @contractShape agent.task-preset
+ * @contractRole canonical
+ */
+export declare const AgentTaskPresetSchema: z.ZodType<AgentTaskPresetDefinition, AgentTaskPresetSchemaInput>;
+export type AgentTaskPreset = z.infer<typeof AgentTaskPresetSchema>;
+export {};
+//# sourceMappingURL=task-preset.d.ts.map

package/dist/agent/task-preset.js

@@ -0,0 +1,24 @@
+// LLM AGENTS MAY NOT EDIT THIS FILE UNDER ANY CIRCUMSTANCES. DO NOT EDIT - generated from Kotlin data classes via OpenAPI. Edit the backend owner and run: make docs-openapi && make docs-zod
+import { z } from "zod/v4";
+import { AgentTaskPresetPhaseSchema } from "./task-preset-phase.js";
+const AgentTaskPresetSchemaDefinition = z.object({
+    /** How the preset runs: FULL focuses a full research run on its topic; MICRO runs it as one bounded research task. */
+    execution: z.enum(["FULL", "MICRO"]),
+    /** Stable key to send in taskPresetKey. */
+    key: z.string(),
+    /** Display name of the topic the preset researches. */
+    name: z.string(),
+    /** Dispatch phase for intra-job ordering: PRIMARY presets run first; FINAL presets defer until the primary wave completes so they read the freshly-updated entity dossier. */
+    phase: AgentTaskPresetPhaseSchema,
+});
+/**
+ * A research preset: one named topic a research run can focus on.
+ *
+ * @openapiSchema AgentTaskPreset
+ * @endpoint GET /v1/research-runs/presets
+ * @usedBySchema AgentTaskPresetCatalogSchema
+ * @contractShape agent.task-preset
+ * @contractRole canonical
+ */
+export const AgentTaskPresetSchema = AgentTaskPresetSchemaDefinition;
+//# sourceMappingURL=task-preset.js.map

package/dist/billing/catalog-plan.d.ts

@@ -12,7 +12,16 @@ declare const BillingCatalogPlanSchemaDefinition: z.ZodObject<{
         PRO_YEARLY: "PRO_YEARLY";
         PRO_YEARLY_PROMOTION: "PRO_YEARLY_PROMOTION";
         UNLIMITED_MONTHLY: "UNLIMITED_MONTHLY";
-    }>, z.ZodString]>;
+    }>, z.ZodString]> & {
+        enum: {
+            PLUS_MONTHLY: "PLUS_MONTHLY";
+            PLUS_YEARLY: "PLUS_YEARLY";
+            PRO_MONTHLY: "PRO_MONTHLY";
+            PRO_YEARLY: "PRO_YEARLY";
+            PRO_YEARLY_PROMOTION: "PRO_YEARLY_PROMOTION";
+            UNLIMITED_MONTHLY: "UNLIMITED_MONTHLY";
+        };
+    };
     tier: z.ZodEnum<{
         ESSENTIAL: "ESSENTIAL";
         PLUS: "PLUS";

package/dist/billing/checkout-mutation.d.ts

@@ -7,7 +7,16 @@ declare const BillingCheckoutMutationSchemaDefinition: z.ZodObject<{
         PRO_YEARLY: "PRO_YEARLY";
         PRO_YEARLY_PROMOTION: "PRO_YEARLY_PROMOTION";
         UNLIMITED_MONTHLY: "UNLIMITED_MONTHLY";
-    }>, z.ZodString]>;
+    }>, z.ZodString]> & {
+        enum: {
+            PLUS_MONTHLY: "PLUS_MONTHLY";
+            PLUS_YEARLY: "PLUS_YEARLY";
+            PRO_MONTHLY: "PRO_MONTHLY";
+            PRO_YEARLY: "PRO_YEARLY";
+            PRO_YEARLY_PROMOTION: "PRO_YEARLY_PROMOTION";
+            UNLIMITED_MONTHLY: "UNLIMITED_MONTHLY";
+        };
+    };
     uiMode: z.ZodOptional<z.ZodEnum<{
         ELEMENTS: "ELEMENTS";
         HOSTED_PAGE: "HOSTED_PAGE";

package/dist/billing/checkout.d.ts

@@ -9,7 +9,16 @@ declare const BillingCheckoutSchemaDefinition: z.ZodObject<{
         PRO_YEARLY: "PRO_YEARLY";
         PRO_YEARLY_PROMOTION: "PRO_YEARLY_PROMOTION";
         UNLIMITED_MONTHLY: "UNLIMITED_MONTHLY";
-    }>, z.ZodString]>;
+    }>, z.ZodString]> & {
+        enum: {
+            PLUS_MONTHLY: "PLUS_MONTHLY";
+            PLUS_YEARLY: "PLUS_YEARLY";
+            PRO_MONTHLY: "PRO_MONTHLY";
+            PRO_YEARLY: "PRO_YEARLY";
+            PRO_YEARLY_PROMOTION: "PRO_YEARLY_PROMOTION";
+            UNLIMITED_MONTHLY: "UNLIMITED_MONTHLY";
+        };
+    };
     publishableKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strip>;

package/dist/billing/plan-change-mutation.d.ts

@@ -7,7 +7,16 @@ declare const BillingPlanChangeMutationSchemaDefinition: z.ZodObject<{
         PRO_YEARLY: "PRO_YEARLY";
         PRO_YEARLY_PROMOTION: "PRO_YEARLY_PROMOTION";
         UNLIMITED_MONTHLY: "UNLIMITED_MONTHLY";
-    }>, z.ZodString]>;
+    }>, z.ZodString]> & {
+        enum: {
+            PLUS_MONTHLY: "PLUS_MONTHLY";
+            PLUS_YEARLY: "PLUS_YEARLY";
+            PRO_MONTHLY: "PRO_MONTHLY";
+            PRO_YEARLY: "PRO_YEARLY";
+            PRO_YEARLY_PROMOTION: "PRO_YEARLY_PROMOTION";
+            UNLIMITED_MONTHLY: "UNLIMITED_MONTHLY";
+        };
+    };
     prorationDate: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strip>;
 type BillingPlanChangeMutationDefinition = z.infer<typeof BillingPlanChangeMutationSchemaDefinition>;

package/dist/billing/plan-change.d.ts

@@ -10,7 +10,16 @@ declare const BillingPlanChangeSchemaDefinition: z.ZodObject<{
         PRO_YEARLY: "PRO_YEARLY";
         PRO_YEARLY_PROMOTION: "PRO_YEARLY_PROMOTION";
         UNLIMITED_MONTHLY: "UNLIMITED_MONTHLY";
-    }>, z.ZodString]>;
+    }>, z.ZodString]> & {
+        enum: {
+            PLUS_MONTHLY: "PLUS_MONTHLY";
+            PLUS_YEARLY: "PLUS_YEARLY";
+            PRO_MONTHLY: "PRO_MONTHLY";
+            PRO_YEARLY: "PRO_YEARLY";
+            PRO_YEARLY_PROMOTION: "PRO_YEARLY_PROMOTION";
+            UNLIMITED_MONTHLY: "UNLIMITED_MONTHLY";
+        };
+    };
     publishableKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strip>;
 type BillingPlanChangeDefinition = z.infer<typeof BillingPlanChangeSchemaDefinition>;

package/dist/billing/plan-type.d.ts

@@ -24,6 +24,15 @@ export declare const BillingPlanTypeSchema: z.ZodUnion<readonly [z.ZodEnum<{
     PRO_YEARLY: "PRO_YEARLY";
     PRO_YEARLY_PROMOTION: "PRO_YEARLY_PROMOTION";
     UNLIMITED_MONTHLY: "UNLIMITED_MONTHLY";
-}>, z.ZodString]>;
+}>, z.ZodString]> & {
+    enum: {
+        PLUS_MONTHLY: "PLUS_MONTHLY";
+        PLUS_YEARLY: "PLUS_YEARLY";
+        PRO_MONTHLY: "PRO_MONTHLY";
+        PRO_YEARLY: "PRO_YEARLY";
+        PRO_YEARLY_PROMOTION: "PRO_YEARLY_PROMOTION";
+        UNLIMITED_MONTHLY: "UNLIMITED_MONTHLY";
+    };
+};
 export type BillingPlanType = z.infer<typeof BillingPlanTypeSchema>;
 //# sourceMappingURL=plan-type.d.ts.map

package/dist/billing/plan-type.js

@@ -1,5 +1,13 @@
 // LLM AGENTS MAY NOT EDIT THIS FILE UNDER ANY CIRCUMSTANCES. DO NOT EDIT - generated from Kotlin data classes via OpenAPI. Edit the backend owner and run: make docs-openapi && make docs-zod
 import { z } from "zod/v4";
+const BillingPlanTypeSchemaKnownMembers = z.enum([
+    "PLUS_MONTHLY",
+    "PLUS_YEARLY",
+    "PRO_MONTHLY",
+    "PRO_YEARLY",
+    "PRO_YEARLY_PROMOTION",
+    "UNLIMITED_MONTHLY",
+]);
 /**
  * Canonical paid billing plan offered by aVenture.
  *
@@ -18,15 +26,5 @@ import { z } from "zod/v4";
  * @contractShape billing.plan-type
  * @contractRole canonical
  */
-export const BillingPlanTypeSchema = z.union([
-    z.enum([
-        "PLUS_MONTHLY",
-        "PLUS_YEARLY",
-        "PRO_MONTHLY",
-        "PRO_YEARLY",
-        "PRO_YEARLY_PROMOTION",
-        "UNLIMITED_MONTHLY",
-    ]),
-    z.string(),
-]);
+export const BillingPlanTypeSchema = Object.assign(z.union([BillingPlanTypeSchemaKnownMembers, z.string()]), { enum: BillingPlanTypeSchemaKnownMembers.enum });
 //# sourceMappingURL=plan-type.js.map

package/dist/billing/subscription.d.ts

@@ -165,7 +165,16 @@ declare const BillingSubscriptionSchemaDefinition: z.ZodObject<{
         PRO_YEARLY: "PRO_YEARLY";
         PRO_YEARLY_PROMOTION: "PRO_YEARLY_PROMOTION";
         UNLIMITED_MONTHLY: "UNLIMITED_MONTHLY";
-    }>, z.ZodString]>>>;
+    }>, z.ZodString]> & {
+        enum: {
+            PLUS_MONTHLY: "PLUS_MONTHLY";
+            PLUS_YEARLY: "PLUS_YEARLY";
+            PRO_MONTHLY: "PRO_MONTHLY";
+            PRO_YEARLY: "PRO_YEARLY";
+            PRO_YEARLY_PROMOTION: "PRO_YEARLY_PROMOTION";
+            UNLIMITED_MONTHLY: "UNLIMITED_MONTHLY";
+        };
+    }>>;
     pendingPlanAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
     periodEnd: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
     periodStart: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
@@ -176,7 +185,16 @@ declare const BillingSubscriptionSchemaDefinition: z.ZodObject<{
         PRO_YEARLY: "PRO_YEARLY";
         PRO_YEARLY_PROMOTION: "PRO_YEARLY_PROMOTION";
         UNLIMITED_MONTHLY: "UNLIMITED_MONTHLY";
-    }>, z.ZodString]>>>;
+    }>, z.ZodString]> & {
+        enum: {
+            PLUS_MONTHLY: "PLUS_MONTHLY";
+            PLUS_YEARLY: "PLUS_YEARLY";
+            PRO_MONTHLY: "PRO_MONTHLY";
+            PRO_YEARLY: "PRO_YEARLY";
+            PRO_YEARLY_PROMOTION: "PRO_YEARLY_PROMOTION";
+            UNLIMITED_MONTHLY: "UNLIMITED_MONTHLY";
+        };
+    }>>;
     provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
         APP_STORE: "APP_STORE";
         STRIPE: "STRIPE";

package/dist/classification/catalog-bucket.d.ts

@@ -2,25 +2,27 @@ import { z } from "zod/v4";
 declare const ClassificationCatalogBucketSchemaDefinition: z.ZodObject<{
     alias: z.ZodArray<z.ZodString>;
     bucket: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    creatable: z.ZodBoolean;
+    creatable: z.ZodOptional<z.ZodBoolean>;
     hierarchical: z.ZodBoolean;
     label: z.ZodString;
     tag: z.ZodArray<z.ZodIntersection<z.ZodType<{
-        creatable: boolean;
+        creatable?: boolean | undefined;
         isCurrent?: boolean | null | undefined;
         isPrimary?: boolean | null | undefined;
         name: string;
-        writable: boolean;
+        registry: string;
+        writable?: boolean | undefined;
     }, import("./classification.ts").ClassificationSchemaInput, z.core.$ZodTypeInternals<{
-        creatable: boolean;
+        creatable?: boolean | undefined;
         isCurrent?: boolean | null | undefined;
         isPrimary?: boolean | null | undefined;
         name: string;
-        writable: boolean;
+        registry: string;
+        writable?: boolean | undefined;
     }, import("./classification.ts").ClassificationSchemaInput>>, z.ZodObject<{
         bucket: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         classificationId: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
-        creatable: z.ZodBoolean;
+        creatable: z.ZodOptional<z.ZodBoolean>;
         createdAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
         id: z.ZodInt;
         isCurrent: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
@@ -29,11 +31,11 @@ declare const ClassificationCatalogBucketSchemaDefinition: z.ZodObject<{
         slug: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         type: z.ZodString;
         updatedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
-        writable: z.ZodBoolean;
+        writable: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>>;
     tagCount: z.ZodInt;
     type: z.ZodString;
-    writable: z.ZodBoolean;
+    writable: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 type ClassificationCatalogBucketDefinition = z.infer<typeof ClassificationCatalogBucketSchemaDefinition>;
 export interface ClassificationCatalogBucketSchemaInput extends z.input<typeof ClassificationCatalogBucketSchemaDefinition> {

package/dist/classification/catalog-bucket.js

@@ -7,7 +7,7 @@ const ClassificationCatalogBucketSchemaDefinition = z.object({
     /** Canonical classification bucket key. */
     bucket: z.string().nullish(),
     /** Whether missing values in this bucket can be created by name. */
-    creatable: z.boolean(),
+    creatable: z.boolean().optional(),
     /** Whether the bucket has hierarchy semantics. */
     hierarchical: z.boolean(),
     /** Human-readable bucket label (e.g. 'Revenue Model'). */
@@ -19,7 +19,7 @@ const ClassificationCatalogBucketSchemaDefinition = z.object({
     /** Canonical wire value — use as ?type= for /tags, as ?bucketType= for /catalog, and as Tag.type when round-tripping. Matches Tag.type returned in this bucket's tag[]. */
     type: z.string(),
     /** Whether existing rows in this bucket can be joined. */
-    writable: z.boolean(),
+    writable: z.boolean().optional(),
 });
 /**
  * Classification bucket with active registry tags and accepted-spelling aliases.

package/dist/classification/catalog-category.d.ts

@@ -4,36 +4,38 @@ declare const ClassificationCatalogCategorySchemaDefinition: z.ZodObject<{
     category: z.ZodString;
     classification: z.ZodArray<z.ZodType<{
         category: string;
+        classificationId?: number | null | undefined;
         code?: number | null | undefined;
-        creatable: boolean;
+        creatable?: boolean | undefined;
         createdAt?: string | null | undefined;
-        entityClassificationId?: number | null | undefined;
         id: number;
         isCurrent?: boolean | null | undefined;
         isPrimary?: boolean | null | undefined;
         level?: number | null | undefined;
         name: string;
+        registry: string;
         updatedAt?: string | null | undefined;
-        writable: boolean;
+        writable?: boolean | undefined;
     }, import("../standardized/classification.ts").StandardizedClassificationSchemaInput, z.core.$ZodTypeInternals<{
         category: string;
+        classificationId?: number | null | undefined;
         code?: number | null | undefined;
-        creatable: boolean;
+        creatable?: boolean | undefined;
         createdAt?: string | null | undefined;
-        entityClassificationId?: number | null | undefined;
         id: number;
         isCurrent?: boolean | null | undefined;
         isPrimary?: boolean | null | undefined;
         level?: number | null | undefined;
         name: string;
+        registry: string;
         updatedAt?: string | null | undefined;
-        writable: boolean;
+        writable?: boolean | undefined;
     }, import("../standardized/classification.ts").StandardizedClassificationSchemaInput>>>;
     classificationCount: z.ZodInt;
-    creatable: z.ZodBoolean;
+    creatable: z.ZodOptional<z.ZodBoolean>;
     hierarchical: z.ZodBoolean;
     label: z.ZodString;
-    writable: z.ZodBoolean;
+    writable: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 type ClassificationCatalogCategoryDefinition = z.infer<typeof ClassificationCatalogCategorySchemaDefinition>;
 export interface ClassificationCatalogCategorySchemaInput extends z.input<typeof ClassificationCatalogCategorySchemaDefinition> {

package/dist/classification/catalog-category.js

@@ -11,13 +11,13 @@ const ClassificationCatalogCategorySchemaDefinition = z.object({
     /** Total standardized classifications in this category. */
     classificationCount: z.int(),
     /** Whether missing values in this category can be created by name. */
-    creatable: z.boolean(),
+    creatable: z.boolean().optional(),
     /** Whether the category has hierarchy semantics. */
     hierarchical: z.boolean(),
     /** Human-readable category label. */
     label: z.string(),
     /** Whether existing rows in this category can be joined. */
-    writable: z.boolean(),
+    writable: z.boolean().optional(),
 });
 /**
  * Standardized classification category with accepted spellings and registry rows.

package/dist/classification/catalog.d.ts

@@ -3,19 +3,20 @@ declare const ClassificationCatalogSchemaDefinition: z.ZodObject<{
     bucket: z.ZodArray<z.ZodType<{
         alias: string[];
         bucket?: string | null | undefined;
-        creatable: boolean;
+        creatable?: boolean | undefined;
         hierarchical: boolean;
         label: string;
         tag: ({
-            creatable: boolean;
+            creatable?: boolean | undefined;
             isCurrent?: boolean | null | undefined;
             isPrimary?: boolean | null | undefined;
             name: string;
-            writable: boolean;
+            registry: string;
+            writable?: boolean | undefined;
         } & {
             bucket?: string | null | undefined;
             classificationId?: number | null | undefined;
-            creatable: boolean;
+            creatable?: boolean | undefined;
             createdAt?: string | null | undefined;
             id: number;
             isCurrent?: boolean | null | undefined;
@@ -24,27 +25,28 @@ declare const ClassificationCatalogSchemaDefinition: z.ZodObject<{
             slug?: string | null | undefined;
             type: string;
             updatedAt?: string | null | undefined;
-            writable: boolean;
+            writable?: boolean | undefined;
         })[];
         tagCount: number;
         type: string;
-        writable: boolean;
+        writable?: boolean | undefined;
     }, import("./catalog-bucket.ts").ClassificationCatalogBucketSchemaInput, z.core.$ZodTypeInternals<{
         alias: string[];
         bucket?: string | null | undefined;
-        creatable: boolean;
+        creatable?: boolean | undefined;
         hierarchical: boolean;
         label: string;
         tag: ({
-            creatable: boolean;
+            creatable?: boolean | undefined;
             isCurrent?: boolean | null | undefined;
             isPrimary?: boolean | null | undefined;
             name: string;
-            writable: boolean;
+            registry: string;
+            writable?: boolean | undefined;
         } & {
             bucket?: string | null | undefined;
             classificationId?: number | null | undefined;
-            creatable: boolean;
+            creatable?: boolean | undefined;
             createdAt?: string | null | undefined;
             id: number;
             isCurrent?: boolean | null | undefined;
@@ -53,56 +55,58 @@ declare const ClassificationCatalogSchemaDefinition: z.ZodObject<{
             slug?: string | null | undefined;
             type: string;
             updatedAt?: string | null | undefined;
-            writable: boolean;
+            writable?: boolean | undefined;
         })[];
         tagCount: number;
         type: string;
-        writable: boolean;
+        writable?: boolean | undefined;
     }, import("./catalog-bucket.ts").ClassificationCatalogBucketSchemaInput>>>;
     category: z.ZodArray<z.ZodType<{
         alias: string[];
         category: string;
         classification: {
             category: string;
+            classificationId?: number | null | undefined;
             code?: number | null | undefined;
-            creatable: boolean;
+            creatable?: boolean | undefined;
             createdAt?: string | null | undefined;
-            entityClassificationId?: number | null | undefined;
             id: number;
             isCurrent?: boolean | null | undefined;
             isPrimary?: boolean | null | undefined;
             level?: number | null | undefined;
             name: string;
+            registry: string;
             updatedAt?: string | null | undefined;
-            writable: boolean;
+            writable?: boolean | undefined;
         }[];
         classificationCount: number;
-        creatable: boolean;
+        creatable?: boolean | undefined;
         hierarchical: boolean;
         label: string;
-        writable: boolean;
+        writable?: boolean | undefined;
     }, import("./catalog-category.ts").ClassificationCatalogCategorySchemaInput, z.core.$ZodTypeInternals<{
         alias: string[];
         category: string;
         classification: {
             category: string;
+            classificationId?: number | null | undefined;
             code?: number | null | undefined;
-            creatable: boolean;
+            creatable?: boolean | undefined;
             createdAt?: string | null | undefined;
-            entityClassificationId?: number | null | undefined;
             id: number;
             isCurrent?: boolean | null | undefined;
             isPrimary?: boolean | null | undefined;
             level?: number | null | undefined;
             name: string;
+            registry: string;
             updatedAt?: string | null | undefined;
-            writable: boolean;
+            writable?: boolean | undefined;
         }[];
         classificationCount: number;
-        creatable: boolean;
+        creatable?: boolean | undefined;
         hierarchical: boolean;
         label: string;
-        writable: boolean;
+        writable?: boolean | undefined;
     }, import("./catalog-category.ts").ClassificationCatalogCategorySchemaInput>>>;
     generatedAt: z.ZodISODateTime;
     totalBucket: z.ZodInt;