@yahoo/uds-create-config 2.44.0 → 3.0.0

package/dist/framework/schemas.js

@@ -0,0 +1,615 @@
+import { ref } from "./utils/refs.js";
+import { planDelete, planRename } from "./plan.js";
+import { compileSchema } from "./utils/compiled-schema.js";
+import { sectionDelta } from "./utils/field-path.js";
+import { deriveCreateSchema, deriveMemberUpdateSchema, deriveUpdateSchema } from "./utils/field-schema.js";
+import { z } from "zod";
+//#region src/framework/schemas.ts
+/**
+* An entity's operation set is its `schemas` map — one entry per verb, `{ input, readOnly, handler? }`.
+* `defaultSchemas` builds the defaults from a kind's `fields`/`subEntities` (create/update/delete/rename,
+* the reads list/get/dependents, and sub-* per collection); `mergeSchemas` folds the author's `schemas`
+* param over them — override a derived op's data schema, add a custom op, or remove one with `null`.
+* `opsForKind` then just loops the merged map. No fixed CRUD structure is hardcoded downstream.
+*
+* A mutation op's input wraps `{ path, data: <create/update schema> }` — the same shape `Config.apply`
+* validates against — so a tool's advertised input and the applied patch can't drift.
+*/
+/** The concrete fields for `ctx`. */
+function resolveFields(fields, ctx = {}) {
+	return typeof fields === "function" ? fields(ctx) : fields;
+}
+/** Whether a context carries nothing a factory could read, so the storage shape answers. */
+const bare = (ctx) => ctx.config === void 0 && ctx.body === void 0 && ctx.parent === void 0;
+/** Build the concrete schema — calling the factory when there is one. */
+function resolveSchema(schema, ctx = {}) {
+	return typeof schema === "function" ? schema(ctx) : schema;
+}
+/** An op's input, resolved and closed. A key the op does not take is refused rather than dropped, so a
+*  misspelled `data` or a stray `to` on an update names itself instead of writing nothing. The closed
+*  shape is also what the JSON schema advertises (`additionalProperties: false`). */
+function resolveInputSchema(schema, ctx = {}) {
+	const resolved = resolveSchema(schema, ctx);
+	return resolved instanceof z.ZodObject ? resolved.strict() : resolved;
+}
+/**
+* A path input, which also accepts the `<kind>:<path>` marker form.
+*
+* That marker is how every ref in a config is written, so it is the form a reader is handed back: a
+* Component's resolved styles report `token:color/brand`, and the obvious next call is to ask for that
+* Token by the name it was just given. Refusing it failed as `token "token:color/brand" not found`,
+* which reads as a missing entity rather than as a spelling this op declined — and on a create it
+* would have minted an entity actually named `token:color/brand`.
+*
+* Stripped only when the marker names this op's kind. A prefix that names something else is left
+* exactly as sent: a path may legitimately carry a namespace of its own (`uds:VStack`), and coercing
+* one kind's address into another's would answer a mistaken call with a plausible wrong entity instead
+* of a miss — the same stance the entity accessors take (`Component.get(config, 'icon:Trophy')`).
+*/
+function pathInput(kind, fallback) {
+	const marker = `${kind}:`;
+	return (fallback === void 0 ? z.string() : z.string().default(fallback)).transform((value) => value.startsWith(marker) ? value.slice(marker.length) : value);
+}
+/** The verbs a singleton kind does not offer: its one item is never made, dropped, moved or ordered,
+*  and it has no group nodes. A prefix, so a verb's companions (`rename-plan`, `delete-plan`) go with
+*  it. */
+const NOT_ON_A_SINGLETON = /^(create|delete|rename|reorder)(-|$)/;
+/** A verb → its Title-Cased fallback label (`sub-create` → `Sub Create`). Local rather than
+*  registry's copy: registry imports this file, so importing back would be circular. */
+const verbTitle = (verb) => verb.split(/[-_/]/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+/** The default op map for a kind — CRUD + reads + one set of sub-ops per collection. A mutation's
+*  input wraps `{ path, data }` (the shape `Config.apply` validates), a read takes `{ path }` or
+*  `{}`; a sub-verb carries its field (`sub-create/parts`) so `${kind}/${verb}` stays a unique path.
+*  Each carries a default `handler`: a mutation runs `config.apply(<patch>)`, a read runs the
+*  matching query — the behavior the Operation entity surfaces as `execute`. */
+function defaultSchemas(kind, declaredFields, groupFields, subEntities, { singleton = false } = {}) {
+	const fields = resolveFields(declaredFields);
+	const createSchema = compileSchema(deriveCreateSchema(fields));
+	const updateSchema = compileSchema(deriveUpdateSchema(fields));
+	const bodyInput = (whole) => {
+		const compiled = whole ? createSchema : updateSchema;
+		if (typeof declaredFields !== "function") return z.object({
+			path: PATH,
+			data: compiled
+		});
+		return (ctx) => {
+			if (bare(ctx)) return z.object({
+				path: PATH,
+				data: compiled
+			});
+			const built = declaredFields(ctx);
+			const data = whole ? deriveCreateSchema(built) : deriveUpdateSchema(built);
+			return z.object({
+				path: PATH,
+				data
+			});
+		};
+	};
+	const member = z.record(z.string(), z.unknown());
+	const p = (input) => String(input.path);
+	const PATH = pathInput(kind, singleton ? kind : void 0);
+	const RETIRED = z.boolean().optional().describe("Pass false to leave out hidden and deprecated entries; omit for every entry.");
+	const schemas = {
+		create: {
+			input: bodyInput(true),
+			readOnly: false,
+			label: "Create",
+			description: `Create a ${kind} at a new qualified \`path\` — \`data\` holds its fields.`,
+			scope: "item",
+			creates: true,
+			handler: (i, c) => c.apply({
+				kind,
+				operation: "create",
+				path: p(i),
+				data: i.data
+			})
+		},
+		update: {
+			input: bodyInput(false),
+			readOnly: false,
+			label: "Update",
+			description: `Update a ${kind} — a partial \`data\` whose KEYS ARE FIELD PATHS. \`{ "value": … }\` replaces that field; \`{ "value.brand": … }\` reaches inside and changes only that, leaving its siblings alone; \`null\` at either address removes what is there. Nothing you don't name is touched.`,
+			scope: "item",
+			handler: (i, c) => c.apply({
+				kind,
+				operation: "update",
+				path: p(i),
+				data: i.data
+			})
+		},
+		/**
+		* The whole-body write, and the one an `update` cannot be.
+		*
+		* `update` is a merge — it keeps every field the delta didn't name, which makes it unable to
+		* remove the shape of something. On a borrowed item it merges into the borrow's envelope by
+		* design, so `update` can never dissolve one. `create` refuses an occupied path, and
+		* delete-then-create is refused by any referrer and drops the item to the end of its collection.
+		*
+		* So this exists for edits that are a whole body by nature: a `linked-system/copy` landing the
+		* literal a pointer stood for, or a `link` turning a row of yours into an extension through a pin
+		* — one state replacing another rather than a field changing.
+		*
+		* Reach for `update` for anything else. This drops every field it doesn't carry.
+		*/
+		replace: {
+			input: bodyInput(true),
+			readOnly: false,
+			label: "Replace",
+			description: `Replace the ${kind} at \`path\` with a COMPLETE \`data\` body, in place — every field it doesn't carry is dropped. Use \`update\` to change some fields and keep the rest; this is for a body that is wholly one thing replacing another (dissolving a borrow into a local entity, or turning a local entity into a borrow).`,
+			scope: "item",
+			approval: "destructive",
+			handler: (i, c) => c.apply({
+				kind,
+				operation: "replace",
+				path: p(i),
+				data: i.data
+			})
+		},
+		delete: {
+			input: z.object({ path: PATH }),
+			readOnly: false,
+			label: "Delete",
+			description: `Delete the ${kind} at \`path\` — refused while other entities still reference it.`,
+			scope: "item",
+			approval: "destructive",
+			handler: (i, c) => c.apply({
+				kind,
+				operation: "delete",
+				path: p(i)
+			})
+		},
+		rename: {
+			input: z.object({
+				path: PATH,
+				to: PATH
+			}),
+			readOnly: false,
+			label: "Rename",
+			description: `Rename the ${kind} \`path\` to \`to\` — every reference cascades automatically.`,
+			scope: "item",
+			approval: "reference-change",
+			handler: (i, c) => c.apply({
+				kind,
+				operation: "rename",
+				path: p(i),
+				to: String(i.to)
+			})
+		},
+		list: {
+			input: z.object({ retired: RETIRED }),
+			readOnly: true,
+			label: "List",
+			description: `List every ${kind} in the design system.`,
+			scope: "collection",
+			handler: (i, c) => c.list(kind, { retired: i.retired !== false })
+		},
+		get: {
+			input: z.object({ path: PATH }),
+			readOnly: true,
+			label: "Get",
+			description: `Get one ${kind} by its qualified \`path\`.`,
+			scope: "item",
+			handler: (i, c) => c.resolve(kind, p(i))
+		},
+		dependents: {
+			input: z.object({ path: PATH }),
+			readOnly: true,
+			label: "Dependents",
+			description: `What references a given ${kind} (delete-safety / impact).`,
+			scope: "item",
+			title: (entity) => `${entity} dependents`,
+			handler: (i, c) => c.dependentsOf(kind, p(i))
+		},
+		"rename-plan": {
+			input: z.object({
+				path: PATH,
+				to: PATH
+			}),
+			readOnly: true,
+			label: "Plan a rename",
+			description: `What renaming the ${kind} \`path\` to \`to\` would rewrite — every entity the cascade touches, by kind and path — and whether the rename would be refused. Same input as \`rename\`; writes nothing.`,
+			scope: "item",
+			title: (entity) => `Plan renaming ${entity}`,
+			handler: (i, c) => planRename({
+				config: c,
+				kind,
+				path: p(i),
+				to: String(i.to)
+			})
+		},
+		"delete-plan": {
+			input: z.object({ path: PATH }),
+			readOnly: true,
+			label: "Plan a delete",
+			description: `What deleting the ${kind} at \`path\` runs into — the entities still pointing at it, as data, and the refusal the delete would answer with. Same input as \`delete\`; writes nothing.`,
+			scope: "item",
+			title: (entity) => `Plan deleting ${entity}`,
+			handler: (i, c) => planDelete({
+				config: c,
+				kind,
+				path: p(i)
+			})
+		},
+		"group-list": {
+			input: z.object({ retired: RETIRED }),
+			readOnly: true,
+			label: "List groups",
+			description: `List every ${kind} GROUP — the path prefixes items are organized under, each with its own stored metadata.`,
+			scope: "collection",
+			title: (entity) => `${entity} groups`,
+			handler: (i, c) => c.groups(kind, { retired: i.retired !== false })
+		},
+		"group-get": {
+			input: z.object({ path: PATH }),
+			readOnly: true,
+			label: "Get group",
+			description: `Get one ${kind} GROUP by its path prefix — its own metadata plus the items that sit under it.`,
+			scope: "group",
+			title: (entity) => `Get ${entity} Group`,
+			handler: (i, c) => ({
+				path: p(i),
+				meta: c.groups(kind).find((group) => group.path === p(i))?.meta,
+				members: c.members(kind, p(i)).map((member) => member.path)
+			})
+		},
+		"group-update": {
+			input: z.object({
+				path: PATH,
+				data: compileSchema(deriveUpdateSchema(groupFields))
+			}),
+			readOnly: false,
+			label: "Update group",
+			description: `Edit a ${kind} GROUP's own metadata (its \`label\`/\`description\` and any fields the group carries) — \`path\` is the group prefix, not an item.`,
+			scope: "group",
+			title: (entity) => `Update ${entity} Group`,
+			handler: (i, c) => c.apply({
+				kind,
+				operation: "group-update",
+				path: p(i),
+				data: i.data
+			})
+		},
+		"group-rename": {
+			input: z.object({
+				path: PATH,
+				to: PATH
+			}),
+			readOnly: false,
+			label: "Rename group",
+			description: `Rename a ${kind} GROUP — moves its stored metadata AND every item whose path extends it, as one edit. \`path\` is the group prefix, not an item.`,
+			scope: "group",
+			approval: "reference-change",
+			title: (entity) => `Rename ${entity} Group`,
+			handler: (i, c) => c.apply({
+				kind,
+				operation: "group-rename",
+				path: p(i),
+				to: String(i.to)
+			})
+		},
+		"group-delete": {
+			input: z.object({ path: PATH }),
+			readOnly: false,
+			label: "Delete group",
+			description: `Delete a ${kind} GROUP and every item under it — membership is emergent from paths, so nothing is left for the group to be derived from.`,
+			scope: "group",
+			approval: "destructive",
+			title: (entity) => `Delete ${entity} Group`,
+			handler: (i, c) => c.apply({
+				kind,
+				operation: "group-delete",
+				path: p(i)
+			})
+		},
+		reorder: {
+			input: z.object({ order: z.array(z.string()) }),
+			readOnly: false,
+			label: "Reorder",
+			description: `Rearrange this ${kind}'s items. \`order\` is the complete sequence, not a move.`,
+			scope: "collection",
+			title: (entity) => `Reorder ${entity}`,
+			handler: (i, c) => c.apply({
+				kind,
+				operation: "reorder",
+				order: i.order
+			})
+		},
+		"group-reorder": {
+			input: z.object({ order: z.array(z.string()) }),
+			readOnly: false,
+			label: "Reorder groups",
+			description: `Rearrange this ${kind}'s GROUP nodes — the folders, not the items inside them. \`order\` is the complete sequence, not a move.`,
+			scope: "group",
+			title: (entity) => `Reorder ${entity} Groups`,
+			handler: (i, c) => c.apply({
+				kind,
+				operation: "group-reorder",
+				order: i.order
+			})
+		}
+	};
+	/**
+	* One collection's whole op surface — CRUD, rename, reorder and the two reads.
+	*
+	* Takes the field path rather than a field name, so a nested collection (a variant prop's
+	* `value`, at `props/value`) derives the identical surface: the verb carries the path, and the
+	* Patch's `owner` says which member of the outer collection it acts inside. One body, because a
+	* nested collection that offered a different set of ops — or the same ones described differently —
+	* would be a second thing to keep in step with this one.
+	*/
+	const declareSubOps = (field, subEntity, owner) => {
+		const address = owner ? {
+			path: PATH,
+			owner: z.string()
+		} : { path: PATH };
+		const o = (i) => owner ? String(i.owner) : void 0;
+		const inside = owner ? ` of the \`${owner.collection}\` member \`owner\`` : "";
+		const declared = subEntity.fields;
+		const memberCreate = typeof declared === "function" ? (ctx) => declared(ctx) : compileSchema(declared ?? member);
+		const memberUpdate = typeof declared === "function" ? (ctx) => deriveMemberUpdateSchema(declared(ctx)) : compileSchema(declared ? deriveMemberUpdateSchema(declared) : member);
+		/** Wrap a member schema in its op envelope, staying a factory if the member is one. */
+		const envelope = (data, rest) => typeof data === "function" ? (ctx) => z.object({
+			...rest,
+			data: data(ctx)
+		}) : z.object({
+			...rest,
+			data
+		});
+		if (subEntity.singleton) {
+			if (owner) throw new Error(`${kind}: singleton sub-entity "${field}" cannot be nested inside a member of "${owner.collection}"`);
+			schemas[`sub-get/${field}`] = {
+				input: z.object({ ...address }),
+				readOnly: true,
+				label: "Get",
+				description: `Get a ${kind}'s \`${field}\` section.`,
+				scope: "item",
+				handler: (i, c) => subEntity.get(c, ref(kind, p(i)))
+			};
+			schemas[`sub-update/${field}`] = {
+				input: envelope(memberUpdate, { ...address }),
+				readOnly: false,
+				label: "Update",
+				description: `Update a ${kind}'s \`${field}\` section — a partial \`data\` whose KEYS ARE FIELD PATHS. \`{ "prefix": … }\` sets that field and leaves every sibling alone; \`null\` removes what is there.`,
+				scope: "item",
+				handler: (i, c) => c.apply({
+					kind,
+					operation: "update",
+					path: p(i),
+					data: sectionDelta(field, i.data)
+				})
+			};
+			return;
+		}
+		const k = (i) => String(i.key);
+		const derivesKey = subEntity.key !== void 0;
+		const optionalKey = (i) => i.key === void 0 ? void 0 : String(i.key);
+		const memberKeyInput = derivesKey ? z.string().optional() : z.string();
+		const keyed = derivesKey ? "" : " (`key` + `data`)";
+		const derived = derivesKey ? " The key is derived from `data`, so leave it out." : "";
+		schemas[`sub-create/${field}`] = {
+			input: envelope(memberCreate, {
+				...address,
+				key: memberKeyInput
+			}),
+			readOnly: false,
+			label: "Add",
+			description: `Add a \`${field}\` member${keyed} to a ${kind}${inside}.${derived}`,
+			scope: "item",
+			creates: true,
+			handler: (i, c) => c.apply({
+				kind,
+				operation: "sub-create",
+				path: p(i),
+				field,
+				owner: o(i),
+				key: optionalKey(i),
+				data: i.data
+			})
+		};
+		schemas[`sub-upsert/${field}`] = {
+			input: envelope(memberCreate, {
+				...address,
+				key: memberKeyInput
+			}),
+			readOnly: false,
+			label: "Set",
+			description: `Set a \`${field}\` member of a ${kind}${inside} to \`data\` — added when absent, replaced WHOLE when present.${derived} Use \`sub-create/${field}\` when the member must be new, and \`sub-update/${field}\` to change some of its fields.`,
+			scope: "item",
+			handler: (i, c) => c.apply({
+				kind,
+				operation: "sub-upsert",
+				path: p(i),
+				field,
+				owner: o(i),
+				key: optionalKey(i),
+				data: i.data
+			})
+		};
+		schemas[`sub-update/${field}`] = {
+			input: envelope(memberUpdate, {
+				...address,
+				key: z.string()
+			}),
+			readOnly: false,
+			label: "Update",
+			description: `Update a ${kind}'s \`${field}\` member \`key\`${inside} — a partial \`data\` whose KEYS ARE FIELD PATHS. \`{ "layers": … }\` replaces that field; \`{ "layers.root.bg": … }\` changes only that leaf and leaves every sibling alone; \`null\` at either address removes what is there. Nothing you don't name is touched, so two edits to one member compose in a single batch. Use \`sub-upsert/${field}\` to replace the member whole.`,
+			scope: "item",
+			handler: (i, c) => c.apply({
+				kind,
+				operation: "sub-update",
+				path: p(i),
+				field,
+				owner: o(i),
+				key: k(i),
+				data: i.data
+			})
+		};
+		schemas[`sub-delete/${field}`] = {
+			input: z.object({
+				...address,
+				key: z.string()
+			}),
+			readOnly: false,
+			label: "Remove",
+			description: `Remove the \`${field}\` member \`key\` from a ${kind}${inside}.`,
+			scope: "item",
+			approval: "destructive",
+			handler: (i, c) => c.apply({
+				kind,
+				operation: "sub-delete",
+				path: p(i),
+				field,
+				owner: o(i),
+				key: k(i)
+			})
+		};
+		schemas[`sub-rename/${field}`] = {
+			input: z.object({
+				...address,
+				key: z.string(),
+				to: z.string()
+			}),
+			readOnly: false,
+			label: "Rename",
+			description: `Rename a ${kind}'s \`${field}\` member \`key\`${inside} to \`to\` (references cascade).`,
+			scope: "item",
+			approval: "reference-change",
+			handler: (i, c) => c.apply({
+				kind,
+				operation: "sub-rename",
+				path: p(i),
+				field,
+				owner: o(i),
+				key: k(i),
+				to: String(i.to)
+			})
+		};
+		schemas[`sub-reorder/${field}`] = {
+			input: z.object({
+				...address,
+				order: z.array(z.string())
+			}),
+			readOnly: false,
+			label: "Reorder",
+			description: `Reorder a ${kind}'s \`${field}\` collection${inside} to match \`order\`.`,
+			scope: "collection",
+			handler: (i, c) => c.apply({
+				kind,
+				operation: "sub-reorder",
+				path: p(i),
+				field,
+				owner: o(i),
+				order: i.order
+			})
+		};
+		schemas[`sub-list/${field}`] = {
+			input: z.object({ ...address }),
+			readOnly: true,
+			label: "List",
+			description: `List a ${kind}'s \`${field}\` members${inside} — each with the ref that addresses it.`,
+			scope: "collection",
+			handler: (i, c) => subEntity.list(c, ref(kind, p(i)), o(i))
+		};
+		schemas[`sub-get/${field}`] = {
+			input: z.object({
+				...address,
+				key: z.string()
+			}),
+			readOnly: true,
+			label: "Get",
+			description: `Get one \`${field}\` member of a ${kind}${inside} by its \`key\`.`,
+			scope: "item",
+			handler: (i, c) => subEntity.get(c, ref(kind, p(i)), k(i), o(i))
+		};
+	};
+	for (const [field, subEntity] of Object.entries(subEntities)) {
+		declareSubOps(field, subEntity, void 0);
+		for (const [nested, nestedEntity] of Object.entries(subEntity.subEntities ?? {})) declareSubOps(`${field}/${nested}`, nestedEntity, { collection: field });
+	}
+	if (singleton) {
+		for (const [verb, entry] of Object.entries(schemas)) if (NOT_ON_A_SINGLETON.test(verb) || entry.scope === "group" || verb.startsWith("group-")) delete schemas[verb];
+	}
+	return schemas;
+}
+/**
+* A kind's own body schema for a verb, carrying the metadata every entity may carry.
+*
+* A create or replace body is stored whole, so the universal fields (`label`, `description`,
+* `copiedFrom`) have to be accepted on it whether the schema was derived or supplied — a kind that
+* spells out its own create body is not opting out of them. Any other verb's schema is taken as is.
+*/
+function bodySchema(verb, data) {
+	const whole = verb === "create" || verb === "replace";
+	const extendable = data instanceof z.ZodObject || data instanceof z.ZodDiscriminatedUnion;
+	return whole && extendable ? compileSchema(deriveCreateSchema(data)) : data;
+}
+/** Fold the author's `schemas` over the defaults — override (`{ data }` rewraps `{ path, data }`),
+*  add (a new verb's full entry), remove (`null`). Everything else stays derived. */
+function mergeSchemas(kind, defaults, user, fields) {
+	const out = { ...defaults };
+	for (const [verb, entry] of Object.entries(user ?? {})) {
+		if (entry === null) {
+			delete out[verb];
+			continue;
+		}
+		if ("data" in entry || "path" in entry || "to" in entry) {
+			const base = out[verb];
+			const { data, path, to, ...presentation } = entry;
+			const baseInput = base?.input;
+			const address = (own) => own ? pathInput(kind).pipe(own) : void 0;
+			const envelope = (ctx) => {
+				const resolved = baseInput ? resolveSchema(baseInput, ctx) : void 0;
+				const shape = { ...resolved instanceof z.ZodObject ? resolved.shape : {} };
+				if (!shape.path) shape.path = pathInput(kind);
+				const ownPath = address(path);
+				if (ownPath) shape.path = ownPath;
+				const ownTo = address(to);
+				if (ownTo) shape.to = ownTo;
+				if (data) shape.data = bodySchema(verb, typeof data === "function" ? data({
+					...ctx,
+					fields: fields ? resolveFields(fields, ctx) : z.object({})
+				}) : data);
+				return z.object(shape);
+			};
+			const input = typeof data === "function" || typeof baseInput === "function" ? envelope : envelope({});
+			out[verb] = {
+				...base,
+				...presentation,
+				readOnly: base?.readOnly ?? false,
+				label: base?.label ?? verbTitle(verb),
+				description: presentation.description ?? base?.description ?? `${verb} ${kind}`,
+				scope: base?.scope ?? "item",
+				handler: base?.handler,
+				input
+			};
+		} else if ("input" in entry) out[verb] = {
+			...entry,
+			input: entry.input,
+			readOnly: entry.readOnly ?? false,
+			label: entry.label ?? verbTitle(verb),
+			description: entry.description ?? `${verb} ${kind}`,
+			scope: entry.scope ?? "item"
+		};
+		else {
+			const base = out[verb];
+			if (!base) throw new Error(`${kind} schema presentation override names unknown operation "${verb}"`);
+			out[verb] = {
+				...base,
+				...entry
+			};
+		}
+	}
+	return out;
+}
+/** The data validator for a verb — the `data` field inside its `{ path, data }` op input. `Config.apply`
+*  validates a patch's `data` against this (create/update/sub-*), so `schemas` stays the single
+*  source: the create/update/member validators aren't stored separately, they're read off the op
+*  input. Undefined for a verb with no data (delete/rename), a removed op, or a non-`{path,data}` input. */
+function dataSchema(schemas, verb, ctx = {}) {
+	const declared = schemas[verb]?.input;
+	if (!declared) return void 0;
+	const input = resolveSchema(declared, ctx);
+	return input instanceof z.ZodObject ? input.shape.data : void 0;
+}
+//#endregion
+export { dataSchema, defaultSchemas, mergeSchemas, pathInput, resolveFields, resolveInputSchema, resolveSchema };