primitive-admin 1.2.0-alpha.0 → 1.2.0-alpha.10

package/dist/src/lib/schema-codegen/generated-schema-descriptor.js

@@ -0,0 +1,269 @@
+/**
+ * GENERATED FILE — DO NOT EDIT BY HAND.
+ *
+ * Vendored byte-for-byte from the canonical server module
+ * `src/function-runs/schema-descriptor.ts` — the SAME interpretation the server
+ * validator (`validateValue`) enforces. The CLI cannot import server `src/`
+ * at runtime, so the CLI's schema type converters import this committed
+ * copy instead.
+ *
+ * Regenerate with:
+ *   node cli/scripts/gen-schema-descriptor.mjs   (runs at CLI prebuild)
+ *
+ * A CI freshness guard
+ * (`cli/scripts/gen-schema-descriptor.mjs --check`, also asserted by
+ * `cli/tests/unit/schema-codegen-descriptor-drift-guard.test.ts`) fails if
+ * this committed copy does not match the source — see issue #1442 / #998.
+ */
+/**
+ * Canonical interpretation of the JSON-Schema subset the workflow platform
+ * supports (issue #1442).
+ *
+ * The server validator (`validateValue` in `schema-validation.ts`) and the CLI
+ * schema type converter (`schema-codegen/schemaToTs.ts`) must agree EXACTLY
+ * on how an `inputSchema`/`outputSchema` is interpreted —
+ * otherwise a generated `<Key>Input` type promises a shape the runtime does not
+ * enforce (or rejects a value the runtime accepts). Previously the converter
+ * re-derived those interpretation decisions by hand, which drifts from the
+ * validator over time.
+ *
+ * This module is the single source of that interpretation. Both consumers read
+ * from `describeSchema` + `isType`:
+ *
+ *   - the type gate is checked before `enum` (a value failing `type` is
+ *     rejected before `enum` is consulted);
+ *   - a type UNION (`type: ["string","null"]`) never descends into
+ *     `properties`/`items` — only the exact string types `"object"`/`"array"`
+ *     do;
+ *   - `integer` means `Number.isInteger`;
+ *   - `additionalProperties` only closes an object; it is not a nested schema.
+ *
+ * It is deliberately dependency-free (no imports) so the CLI can vendor a
+ * byte-for-byte copy as a committed artifact via
+ * `cli/scripts/gen-workflow-schema-descriptor.mjs` (the #998 gen-allowlist
+ * pattern). A drift-guard test runs that generator in `--check` mode, so a
+ * change here that isn't regenerated into the CLI artifact fails CI. The CLI
+ * never imports server `src/` at runtime — only the build-time generator reads
+ * this file.
+ */
+/** Does a value satisfy a JSON-schema `type` name? `integer` = `Number.isInteger`. */
+export function isType(value, type) {
+    if (type === "array")
+        return Array.isArray(value);
+    if (type === "object")
+        return !!value && typeof value === "object" && !Array.isArray(value);
+    if (type === "string")
+        return typeof value === "string";
+    if (type === "number")
+        return typeof value === "number" && !Number.isNaN(value);
+    if (type === "integer")
+        return Number.isInteger(value);
+    if (type === "boolean")
+        return typeof value === "boolean";
+    if (type === "null")
+        return value === null;
+    // Unknown type name: nothing to enforce, so treat as a match (the validator
+    // must not reject a value against a keyword it does not model).
+    return true;
+}
+const EMPTY_DESCRIPTOR = {
+    isUnion: false,
+    singularType: null,
+    types: [],
+    enumValues: null,
+    object: null,
+    array: null,
+    oneOf: null,
+};
+/**
+ * Sibling constraint keywords that make a `oneOf` node a MIXED schema rather
+ * than a clean tagged union (#1511). A clean discriminated union carries only
+ * the `oneOf` keyword (plus annotations like `description`/`title`); it never
+ * combines with a top-level `type`/`properties`/`required`/`additionalProperties`/
+ * `items`/`enum`. When any of these co-occur with `oneOf`, the validator's
+ * branch-select would early-return and skip those sibling constraints, silently
+ * loosening validation. So a mixed node is NOT treated as a clean tagged union.
+ */
+const ONEOF_SIBLING_CONSTRAINT_KEYS = [
+    "type",
+    "properties",
+    "required",
+    "additionalProperties",
+    "items",
+    "enum",
+];
+function hasOneOfSiblingConstraints(schema) {
+    return ONEOF_SIBLING_CONSTRAINT_KEYS.some((k) => Object.prototype.hasOwnProperty.call(schema, k));
+}
+/**
+ * A discriminator tag must be a comparable scalar (string/number/boolean) so
+ * the validator's strict-`===` branch-select can match it against a JSON-parsed
+ * value (#1511). An object/array literal is structurally identical after a JSON
+ * round-trip but never the same reference, so it would always "match no case".
+ * Restricting the auto-detected discriminator to scalars keeps a non-scalar tag
+ * from being treated as a (never-matchable) discriminator.
+ */
+function isScalarDiscriminatorLiteral(value) {
+    return (typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean");
+}
+/**
+ * Interpret a `oneOf`/`anyOf` node as a discriminated (tagged) union (#1511).
+ *
+ * The tagged-union interpretation is scoped to a clearly-intended tagged union:
+ * EVERY member must be `type: "object"`. Anything else (a mixed/scalar `oneOf`)
+ * returns `null` and is ignored downstream, exactly as before.
+ *
+ * Within that scope:
+ *   - `anyOf` is not supported in v1 → `invalid` (codegen error suggests `oneOf`);
+ *   - a `oneOf` with fewer than 2 members → `invalid`;
+ *   - the discriminator is auto-detected: the single property present in EVERY
+ *     member as a single-literal `enum` whose literal is a comparable scalar
+ *     (string/number/boolean), with distinct literals across members (a
+ *     non-scalar literal is not a candidate — see `isScalarDiscriminatorLiteral`);
+ *   - zero or more-than-one candidate discriminator → `invalid` (ambiguity).
+ *
+ * Pure and dependency-free so the CLI can vendor a byte-for-byte copy.
+ */
+function describeOneOf(schema) {
+    const rawOneOf = Array.isArray(schema.oneOf) ? schema.oneOf : null;
+    const rawAnyOf = Array.isArray(schema.anyOf) ? schema.anyOf : null;
+    // `oneOf` takes precedence; only one keyword is interpreted per node.
+    const keyword = rawOneOf
+        ? "oneOf"
+        : rawAnyOf
+            ? "anyOf"
+            : null;
+    const members = rawOneOf ?? rawAnyOf;
+    if (!keyword || !members)
+        return null;
+    // Scope to a clearly-intended tagged union: every member is `type: "object"`.
+    // A member that is not a plain object type means this is NOT a tagged union;
+    // leave it to the existing ignore-and-render-`unknown` path (backward compat).
+    const allObjects = members.length >= 1 &&
+        members.every((m) => !!m &&
+            typeof m === "object" &&
+            !Array.isArray(m) &&
+            m.type === "object");
+    if (!allObjects)
+        return null;
+    // `anyOf` is not supported in v1 (resolved Fork 1 = oneOf only). An all-object
+    // `anyOf` that looks like a tagged union gets a clear error suggesting oneOf.
+    if (keyword === "anyOf") {
+        return {
+            kind: "invalid",
+            reason: "anyOf is not supported for discriminated unions (issue #1511). Use oneOf instead.",
+        };
+    }
+    if (members.length < 2) {
+        return {
+            kind: "invalid",
+            reason: "A discriminated-union oneOf needs at least 2 object members (issue #1511).",
+        };
+    }
+    // For each member, collect its single-literal-enum properties → { name: literal }.
+    // The literal must be a comparable scalar (string/number/boolean): the
+    // validator branch-selects with strict `===`, so a non-scalar tag (object or
+    // array) on a JSON-parsed value is never the same reference as the schema
+    // literal and would always "match no case". Restricting the auto-detected
+    // discriminator to scalars means a non-scalar tag is not a candidate, so the
+    // union routes through the normal not-a-tagged-union path (below) instead of
+    // being accepted as a union that can never validate.
+    const memberLiteralProps = members.map((m) => {
+        const map = new Map();
+        const props = m.properties;
+        if (props && typeof props === "object" && !Array.isArray(props)) {
+            for (const [name, sub] of Object.entries(props)) {
+                if (sub &&
+                    typeof sub === "object" &&
+                    Array.isArray(sub.enum) &&
+                    sub.enum.length === 1 &&
+                    isScalarDiscriminatorLiteral(sub.enum[0])) {
+                    map.set(name, sub.enum[0]);
+                }
+            }
+        }
+        return map;
+    });
+    // A candidate discriminator is present as a single-literal enum in EVERY
+    // member, with distinct literals across members (so a value's tag selects
+    // exactly one branch).
+    const candidates = [];
+    for (const name of memberLiteralProps[0].keys()) {
+        if (!memberLiteralProps.every((mp) => mp.has(name)))
+            continue;
+        const literals = memberLiteralProps.map((mp) => mp.get(name));
+        const distinct = new Set(literals.map((l) => JSON.stringify(l)));
+        if (distinct.size === literals.length)
+            candidates.push(name);
+    }
+    if (candidates.length !== 1) {
+        return {
+            kind: "invalid",
+            reason: candidates.length === 0
+                ? "No discriminator found for the oneOf tagged union (issue #1511): every member must share exactly one property declared as a distinct single-literal enum."
+                : `Ambiguous discriminator for the oneOf tagged union (issue #1511): multiple candidate properties (${candidates.join(", ")}). Exactly one is required.`,
+        };
+    }
+    // A clean tagged union carries ONLY `oneOf`. If it co-occurs with sibling
+    // top-level constraints (`type`, `properties`, `required`,
+    // `additionalProperties`, `items`, `enum`), it is a MIXED schema, not a clean
+    // tagged union: the validator's branch-select would early-return and skip
+    // those siblings, loosening validation. Reject-mixed keeps all three
+    // consumers fail-closed — the validator falls through to the normal
+    // type/object gates (still enforcing the siblings, exactly as before #1511),
+    // codegen throws this `reason`, and the request guard flags `unsupported-oneof`.
+    if (hasOneOfSiblingConstraints(schema)) {
+        return {
+            kind: "invalid",
+            reason: "A discriminated-union oneOf must be the only top-level constraint (issue #1511): it cannot be combined with sibling type/properties/required/additionalProperties/items/enum. Move the shared constraints into each member instead.",
+        };
+    }
+    const discriminant = candidates[0];
+    return {
+        kind: "valid",
+        discriminant,
+        members: members.map((m, i) => ({
+            discriminantValue: memberLiteralProps[i].get(discriminant),
+            schema: m,
+        })),
+    };
+}
+/**
+ * Interpret a parsed schema node. A non-object schema (null, array, scalar)
+ * enforces nothing → the empty descriptor.
+ */
+export function describeSchema(schema) {
+    if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+        return EMPTY_DESCRIPTOR;
+    }
+    const typeSpec = schema.type;
+    const isUnion = Array.isArray(typeSpec);
+    const singularType = typeof typeSpec === "string" ? typeSpec : null;
+    // Mirror the validator's normalization exactly: an array stays an array; a
+    // truthy non-array becomes `[typeSpec]`; anything falsy is `[]`.
+    const types = isUnion ? typeSpec : typeSpec ? [typeSpec] : [];
+    const enumValues = Array.isArray(schema.enum)
+        ? schema.enum
+        : null;
+    const props = schema.properties;
+    const object = singularType === "object" &&
+        props &&
+        typeof props === "object" &&
+        !Array.isArray(props)
+        ? {
+            properties: props,
+            required: Array.isArray(schema.required)
+                ? schema.required
+                : [],
+            additionalPropertiesClosed: schema.additionalProperties === false,
+        }
+        : null;
+    const array = singularType === "array" && schema.items
+        ? { items: schema.items }
+        : null;
+    const oneOf = describeOneOf(schema);
+    return { isUnion, singularType, types, enumValues, object, array, oneOf };
+}
+//# sourceMappingURL=generated-schema-descriptor.js.map

package/dist/src/lib/schema-codegen/generated-schema-descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generated-schema-descriptor.js","sourceRoot":"","sources":["../../../../src/lib/schema-codegen/generated-schema-descriptor.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/schema-codegen/naming.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Identifier-naming helpers for the schema codegens (issue #1442, written for
+ * `workflows codegen`; `functions codegen` and the prompt codegen read them
+ * since #3190 retired it).
+ *
+ * Keys resolve case-insensitively server-side and may contain
+ * characters that aren't valid TS identifiers (`.`, `-`). Only the emitted
+ * identifiers are sanitized — the runtime call always passes the ORIGINAL key
+ * string.
+ *
+ * Type names: `pascalCase(key) + "Input" | "Output"` (reuses `pascalCase` from
+ * the database codegen so the two commands share one PascalCase rule).
+ * Factory property: a camelCase form of the key.
+ */
+/**
+ * `create-checkout-session` / `createCheckoutSession` → `CreateCheckoutSession`.
+ * A digit-leading key (`123-job` → `_123Job`) is prefixed with `_` so the
+ * emitted type name is a valid TS identifier.
+ */
+export declare function workflowTypeBaseName(key: string): string;
+/** PascalCase base + `Input` (e.g. `CreateCheckoutSessionInput`). */
+export declare function workflowInputTypeName(key: string): string;
+/** PascalCase base + `Output` (e.g. `CreateCheckoutSessionOutput`). */
+export declare function workflowOutputTypeName(key: string): string;
+/**
+ * camelCase factory function name for a workflow key: PascalCase, then lowercase
+ * the first character (`create-checkout-session` → `createCheckoutSession`,
+ * `refresh-sheet` → `refreshSheet`). Used as the top-level exported factory
+ * function name in the per-workflow generated file, so it must be a legal
+ * function identifier: a digit-leading key (`123-job` → `_123Job`) is
+ * underscore-prefixed, and a key that lands on a JS reserved word (`delete`,
+ * `new`, `import`) is underscore-suffixed (`delete_`). Only the emitted
+ * identifier changes; the runtime call still passes the ORIGINAL key string.
+ */
+export declare function workflowFactoryName(key: string): string;

package/dist/src/lib/schema-codegen/naming.js

@@ -0,0 +1,83 @@
+/**
+ * Identifier-naming helpers for the schema codegens (issue #1442, written for
+ * `workflows codegen`; `functions codegen` and the prompt codegen read them
+ * since #3190 retired it).
+ *
+ * Keys resolve case-insensitively server-side and may contain
+ * characters that aren't valid TS identifiers (`.`, `-`). Only the emitted
+ * identifiers are sanitized — the runtime call always passes the ORIGINAL key
+ * string.
+ *
+ * Type names: `pascalCase(key) + "Input" | "Output"` (reuses `pascalCase` from
+ * the database codegen so the two commands share one PascalCase rule).
+ * Factory property: a camelCase form of the key.
+ */
+import { pascalCase } from "../db-codegen/dbNaming.js";
+/**
+ * Ensure an identifier is a valid TS identifier start. The server accepts
+ * workflow keys matching `^[a-z0-9][a-z0-9-_]{2,}$`, so a digit-leading key
+ * like `123-job` PascalCases to `123Job` — not a legal TS type name or
+ * unquoted object property, since identifiers can't start with a digit.
+ * Prefix an underscore in that case (`123Job` → `_123Job`). Only the emitted
+ * identifier changes; the runtime call still passes the ORIGINAL key string.
+ */
+function ensureValidIdentifierStart(name) {
+    const first = name.charAt(0);
+    if (first >= "0" && first <= "9") {
+        return `_${name}`;
+    }
+    return name;
+}
+/**
+ * `create-checkout-session` / `createCheckoutSession` → `CreateCheckoutSession`.
+ * A digit-leading key (`123-job` → `_123Job`) is prefixed with `_` so the
+ * emitted type name is a valid TS identifier.
+ */
+export function workflowTypeBaseName(key) {
+    return ensureValidIdentifierStart(pascalCase(key));
+}
+/** PascalCase base + `Input` (e.g. `CreateCheckoutSessionInput`). */
+export function workflowInputTypeName(key) {
+    return `${workflowTypeBaseName(key)}Input`;
+}
+/** PascalCase base + `Output` (e.g. `CreateCheckoutSessionOutput`). */
+export function workflowOutputTypeName(key) {
+    return `${workflowTypeBaseName(key)}Output`;
+}
+/**
+ * Reserved words that cannot be used as a bare `function <name>` declaration.
+ * The per-workflow factory is now a top-level exported function (not an
+ * object-literal property), so a key that camelCases to one of these must be
+ * escaped or `export function delete(client) {}` is a syntax error. Covers ES
+ * reserved words plus the strict-mode/future set — a workflow key resolves case
+ * -insensitively and matches `^[a-z0-9][a-z0-9-_]{2,}$`, so only the lowercase
+ * single-word forms can actually collide.
+ */
+const RESERVED_WORDS = new Set([
+    "break", "case", "catch", "class", "const", "continue", "debugger",
+    "default", "delete", "do", "else", "enum", "export", "extends", "false",
+    "finally", "for", "function", "if", "import", "in", "instanceof", "new",
+    "null", "return", "super", "switch", "this", "throw", "true", "try",
+    "typeof", "var", "void", "while", "with", "yield", "let", "static",
+    "implements", "interface", "package", "private", "protected", "public",
+    "await",
+]);
+/**
+ * camelCase factory function name for a workflow key: PascalCase, then lowercase
+ * the first character (`create-checkout-session` → `createCheckoutSession`,
+ * `refresh-sheet` → `refreshSheet`). Used as the top-level exported factory
+ * function name in the per-workflow generated file, so it must be a legal
+ * function identifier: a digit-leading key (`123-job` → `_123Job`) is
+ * underscore-prefixed, and a key that lands on a JS reserved word (`delete`,
+ * `new`, `import`) is underscore-suffixed (`delete_`). Only the emitted
+ * identifier changes; the runtime call still passes the ORIGINAL key string.
+ */
+export function workflowFactoryName(key) {
+    const pascal = pascalCase(key);
+    if (pascal.length === 0)
+        return pascal;
+    const camel = pascal.charAt(0).toLowerCase() + pascal.slice(1);
+    const safeStart = ensureValidIdentifierStart(camel);
+    return RESERVED_WORDS.has(safeStart) ? `${safeStart}_` : safeStart;
+}
+//# sourceMappingURL=naming.js.map

package/dist/src/lib/schema-codegen/naming.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"naming.js","sourceRoot":"","sources":["../../../../src/lib/schema-codegen/naming.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAEvD;;;;;;;GAOG;AACH,SAAS,0BAA0B,CAAC,IAAY;IAC9C,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IAC7B,IAAI,KAAK,IAAI,GAAG,IAAI,KAAK,IAAI,GAAG,EAAE,CAAC;QACjC,OAAO,IAAI,IAAI,EAAE,CAAC;IACpB,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,GAAW;IAC9C,OAAO,0BAA0B,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC;AACrD,CAAC;AAED,qEAAqE;AACrE,MAAM,UAAU,qBAAqB,CAAC,GAAW;IAC/C,OAAO,GAAG,oBAAoB,CAAC,GAAG,CAAC,OAAO,CAAC;AAC7C,CAAC;AAED,uEAAuE;AACvE,MAAM,UAAU,sBAAsB,CAAC,GAAW;IAChD,OAAO,GAAG,oBAAoB,CAAC,GAAG,CAAC,QAAQ,CAAC;AAC9C,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,cAAc,GAAG,IAAI,GAAG,CAAC;IAC7B,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU;IAClE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO;IACvE,SAAS,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK;IACvE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK;IACnE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ;IAClE,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ;IACtE,OAAO;CACR,CAAC,CAAC;AAEH;;;;;;;;;GASG;AACH,MAAM,UAAU,mBAAmB,CAAC,GAAW;IAC7C,MAAM,MAAM,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;IAC/B,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,MAAM,CAAC;IACvC,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC/D,MAAM,SAAS,GAAG,0BAA0B,CAAC,KAAK,CAAC,CAAC;IACpD,OAAO,cAAc,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC;AACrE,CAAC"}

package/dist/src/lib/schema-codegen/schemaToTs.d.ts

@@ -0,0 +1,82 @@
+/**
+ * JSON-Schema → TypeScript converter shared by `functions codegen` and the
+ * prompt codegen (issue #1442, written for `workflows codegen`, which #3190
+ * retired).
+ *
+ * An `inputSchema`/`outputSchema` is real JSON Schema. This converter
+ * types only the subset the server's validator descends into — and it reads
+ * that interpretation from the SAME descriptor the server validator consumes,
+ * vendored into the CLI as `generated-schema-descriptor.ts` (a byte copy of
+ * `src/function-runs/schema-descriptor.ts`, kept fresh by
+ * `cli/scripts/gen-schema-descriptor.mjs` + its drift guard). So the
+ * generated type and the runtime validation can never disagree on:
+ *
+ *   - `type` single scalar (`string`/`number`/`integer`/`boolean`/`null`) →
+ *     the mapped TS scalar.
+ *   - `type` array-union — only when every member is a scalar/`null` → a TS
+ *     union. A union that contains `object` or `array` renders `unknown`,
+ *     because the server only walks `properties`/`items` for the bare string
+ *     `"object"`/`"array"` — a union is never descended, so a precise-looking
+ *     type would over-promise.
+ *   - `enum` → a scalar-literal union, intersected with the declared `type`
+ *     first (the server gates on `type` before checking `enum`).
+ *   - `type: "object"` with `properties` → a nested object type; `required[]`
+ *     drives `name:` vs `name?:`. An OPEN object (no `additionalProperties:
+ *     false`) also emits `[key: string]: unknown` so extra keys the runtime
+ *     validator accepts don't hit TS excess-property errors; a CLOSED object
+ *     (`additionalProperties: false`) omits the index signature.
+ *   - `type: "array"` with `items` → `T[]`.
+ *   - `oneOf` whose members are ALL `type: "object"` → a discriminated
+ *     (tagged) union: the `|`-union of member object types, keyed by an
+ *     auto-detected single-literal-`enum` discriminator (#1511). A defective
+ *     all-object tagged union (no/ambiguous discriminator, <2 members) or an
+ *     all-object `anyOf` (unsupported in v1) is a STRICT codegen error, not a
+ *     silent `unknown` (Fork 3, resolved by the maintainer).
+ *
+ * Everything else the server ignores (`$ref`, `allOf`, `format`,
+ * `patternProperties`, numeric constraints, tuple `items`, and a `oneOf`/`anyOf`
+ * whose members are NOT all objects) renders `unknown`.
+ *
+ * Errors are NOT swallowed here — a malformed schema fails upstream at parse
+ * time, and a defective tagged union throws — this walker otherwise returns
+ * `unknown` for anything it does not recognize.
+ *
+ * FORMATTING CONTRACT (#1565): the types emitted here must be a fixed point of
+ * Prettier's DEFAULT config, since `workflows codegen --check` byte-compares
+ * the emission against disk. Long unions therefore render through
+ * `codegen-shared/prettierStable.ts` (which reproduces Prettier's width
+ * decision) instead of being joined with `" | "`. There is no Prettier
+ * dependency and no automated round-trip test, so verify any change to these
+ * shapes by hand — see that module's header.
+ */
+import { type TypeNode } from "../codegen-shared/prettierStable.js";
+/**
+ * Convert a parsed JSON Schema node to a TypeScript type expression. Object
+ * types render multi-line (2-space indent per level); everything else renders
+ * on a single line unless it is too wide for Prettier's default print width
+ * (#1565). `indent` is the current indentation depth.
+ */
+export declare function schemaToTsType(schema: any, indent?: number): string;
+/**
+ * `schemaToTsType` as a wrappable node — the emitters print it at the position
+ * it actually occupies so long unions/objects wrap exactly as Prettier would
+ * (#1565). See `codegen-shared/prettierStable.ts`.
+ */
+export declare function schemaToTypeNode(schema: any): TypeNode;
+/**
+ * True when the schema REJECTS an empty object `{}` — i.e. the client's
+ * `rootInput: options.input ?? {}` fallback would fail validation, so `input`
+ * must be a compile-time-required option (issue #1442, P4). Derived from the
+ * shared descriptor so it matches the server validator exactly:
+ *
+ *   - a valid top-level discriminated-union (`oneOf`): the runtime always
+ *     requires the discriminator present, so `{}` matches no case;
+ *   - a declared top-level `type` that `{}` does not satisfy (anything but
+ *     `object`, e.g. `string`/`array`, or a union with no `object` arm);
+ *   - a top-level `enum` (a fresh `{}` is never an enum member);
+ *   - `type: "object"` with a non-empty `required[]` (a missing required key).
+ *
+ * An all-optional object schema, or a schema with no top-level constraints,
+ * accepts `{}` → `input` is optional.
+ */
+export declare function schemaRejectsEmptyObject(schema: any): boolean;