@standards/schema 0.0.0-stage → 1.0.0-alpha.384

package/dist/index-CH-Vc-pK.d.ts

@@ -0,0 +1,279 @@
+
+import { Y as ObjectImage, u as RecordAppearance } from "./objects-CH22DJOx.js";
+import { i as AttributeType, n as Attribute } from "./attributes-D35Lcoui.js";
+import { z as z$1 } from "zod";
+import { ColorId, IconName } from "@standards/constants";
+//#region src/types/mutations.d.ts
+interface AddAttributeInput {
+  name: string;
+  label: string;
+  type: AttributeType;
+  required?: boolean;
+  unique?: boolean;
+  description?: string;
+  placeholder?: string;
+  icon?: IconName;
+  defaultValue?: unknown;
+  metadata?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+interface CreateCustomObjectInput {
+  name: string;
+  label: string;
+  pluralLabel?: string;
+  labelExpression: string;
+  embeddingExpression?: string;
+  description?: string;
+  icon?: IconName;
+  color?: ColorId;
+  image?: ObjectImage;
+  attributes?: (Attribute | {
+    build: () => Attribute;
+  })[];
+  metadata?: Record<string, unknown>;
+}
+interface UpdateObjectInput {
+  label?: string;
+  pluralLabel?: string;
+  description?: string;
+  icon?: IconName;
+  /** `null` clears it: the colour then derives from the object name. */
+  color?: ColorId | null;
+  /** `null` clears it: record images then crop to a square, and are found nowhere. */
+  image?: ObjectImage | null;
+  labelExpression?: string;
+  embeddingExpression?: string;
+  metadata?: Record<string, unknown>;
+}
+interface RelationOption {
+  id: string;
+  objectId: string;
+  objectName: string;
+  objectLabel: string;
+  objectIcon?: string;
+  objectColor?: ColorId;
+  /** How the target object crops its records' images: all an option needs of its image settings. */
+  objectImage?: Pick<ObjectImage, "shape">;
+  /** The target record's own icon / image; absent when it has neither. */
+  appearance?: RecordAppearance;
+  label: string;
+}
+interface RelationOptionsResponse {
+  options: RelationOption[];
+  hasMore: boolean;
+  total: number;
+  nextOffset?: number;
+}
+//#endregion
+//#region src/validation/config/schemas.d.ts
+/**
+ * `baseConfigSchema`'s keys — the model never sets these directly, and the
+ * prompt (`attribute-reference.ts`'s `BASE_CONFIG_KEYS`) already hides them
+ * from every `<attribute_types>` line. `ADD_ATTRIBUTE_WIRE` omits them from
+ * each per-type wire config for the same reason, so the wire never offers a
+ * key the model was never told about — and never exposes `metadata`, the one
+ * genuine open record among them, on the wire. Single source: the runtime
+ * prompt imports this instead of keeping its own copy.
+ */
+declare const WIRE_OMITTED_CONFIG_KEYS: readonly ["placeholder", "description", "defaultValue", "icon", "order", "hidden", "archived", "deprecated", "metadata"];
+/**
+ * The omitted base keys one attribute type's wire offers back, each with the
+ * wire schema it is validated by. Karl's ruling on #4537 (2026-09-27, «
+ * Relations seulement »): a relation field takes its own icon, a catalogue
+ * name the agent finds with `search_icons`, exactly as an object icon; every
+ * other type keeps `icon` omitted. Single source for the wire
+ * (`ADD_ATTRIBUTE_WIRE`) and the prompt (`attribute-reference.ts`), so the
+ * key the model is told about is the key the wire accepts.
+ */
+declare const WIRE_OFFERED_BASE_CONFIG: Partial<Record<AttributeType, Partial<Record<(typeof WIRE_OMITTED_CONFIG_KEYS)[number], z$1.ZodType>>>>;
+/** The keys hidden from `attributeType`'s wire config and its prompt line. */
+declare function wireOmittedConfigKeysFor(attributeType: AttributeType): readonly string[];
+/** `omit()` mask of the type keys hidden from `attributeType`'s wire. */
+declare function wireHiddenTypeConfigMask(attributeType: AttributeType): Record<string, true>;
+/**
+ * Builds the `superRefine` that refuses a key belonging to a DIFFERENT type
+ * than the one sent.
+ *
+ * Two wire shapes merge several types into one member for size — the nine
+ * simple attribute types of `ADD_ATTRIBUTE_WIRE`, and the seven simple
+ * qualified-property types below — so a merged member structurally accepts
+ * every merged type's keys. Without this, a `text`-only `format` sent on a
+ * `number` parses and is then silently `.strip()`-ped at store: a key lost
+ * with no feedback. Checked against the SENT type, and the message names the
+ * keys that type does accept so the next call is right. One factory rather
+ * than two near-identical loops — the second one drifted first.
+ */
+declare function refuseForeignKeys<T extends string>(keysByType: Readonly<Record<T, ReadonlySet<string>>>, noun: string, alwaysAllowed?: readonly string[]): (type: T, subject: Record<string, unknown> | undefined, ctx: z$1.RefinementCtx, path?: readonly string[]) => void;
+declare const statusGroupSchema: z$1.ZodEnum<{
+  idle: "idle";
+  in_progress: "in_progress";
+  finished: "finished";
+}>;
+declare const selectOptionWriteSchema: z$1.ZodObject<{
+  value: z$1.ZodString;
+  label: z$1.ZodString;
+  description: z$1.ZodOptional<z$1.ZodString>;
+  inverse: z$1.ZodOptional<z$1.ZodString>;
+  archived: z$1.ZodOptional<z$1.ZodBoolean>;
+  color: z$1.ZodEnum<{
+    stone: "stone";
+    clay: "clay";
+    brick: "brick";
+    terra: "terra";
+    ochre: "ochre";
+    moss: "moss";
+    sage: "sage";
+    lagoon: "lagoon";
+    ink: "ink";
+    iris: "iris";
+    peony: "peony";
+  }>;
+}, z$1.core.$strict>;
+declare const multiselectOptionWriteSchema: z$1.ZodObject<{
+  value: z$1.ZodString;
+  label: z$1.ZodString;
+  description: z$1.ZodOptional<z$1.ZodString>;
+  inverse: z$1.ZodOptional<z$1.ZodString>;
+  archived: z$1.ZodOptional<z$1.ZodBoolean>;
+  color: z$1.ZodEnum<{
+    stone: "stone";
+    clay: "clay";
+    brick: "brick";
+    terra: "terra";
+    ochre: "ochre";
+    moss: "moss";
+    sage: "sage";
+    lagoon: "lagoon";
+    ink: "ink";
+    iris: "iris";
+    peony: "peony";
+  }>;
+}, z$1.core.$strict>;
+declare const statusOptionWriteSchema: z$1.ZodObject<{
+  value: z$1.ZodString;
+  label: z$1.ZodString;
+  description: z$1.ZodOptional<z$1.ZodString>;
+  inverse: z$1.ZodOptional<z$1.ZodString>;
+  archived: z$1.ZodOptional<z$1.ZodBoolean>;
+  color: z$1.ZodEnum<{
+    stone: "stone";
+    clay: "clay";
+    brick: "brick";
+    terra: "terra";
+    ochre: "ochre";
+    moss: "moss";
+    sage: "sage";
+    lagoon: "lagoon";
+    ink: "ink";
+    iris: "iris";
+    peony: "peony";
+  }>;
+  group: z$1.ZodEnum<{
+    idle: "idle";
+    in_progress: "in_progress";
+    finished: "finished";
+  }>;
+}, z$1.core.$strict>;
+/**
+ * Drops, from every option of an attribute config or body, the keys
+ * `optionSchema` does not know — typically an `id` the code builder accepted
+ * without complaint (#4356). Sync stores options through it, and the schema
+ * state reads them through it, so one stale key no longer 400s the whole state.
+ * The options of a `relation()`/`document()`'s `.qualifyWith()` properties are
+ * validated by the same schema, so each property definition goes through it too.
+ *
+ * Order is kept, and a config with nothing to drop is returned as is. A list
+ * or option that is not the expected shape is left for strict validation to
+ * refuse.
+ */
+declare function withoutUnknownOptionKeys<T extends object>(config: T): T;
+/**
+ * Property types whose config differs from `baseConfigSchema` only by
+ * independent optional scalars — no options array, no relation targets. Same
+ * shape as `SIMPLE_ATTRIBUTE_TYPES` in `architect/operations/schema.ts` minus
+ * `richtext`/`user` (not valid property types) — none of these seven types'
+ * keys collide, proven by `tests/validation/config/property-config.test.ts`.
+ * Merged into one wire member for the same reason `ADD_ATTRIBUTE_WIRE` merges
+ * its nine: the model reads one shape instead of seven near-identical ones,
+ * and this is also what keeps a qualified relation/document's `add_attribute`
+ * leaf under its wire-size cap (`tests/architect/wire-schema-size.test.ts`) —
+ * ten separate members, each paying its own JSON Schema object/`$defs`
+ * boilerplate, blew the budget even after the base config keys were omitted.
+ */
+declare const SIMPLE_PROPERTY_TYPES: readonly ["text", "number", "checkbox", "date", "phone", "currency", "location"];
+declare const propertyAttributeSchema: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<Readonly<{
+  [k: string]: z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>;
+}>, z$1.core.$strip>, ...z$1.ZodObject<Readonly<{
+  [k: string]: z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>;
+}>, z$1.core.$strip>[]], "type">;
+declare const propertySchemaSchema: z$1.ZodObject<{
+  definitions: z$1.ZodArray<z$1.ZodDiscriminatedUnion<[z$1.ZodObject<Readonly<{
+    [k: string]: z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>;
+  }>, z$1.core.$strip>, ...z$1.ZodObject<Readonly<{
+    [k: string]: z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>;
+  }>, z$1.core.$strip>[]], "type">>;
+}, z$1.core.$strip>;
+/**
+ * The wire-facing property union, derived from the stored one: the same seven
+ * simple types merged into one member, the option-carrying types alongside,
+ * everything the model never sets omitted, and `.strict()` so an invented key
+ * is refused by name instead of silently stripped at store.
+ */
+declare const propertyAttributeWireSchema: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<Readonly<{
+  [k: string]: z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>;
+}>, z$1.core.$strip>, ...z$1.ZodObject<Readonly<{
+  [k: string]: z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>;
+}>, z$1.core.$strip>[]], "type">;
+declare const propertySchemaWireSchema: z$1.ZodObject<{
+  definitions: z$1.ZodArray<z$1.ZodDiscriminatedUnion<[z$1.ZodObject<Readonly<{
+    [k: string]: z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>;
+  }>, z$1.core.$strip>, ...z$1.ZodObject<Readonly<{
+    [k: string]: z$1.core.$ZodType<unknown, unknown, z$1.core.$ZodTypeInternals<unknown, unknown>>;
+  }>, z$1.core.$strip>[]], "type">>;
+}, z$1.core.$strict>;
+/**
+ * A month or a year has no time of day and no range end to pair with in this
+ * slice (#5325): `precision` narrower than a day is refused beside
+ * `includeTime` or `endDate`, on the attribute and on each date property it
+ * qualifies an edge with.
+ */
+declare function datePrecisionIssues(type: string, config: Record<string, unknown>, path?: PropertyKey[]): {
+  path: PropertyKey[];
+  message: string;
+}[];
+/**
+ * Map of attribute type to config schema
+ */
+declare const attributeConfigSchemas: Record<AttributeType, z$1.ZodObject<z$1.ZodRawShape>>;
+/**
+ * Get the config schema for a specific attribute type
+ */
+declare function getAttributeConfigSchema(type: AttributeType): z$1.ZodObject<z$1.ZodRawShape>;
+/**
+ * Validate and strip unknown properties from attribute config
+ * This ensures only allowed properties are stored in the database
+ */
+declare function parseAttributeConfig(type: AttributeType, config: Record<string, unknown>): Record<string, unknown>;
+/**
+ * The config contract as a WRITE applies it: the stored schema plus the
+ * stricter option and icon rules newly written values must satisfy.
+ */
+declare function getAttributeConfigWriteSchema(type: AttributeType): z$1.ZodObject<z$1.ZodRawShape>;
+/**
+ * Strict parser for newly created attribute definitions.
+ *
+ * Top-level config remains strip-compatible with the historical config
+ * contract, while newly written icons and select-like option objects are
+ * validated strictly.
+ */
+declare function parseAttributeConfigForCreate(type: AttributeType, input: unknown): Record<string, unknown>;
+/**
+ * Patch-aware parser for persisted attributes.
+ *
+ * An explicit options patch owns and strictly validates the complete new
+ * list. Omission means the stored legacy list is preserved without
+ * reconstruction, including options that predate required colours/groups.
+ */
+declare function parseAttributeConfigForUpdate(stored: Attribute, patch: Partial<AddAttributeInput>): Record<string, unknown>;
+//#endregion
+export { AddAttributeInput as C, UpdateObjectInput as D, RelationOptionsResponse as E, withoutUnknownOptionKeys as S, RelationOption as T, selectOptionWriteSchema as _, datePrecisionIssues as a, wireHiddenTypeConfigMask as b, multiselectOptionWriteSchema as c, parseAttributeConfigForUpdate as d, propertyAttributeSchema as f, refuseForeignKeys as g, propertySchemaWireSchema as h, attributeConfigSchemas as i, parseAttributeConfig as l, propertySchemaSchema as m, WIRE_OFFERED_BASE_CONFIG as n, getAttributeConfigSchema as o, propertyAttributeWireSchema as p, WIRE_OMITTED_CONFIG_KEYS as r, getAttributeConfigWriteSchema as s, SIMPLE_PROPERTY_TYPES as t, parseAttributeConfigForCreate as u, statusGroupSchema as v, CreateCustomObjectInput as w, wireOmittedConfigKeysFor as x, statusOptionWriteSchema as y };

package/dist/index-CSDAHifu.d.mts

@@ -0,0 +1,53 @@
+
+import { n as Attribute } from "./attributes-CZD_B0mZ.mjs";
+import { z as z$1 } from "zod";
+//#region src/validation/core/types.d.ts
+/**
+ * Validation messages for Zod validators.
+ * All functions receive the full Attribute to access label, type, etc.
+ * Can be customized for i18n support.
+ */
+interface ValidationMessages {
+  required: (attr: Attribute) => string;
+  invalidType: (attr: Attribute, expected: string) => string;
+  minLength: (attr: Attribute, min: number) => string;
+  maxLength: (attr: Attribute, max: number) => string;
+  invalidPattern: (attr: Attribute) => string;
+  minValue: (attr: Attribute, min: number) => string;
+  maxValue: (attr: Attribute, max: number) => string;
+  mustBeInteger: (attr: Attribute) => string;
+  invalidDate: (attr: Attribute) => string;
+  invalidOption: (attr: Attribute, options: string[]) => string;
+  invalidId: (attr: Attribute) => string;
+  maxItems: (attr: Attribute, max: number) => string;
+  invalidRichtext: (attr: Attribute) => string;
+  invalidPhone: (attr: Attribute) => string;
+  invalidCurrency: (attr: Attribute) => string;
+  invalidLocation: (attr: Attribute) => string;
+}
+/**
+ * Validation result
+ */
+interface ValidationResult {
+  success: boolean;
+  data?: Record<string, unknown>;
+  errors?: Array<{
+    path: string[];
+    message: string;
+  }>;
+}
+//#endregion
+//#region src/validation/core/messages.d.ts
+declare const DEFAULT_VALIDATION_MESSAGES: ValidationMessages;
+//#endregion
+//#region src/validation/core/errors.d.ts
+/**
+ * Format Zod validation errors into a consistent structure.
+ * This eliminates code duplication across multiple validation functions.
+ */
+declare function formatZodErrors(error: z$1.ZodError): Array<{
+  path: string[];
+  message: string;
+}>;
+//#endregion
+export { ValidationResult as i, DEFAULT_VALIDATION_MESSAGES as n, ValidationMessages as r, formatZodErrors as t };