toolcraft 0.0.100 → 0.0.102

package/composition.json

@@ -48,13 +48,18 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.100",
+      "version": "0.0.102",
       "license": "MIT"
     },
     {
       "name": "toolcraft-design",
       "version": "0.0.2",
       "license": "MIT"
+    },
+    {
+      "name": "toolcraft-schema",
+      "version": "0.0.102",
+      "license": "MIT"
     }
   ]
 }

package/dist/cli.d.ts

@@ -27,6 +27,8 @@ export interface RunCLIOptions<TServices extends object = Record<string, unknown
     logLevel?: LogLevel;
     logger?: RuntimeLoggerInput;
     outputEmitter?: (entry: string) => void;
+    promptInput?: NodeJS.ReadableStream;
+    promptOutput?: NodeJS.WritableStream;
     projectRoot?: string;
     rootDisplayName?: string;
     rootUsageName?: string;

package/dist/cli.js

@@ -2,6 +2,7 @@ import "./node-require-shim.js";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { Command as CommanderCommand, CommanderError, InvalidArgumentError, Option } from "commander";
+import { validate as validateSchema } from "toolcraft-schema";
 import { cancel, configureTheme, confirm, createLogger, formatCommandList, formatOptionList, getTheme, helpFormatterPlain, isCancel, note, promptText, renderTable, resetOutputFormatCache, select, text } from "toolcraft-design";
 import { ApprovalDeclinedError, UserError, assertCommandRequirements, getCommandSourcePath, hasMcpProxyConfig, resolveCommandSecrets } from "./index.js";
 import { hasOwnErrorCode } from "./error-codes.js";
@@ -1761,7 +1762,18 @@ function enumOptionLabel(schema, value) {
     }
     return schema.labels[key] ?? key;
 }
-async function promptForField(field) {
+function withPromptStreams(options, streams) {
+    return {
+        ...options,
+        ...(streams.input === undefined ? {} : { input: streams.input }),
+        ...(streams.output === undefined ? {} : { output: streams.output })
+    };
+}
+function throwPromptCancellation() {
+    cancel("Operation cancelled.");
+    throw new UserError("Operation cancelled.");
+}
+async function promptForField(field, streams = {}) {
     const schema = field.schema;
     if (schema.kind === "enum") {
         const options = schema.loadOptions
@@ -1770,37 +1782,34 @@ async function promptForField(field) {
                 label: enumOptionLabel(schema, value),
                 value
             }));
-        const selected = await select({
+        const selected = await select(withPromptStreams({
             message: field.description ?? fieldPromptLabel(field),
             options,
             initialValue: field.hasDefault ? field.defaultValue : undefined
-        });
+        }, streams));
         if (isCancel(selected)) {
-            cancel("Operation cancelled.");
-            throw new UserError("Operation cancelled.");
+            throwPromptCancellation();
         }
         return selected;
     }
     if (field.schema.kind === "boolean") {
-        const selected = await confirm({
+        const selected = await confirm(withPromptStreams({
             message: fieldPromptLabel(field),
             initialValue: field.hasDefault ? Boolean(field.defaultValue) : undefined
-        });
+        }, streams));
         if (isCancel(selected)) {
-            cancel("Operation cancelled.");
-            throw new UserError("Operation cancelled.");
+            throwPromptCancellation();
         }
         return selected;
     }
-    const entered = await promptText({
+    const entered = await promptText(withPromptStreams({
         message: fieldPromptLabel(field),
         initialValue: field.hasDefault && field.defaultValue !== undefined
             ? formatResolvedValue(field.defaultValue)
             : undefined
-    });
+    }, streams));
     if (isCancel(entered)) {
-        cancel("Operation cancelled.");
-        throw new UserError("Operation cancelled.");
+        throwPromptCancellation();
     }
     if (typeof entered !== "string") {
         throw new UserError(`Missing required parameter "${field.displayPath}".`);
@@ -2825,7 +2834,7 @@ async function enforceVariantConstraints(params, fields, dynamicFields, variants
         }
     }
 }
-async function resolveParams(fields, dynamicFields, variants, positionalValues, optionValues, rawArgv, casing, presetPath, shouldPrompt) {
+async function resolveParams(fields, dynamicFields, variants, positionalValues, optionValues, rawArgv, casing, presetPath, shouldPrompt, missingParameterContext, promptStreams) {
     const params = {};
     const presetValues = typeof presetPath === "string" && presetPath.length > 0
         ? await loadPresetValues(fields, presetPath)
@@ -2835,6 +2844,7 @@ async function resolveParams(fields, dynamicFields, variants, positionalValues,
     const errors = [];
     for (const field of fields) {
         let value;
+        let resolvedMissing = false;
         let source;
         if (field.positionalIndex !== undefined) {
             const positionalValue = positionalValues[field.positionalIndex];
@@ -2885,8 +2895,49 @@ async function resolveParams(fields, dynamicFields, variants, positionalValues,
             }
             value = parsed.value;
         }
+        if (value === undefined &&
+            field.optional &&
+            missingParameterContext !== undefined &&
+            field.schema.cli?.resolveMissing !== undefined) {
+            const resolution = await field.schema.cli.resolveMissing({
+                ...missingParameterContext,
+                params: { ...params }
+            });
+            const choices = resolution?.choices ?? [];
+            if (choices.length === 1) {
+                value = choices[0]?.value;
+                resolvedMissing = true;
+                source = "prompt";
+            }
+            else if (choices.length > 1) {
+                const selected = await select(withPromptStreams({
+                    message: resolution?.message ?? field.description ?? fieldPromptLabel(field),
+                    options: choices.map((choice) => ({
+                        label: choice.label,
+                        value: choice.value
+                    }))
+                }, promptStreams));
+                if (isCancel(selected)) {
+                    throwPromptCancellation();
+                }
+                value = selected;
+                resolvedMissing = true;
+                source = "prompt";
+            }
+        }
+        if (resolvedMissing) {
+            const validation = validateSchema(field.schema, value);
+            if (!validation.ok) {
+                errors.push(...validation.issues.map((issue) => ({
+                    path: field.displayPath,
+                    message: issue.message
+                })));
+                continue;
+            }
+            value = validation.value;
+        }
         if (value === undefined && shouldPrompt && !field.optional) {
-            value = await promptForField(field);
+            value = await promptForField(field, promptStreams);
             source = "prompt";
         }
         if (value === undefined && field.hasDefault) {
@@ -2942,7 +2993,7 @@ function getResolvedFlags(command) {
     const flags = command.optsWithGlobals();
     return flags;
 }
-async function executeCommand(state, services, requirementOptions, runtimeFetch, runtimeOptions, runtimeEnv, runtimeFs, outputEmitter, diagnosticsOptions, onErrorReportContext) {
+async function executeCommand(state, services, requirementOptions, runtimeFetch, runtimeOptions, runtimeEnv, runtimeFs, outputEmitter, promptStreams, diagnosticsOptions, onErrorReportContext) {
     const logger = createLogger(outputEmitter);
     const primitives = {
         logger,
@@ -2960,7 +3011,20 @@ async function executeCommand(state, services, requirementOptions, runtimeFetch,
                 : diagnosticsOptions.logLevel),
         logger: diagnosticsOptions.logger ?? writeCLIDiagnosticEvent
     });
-    const shouldPrompt = !resolvedFlags.yes && Boolean(process.stdin.isTTY);
+    const promptInput = promptStreams.input ?? process.stdin;
+    const promptOutput = promptStreams.output ?? process.stdout;
+    const stdinTTY = Boolean(promptInput.isTTY);
+    const stdoutTTY = Boolean(promptOutput.isTTY);
+    const shouldPrompt = !resolvedFlags.yes && stdinTTY;
+    const missingParameterContext = !resolvedFlags.yes && output === "rich" && stdinTTY && stdoutTTY
+        ? {
+            commandPath: state.commandPath,
+            params: {},
+            output,
+            stdinTTY,
+            stdoutTTY
+        }
+        : undefined;
     const runtime = await resolveFixtureRuntime(state.command, services, requirementOptions, runtimeFetch, runtimeEnv, runtimeFs);
     const preflightContext = {
         ...runtime.services,
@@ -2979,7 +3043,7 @@ async function executeCommand(state, services, requirementOptions, runtimeFetch,
     try {
         await withOutputFormat(output, async () => {
             await assertCommandRequirements(state.command, preflightContext, runtime.requirementOptions);
-            const params = await resolveParams(state.fields, state.dynamicFields, state.variants, state.positionalValues, optionValues, state.rawArgv, state.casing, state.presetsEnabled ? resolvedFlags.preset : undefined, shouldPrompt);
+            const params = await resolveParams(state.fields, state.dynamicFields, state.variants, state.positionalValues, optionValues, state.rawArgv, state.casing, state.presetsEnabled ? resolvedFlags.preset : undefined, shouldPrompt, missingParameterContext, promptStreams);
             resolvedParams = params;
             runtimeSecrets = runtime.secrets;
             const context = {
@@ -3607,6 +3671,9 @@ export async function runCLI(roots, options = {}) {
             lastActionCommand = state.actionCommand;
             resolvedCommandPath = formatCliCommandPath(state.commandPath);
             await executeCommand(state, servicesWithBuiltIns, requirementOptions, runtimeFetch, runtimeOptions, options.env, options.fs, options.outputEmitter, {
+                input: options.promptInput,
+                output: options.promptOutput
+            }, {
                 logLevel: options.logLevel,
                 logger: options.logger,
                 verboseControlEnabled: controls.verbose

package/dist/composition.json

@@ -48,13 +48,18 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.100",
+      "version": "0.0.102",
       "license": "MIT"
     },
     {
       "name": "toolcraft-design",
       "version": "0.0.2",
       "license": "MIT"
+    },
+    {
+      "name": "toolcraft-schema",
+      "version": "0.0.102",
+      "license": "MIT"
     }
   ]
 }

package/node_modules/toolcraft-design/dist/explorer/jobs.d.ts

@@ -1,6 +1,7 @@
 import type { ExplorerEvent } from "./events.js";
 import type { DetailCtx, DetailItem } from "./state.js";
 export declare const LOADING_INDICATOR_MS = 150;
+export declare const DETAIL_DEBOUNCE_MS = 100;
 export declare function createDetailJobs(emit: (event: ExplorerEvent) => void): {
     schedule: (rowId: string, items: (ctx: DetailCtx) => Promise<DetailItem[]>, ctx: DetailCtx) => Promise<void>;
     abort: () => void;

package/node_modules/toolcraft-design/dist/explorer/jobs.js

@@ -1,6 +1,8 @@
 export const LOADING_INDICATOR_MS = 150;
+export const DETAIL_DEBOUNCE_MS = 100;
 export function createDetailJobs(emit) {
     let token = 0;
+    let lastScheduleAt = 0;
     let current = null;
     const abortedTokens = new Set();
     return {
@@ -9,6 +11,9 @@ export function createDetailJobs(emit) {
                 current.controller.abort();
                 clearTimeout(current.loadingTimer);
             }
+            const scheduledAt = Date.now();
+            const debounce = scheduledAt - lastScheduleAt < DETAIL_DEBOUNCE_MS;
+            lastScheduleAt = scheduledAt;
             const nextToken = ++token;
             const controller = new AbortController();
             let finished = false;
@@ -19,6 +24,12 @@ export function createDetailJobs(emit) {
             }, LOADING_INDICATOR_MS);
             current = { controller, loadingTimer, token: nextToken };
             try {
+                if (debounce) {
+                    await waitUnlessAborted(DETAIL_DEBOUNCE_MS, controller.signal);
+                    if (controller.signal.aborted || nextToken !== token) {
+                        return;
+                    }
+                }
                 const loadedItems = await items({ ...ctx, signal: controller.signal });
                 finished = true;
                 if (!abortedTokens.has(nextToken)) {
@@ -51,6 +62,23 @@ export function createDetailJobs(emit) {
         }
     };
 }
+function waitUnlessAborted(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal.aborted) {
+            resolve();
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            resolve();
+        };
+        const timer = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}
 function toError(error) {
     if (error instanceof Error) {
         return error;

package/node_modules/toolcraft-design/dist/explorer/render/detail.js

@@ -26,7 +26,7 @@ function renderDetailBody(state, screen, rect, row) {
         return;
     }
     if (items === null) {
-        writeLine(screen, rect, 0, state.detail.loading ? "Loading detail..." : state.emptyHint, styles.muted);
+        writeLine(screen, rect, 0, row === null ? state.emptyHint : "Loading detail...", styles.muted);
         return;
     }
     if (items.length === 0) {

package/node_modules/toolcraft-design/dist/explorer/render/list.js

@@ -13,7 +13,7 @@ export function renderList(state, screen, layout) {
         writeLine(screen, rect, 0, "Terminal too narrow", styles.muted);
         return;
     }
-    drawPaneFrame(screen, rect, "Plans", state.focused === "list" ? styles.borderFocused : styles.border);
+    drawPaneFrame(screen, rect, state.title, state.focused === "list" ? styles.borderFocused : styles.border);
     const bodyRect = paneBodyRect(rect);
     if (bodyRect.width <= 0 || bodyRect.height <= 0) {
         return;

package/node_modules/toolcraft-schema/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Poe Platform
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/toolcraft-schema/README.md

@@ -0,0 +1,89 @@
+# toolcraft-schema
+
+Zero-dependency schema builder for typed command inputs, runtime validation,
+and JSON Schema generation.
+
+## Features
+
+- Zero runtime dependencies
+- Typed schema descriptors
+- `Static<typeof schema>` type inference
+- Runtime validation with `validateValue()`
+- JSON Schema serialization via `toJsonSchema()`
+- JSON Schema document serialization via `toJsonSchemaDocument()`
+
+## Usage
+
+```ts
+import { S, toJsonSchema, toJsonSchemaDocument, validateValue } from "toolcraft-schema";
+import type { Static } from "toolcraft-schema";
+
+const schema = S.Object({
+  name: S.String({ description: "User name" }),
+  retries: S.Optional(S.Number({ default: 3 })),
+  mode: S.Enum(["fast", "safe"] as const, { default: "safe" }),
+  tags: S.Array(S.String(), { default: [] })
+});
+
+type Input = Static<typeof schema>;
+// {
+//   name: string;
+//   retries?: number;
+//   mode: "fast" | "safe";
+//   tags: string[];
+// }
+
+const jsonSchema = toJsonSchema(schema);
+const document = toJsonSchemaDocument(schema, {
+  id: "https://example.test/schema.json",
+  title: "Example schema"
+});
+const validation = validateValue(schema, {
+  name: "Ada",
+  mode: "safe",
+  tags: []
+});
+```
+
+## API
+
+### Builders
+
+- `S.String({ description?, default?, short?, cliAliases? })`
+- `S.Number({ description?, default?, short?, cliAliases? })`
+- `S.Boolean({ description?, default?, short?, cliAliases? })`
+- `S.Enum(values, { description?, default?, short?, cliAliases? })`
+- `S.Array(itemSchema, { description?, default?, short?, cliAliases? })`
+- `S.Record(valueSchema, { description?, default? })`
+- `S.Union([schemaA, schemaB], { description?, default? })`
+- `S.OneOf([schemaA, schemaB], { description?, default? })`
+- `S.Object({ [key]: schema })`
+- `S.Optional(schema)`
+
+### Type helpers
+
+- `Static<typeof schema>` infers the runtime TypeScript shape for a schema descriptor.
+- Object properties wrapped in `S.Optional(...)` become optional properties in `Static`.
+
+### JSON Schema generation
+
+- `toJsonSchema(schema)` converts any schema descriptor to standard JSON Schema.
+- `toJsonSchemaDocument(schema, options)` wraps `toJsonSchema(schema)` in a full JSON Schema document with `$schema`, optional `$id`, `title`, and `description`.
+- Object properties not wrapped in `S.Optional(...)` are emitted in `required`.
+- Defaults provided to schema builders are emitted as JSON Schema `default`.
+- Nested `S.Object(...)` schemas produce nested JSON Schema objects.
+- `S.Enum(...)` rejects empty or duplicate values at runtime for JavaScript callers.
+
+### Runtime validation
+
+- `validateValue(schema, value)` returns `{ ok: true, value }` for valid input.
+- Invalid input returns `{ ok: false, issues }` with path-aware diagnostics.
+- Validation applies defaults from schema descriptors.
+
+## Environment Variables
+
+This package exposes no environment variables.
+
+## Configuration
+
+This package currently exposes no package-level configuration options.

package/node_modules/toolcraft-schema/dist/index.compile-check.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/toolcraft-schema/dist/index.compile-check.js

@@ -0,0 +1,17 @@
+import { S, toJsonSchemaDocument } from "./index.js";
+const ignoredStringSchema = S.String({ description: "Name", default: "guest" });
+const ignoredNumberSchema = S.Number({ description: "Count", default: 1 });
+const ignoredBooleanSchema = S.Boolean({ description: "Enabled", default: false });
+const ignoredEnumSchema = S.Enum(["admin", "user"], { default: "admin" });
+const ignoredIntegerEnumSchema = S.Enum([1, 2], { jsonType: "integer" });
+const ignoredArraySchema = S.Array(S.String(), { default: ["a"] });
+const ignoredObjectSchema = S.Object({
+    name: S.String(),
+    retries: S.Optional(S.Number())
+});
+const ignoredOptionalSchema = S.Optional(S.Boolean());
+const ignoredJsonSchemaDocument = toJsonSchemaDocument(ignoredObjectSchema, {
+    id: "https://example.test/schema.json",
+    title: "Example schema",
+    description: "Example schema document"
+});

package/node_modules/toolcraft-schema/dist/index.d.ts

@@ -0,0 +1,182 @@
+import { Json } from "./json.js";
+import { OneOf } from "./oneof.js";
+import { Record as RecordBuilder } from "./record.js";
+import { Union } from "./union.js";
+import { validate } from "./validate.js";
+import type { JsonValue, JsonValueSchema } from "./json.js";
+import type { JsonSchemaDocument, JsonSchemaDocumentOptions } from "./json-schema-document.js";
+import type { OneOfSchema } from "./oneof.js";
+import type { RecordSchema } from "./record.js";
+import type { UnionSchema } from "./union.js";
+import type { ValidationIssue, ValidationResult } from "./validate.js";
+type JsonSchemaType = "string" | "number" | "integer" | "boolean" | "array" | "object";
+type SchemaKind = "string" | "number" | "boolean" | "enum" | "array" | "object" | "optional" | "oneOf" | "union" | "record" | "json";
+type EnumValue = string | number | boolean;
+type JsonSchemaEnumValue = EnumValue | null;
+type NumberJsonType = "number" | "integer";
+type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
+type ObjectShape = Record<string, AnySchema>;
+type EmptyOptions = Record<never, never>;
+type SchemaScope = "cli" | "mcp" | "sdk";
+export type CliOutputMode = "rich" | "md" | "json";
+export interface CliMissingParameterChoice<TValue> {
+    label: string;
+    value: TValue;
+}
+export interface CliMissingParameterContext {
+    commandPath: string;
+    params: Readonly<Record<string, unknown>>;
+    output: CliOutputMode;
+    stdinTTY: boolean;
+    stdoutTTY: boolean;
+}
+export interface CliMissingParameterResolution<TValue> {
+    choices: readonly CliMissingParameterChoice<TValue>[];
+    message?: string;
+}
+export interface CliSchemaOptions<TValue> {
+    resolveMissing?: (context: CliMissingParameterContext) => CliMissingParameterResolution<TValue> | undefined | Promise<CliMissingParameterResolution<TValue> | undefined>;
+}
+type StringMetadata = {
+    format?: string;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    secret?: boolean;
+};
+type NumberMetadata = {
+    maximum?: number;
+    minimum?: number;
+    secret?: boolean;
+};
+type ArrayMetadata = {
+    maxItems?: number;
+    minItems?: number;
+};
+type ObjectMetadata = {
+    additionalProperties?: boolean;
+};
+type OptionalKeys<TShape extends ObjectShape> = {
+    [TKey in keyof TShape]: TShape[TKey] extends OptionalSchema<any> ? TKey : never;
+}[keyof TShape];
+type RequiredKeys<TShape extends ObjectShape> = Exclude<keyof TShape, OptionalKeys<TShape>>;
+type PropertyStatic<TSchema extends AnySchema> = TSchema extends OptionalSchema<infer TInner> ? Static<TInner> : Static<TSchema>;
+type InferObject<TShape extends ObjectShape> = {
+    [TKey in RequiredKeys<TShape>]: PropertyStatic<TShape[TKey]>;
+} & {
+    [TKey in OptionalKeys<TShape>]?: PropertyStatic<TShape[TKey]>;
+};
+type SchemaOptions<TDefault> = {
+    cli?: CliSchemaOptions<TDefault>;
+    description?: string;
+    cliDescription?: string;
+    cliAliases?: readonly string[];
+    default?: TDefault;
+    nullable?: boolean;
+    requiredScopes?: readonly SchemaScope[];
+    short?: string;
+    scope?: readonly SchemaScope[];
+    global?: boolean;
+};
+type WithNullable<TSchema extends AnySchema, TOptions extends {
+    nullable?: boolean;
+}> = TOptions extends {
+    readonly nullable: true;
+} ? TSchema & {
+    readonly nullable: true;
+} : TSchema;
+export interface SchemaBase<TKind extends SchemaKind, TStatic> {
+    readonly kind: TKind;
+    readonly cli?: CliSchemaOptions<TStatic>;
+    readonly description?: string;
+    readonly cliDescription?: string;
+    readonly cliAliases?: readonly string[];
+    readonly default?: TStatic;
+    readonly nullable?: boolean;
+    readonly requiredScopes?: readonly SchemaScope[];
+    readonly short?: string;
+    readonly scope?: readonly SchemaScope[];
+    readonly global?: boolean;
+    readonly __static?: TStatic;
+}
+export interface JsonSchema {
+    additionalProperties?: boolean | JsonSchema;
+    type?: JsonSchemaType;
+    description?: string;
+    default?: unknown;
+    enum?: ReadonlyArray<JsonSchemaEnumValue>;
+    format?: string;
+    items?: JsonSchema;
+    maxItems?: number;
+    maximum?: number;
+    maxLength?: number;
+    minItems?: number;
+    minimum?: number;
+    minLength?: number;
+    nullable?: boolean;
+    oneOf?: JsonSchema[];
+    pattern?: string;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+}
+export interface StringSchema extends SchemaBase<"string", string>, StringMetadata {
+}
+export interface NumberSchema extends SchemaBase<"number", number>, NumberMetadata {
+    readonly jsonType?: NumberJsonType;
+}
+export type BooleanSchema = SchemaBase<"boolean", boolean>;
+export interface EnumSchema<TValues extends NonEmptyReadonlyArray<EnumValue>> extends SchemaBase<"enum", TValues[number]> {
+    readonly values: TValues;
+    readonly jsonType?: "integer";
+    readonly labels?: Partial<Record<string, string>>;
+    readonly loadOptions?: (() => Array<{
+        label: string;
+        value: string;
+    }>) | (() => Promise<Array<{
+        label: string;
+        value: string;
+    }>>);
+}
+export interface ArraySchema<TItem extends AnySchema> extends SchemaBase<"array", Array<Static<TItem>>>, ArrayMetadata {
+    readonly item: TItem;
+}
+export interface ObjectSchema<TShape extends ObjectShape> extends SchemaBase<"object", InferObject<TShape>>, ObjectMetadata {
+    readonly shape: TShape;
+}
+export interface OptionalSchema<TInner extends AnySchema> extends SchemaBase<"optional", Static<TInner> | undefined> {
+    readonly inner: TInner;
+}
+export type AnySchema = StringSchema | NumberSchema | BooleanSchema | EnumSchema<NonEmptyReadonlyArray<EnumValue>> | ArraySchema<AnySchema> | ObjectSchema<ObjectShape> | OptionalSchema<AnySchema> | OneOfSchema<Record<string, ObjectSchema<any>>, string> | UnionSchema<readonly ObjectSchema<any>[]> | RecordSchema<AnySchema> | JsonValueSchema;
+export type Static<TSchema extends AnySchema> = TSchema extends {
+    readonly nullable: true;
+} ? TSchema extends SchemaBase<any, infer TStatic> ? TStatic | null : never : TSchema extends SchemaBase<any, infer TStatic> ? TStatic : never;
+export declare const S: {
+    readonly String: <const TOptions extends SchemaOptions<string> & StringMetadata = EmptyOptions>(options?: TOptions) => WithNullable<StringSchema, TOptions>;
+    readonly Number: <const TOptions extends SchemaOptions<number> & NumberMetadata & {
+        jsonType?: NumberJsonType;
+    } = EmptyOptions>(options?: TOptions) => WithNullable<NumberSchema, TOptions>;
+    readonly Boolean: <const TOptions extends SchemaOptions<boolean> = EmptyOptions>(options?: TOptions) => WithNullable<BooleanSchema, TOptions>;
+    readonly Enum: <const TValues extends NonEmptyReadonlyArray<EnumValue>, const TOptions extends SchemaOptions<TValues[number]> & {
+        jsonType?: "integer";
+        labels?: Partial<Record<string, string>>;
+        loadOptions?: (() => Array<{
+            label: string;
+            value: string;
+        }>) | (() => Promise<Array<{
+            label: string;
+            value: string;
+        }>>);
+    } = EmptyOptions>(values: TValues, options?: TOptions) => WithNullable<EnumSchema<TValues>, TOptions>;
+    readonly Array: <TItem extends AnySchema, const TOptions extends SchemaOptions<Array<Static<TItem>>> & ArrayMetadata = EmptyOptions>(item: TItem, options?: TOptions) => WithNullable<ArraySchema<TItem>, TOptions>;
+    readonly Object: <const TShape extends ObjectShape, const TOptions extends SchemaOptions<InferObject<TShape>> & ObjectMetadata = EmptyOptions>(shape: TShape, options?: TOptions) => WithNullable<ObjectSchema<TShape>, TOptions>;
+    readonly Optional: <TInner extends AnySchema>(inner: TInner) => OptionalSchema<TInner>;
+    readonly OneOf: typeof OneOf;
+    readonly Union: typeof Union;
+    readonly Record: typeof RecordBuilder;
+    readonly Json: typeof Json;
+};
+export declare function toJsonSchema(schema: AnySchema): JsonSchema;
+export declare function toJsonSchemaDocument(schema: AnySchema, options?: JsonSchemaDocumentOptions): JsonSchemaDocument;
+export { Json, OneOf, RecordBuilder as Record, Union, validate };
+export type { JsonSchemaDocument, JsonSchemaDocumentOptions } from "./json-schema-document.js";
+export type { JsonValue, JsonValueSchema, OneOfSchema, RecordSchema, UnionSchema, ValidationIssue, ValidationResult };