@kamilio/wire 0.1.8 → 0.1.10

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/viewport.d.ts

@@ -0,0 +1,18 @@
+/** Select wrapped rows from the tail, retaining only one viewport of rows. */
+export declare function selectViewportTail<T, R>(items: readonly T[], height: number, offset: number, renderRows: (item: T) => readonly R[]): {
+    rows: R[];
+    offset: number;
+};
+export declare function createViewport<T extends {
+    id: string;
+}>({ capacity }: {
+    capacity: number;
+}): {
+    append(item: T): void;
+    scroll(delta: number): void;
+    items(): readonly T[];
+    offset(): number;
+    unseen(): number;
+    find(predicate: (item: T) => boolean): number;
+    follow(): void;
+};

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/viewport.js

@@ -0,0 +1,56 @@
+/** Select wrapped rows from the tail, retaining only one viewport of rows. */
+export function selectViewportTail(items, height, offset, renderRows) {
+    height = Math.max(0, Math.floor(height));
+    offset = Math.max(0, Math.floor(offset));
+    if (!height)
+        return { rows: [], offset: 0 };
+    const selected = [];
+    const oldest = [];
+    let visited = 0;
+    for (let index = items.length - 1; index >= 0; index--) {
+        const rows = renderRows(items[index]);
+        for (let row = rows.length - 1; row >= 0; row--) {
+            const value = rows[row];
+            oldest.push(value);
+            if (oldest.length > height)
+                oldest.shift();
+            if (visited >= offset && selected.length < height)
+                selected.push(value);
+            visited++;
+            if (selected.length === height)
+                return { rows: selected.reverse(), offset };
+        }
+    }
+    return { rows: oldest.reverse(), offset: Math.min(offset, Math.max(0, visited - height)) };
+}
+export function createViewport({ capacity }) {
+    if (!Number.isInteger(capacity) || capacity < 1)
+        throw new RangeError("capacity must be a positive integer");
+    const live = new Map();
+    let held;
+    let position = 0;
+    let unseen = 0;
+    return {
+        append(item) {
+            live.set(item.id, item);
+            if (live.size > capacity)
+                live.delete(live.keys().next().value);
+            if (held)
+                unseen++;
+        },
+        scroll(delta) {
+            position = Math.max(0, position + Math.trunc(delta));
+            if (position && !held)
+                held = Array.from(live.values());
+            if (!position) {
+                held = undefined;
+                unseen = 0;
+            }
+        },
+        items() { return held ?? Array.from(live.values()); },
+        offset() { return position; },
+        unseen() { return unseen; },
+        find(predicate) { return (held ?? Array.from(live.values())).findIndex(predicate); },
+        follow() { position = 0; held = undefined; unseen = 0; }
+    };
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/package.json

@@ -1,7 +1,6 @@
 {
-  "name": "toolcraft-design",
-  "version": "0.0.2",
   "private": true,
+  "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,21 +13,26 @@
     "generate:docs": "tsx scripts/generate-docs.ts all",
     "generate:design-docs:markdown": "tsx scripts/generate-docs.ts markdown",
     "generate:design-docs:json": "tsx scripts/generate-docs.ts json",
-    "generate:design-docs:all": "tsx scripts/generate-docs.ts all"
+    "generate:design-docs:all": "tsx scripts/generate-docs.ts all",
+    "test:unit": "cd ../.. && vitest run packages/toolcraft-design"
   },
   "files": [
-    "dist"
+    "dist",
+    "LICENSE"
   ],
-  "dependencies": {
-    "fast-string-width": "^3.0.2",
-    "fast-wrap-ansi": "^0.2.0",
-    "sisteransi": "^1.0.5"
-  },
   "exports": {
+    "./escape-terminal-text": {
+      "types": "./dist/escape-terminal-text.d.ts",
+      "import": "./dist/escape-terminal-text.js"
+    },
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./render-markdown-plaintext": {
+      "types": "./dist/render-markdown-plaintext.d.ts",
+      "import": "./dist/render-markdown-plaintext.js"
+    },
     "./*": {
       "types": "./dist/*.d.ts",
       "import": "./dist/*.js"

package/node_modules/toolcraft/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/node_modules/toolcraft-schema/README.md

@@ -0,0 +1,151 @@
+# 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>` for legacy inference; `Input` and `Output` for parsed defaults
+- Standard Schema v1 validation and Standard JSON Schema v1 conversion
+- Runtime validation with `validate()`
+- JSON Schema serialization via `toJsonSchema()`
+- JSON Schema document serialization via `toJsonSchemaDocument()`
+- Native JSON Schema compilation and property projection with reference support
+
+## Usage
+
+```ts
+import { S, toJsonSchema, toJsonSchemaDocument, validate } from "toolcraft-schema";
+import type { Static } from "toolcraft-schema";
+
+const schema = S.Object({
+  name: S.String({ description: "User name", minLength: 1 }),
+  retries: S.Optional(S.Number({ default: 3, minimum: 0, jsonType: "integer" })),
+  mode: S.Enum(["fast", "safe"] as const, { default: "safe" }),
+  tags: S.Array(S.String(), { default: [], maxItems: 5 })
+});
+
+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 = validate(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)`
+- `S.Union([objectSchemaA, objectSchemaB])`
+- `S.OneOf({ discriminator: "kind", branches: { text: objectSchemaA, count: objectSchemaB } })`
+- `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`.
+- Schemas declared with `nullable: true` infer `null` and emit standard JSON Schema null unions.
+- `Input<typeof schema>` describes accepted inputs. `Output<typeof schema>` makes optional properties with defaults required after parsing, including nested objects and arrays. `Static` keeps its existing optional-property behavior.
+
+### 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` and must satisfy the schema.
+- String, number, and array constraints are emitted as JSON Schema validation keywords.
+- Nested `S.Object(...)` schemas produce nested JSON Schema objects. Object schemas default to `additionalProperties: false`; pass `additionalProperties: true` to allow unknown keys.
+- `S.Enum(...)` rejects empty or duplicate values at runtime for JavaScript callers.
+- Invalid builder configuration fails fast, including invalid regex patterns, negative lengths/counts, inverted min/max pairs, non-finite numeric bounds, and integer schemas with non-integer defaults.
+
+### Runtime validation
+
+- `validate(schema, value)` returns `{ ok: true, value }` for valid input.
+- Invalid input returns `{ ok: false, issues }` with path-aware diagnostics.
+- Validation fills missing optional properties with their inner schema defaults. Required properties remain required. Use `{ defaults: "none" }` to disable defaults, or `{ defaults: "all" }` to also fill required properties. Each parsed default is an independent copy.
+
+`compileJsonSchema(document, options)` validates complete native JSON Schema
+documents. `projectJsonSchemaProperties(document, options)` supplies stable
+property names, unconditional required metadata, resolved schema annotations,
+and candidate validators for CLI generation. It follows references, compositions,
+embedded resource IDs and conditional declarations using the same compiler.
+Property candidate validators accept values matching at least one declaration;
+validate the complete object to enforce branch-dependent and combined constraints.
+Both functions accept a `registry` for external schema documents without network
+fetching.
+
+`isJsonValue(value, options)` checks JSON data without invoking getters or
+serialization hooks. It rejects cycles, sparse arrays, non-finite numbers and
+non-JSON prototypes. Defaults bound the tree to 10,000 nodes and depth 64.
+Use `maxNodes` for larger bounded documents (`Infinity` removes the node budget), or `maxDepth` (0–256) to choose a
+depth budget. Shared objects count once for each occurrence in the JSON tree;
+options never change other calls' budgets.
+
+## Use with Standard Schema consumers
+
+Pass a builder result directly to libraries that accept Standard Schema and
+Standard JSON Schema, including tiny MCP servers. No adapter is required.
+
+```ts
+import { S } from "toolcraft-schema";
+import { createServer } from "tiny-stdio-mcp-server";
+
+const input = S.Object({
+  query: S.String(),
+  limit: S.Optional(S.Number({ default: 10 }))
+});
+
+createServer({ name: "search", version: "1" })
+  .tool("search", "Search", input, ({ query, limit }) => {
+    // query: string; limit: number (the default has been applied)
+    return `${query}: ${limit}`;
+  });
+
+const parsed = await input["~standard"].validate({ query: "hello" });
+// { value: { query: "hello", limit: 10 } } or { issues: [...] }
+const document = input["~standard"].jsonSchema.input({ target: "draft-2020-12" });
+const outputDocument = input["~standard"].jsonSchema.output({ target: "draft-2020-12" });
+```
+
+Standard validation uses the default optional-property behavior of `validate`.
+Input conversion keeps defaulted optional properties optional; output conversion
+marks them required. Direct `toJsonSchema(schema, { io: "output" })` also exposes
+this output shape. Converters support `draft-07` and `draft-2020-12`, and reject
+unsupported targets. Native schemas attached with `withJsonSchema` remain the
+authoritative contract; projection defaults do not alter their values.
+
+The `~standard` methods are non-enumerable. JSON serialization and structured
+cloning keep the existing data descriptors. A spread or structured clone does
+not retain methods: call `withStandardSchema(copiedDescriptor)` to attach them
+when passing the copy to a standard consumer. Existing `validate` and
+`toJsonSchema` functions continue to accept these plain descriptors.
+
+## Environment Variables
+
+This package exposes no environment variables.
+
+## Configuration
+
+This package currently exposes no package-level configuration options.

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/clone-default.d.ts

@@ -0,0 +1 @@
+export declare function cloneDefaultValue<Value>(value: Value): Value;

package/node_modules/toolcraft/node_modules/toolcraft-schema/dist/clone-default.js

@@ -0,0 +1,26 @@
+export function cloneDefaultValue(value) {
+    const copies = new WeakMap();
+    function copy(current) {
+        if (current === null || typeof current !== "object")
+            return current;
+        const existing = copies.get(current);
+        if (existing !== undefined)
+            return existing;
+        const prototype = Object.getPrototypeOf(current);
+        if (!Array.isArray(current) && prototype !== Object.prototype && prototype !== null) {
+            return current;
+        }
+        const result = Array.isArray(current) ? new Array(current.length) : Object.create(prototype);
+        copies.set(current, result);
+        for (const key of Object.keys(current)) {
+            Object.defineProperty(result, key, {
+                value: copy(current[key]),
+                enumerable: true,
+                configurable: true,
+                writable: true
+            });
+        }
+        return result;
+    }
+    return copy(value);
+}

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

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

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

@@ -0,0 +1,18 @@
+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 ignoredNullEnumSchema = S.Enum([null]);
+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/node_modules/toolcraft-schema/dist/index.d.ts

@@ -0,0 +1,220 @@
+import { type Standardized } from "./standard.js";
+import { Json } from "./json.js";
+import { OneOf } from "./oneof.js";
+import { Record as RecordBuilder } from "./record.js";
+import { Union } from "./union.js";
+import { isPlainRecord, 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, ValidationOptions, ValidationResult } from "./validate.js";
+type JsonSchemaType = "string" | "number" | "integer" | "boolean" | "array" | "object" | "null";
+type SchemaKind = "string" | "number" | "boolean" | "enum" | "array" | "object" | "optional" | "oneOf" | "union" | "record" | "json";
+type EnumValue = string | number | boolean | 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) & (TOptions extends {
+    readonly default: infer Value;
+} ? undefined extends Value ? unknown : {
+    readonly default: Exclude<TSchema["default"], undefined>;
+} : unknown);
+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;
+    allOf?: JsonSchema[];
+    anyOf?: JsonSchema[];
+    type?: JsonSchemaType | JsonSchemaType[];
+    description?: string;
+    default?: unknown;
+    enum?: ReadonlyArray<JsonValue>;
+    const?: JsonValue;
+    format?: string;
+    items?: JsonSchema;
+    maxItems?: number;
+    maximum?: number;
+    maxLength?: number;
+    minItems?: number;
+    minimum?: number;
+    minLength?: number;
+    nullable?: boolean;
+    not?: JsonSchema;
+    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>> | (SchemaBase<"array", any> & ArrayMetadata & {
+    readonly item: AnySchema;
+}) | (SchemaBase<"object", any> & ObjectMetadata & {
+    readonly shape: ObjectShape;
+}) | (SchemaBase<"optional", any> & {
+    readonly inner: AnySchema;
+}) | (SchemaBase<"oneOf", any> & {
+    readonly discriminator: string;
+    readonly branches: Record<string, ObjectSchema<any>>;
+}) | (SchemaBase<"union", any> & {
+    readonly branches: readonly ObjectSchema<any>[];
+}) | (SchemaBase<"record", any> & {
+    readonly value: 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) => Standardized<WithNullable<StringSchema, TOptions>>;
+    readonly Number: <const TOptions extends SchemaOptions<number> & NumberMetadata & {
+        jsonType?: NumberJsonType;
+    } = EmptyOptions>(options?: TOptions) => Standardized<WithNullable<NumberSchema, TOptions>>;
+    readonly Boolean: <const TOptions extends SchemaOptions<boolean> = EmptyOptions>(options?: TOptions) => Standardized<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) => Standardized<WithNullable<EnumSchema<TValues>, TOptions>>;
+    readonly Array: <TItem extends AnySchema, const TOptions extends SchemaOptions<Array<Static<TItem>>> & ArrayMetadata = EmptyOptions>(item: TItem, options?: TOptions) => Standardized<WithNullable<ArraySchema<TItem>, TOptions>>;
+    readonly Object: <const TShape extends ObjectShape, const TOptions extends SchemaOptions<InferObject<TShape>> & ObjectMetadata = EmptyOptions>(shape: TShape, options?: TOptions) => Standardized<WithNullable<ObjectSchema<TShape>, TOptions>>;
+    readonly Optional: <TInner extends AnySchema>(inner: TInner) => Standardized<OptionalSchema<TInner>>;
+    readonly OneOf: typeof OneOf;
+    readonly Union: typeof Union;
+    readonly Record: typeof RecordBuilder;
+    readonly Json: typeof Json;
+};
+export interface JsonSchemaOptions {
+    io?: "input" | "output";
+    target?: "draft-07" | "draft-2020-12";
+}
+export declare function toJsonSchema(schema: AnySchema, options?: JsonSchemaOptions): JsonSchema;
+export declare function toJsonSchemaDocument(schema: AnySchema, options?: JsonSchemaDocumentOptions): JsonSchemaDocument;
+export { Json, OneOf, RecordBuilder as Record, Union, isPlainRecord, validate };
+export { isJsonValue } from "./json.js";
+export type { JsonValueValidationOptions } from "./json.js";
+export { cloneDefaultValue } from "./clone-default.js";
+export { unicodeLength } from "./json-schema/utils.js";
+export { compileJsonSchema, formatIssues } from "./json-schema/index.js";
+export { projectJsonSchemaProperties } from "./json-schema/properties.js";
+export type { JsonSchemaProperty } from "./json-schema/properties.js";
+export { normalizeLegacyNullability } from "./json-schema/normalize-nullability.js";
+export { withJsonSchema, nativeJsonSchema } from "./native-json-schema.js";
+export type { NativeSchema } from "./native-json-schema.js";
+export type { CompileJsonSchemaOptions, CompiledJsonSchema } from "./json-schema/index.js";
+export type { JsonSchemaDocument, JsonSchemaDocumentOptions } from "./json-schema-document.js";
+export type { JsonValue, JsonValueSchema, OneOfSchema, RecordSchema, UnionSchema, ValidationIssue, ValidationOptions, ValidationResult };
+export { withStandardSchema } from "./standard.js";
+export type { Input, Output, StandardSchema, Standardized, StandardIssue, StandardResult, StandardJsonSchemaOptions } from "./standard.js";