schematch 0.0.1

package/dist/errors.js

@@ -0,0 +1,149 @@
+import { prettifyStandardSchemaError } from './standard-schema/errors.js';
+import { validateSync } from './standard-schema/validation.js';
+/**
+ * Error thrown (or returned) when no case in a match expression matched the input.
+ *
+ * Implements {@link StandardSchemaV1.FailureResult} so it can be used directly as a
+ * standard-schema failure result — the `.issues` array contains per-case validation details.
+ */
+export class NonExhaustiveError extends Error {
+    constructor(input, options) {
+        const issues = buildIssues(input, options);
+        const message = buildErrorMessage(input, issues, options);
+        super(message);
+        this.input = input;
+        this.issues = issues;
+        this.schemas = options?.schemas;
+        this.discriminator = options?.discriminator;
+    }
+}
+/** Build standard-schema issues from the match failure. */
+function buildIssues(input, options) {
+    const issues = [];
+    const schemas = options?.schemas;
+    if (!schemas || schemas.length === 0) {
+        issues.push({ message: formatNoMatchMessage(input) });
+        return issues;
+    }
+    const disc = options?.discriminator;
+    if (disc && !disc.matched) {
+        // Discriminator miss — the discriminator value wasn't one of the expected values.
+        // Single issue is sufficient.
+        let discValueStr;
+        try {
+            discValueStr = JSON.stringify(disc.value);
+        }
+        catch {
+            discValueStr = String(disc.value);
+        }
+        const expectedStr = disc.expected.map(v => {
+            try {
+                return JSON.stringify(v);
+            }
+            catch {
+                return String(v);
+            }
+        }).join(', ');
+        issues.push({
+            message: `Discriminator '${disc.key}' has value ${discValueStr} but expected one of: ${expectedStr}`,
+            path: [disc.key],
+        });
+        return issues;
+    }
+    // Collect per-case issues
+    for (let i = 0; i < schemas.length; i += 1) {
+        try {
+            const result = validateSync(schemas[i], input);
+            if ('issues' in result && result.issues) {
+                for (const issue of result.issues) {
+                    issues.push({
+                        message: `Case ${i + 1}: ${issue.message}`,
+                        path: issue.path,
+                    });
+                }
+            }
+        }
+        catch {
+            // Validation threw (e.g. async schema used in sync context) — skip
+        }
+    }
+    if (issues.length === 0) {
+        issues.push({ message: formatNoMatchMessage(input) });
+    }
+    return issues;
+}
+function formatNoMatchMessage(input) {
+    let displayedValue;
+    try {
+        displayedValue = JSON.stringify(input);
+    }
+    catch {
+        displayedValue = String(input);
+    }
+    return `No schema matches value ${displayedValue}`;
+}
+function buildErrorMessage(input, issues, options) {
+    let displayedValue;
+    try {
+        displayedValue = JSON.stringify(input);
+    }
+    catch {
+        displayedValue = String(input);
+    }
+    const lines = [`Schema matching error: no schema matches value ${displayedValue}`];
+    const disc = options?.discriminator;
+    if (disc) {
+        let discValueStr;
+        try {
+            discValueStr = JSON.stringify(disc.value);
+        }
+        catch {
+            discValueStr = String(disc.value);
+        }
+        const expectedStr = disc.expected.map(v => {
+            try {
+                return JSON.stringify(v);
+            }
+            catch {
+                return String(v);
+            }
+        }).join(', ');
+        if (disc.matched) {
+            // Discriminator value was found in the dispatch table but full validation failed.
+            // Show the matched value and per-case issues for just the matched branch.
+            lines.push(`  Discriminator '${disc.key}' matched ${discValueStr} (options: ${expectedStr}) but failed validation:`);
+            appendPerCaseIssues(lines, options?.schemas, input);
+        }
+        else {
+            // Discriminator value was not in the dispatch table — that's the whole story.
+            lines.push(`  Discriminator '${disc.key}' has value ${discValueStr} but expected one of: ${expectedStr}`);
+        }
+    }
+    else {
+        // No discriminator — show per-case issues for all schemas
+        appendPerCaseIssues(lines, options?.schemas, input);
+    }
+    return lines.join('\n');
+}
+function appendPerCaseIssues(lines, schemas, input) {
+    if (!schemas || schemas.length === 0)
+        return;
+    for (let i = 0; i < schemas.length; i += 1) {
+        try {
+            const result = validateSync(schemas[i], input);
+            if ('issues' in result && result.issues) {
+                const pretty = prettifyStandardSchemaError(result);
+                if (pretty) {
+                    lines.push(`  Case ${i + 1}:`);
+                    for (const line of pretty.split('\n')) {
+                        lines.push(`    ${line}`);
+                    }
+                }
+            }
+        }
+        catch {
+            // Validation threw (e.g. async schema used in sync context) — skip
+        }
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { match, matchAsync } from './match.js';
+export { isMatching, isMatchingAsync } from './is-matching.js';
+export { NonExhaustiveError } from './errors.js';
+export type { StandardSchemaV1 } from './standard-schema/contract.js';
+export { prettifyStandardSchemaError, StandardSchemaV1Error, toDotPath } from './standard-schema/errors.js';
+export { looksLikeStandardSchema, looksLikeStandardSchemaFailure } from './standard-schema/utils.js';
+export type { InferInput, InferOutput, StandardSchema } from './types.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+export { match, matchAsync } from './match.js';
+export { isMatching, isMatchingAsync } from './is-matching.js';
+export { NonExhaustiveError } from './errors.js';
+export { prettifyStandardSchemaError, StandardSchemaV1Error, toDotPath } from './standard-schema/errors.js';
+export { looksLikeStandardSchema, looksLikeStandardSchemaFailure } from './standard-schema/utils.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,EAAE,UAAU,EAAC,MAAM,YAAY,CAAA;AAC5C,OAAO,EAAC,UAAU,EAAE,eAAe,EAAC,MAAM,kBAAkB,CAAA;AAC5D,OAAO,EAAC,kBAAkB,EAAC,MAAM,aAAa,CAAA;AAG9C,OAAO,EAAC,2BAA2B,EAAE,qBAAqB,EAAE,SAAS,EAAC,MAAM,6BAA6B,CAAA;AACzG,OAAO,EAAC,uBAAuB,EAAE,8BAA8B,EAAC,MAAM,4BAA4B,CAAA"}

package/dist/is-matching.d.ts

@@ -0,0 +1,6 @@
+import type { StandardSchemaV1 } from './standard-schema/contract.js';
+import type { InferOutput } from './types.js';
+export declare function isMatching<const schema extends StandardSchemaV1>(schema: schema): (value: unknown) => value is InferOutput<schema>;
+export declare function isMatching<const schema extends StandardSchemaV1>(schema: schema, value: unknown): value is InferOutput<schema>;
+export declare function isMatchingAsync<const schema extends StandardSchemaV1>(schema: schema): (value: unknown) => Promise<boolean>;
+export declare function isMatchingAsync<const schema extends StandardSchemaV1>(schema: schema, value: unknown): Promise<boolean>;

package/dist/is-matching.js

@@ -0,0 +1,28 @@
+import { ASYNC_REQUIRED, NO_MATCH, matchSchemaAsync, matchSchemaSync } from './standard-schema/compiled.js';
+import { assertStandardSchema } from './standard-schema/validation.js';
+export function isMatching(schema, value) {
+    assertStandardSchema(schema);
+    if (arguments.length === 1) {
+        return (next) => isMatchingValue(schema, next);
+    }
+    return isMatchingValue(schema, value);
+}
+export function isMatchingAsync(schema, value) {
+    assertStandardSchema(schema);
+    if (arguments.length === 1) {
+        return async (next) => {
+            return (await matchSchemaAsync(schema, next)) !== NO_MATCH;
+        };
+    }
+    return (async () => {
+        return (await matchSchemaAsync(schema, value)) !== NO_MATCH;
+    })();
+}
+const isMatchingValue = (schema, value) => {
+    const result = matchSchemaSync(schema, value);
+    if (result === ASYNC_REQUIRED) {
+        throw new Error('Schema validation returned a Promise. Use isMatchingAsync instead.');
+    }
+    return result !== NO_MATCH;
+};
+//# sourceMappingURL=is-matching.js.map

package/dist/is-matching.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-matching.js","sourceRoot":"","sources":["../src/is-matching.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,cAAc,EAAE,QAAQ,EAAE,gBAAgB,EAAE,eAAe,EAAC,MAAM,+BAA+B,CAAA;AACzG,OAAO,EAAC,oBAAoB,EAAC,MAAM,iCAAiC,CAAA;AAUpE,MAAM,UAAU,UAAU,CACxB,MAAc,EACd,KAAe;IAEf,oBAAoB,CAAC,MAAM,CAAC,CAAA;IAC5B,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC3B,OAAO,CAAC,IAAa,EAA+B,EAAE,CAAC,eAAe,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;IACtF,CAAC;IACD,OAAO,eAAe,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;AACvC,CAAC;AASD,MAAM,UAAU,eAAe,CAC7B,MAAc,EACd,KAAe;IAEf,oBAAoB,CAAC,MAAM,CAAC,CAAA;IAC5B,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC3B,OAAO,KAAK,EAAE,IAAa,EAAE,EAAE;YAC7B,OAAO,CAAC,MAAM,gBAAgB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,KAAK,QAAQ,CAAA;QAC5D,CAAC,CAAA;IACH,CAAC;IACD,OAAO,CAAC,KAAK,IAAI,EAAE;QACjB,OAAO,CAAC,MAAM,gBAAgB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,KAAK,QAAQ,CAAA;IAC7D,CAAC,CAAC,EAAE,CAAA;AACN,CAAC;AAED,MAAM,eAAe,GAAG,CACtB,MAAc,EACd,KAAc,EACgB,EAAE;IAChC,MAAM,MAAM,GAAG,eAAe,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IAC7C,IAAI,MAAM,KAAK,cAAc,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CAAC,oEAAoE,CAAC,CAAA;IACvF,CAAC;IACD,OAAO,MAAM,KAAK,QAAQ,CAAA;AAC5B,CAAC,CAAA"}

package/dist/match.d.ts

@@ -0,0 +1,221 @@
+import type { StandardSchemaV1 } from './standard-schema/contract.js';
+import type { InferInput, InferOutput } from './types.js';
+import { NonExhaustiveError } from './errors.js';
+/** Resolves `Unset` to `never` for use in StandardSchema types. */
+type ResolveOutput<T> = T extends typeof unset ? never : T;
+type MatchState<output> = {
+    matched: true;
+    value: output;
+} | {
+    matched: false;
+    value: undefined;
+};
+declare const unset: unique symbol;
+type Unset = typeof unset;
+type WithReturn<current, next> = current extends Unset ? next : current | next;
+type WithAsyncReturn<current, next> = current extends Unset ? Awaited<next> : current | Awaited<next>;
+type MatchFactory = {
+    <const input, output = Unset>(value: input): MatchExpression<input, output>;
+    input<input>(): ReusableMatcher<input, Unset>;
+    output<output>(): ReusableMatcher<unknown, output>;
+    case<input, schema extends StandardSchemaV1, result>(schema: schema, handler: (value: InferOutput<schema>, input: input) => result): ReusableMatcher<input, WithReturn<Unset, result>, InferInput<schema>>;
+    case<input, schema extends StandardSchemaV1, result>(schema: schema, predicate: (value: InferOutput<schema>, input: input) => unknown, handler: (value: InferOutput<schema>, input: input) => result): ReusableMatcher<input, WithReturn<Unset, result>, InferInput<schema>>;
+    case<input, schemas extends readonly [StandardSchemaV1, ...StandardSchemaV1[]], result>(...args: [...schemas, (value: InferOutput<schemas[number]>, input: input) => result]): ReusableMatcher<input, WithReturn<Unset, result>, InferInput<schemas[number]>>;
+};
+type MatchAsyncFactory = {
+    <const input, output = Unset>(value: input): MatchExpressionAsync<input, output>;
+    input<input>(): ReusableMatcherAsync<input, Unset>;
+    output<output>(): ReusableMatcherAsync<unknown, output>;
+    case<input, schema extends StandardSchemaV1, result>(schema: schema, handler: (value: InferOutput<schema>, input: input) => result | Promise<result>): ReusableMatcherAsync<input, WithAsyncReturn<Unset, result>, InferInput<schema>>;
+    case<input, schema extends StandardSchemaV1, result>(schema: schema, predicate: (value: InferOutput<schema>, input: input) => unknown | Promise<unknown>, handler: (value: InferOutput<schema>, input: input) => result | Promise<result>): ReusableMatcherAsync<input, WithAsyncReturn<Unset, result>, InferInput<schema>>;
+    case<input, schemas extends readonly [StandardSchemaV1, ...StandardSchemaV1[]], result>(...args: [...schemas, (value: InferOutput<schemas[number]>, input: input) => result | Promise<result>]): ReusableMatcherAsync<input, WithAsyncReturn<Unset, result>, InferInput<schemas[number]>>;
+};
+export declare const match: MatchFactory;
+export declare const matchAsync: MatchAsyncFactory;
+declare class MatchExpression<input, output, CaseInputs = never> {
+    private input;
+    private matched;
+    private value;
+    private schemas;
+    constructor(input: input, matched: boolean, value: output | undefined);
+    case<schema extends StandardSchemaV1, result>(schema: schema, handler: (value: InferOutput<schema>, input: input) => result): MatchExpression<input, WithReturn<output, result>, CaseInputs | InferInput<schema>>;
+    case<schema extends StandardSchemaV1, result>(schema: schema, predicate: (value: InferOutput<schema>, input: input) => unknown, handler: (value: InferOutput<schema>, input: input) => result): MatchExpression<input, WithReturn<output, result>, CaseInputs | InferInput<schema>>;
+    case<schemas extends readonly [StandardSchemaV1, ...StandardSchemaV1[]], result>(...args: [...schemas, (value: InferOutput<schemas[number]>, input: input) => result]): MatchExpression<input, WithReturn<output, result>, CaseInputs | InferInput<schemas[number]>>;
+    when<result>(predicate: (value: input) => unknown, handler: (value: input, input: input) => result): MatchExpression<input, WithReturn<output, result>, CaseInputs>;
+    /**
+     * Terminates the match expression with a default behavior when no case matches.
+     *
+     * @overload `.default('assert')` — Throws a {@link NonExhaustiveError} if no case matched. Accepts any input.
+     * @overload `.default('never')` — Throws a {@link NonExhaustiveError} if no case matched. Produces a type error if the input doesn't match the union of case input types.
+     * @overload `.default('reject')` — Returns a {@link NonExhaustiveError} instance (instead of throwing) if no case matched. Accepts any input.
+     * @overload `.default(handler)` — Calls the handler with the input value if no case matched.
+     */
+    default(
+    /** Throw a {@link NonExhaustiveError} if no case matched. Accepts any input type. */
+    mode: 'assert'): output;
+    default(
+    /**
+     * Throw a {@link NonExhaustiveError} if no case matched.
+     * Constrains the input type to the union of all case schema input types —
+     * produces a compile-time error if the match input doesn't extend that union.
+     */
+    mode: input extends CaseInputs ? 'never' : never): output;
+    default(
+    /** Return a {@link NonExhaustiveError} instance (instead of throwing) if no case matched. */
+    mode: 'reject'): output | NonExhaustiveError;
+    default<result>(
+    /** A fallback handler called with the raw input when no case matched. */
+    handler: (value: input) => result): WithReturn<output, result>;
+    output<O>(): MatchExpression<input, O, CaseInputs>;
+    returnType(): this;
+    narrow(): this;
+}
+declare class MatchExpressionAsync<input, output, CaseInputs = never> {
+    private input;
+    private state;
+    private schemas;
+    constructor(input: input, state: Promise<MatchState<output>>, schemas?: StandardSchemaV1[]);
+    case<schema extends StandardSchemaV1, result>(schema: schema, handler: (value: InferOutput<schema>, input: input) => result | Promise<result>): MatchExpressionAsync<input, WithAsyncReturn<output, result>, CaseInputs | InferInput<schema>>;
+    case<schema extends StandardSchemaV1, result>(schema: schema, predicate: (value: InferOutput<schema>, input: input) => unknown | Promise<unknown>, handler: (value: InferOutput<schema>, input: input) => result | Promise<result>): MatchExpressionAsync<input, WithAsyncReturn<output, result>, CaseInputs | InferInput<schema>>;
+    case<schemas extends readonly [StandardSchemaV1, ...StandardSchemaV1[]], result>(...args: [...schemas, (value: InferOutput<schemas[number]>, input: input) => result | Promise<result>]): MatchExpressionAsync<input, WithAsyncReturn<output, result>, CaseInputs | InferInput<schemas[number]>>;
+    when<result>(predicate: (value: input) => unknown | Promise<unknown>, handler: (value: input, input: input) => result | Promise<result>): MatchExpressionAsync<input, WithAsyncReturn<output, result>, CaseInputs>;
+    /**
+     * Terminates the async match expression with a default behavior when no case matches.
+     *
+     * @overload `.default('assert')` — Throws a {@link NonExhaustiveError} if no case matched.
+     * @overload `.default('never')` — Throws a {@link NonExhaustiveError} if no case matched. Type error if input doesn't match case union.
+     * @overload `.default('reject')` — Resolves to a {@link NonExhaustiveError} instance if no case matched.
+     * @overload `.default(handler)` — Calls the handler with the input value if no case matched.
+     */
+    default(
+    /** Throw a {@link NonExhaustiveError} if no case matched. Accepts any input type. */
+    mode: 'assert'): Promise<output>;
+    default(
+    /**
+     * Throw a {@link NonExhaustiveError} if no case matched.
+     * Constrains the input type to the union of all case schema input types.
+     */
+    mode: input extends CaseInputs ? 'never' : never): Promise<output>;
+    default(
+    /** Resolve to a {@link NonExhaustiveError} instance if no case matched. */
+    mode: 'reject'): Promise<output | NonExhaustiveError>;
+    default<result>(
+    /** A fallback handler called with the raw input when no case matched. */
+    handler: (value: input) => result | Promise<result>): Promise<WithAsyncReturn<output, result>>;
+    output<O>(): MatchExpressionAsync<input, O, CaseInputs>;
+    returnType(): this;
+    narrow(): this;
+}
+type ReusableClause<input> = {
+    schemas: StandardSchemaV1[];
+    predicate?: (value: unknown, input: input) => unknown;
+    handler: (value: unknown, input: input) => unknown;
+};
+type ReusableWhenClause<input> = {
+    when: (input: input) => unknown;
+    handler: (value: input, input: input) => unknown;
+};
+declare class ReusableMatcher<input, output, CaseInputs = never> {
+    private readonly terminal;
+    private readonly clauses;
+    private dispatch;
+    /**
+     * Standard Schema V1 interface. The matcher itself is a valid standard-schema:
+     * - `validate(value)` tries all cases in order and returns `{ value }` on match or `{ issues }` on failure.
+     * - `types.input` is the union of all case schema input types (`CaseInputs`).
+     * - `types.output` is the union of all case handler return types.
+     */
+    readonly '~standard': StandardSchemaV1.Props<CaseInputs, ResolveOutput<output>>;
+    constructor(terminal: MatchState<output>, clauses?: Array<ReusableClause<input> | ReusableWhenClause<input>>);
+    private getDispatch;
+    case<schema extends StandardSchemaV1, result>(schema: schema, handler: (value: InferOutput<schema>, input: input) => result): ReusableMatcher<input, WithReturn<output, result>, CaseInputs | InferInput<schema>>;
+    case<schema extends StandardSchemaV1, result>(schema: schema, predicate: (value: InferOutput<schema>, input: input) => unknown, handler: (value: InferOutput<schema>, input: input) => result): ReusableMatcher<input, WithReturn<output, result>, CaseInputs | InferInput<schema>>;
+    case<schemas extends readonly [StandardSchemaV1, ...StandardSchemaV1[]], result>(...args: [...schemas, (value: InferOutput<schemas[number]>, input: input) => result]): ReusableMatcher<input, WithReturn<output, result>, CaseInputs | InferInput<schemas[number]>>;
+    when<result>(predicate: (value: input) => unknown, handler: (value: input, input: input) => result): ReusableMatcher<input, WithReturn<output, result>, CaseInputs>;
+    output<O>(): ReusableMatcher<input, O, CaseInputs>;
+    /**
+     * Terminates the reusable matcher and returns a function that executes the match.
+     *
+     * @overload `.default('assert')` — Returns a function that throws {@link NonExhaustiveError} on no match. Accepts `unknown` input.
+     * @overload `.default('never')` — Returns a function that throws {@link NonExhaustiveError} on no match. Input type is constrained to the union of case schema input types.
+     * @overload `.default('reject')` — Returns a function whose return type includes {@link NonExhaustiveError} (returned, not thrown) on no match.
+     * @overload `.default(handler)` — Returns a function that calls the handler on no match.
+     */
+    default(
+    /** Throw a {@link NonExhaustiveError} if no case matched. Accepts any input type. */
+    mode: 'assert'): (input: input) => output;
+    default(
+    /**
+     * Throw a {@link NonExhaustiveError} if no case matched.
+     * The returned function's input type is constrained to the union of all case schema input types.
+     */
+    mode: 'never'): (input: CaseInputs) => output;
+    default(
+    /** Return a {@link NonExhaustiveError} instance (instead of throwing) if no case matched. */
+    mode: 'reject'): (input: input) => output | NonExhaustiveError;
+    default<result>(
+    /** A fallback handler called with the raw input when no case matched. */
+    handler: (value: input) => result): (input: input) => WithReturn<output, result>;
+    private buildNonExhaustiveError;
+    /** Build a standard-schema FailureResult for use in `~standard.validate`. */
+    private buildFailureResult;
+    private execClause;
+    private exec;
+}
+type ReusableClauseAsync<input> = {
+    schemas: StandardSchemaV1[];
+    predicate?: (value: unknown, input: input) => unknown | Promise<unknown>;
+    handler: (value: unknown, input: input) => unknown | Promise<unknown>;
+};
+type ReusableWhenClauseAsync<input> = {
+    when: (input: input) => unknown | Promise<unknown>;
+    handler: (value: input, input: input) => unknown | Promise<unknown>;
+};
+declare class ReusableMatcherAsync<input, output, CaseInputs = never> {
+    private readonly terminal;
+    private readonly clauses;
+    private dispatch;
+    /**
+     * Standard Schema V1 interface (async). The matcher itself is a valid standard-schema:
+     * - `validate(value)` tries all cases in order and returns `Promise<{ value }>` on match or `Promise<{ issues }>` on failure.
+     * - `types.input` is the union of all case schema input types (`CaseInputs`).
+     * - `types.output` is the union of all case handler return types.
+     */
+    readonly '~standard': StandardSchemaV1.Props<CaseInputs, ResolveOutput<output>>;
+    constructor(terminal: Promise<MatchState<output>>, clauses?: Array<ReusableClauseAsync<input> | ReusableWhenClauseAsync<input>>);
+    private getDispatch;
+    case<schema extends StandardSchemaV1, result>(schema: schema, handler: (value: InferOutput<schema>, input: input) => result | Promise<result>): ReusableMatcherAsync<input, WithAsyncReturn<output, result>, CaseInputs | InferInput<schema>>;
+    case<schema extends StandardSchemaV1, result>(schema: schema, predicate: (value: InferOutput<schema>, input: input) => unknown | Promise<unknown>, handler: (value: InferOutput<schema>, input: input) => result | Promise<result>): ReusableMatcherAsync<input, WithAsyncReturn<output, result>, CaseInputs | InferInput<schema>>;
+    case<schemas extends readonly [StandardSchemaV1, ...StandardSchemaV1[]], result>(...args: [...schemas, (value: InferOutput<schemas[number]>, input: input) => result | Promise<result>]): ReusableMatcherAsync<input, WithAsyncReturn<output, result>, CaseInputs | InferInput<schemas[number]>>;
+    when<result>(predicate: (value: input) => unknown | Promise<unknown>, handler: (value: input, input: input) => result | Promise<result>): ReusableMatcherAsync<input, WithAsyncReturn<output, result>, CaseInputs>;
+    output<O>(): ReusableMatcherAsync<input, O, CaseInputs>;
+    /**
+     * Terminates the async reusable matcher and returns a function that executes the match.
+     *
+     * @overload `.default('assert')` — Returns an async function that throws {@link NonExhaustiveError} on no match.
+     * @overload `.default('never')` — Returns an async function that throws on no match, with input constrained to case union.
+     * @overload `.default('reject')` — Returns an async function that resolves to {@link NonExhaustiveError} on no match.
+     * @overload `.default(handler)` — Returns an async function that calls the handler on no match.
+     */
+    default(
+    /** Throw a {@link NonExhaustiveError} if no case matched. Accepts any input type. */
+    mode: 'assert'): (input: input) => Promise<output>;
+    default(
+    /**
+     * Throw a {@link NonExhaustiveError} if no case matched.
+     * The returned function's input type is constrained to the union of all case schema input types.
+     */
+    mode: 'never'): (input: CaseInputs) => Promise<output>;
+    default(
+    /** Resolve to a {@link NonExhaustiveError} instance if no case matched. */
+    mode: 'reject'): (input: input) => Promise<output | NonExhaustiveError>;
+    default<result>(
+    /** A fallback handler called with the raw input when no case matched. */
+    handler: (value: input) => result | Promise<result>): (input: input) => Promise<WithAsyncReturn<output, result>>;
+    private buildNonExhaustiveError;
+    /** Build a standard-schema FailureResult for use in `~standard.validate`. */
+    private buildFailureResult;
+    private execClause;
+    private exec;
+}
+export {};