@blade-hq/agent-client 1.1.1 → 1.1.2

package/node_modules/@ark/schema/out/parse.js

@@ -0,0 +1,215 @@
+import { domainDescriptions, entriesOf, flatMorph, hasDomain, isArray, isEmptyObject, printable, throwInternalError, throwParseError, unset } from "@ark/util";
+import { nodeClassesByKind, nodeImplementationsByKind } from "./kinds.js";
+import { Disjoint } from "./shared/disjoint.js";
+import { constraintKeys, defaultValueSerializer, isNodeKind, precedenceOfKind } from "./shared/implement.js";
+import { $ark } from "./shared/registry.js";
+import { hasArkKind, isNode } from "./shared/utils.js";
+export const schemaKindOf = (schema, allowedKinds) => {
+    const kind = discriminateRootKind(schema);
+    if (allowedKinds && !allowedKinds.includes(kind)) {
+        return throwParseError(`Root of kind ${kind} should be one of ${allowedKinds}`);
+    }
+    return kind;
+};
+const discriminateRootKind = (schema) => {
+    if (hasArkKind(schema, "root"))
+        return schema.kind;
+    if (typeof schema === "string") {
+        return (schema[0] === "$" ? "alias"
+            : schema in domainDescriptions ? "domain"
+                : "proto");
+    }
+    if (typeof schema === "function")
+        return "proto";
+    // throw at end of function
+    if (typeof schema !== "object" || schema === null)
+        return throwParseError(writeInvalidSchemaMessage(schema));
+    if ("morphs" in schema)
+        return "morph";
+    if ("branches" in schema || isArray(schema))
+        return "union";
+    if ("unit" in schema)
+        return "unit";
+    if ("reference" in schema)
+        return "alias";
+    const schemaKeys = Object.keys(schema);
+    if (schemaKeys.length === 0 || schemaKeys.some(k => k in constraintKeys))
+        return "intersection";
+    if ("proto" in schema)
+        return "proto";
+    if ("domain" in schema)
+        return "domain";
+    return throwParseError(writeInvalidSchemaMessage(schema));
+};
+export const writeInvalidSchemaMessage = (schema) => `${printable(schema)} is not a valid type schema`;
+const nodeCountsByPrefix = {};
+const serializeListableChild = (listableNode) => isArray(listableNode) ?
+    listableNode.map(node => node.collapsibleJson)
+    : listableNode.collapsibleJson;
+export const nodesByRegisteredId = {};
+$ark.nodesByRegisteredId = nodesByRegisteredId;
+export const registerNodeId = (prefix) => {
+    nodeCountsByPrefix[prefix] ??= 0;
+    return `${prefix}${++nodeCountsByPrefix[prefix]}`;
+};
+export const parseNode = (ctx) => {
+    const impl = nodeImplementationsByKind[ctx.kind];
+    const configuredSchema = impl.applyConfig?.(ctx.def, ctx.$.resolvedConfig) ?? ctx.def;
+    const inner = {};
+    const { meta: metaSchema, ...innerSchema } = configuredSchema;
+    const meta = metaSchema === undefined ? {}
+        : typeof metaSchema === "string" ? { description: metaSchema }
+            : metaSchema;
+    // ensure node entries are parsed in order of precedence, with non-children
+    // parsed first
+    const innerSchemaEntries = entriesOf(innerSchema)
+        .sort(([lKey], [rKey]) => isNodeKind(lKey) ?
+        isNodeKind(rKey) ? precedenceOfKind(lKey) - precedenceOfKind(rKey)
+            : 1
+        : isNodeKind(rKey) ? -1
+            : lKey < rKey ? -1
+                : 1)
+        .filter(([k, v]) => {
+        // move meta. prefixed props to meta, overwriting existing nested
+        // props of the same name if they exist
+        if (k.startsWith("meta.")) {
+            const metaKey = k.slice(5);
+            meta[metaKey] = v;
+            return false;
+        }
+        return true;
+    });
+    for (const entry of innerSchemaEntries) {
+        const k = entry[0];
+        const keyImpl = impl.keys[k];
+        if (!keyImpl)
+            return throwParseError(`Key ${k} is not valid on ${ctx.kind} schema`);
+        const v = keyImpl.parse ? keyImpl.parse(entry[1], ctx) : entry[1];
+        if (v !== unset && (v !== undefined || keyImpl.preserveUndefined))
+            inner[k] = v;
+    }
+    if (impl.reduce && !ctx.prereduced) {
+        const reduced = impl.reduce(inner, ctx.$);
+        if (reduced) {
+            if (reduced instanceof Disjoint)
+                return reduced.throw();
+            // we can't cache this reduction for now in case the reduction involved
+            // impliedSiblings
+            return withMeta(reduced, meta);
+        }
+    }
+    const node = createNode({
+        id: ctx.id,
+        kind: ctx.kind,
+        inner,
+        meta,
+        $: ctx.$
+    });
+    return node;
+};
+export const createNode = ({ id, kind, inner, meta, $, ignoreCache }) => {
+    const impl = nodeImplementationsByKind[kind];
+    const innerEntries = entriesOf(inner);
+    const children = [];
+    let innerJson = {};
+    for (const [k, v] of innerEntries) {
+        const keyImpl = impl.keys[k];
+        const serialize = keyImpl.serialize ??
+            (keyImpl.child ? serializeListableChild : defaultValueSerializer);
+        innerJson[k] = serialize(v);
+        if (keyImpl.child === true) {
+            const listableNode = v;
+            if (isArray(listableNode))
+                children.push(...listableNode);
+            else
+                children.push(listableNode);
+        }
+        else if (typeof keyImpl.child === "function")
+            children.push(...keyImpl.child(v));
+    }
+    if (impl.finalizeInnerJson)
+        innerJson = impl.finalizeInnerJson(innerJson);
+    let json = { ...innerJson };
+    let metaJson = {};
+    if (!isEmptyObject(meta)) {
+        metaJson = flatMorph(meta, (k, v) => [
+            k,
+            k === "examples" ? v : defaultValueSerializer(v)
+        ]);
+        json.meta = possiblyCollapse(metaJson, "description", true);
+    }
+    innerJson = possiblyCollapse(innerJson, impl.collapsibleKey, false);
+    const innerHash = JSON.stringify({ kind, ...innerJson });
+    json = possiblyCollapse(json, impl.collapsibleKey, false);
+    const collapsibleJson = possiblyCollapse(json, impl.collapsibleKey, true);
+    const hash = JSON.stringify({ kind, ...json });
+    // we have to wait until after reduction to return a cached entry,
+    // since reduction can add impliedSiblings
+    if ($.nodesByHash[hash] && !ignoreCache)
+        return $.nodesByHash[hash];
+    const attachments = {
+        id,
+        kind,
+        impl,
+        inner,
+        innerEntries,
+        innerJson,
+        innerHash,
+        meta,
+        metaJson,
+        json,
+        hash,
+        collapsibleJson: collapsibleJson,
+        children
+    };
+    if (kind !== "intersection") {
+        for (const k in inner)
+            if (k !== "in" && k !== "out")
+                attachments[k] = inner[k];
+    }
+    const node = new nodeClassesByKind[kind](attachments, $);
+    return ($.nodesByHash[hash] = node);
+};
+export const withId = (node, id) => {
+    if (node.id === id)
+        return node;
+    if (isNode(nodesByRegisteredId[id]))
+        throwInternalError(`Unexpected attempt to overwrite node id ${id}`);
+    // have to ignore cache to force creation of new potentially cyclic id
+    return createNode({
+        id,
+        kind: node.kind,
+        inner: node.inner,
+        meta: node.meta,
+        $: node.$,
+        ignoreCache: true
+    });
+};
+export const withMeta = (node, meta, id) => {
+    if (id && isNode(nodesByRegisteredId[id]))
+        throwInternalError(`Unexpected attempt to overwrite node id ${id}`);
+    return createNode({
+        id: id ?? registerNodeId(meta.alias ?? node.kind),
+        kind: node.kind,
+        inner: node.inner,
+        meta,
+        $: node.$
+    });
+};
+const possiblyCollapse = (json, toKey, allowPrimitive) => {
+    const collapsibleKeys = Object.keys(json);
+    if (collapsibleKeys.length === 1 && collapsibleKeys[0] === toKey) {
+        const collapsed = json[toKey];
+        if (allowPrimitive)
+            return collapsed;
+        if (
+        // if the collapsed value is still an object
+        hasDomain(collapsed, "object") &&
+            // and the JSON did not include any implied keys
+            (Object.keys(collapsed).length === 1 || Array.isArray(collapsed))) {
+            // we can replace it with its collapsed value
+            return collapsed;
+        }
+    }
+    return json;
+};

package/node_modules/@ark/schema/out/predicate.d.ts

@@ -0,0 +1,52 @@
+import { BaseConstraint } from "./constraint.ts";
+import type { NodeCompiler } from "./shared/compile.ts";
+import type { BaseErrorContext, BaseNormalizedSchema, declareNode } from "./shared/declare.ts";
+import { type nodeImplementationOf } from "./shared/implement.ts";
+import type { JsonSchema } from "./shared/jsonSchema.ts";
+import { type RegisteredReference } from "./shared/registry.ts";
+import type { ToJsonSchema } from "./shared/toJsonSchema.ts";
+import type { Traversal, TraverseAllows, TraverseApply } from "./shared/traversal.ts";
+export declare namespace Predicate {
+    type Schema<predicate extends Predicate = Predicate> = NormalizedSchema<predicate> | predicate;
+    interface NormalizedSchema<predicate extends Predicate = Predicate> extends BaseNormalizedSchema {
+        readonly predicate: predicate;
+    }
+    interface Inner<predicate extends Predicate = Predicate> {
+        readonly predicate: predicate;
+    }
+    interface ErrorContext extends BaseErrorContext<"predicate"> {
+        readonly predicate?: Predicate;
+    }
+    interface Declaration extends declareNode<{
+        kind: "predicate";
+        schema: Schema;
+        normalizedSchema: NormalizedSchema;
+        inner: Inner;
+        intersectionIsOpen: true;
+        errorContext: ErrorContext;
+    }> {
+    }
+    type Node = PredicateNode;
+}
+export declare class PredicateNode extends BaseConstraint<Predicate.Declaration> {
+    serializedPredicate: RegisteredReference;
+    compiledCondition: string;
+    compiledNegation: string;
+    impliedBasis: null;
+    expression: string;
+    traverseAllows: TraverseAllows;
+    errorContext: Predicate.ErrorContext;
+    compiledErrorContext: string;
+    traverseApply: TraverseApply;
+    compile(js: NodeCompiler): void;
+    reduceJsonSchema(base: JsonSchema.Constrainable, ctx: ToJsonSchema.Context): JsonSchema;
+}
+export declare const Predicate: {
+    implementation: nodeImplementationOf<Predicate.Declaration>;
+    Node: typeof PredicateNode;
+};
+export type Predicate<data = any> = (data: data, ctx: Traversal) => boolean;
+export declare namespace Predicate {
+    type Casted<input = never, narrowed extends input = input> = (input: input, ctx: Traversal) => input is narrowed;
+    type Castable<input = never, narrowed extends input = input> = Predicate<input> | Casted<input, narrowed>;
+}

package/node_modules/@ark/schema/out/predicate.js

@@ -0,0 +1,63 @@
+import { BaseConstraint } from "./constraint.js";
+import { compileObjectLiteral, implementNode } from "./shared/implement.js";
+import { registeredReference } from "./shared/registry.js";
+const implementation = implementNode({
+    kind: "predicate",
+    hasAssociatedError: true,
+    collapsibleKey: "predicate",
+    keys: {
+        predicate: {}
+    },
+    normalize: schema => typeof schema === "function" ? { predicate: schema } : schema,
+    defaults: {
+        description: node => `valid according to ${node.predicate.name || "an anonymous predicate"}`
+    },
+    intersectionIsOpen: true,
+    intersections: {
+        // as long as the narrows in l and r are individually safe to check
+        // in the order they're specified, checking them in the order
+        // resulting from this intersection should also be safe.
+        predicate: () => null
+    }
+});
+export class PredicateNode extends BaseConstraint {
+    serializedPredicate = registeredReference(this.predicate);
+    compiledCondition = `${this.serializedPredicate}(data, ctx)`;
+    compiledNegation = `!${this.compiledCondition}`;
+    impliedBasis = null;
+    expression = this.serializedPredicate;
+    traverseAllows = this.predicate;
+    errorContext = {
+        code: "predicate",
+        description: this.description,
+        meta: this.meta
+    };
+    compiledErrorContext = compileObjectLiteral(this.errorContext);
+    traverseApply = (data, ctx) => {
+        const errorCount = ctx.currentErrorCount;
+        if (!this.predicate(data, ctx.external) &&
+            ctx.currentErrorCount === errorCount)
+            ctx.errorFromNodeContext(this.errorContext);
+    };
+    compile(js) {
+        if (js.traversalKind === "Allows") {
+            js.return(this.compiledCondition);
+            return;
+        }
+        js.initializeErrorCount();
+        js.if(
+        // only add the default error if the predicate didn't add one itself
+        `${this.compiledNegation} && ctx.currentErrorCount === errorCount`, () => js.line(`ctx.errorFromNodeContext(${this.compiledErrorContext})`));
+    }
+    reduceJsonSchema(base, ctx) {
+        return ctx.fallback.predicate({
+            code: "predicate",
+            base,
+            predicate: this.predicate
+        });
+    }
+}
+export const Predicate = {
+    implementation,
+    Node: PredicateNode
+};

package/node_modules/@ark/schema/out/refinements/after.d.ts

@@ -0,0 +1,41 @@
+import type { BaseRoot } from "../roots/root.ts";
+import type { BaseErrorContext, declareNode } from "../shared/declare.ts";
+import { type nodeImplementationOf } from "../shared/implement.ts";
+import type { JsonSchema } from "../shared/jsonSchema.ts";
+import type { ToJsonSchema } from "../shared/toJsonSchema.ts";
+import type { TraverseAllows } from "../shared/traversal.ts";
+import { BaseRange, type BaseRangeInner, type LimitSchemaValue, type UnknownExpandedRangeSchema, type UnknownNormalizedRangeSchema } from "./range.ts";
+export declare namespace After {
+    interface Inner extends BaseRangeInner {
+        rule: Date;
+    }
+    interface NormalizedSchema extends UnknownNormalizedRangeSchema {
+        rule: LimitSchemaValue;
+    }
+    interface ExpandedSchema extends UnknownExpandedRangeSchema {
+        rule: LimitSchemaValue;
+    }
+    type Schema = ExpandedSchema | LimitSchemaValue;
+    interface ErrorContext extends BaseErrorContext<"after">, Inner {
+    }
+    interface Declaration extends declareNode<{
+        kind: "after";
+        schema: Schema;
+        normalizedSchema: NormalizedSchema;
+        inner: Inner;
+        prerequisite: Date;
+        errorContext: ErrorContext;
+    }> {
+    }
+    type Node = AfterNode;
+}
+export declare class AfterNode extends BaseRange<After.Declaration> {
+    impliedBasis: BaseRoot;
+    collapsibleLimitString: string;
+    traverseAllows: TraverseAllows<Date>;
+    reduceJsonSchema(base: JsonSchema, ctx: ToJsonSchema.Context): JsonSchema;
+}
+export declare const After: {
+    implementation: nodeImplementationOf<After.Declaration>;
+    Node: typeof AfterNode;
+};

package/node_modules/@ark/schema/out/refinements/after.js

@@ -0,0 +1,35 @@
+import { describeCollapsibleDate } from "@ark/util";
+import { implementNode } from "../shared/implement.js";
+import { $ark } from "../shared/registry.js";
+import { BaseRange, createDateSchemaNormalizer, parseDateLimit } from "./range.js";
+const implementation = implementNode({
+    kind: "after",
+    collapsibleKey: "rule",
+    hasAssociatedError: true,
+    keys: {
+        rule: {
+            parse: parseDateLimit,
+            serialize: schema => schema.toISOString()
+        }
+    },
+    normalize: createDateSchemaNormalizer("after"),
+    defaults: {
+        description: node => `${node.collapsibleLimitString} or later`,
+        actual: describeCollapsibleDate
+    },
+    intersections: {
+        after: (l, r) => (l.isStricterThan(r) ? l : r)
+    }
+});
+export class AfterNode extends BaseRange {
+    impliedBasis = $ark.intrinsic.Date.internal;
+    collapsibleLimitString = describeCollapsibleDate(this.rule);
+    traverseAllows = data => data >= this.rule;
+    reduceJsonSchema(base, ctx) {
+        return ctx.fallback.date({ code: "date", base, after: this.rule });
+    }
+}
+export const After = {
+    implementation,
+    Node: AfterNode
+};

package/node_modules/@ark/schema/out/refinements/before.d.ts

@@ -0,0 +1,41 @@
+import type { BaseRoot } from "../roots/root.ts";
+import type { BaseErrorContext, declareNode } from "../shared/declare.ts";
+import { type nodeImplementationOf } from "../shared/implement.ts";
+import type { JsonSchema } from "../shared/jsonSchema.ts";
+import type { ToJsonSchema } from "../shared/toJsonSchema.ts";
+import type { TraverseAllows } from "../shared/traversal.ts";
+import { BaseRange, type BaseRangeInner, type LimitSchemaValue, type UnknownExpandedRangeSchema, type UnknownNormalizedRangeSchema } from "./range.ts";
+export declare namespace Before {
+    interface Inner extends BaseRangeInner {
+        rule: Date;
+    }
+    interface NormalizedSchema extends UnknownNormalizedRangeSchema {
+        rule: LimitSchemaValue;
+    }
+    interface ExpandedSchema extends UnknownExpandedRangeSchema {
+        rule: LimitSchemaValue;
+    }
+    type Schema = ExpandedSchema | LimitSchemaValue;
+    interface ErrorContext extends BaseErrorContext<"before">, Inner {
+    }
+    interface Declaration extends declareNode<{
+        kind: "before";
+        schema: Schema;
+        normalizedSchema: NormalizedSchema;
+        inner: Inner;
+        prerequisite: Date;
+        errorContext: ErrorContext;
+    }> {
+    }
+    type Node = BeforeNode;
+}
+export declare class BeforeNode extends BaseRange<Before.Declaration> {
+    collapsibleLimitString: string;
+    traverseAllows: TraverseAllows<Date>;
+    impliedBasis: BaseRoot;
+    reduceJsonSchema(base: JsonSchema, ctx: ToJsonSchema.Context): JsonSchema;
+}
+export declare const Before: {
+    implementation: nodeImplementationOf<Before.Declaration>;
+    Node: typeof BeforeNode;
+};

package/node_modules/@ark/schema/out/refinements/before.js

@@ -0,0 +1,41 @@
+import { describeCollapsibleDate } from "@ark/util";
+import { Disjoint } from "../shared/disjoint.js";
+import { implementNode } from "../shared/implement.js";
+import { $ark } from "../shared/registry.js";
+import { BaseRange, createDateSchemaNormalizer, parseDateLimit } from "./range.js";
+const implementation = implementNode({
+    kind: "before",
+    collapsibleKey: "rule",
+    hasAssociatedError: true,
+    keys: {
+        rule: {
+            parse: parseDateLimit,
+            serialize: schema => schema.toISOString()
+        }
+    },
+    normalize: createDateSchemaNormalizer("before"),
+    defaults: {
+        description: node => `${node.collapsibleLimitString} or earlier`,
+        actual: describeCollapsibleDate
+    },
+    intersections: {
+        before: (l, r) => (l.isStricterThan(r) ? l : r),
+        after: (before, after, ctx) => before.overlapsRange(after) ?
+            before.overlapIsUnit(after) ?
+                ctx.$.node("unit", { unit: before.rule })
+                : null
+            : Disjoint.init("range", before, after)
+    }
+});
+export class BeforeNode extends BaseRange {
+    collapsibleLimitString = describeCollapsibleDate(this.rule);
+    traverseAllows = data => data <= this.rule;
+    impliedBasis = $ark.intrinsic.Date.internal;
+    reduceJsonSchema(base, ctx) {
+        return ctx.fallback.date({ code: "date", base, before: this.rule });
+    }
+}
+export const Before = {
+    implementation,
+    Node: BeforeNode
+};

package/node_modules/@ark/schema/out/refinements/divisor.d.ts

@@ -0,0 +1,43 @@
+import { InternalPrimitiveConstraint, writeInvalidOperandMessage } from "../constraint.ts";
+import type { BaseRoot } from "../roots/root.ts";
+import type { BaseErrorContext, BaseNormalizedSchema, declareNode } from "../shared/declare.ts";
+import { type nodeImplementationOf } from "../shared/implement.ts";
+import type { JsonSchema } from "../shared/jsonSchema.ts";
+import type { TraverseAllows } from "../shared/traversal.ts";
+export declare namespace Divisor {
+    interface Inner {
+        readonly rule: number;
+    }
+    interface NormalizedSchema extends BaseNormalizedSchema {
+        readonly rule: number;
+    }
+    type Schema = NormalizedSchema | number;
+    interface ErrorContext extends BaseErrorContext<"divisor">, Inner {
+    }
+    interface Declaration extends declareNode<{
+        kind: "divisor";
+        schema: Schema;
+        normalizedSchema: NormalizedSchema;
+        inner: Inner;
+        prerequisite: number;
+        errorContext: ErrorContext;
+    }> {
+    }
+    type Node = DivisorNode;
+}
+export declare class DivisorNode extends InternalPrimitiveConstraint<Divisor.Declaration> {
+    traverseAllows: TraverseAllows<number>;
+    readonly compiledCondition: string;
+    readonly compiledNegation: string;
+    readonly impliedBasis: BaseRoot;
+    readonly expression: string;
+    reduceJsonSchema(schema: JsonSchema.Numeric): JsonSchema.Numeric;
+}
+export declare const Divisor: {
+    implementation: nodeImplementationOf<Divisor.Declaration>;
+    Node: typeof DivisorNode;
+};
+export declare const writeIndivisibleMessage: (t: BaseRoot) => string;
+export type writeIndivisibleMessage<actual> = writeInvalidOperandMessage<"divisor", actual>;
+export declare const writeNonIntegerDivisorMessage: <divisor extends number>(divisor: divisor) => writeNonIntegerDivisorMessage<divisor>;
+export type writeNonIntegerDivisorMessage<divisor extends number> = `divisor must be an integer (was ${divisor})`;

package/node_modules/@ark/schema/out/refinements/divisor.js

@@ -0,0 +1,58 @@
+import { throwParseError } from "@ark/util";
+import { InternalPrimitiveConstraint, writeInvalidOperandMessage } from "../constraint.js";
+import { implementNode } from "../shared/implement.js";
+import { $ark } from "../shared/registry.js";
+const implementation = implementNode({
+    kind: "divisor",
+    collapsibleKey: "rule",
+    keys: {
+        rule: {
+            parse: divisor => Number.isInteger(divisor) ? divisor : (throwParseError(writeNonIntegerDivisorMessage(divisor)))
+        }
+    },
+    normalize: schema => typeof schema === "number" ? { rule: schema } : schema,
+    hasAssociatedError: true,
+    defaults: {
+        description: node => node.rule === 1 ? "an integer"
+            : node.rule === 2 ? "even"
+                : `a multiple of ${node.rule}`
+    },
+    intersections: {
+        divisor: (l, r, ctx) => ctx.$.node("divisor", {
+            rule: Math.abs((l.rule * r.rule) / greatestCommonDivisor(l.rule, r.rule))
+        })
+    },
+    obviatesBasisDescription: true
+});
+export class DivisorNode extends InternalPrimitiveConstraint {
+    traverseAllows = data => data % this.rule === 0;
+    compiledCondition = `data % ${this.rule} === 0`;
+    compiledNegation = `data % ${this.rule} !== 0`;
+    impliedBasis = $ark.intrinsic.number.internal;
+    expression = `% ${this.rule}`;
+    reduceJsonSchema(schema) {
+        schema.type = "integer";
+        if (this.rule === 1)
+            return schema;
+        schema.multipleOf = this.rule;
+        return schema;
+    }
+}
+export const Divisor = {
+    implementation,
+    Node: DivisorNode
+};
+export const writeIndivisibleMessage = (t) => writeInvalidOperandMessage("divisor", $ark.intrinsic.number, t);
+export const writeNonIntegerDivisorMessage = (divisor) => `divisor must be an integer (was ${divisor})`;
+// https://en.wikipedia.org/wiki/Euclidean_algorithm
+const greatestCommonDivisor = (l, r) => {
+    let previous;
+    let greatestCommonDivisor = l;
+    let current = r;
+    while (current !== 0) {
+        previous = current;
+        current = greatestCommonDivisor % current;
+        greatestCommonDivisor = previous;
+    }
+    return greatestCommonDivisor;
+};

package/node_modules/@ark/schema/out/refinements/exactLength.d.ts

@@ -0,0 +1,49 @@
+import { InternalPrimitiveConstraint } from "../constraint.ts";
+import type { BaseRoot } from "../roots/root.ts";
+import type { BaseErrorContext, BaseNormalizedSchema, declareNode } from "../shared/declare.ts";
+import { type nodeImplementationOf } from "../shared/implement.ts";
+import type { JsonSchema } from "../shared/jsonSchema.ts";
+import type { TraverseAllows } from "../shared/traversal.ts";
+import { type LengthBoundableData } from "./range.ts";
+export declare namespace ExactLength {
+    interface Inner {
+        readonly rule: number;
+    }
+    interface NormalizedSchema extends BaseNormalizedSchema {
+        readonly rule: number;
+    }
+    type Schema = NormalizedSchema | number;
+    interface ErrorContext extends BaseErrorContext<"exactLength">, Inner {
+    }
+    type Declaration = declareNode<{
+        kind: "exactLength";
+        schema: Schema;
+        normalizedSchema: NormalizedSchema;
+        inner: Inner;
+        prerequisite: LengthBoundableData;
+        errorContext: ErrorContext;
+    }>;
+    type Node = ExactLengthNode;
+}
+export declare class ExactLengthNode extends InternalPrimitiveConstraint<ExactLength.Declaration> {
+    traverseAllows: TraverseAllows<LengthBoundableData>;
+    readonly compiledCondition: string;
+    readonly compiledNegation: string;
+    readonly impliedBasis: BaseRoot;
+    readonly expression: string;
+    reduceJsonSchema(schema: JsonSchema.LengthBoundable): JsonSchema.LengthBoundable;
+}
+export declare const ExactLength: {
+    implementation: nodeImplementationOf<{
+        intersectionIsOpen: false;
+        childKind: never;
+        reducibleTo: "exactLength";
+        kind: "exactLength";
+        schema: ExactLength.Schema;
+        normalizedSchema: ExactLength.NormalizedSchema;
+        inner: ExactLength.Inner;
+        prerequisite: LengthBoundableData;
+        errorContext: ExactLength.ErrorContext;
+    }>;
+    Node: typeof ExactLengthNode;
+};