@blade-hq/agent-client 1.1.1 → 1.1.3

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

@@ -0,0 +1,55 @@
+import { InternalPrimitiveConstraint } from "../constraint.js";
+import { Disjoint } from "../shared/disjoint.js";
+import { implementNode } from "../shared/implement.js";
+import { $ark } from "../shared/registry.js";
+import { ToJsonSchema } from "../shared/toJsonSchema.js";
+import { createLengthRuleParser } from "./range.js";
+const implementation = implementNode({
+    kind: "exactLength",
+    collapsibleKey: "rule",
+    keys: {
+        rule: {
+            parse: createLengthRuleParser("exactLength")
+        }
+    },
+    normalize: schema => typeof schema === "number" ? { rule: schema } : schema,
+    hasAssociatedError: true,
+    defaults: {
+        description: node => `exactly length ${node.rule}`,
+        actual: data => `${data.length}`
+    },
+    intersections: {
+        exactLength: (l, r, ctx) => Disjoint.init("unit", ctx.$.node("unit", { unit: l.rule }), ctx.$.node("unit", { unit: r.rule }), { path: ["length"] }),
+        minLength: (exactLength, minLength) => exactLength.rule >= minLength.rule ?
+            exactLength
+            : Disjoint.init("range", exactLength, minLength),
+        maxLength: (exactLength, maxLength) => exactLength.rule <= maxLength.rule ?
+            exactLength
+            : Disjoint.init("range", exactLength, maxLength)
+    }
+});
+export class ExactLengthNode extends InternalPrimitiveConstraint {
+    traverseAllows = data => data.length === this.rule;
+    compiledCondition = `data.length === ${this.rule}`;
+    compiledNegation = `data.length !== ${this.rule}`;
+    impliedBasis = $ark.intrinsic.lengthBoundable.internal;
+    expression = `== ${this.rule}`;
+    reduceJsonSchema(schema) {
+        switch (schema.type) {
+            case "string":
+                schema.minLength = this.rule;
+                schema.maxLength = this.rule;
+                return schema;
+            case "array":
+                schema.minItems = this.rule;
+                schema.maxItems = this.rule;
+                return schema;
+            default:
+                return ToJsonSchema.throwInternalOperandError("exactLength", schema);
+        }
+    }
+}
+export const ExactLength = {
+    implementation,
+    Node: ExactLengthNode
+};

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

@@ -0,0 +1,34 @@
+import type { BaseConstraint } from "../constraint.ts";
+import type { nodeImplementationOf } from "../shared/implement.ts";
+import { After } from "./after.ts";
+import { Before } from "./before.ts";
+import { ExactLength } from "./exactLength.ts";
+import { Max } from "./max.ts";
+import { MaxLength } from "./maxLength.ts";
+import { Min } from "./min.ts";
+import { MinLength } from "./minLength.ts";
+export interface BoundDeclarations {
+    min: Min.Declaration;
+    max: Max.Declaration;
+    minLength: MinLength.Declaration;
+    maxLength: MaxLength.Declaration;
+    exactLength: ExactLength.Declaration;
+    after: After.Declaration;
+    before: Before.Declaration;
+}
+export interface BoundNodesByKind {
+    min: Min.Node;
+    max: Max.Node;
+    minLength: MinLength.Node;
+    maxLength: MaxLength.Node;
+    exactLength: ExactLength.Node;
+    after: After.Node;
+    before: Before.Node;
+}
+export type BoundKind = keyof BoundDeclarations;
+export type RangeKind = Exclude<BoundKind, "exactLength">;
+export type boundImplementationsByKind = {
+    [k in BoundKind]: nodeImplementationOf<BoundDeclarations[k]>;
+};
+export declare const boundImplementationsByKind: boundImplementationsByKind;
+export declare const boundClassesByKind: Record<BoundKind, typeof BaseConstraint<any>>;

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

@@ -0,0 +1,25 @@
+import { After } from "./after.js";
+import { Before } from "./before.js";
+import { ExactLength } from "./exactLength.js";
+import { Max } from "./max.js";
+import { MaxLength } from "./maxLength.js";
+import { Min } from "./min.js";
+import { MinLength } from "./minLength.js";
+export const boundImplementationsByKind = {
+    min: Min.implementation,
+    max: Max.implementation,
+    minLength: MinLength.implementation,
+    maxLength: MaxLength.implementation,
+    exactLength: ExactLength.implementation,
+    after: After.implementation,
+    before: Before.implementation
+};
+export const boundClassesByKind = {
+    min: Min.Node,
+    max: Max.Node,
+    minLength: MinLength.Node,
+    maxLength: MaxLength.Node,
+    exactLength: ExactLength.Node,
+    after: After.Node,
+    before: Before.Node
+};

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

@@ -0,0 +1,37 @@
+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 { TraverseAllows } from "../shared/traversal.ts";
+import { BaseRange, type BaseRangeInner, type UnknownExpandedRangeSchema } from "./range.ts";
+export declare namespace Max {
+    interface Inner extends BaseRangeInner {
+        rule: number;
+        exclusive?: true;
+    }
+    interface NormalizedSchema extends UnknownExpandedRangeSchema {
+        rule: number;
+    }
+    type Schema = NormalizedSchema | number;
+    interface ErrorContext extends BaseErrorContext<"max">, Inner {
+    }
+    interface Declaration extends declareNode<{
+        kind: "max";
+        schema: Schema;
+        normalizedSchema: NormalizedSchema;
+        inner: Inner;
+        prerequisite: number;
+        errorContext: ErrorContext;
+    }> {
+    }
+    type Node = MaxNode;
+}
+export declare class MaxNode extends BaseRange<Max.Declaration> {
+    impliedBasis: BaseRoot;
+    traverseAllows: TraverseAllows<number>;
+    reduceJsonSchema(schema: JsonSchema.Numeric): JsonSchema.Numeric;
+}
+export declare const Max: {
+    implementation: nodeImplementationOf<Max.Declaration>;
+    Node: typeof MaxNode;
+};

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

@@ -0,0 +1,45 @@
+import { Disjoint } from "../shared/disjoint.js";
+import { implementNode } from "../shared/implement.js";
+import { $ark } from "../shared/registry.js";
+import { BaseRange, parseExclusiveKey } from "./range.js";
+const implementation = implementNode({
+    kind: "max",
+    collapsibleKey: "rule",
+    hasAssociatedError: true,
+    keys: {
+        rule: {},
+        exclusive: parseExclusiveKey
+    },
+    normalize: schema => typeof schema === "number" ? { rule: schema } : schema,
+    defaults: {
+        description: node => {
+            if (node.rule === 0)
+                return node.exclusive ? "negative" : "non-positive";
+            return `${node.exclusive ? "less than" : "at most"} ${node.rule}`;
+        }
+    },
+    intersections: {
+        max: (l, r) => (l.isStricterThan(r) ? l : r),
+        min: (max, min, ctx) => max.overlapsRange(min) ?
+            max.overlapIsUnit(min) ?
+                ctx.$.node("unit", { unit: max.rule })
+                : null
+            : Disjoint.init("range", max, min)
+    },
+    obviatesBasisDescription: true
+});
+export class MaxNode extends BaseRange {
+    impliedBasis = $ark.intrinsic.number.internal;
+    traverseAllows = this.exclusive ? data => data < this.rule : data => data <= this.rule;
+    reduceJsonSchema(schema) {
+        if (this.exclusive)
+            schema.exclusiveMaximum = this.rule;
+        else
+            schema.maximum = this.rule;
+        return schema;
+    }
+}
+export const Max = {
+    implementation,
+    Node: MaxNode
+};

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

@@ -0,0 +1,40 @@
+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 { TraverseAllows } from "../shared/traversal.ts";
+import { BaseRange, type BaseRangeInner, type LengthBoundableData, type UnknownExpandedRangeSchema, type UnknownNormalizedRangeSchema } from "./range.ts";
+export declare namespace MaxLength {
+    interface Inner extends BaseRangeInner {
+        rule: number;
+    }
+    interface NormalizedSchema extends UnknownNormalizedRangeSchema {
+        rule: number;
+    }
+    interface ExpandedSchema extends UnknownExpandedRangeSchema {
+        rule: number;
+    }
+    type Schema = ExpandedSchema | number;
+    interface ErrorContext extends BaseErrorContext<"maxLength">, Inner {
+    }
+    interface Declaration extends declareNode<{
+        kind: "maxLength";
+        schema: Schema;
+        reducibleTo: "exactLength";
+        normalizedSchema: NormalizedSchema;
+        inner: Inner;
+        prerequisite: LengthBoundableData;
+        errorContext: ErrorContext;
+    }> {
+    }
+    type Node = MaxLengthNode;
+}
+export declare class MaxLengthNode extends BaseRange<MaxLength.Declaration> {
+    readonly impliedBasis: BaseRoot;
+    traverseAllows: TraverseAllows<LengthBoundableData>;
+    reduceJsonSchema(schema: JsonSchema.LengthBoundable): JsonSchema.LengthBoundable;
+}
+export declare const MaxLength: {
+    implementation: nodeImplementationOf<MaxLength.Declaration>;
+    Node: typeof MaxLengthNode;
+};

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

@@ -0,0 +1,49 @@
+import { Disjoint } from "../shared/disjoint.js";
+import { implementNode } from "../shared/implement.js";
+import { $ark } from "../shared/registry.js";
+import { ToJsonSchema } from "../shared/toJsonSchema.js";
+import { BaseRange, createLengthRuleParser, createLengthSchemaNormalizer } from "./range.js";
+const implementation = implementNode({
+    kind: "maxLength",
+    collapsibleKey: "rule",
+    hasAssociatedError: true,
+    keys: {
+        rule: {
+            parse: createLengthRuleParser("maxLength")
+        }
+    },
+    reduce: (inner, $) => inner.rule === 0 ? $.node("exactLength", inner) : undefined,
+    normalize: createLengthSchemaNormalizer("maxLength"),
+    defaults: {
+        description: node => `at most length ${node.rule}`,
+        actual: data => `${data.length}`
+    },
+    intersections: {
+        maxLength: (l, r) => (l.isStricterThan(r) ? l : r),
+        minLength: (max, min, ctx) => max.overlapsRange(min) ?
+            max.overlapIsUnit(min) ?
+                ctx.$.node("exactLength", { rule: max.rule })
+                : null
+            : Disjoint.init("range", max, min)
+    }
+});
+export class MaxLengthNode extends BaseRange {
+    impliedBasis = $ark.intrinsic.lengthBoundable.internal;
+    traverseAllows = data => data.length <= this.rule;
+    reduceJsonSchema(schema) {
+        switch (schema.type) {
+            case "string":
+                schema.maxLength = this.rule;
+                return schema;
+            case "array":
+                schema.maxItems = this.rule;
+                return schema;
+            default:
+                return ToJsonSchema.throwInternalOperandError("maxLength", schema);
+        }
+    }
+}
+export const MaxLength = {
+    implementation,
+    Node: MaxLengthNode
+};

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

@@ -0,0 +1,37 @@
+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 { TraverseAllows } from "../shared/traversal.ts";
+import { BaseRange, type BaseRangeInner, type UnknownExpandedRangeSchema } from "./range.ts";
+export declare namespace Min {
+    interface Inner extends BaseRangeInner {
+        rule: number;
+        exclusive?: true;
+    }
+    interface NormalizedSchema extends UnknownExpandedRangeSchema {
+        rule: number;
+    }
+    type Schema = NormalizedSchema | number;
+    interface ErrorContext extends BaseErrorContext<"min">, Inner {
+    }
+    interface Declaration extends declareNode<{
+        kind: "min";
+        schema: Schema;
+        normalizedSchema: NormalizedSchema;
+        inner: Inner;
+        prerequisite: number;
+        errorContext: ErrorContext;
+    }> {
+    }
+    type Node = MinNode;
+}
+export declare class MinNode extends BaseRange<Min.Declaration> {
+    readonly impliedBasis: BaseRoot;
+    traverseAllows: TraverseAllows<number>;
+    reduceJsonSchema(schema: JsonSchema.Numeric): JsonSchema.Numeric;
+}
+export declare const Min: {
+    implementation: nodeImplementationOf<Min.Declaration>;
+    Node: typeof MinNode;
+};

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

@@ -0,0 +1,39 @@
+import { implementNode } from "../shared/implement.js";
+import { $ark } from "../shared/registry.js";
+import { BaseRange, parseExclusiveKey } from "./range.js";
+const implementation = implementNode({
+    kind: "min",
+    collapsibleKey: "rule",
+    hasAssociatedError: true,
+    keys: {
+        rule: {},
+        exclusive: parseExclusiveKey
+    },
+    normalize: schema => typeof schema === "number" ? { rule: schema } : schema,
+    defaults: {
+        description: node => {
+            if (node.rule === 0)
+                return node.exclusive ? "positive" : "non-negative";
+            return `${node.exclusive ? "more than" : "at least"} ${node.rule}`;
+        }
+    },
+    intersections: {
+        min: (l, r) => (l.isStricterThan(r) ? l : r)
+    },
+    obviatesBasisDescription: true
+});
+export class MinNode extends BaseRange {
+    impliedBasis = $ark.intrinsic.number.internal;
+    traverseAllows = this.exclusive ? data => data > this.rule : data => data >= this.rule;
+    reduceJsonSchema(schema) {
+        if (this.exclusive)
+            schema.exclusiveMinimum = this.rule;
+        else
+            schema.minimum = this.rule;
+        return schema;
+    }
+}
+export const Min = {
+    implementation,
+    Node: MinNode
+};

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

@@ -0,0 +1,40 @@
+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 { TraverseAllows } from "../shared/traversal.ts";
+import { BaseRange, type BaseRangeInner, type LengthBoundableData, type UnknownExpandedRangeSchema, type UnknownNormalizedRangeSchema } from "./range.ts";
+export declare namespace MinLength {
+    interface Inner extends BaseRangeInner {
+        rule: number;
+    }
+    interface NormalizedSchema extends UnknownNormalizedRangeSchema {
+        rule: number;
+    }
+    interface ExpandedSchema extends UnknownExpandedRangeSchema {
+        rule: number;
+    }
+    type Schema = ExpandedSchema | number;
+    interface ErrorContext extends BaseErrorContext<"minLength">, Inner {
+    }
+    interface Declaration extends declareNode<{
+        kind: "minLength";
+        schema: Schema;
+        normalizedSchema: NormalizedSchema;
+        inner: Inner;
+        prerequisite: LengthBoundableData;
+        reducibleTo: "intersection";
+        errorContext: ErrorContext;
+    }> {
+    }
+    type Node = MinLengthNode;
+}
+export declare class MinLengthNode extends BaseRange<MinLength.Declaration> {
+    readonly impliedBasis: BaseRoot;
+    traverseAllows: TraverseAllows<LengthBoundableData>;
+    reduceJsonSchema(schema: JsonSchema.LengthBoundable): JsonSchema.LengthBoundable;
+}
+export declare const MinLength: {
+    implementation: nodeImplementationOf<MinLength.Declaration>;
+    Node: typeof MinLengthNode;
+};

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

@@ -0,0 +1,47 @@
+import { implementNode } from "../shared/implement.js";
+import { $ark } from "../shared/registry.js";
+import { ToJsonSchema } from "../shared/toJsonSchema.js";
+import { BaseRange, createLengthRuleParser, createLengthSchemaNormalizer } from "./range.js";
+const implementation = implementNode({
+    kind: "minLength",
+    collapsibleKey: "rule",
+    hasAssociatedError: true,
+    keys: {
+        rule: {
+            parse: createLengthRuleParser("minLength")
+        }
+    },
+    reduce: inner => inner.rule === 0 ?
+        // a minimum length of zero is trivially satisfied
+        $ark.intrinsic.unknown
+        : undefined,
+    normalize: createLengthSchemaNormalizer("minLength"),
+    defaults: {
+        description: node => node.rule === 1 ? "non-empty" : `at least length ${node.rule}`,
+        // avoid default message like "must be non-empty (was 0)"
+        actual: data => (data.length === 0 ? "" : `${data.length}`)
+    },
+    intersections: {
+        minLength: (l, r) => (l.isStricterThan(r) ? l : r)
+    }
+});
+export class MinLengthNode extends BaseRange {
+    impliedBasis = $ark.intrinsic.lengthBoundable.internal;
+    traverseAllows = data => data.length >= this.rule;
+    reduceJsonSchema(schema) {
+        switch (schema.type) {
+            case "string":
+                schema.minLength = this.rule;
+                return schema;
+            case "array":
+                schema.minItems = this.rule;
+                return schema;
+            default:
+                return ToJsonSchema.throwInternalOperandError("minLength", schema);
+        }
+    }
+}
+export const MinLength = {
+    implementation,
+    Node: MinLengthNode
+};

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

@@ -0,0 +1,43 @@
+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 { ToJsonSchema } from "../shared/toJsonSchema.ts";
+export declare namespace Pattern {
+    interface NormalizedSchema extends BaseNormalizedSchema {
+        readonly rule: string;
+        readonly flags?: string;
+    }
+    interface Inner {
+        readonly rule: string;
+        readonly flags?: string;
+    }
+    type Schema = NormalizedSchema | string | RegExp;
+    interface ErrorContext extends BaseErrorContext<"pattern">, Inner {
+    }
+    interface Declaration extends declareNode<{
+        kind: "pattern";
+        schema: Schema;
+        normalizedSchema: NormalizedSchema;
+        inner: Inner;
+        intersectionIsOpen: true;
+        prerequisite: string;
+        errorContext: ErrorContext;
+    }> {
+    }
+    type Node = PatternNode;
+}
+export declare class PatternNode extends InternalPrimitiveConstraint<Pattern.Declaration> {
+    readonly instance: RegExp;
+    readonly expression: string;
+    traverseAllows: (string: string) => boolean;
+    readonly compiledCondition: string;
+    readonly compiledNegation: string;
+    readonly impliedBasis: BaseRoot;
+    reduceJsonSchema(base: JsonSchema.String, ctx: ToJsonSchema.Context): JsonSchema.String;
+}
+export declare const Pattern: {
+    implementation: nodeImplementationOf<Pattern.Declaration>;
+    Node: typeof PatternNode;
+};

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

@@ -0,0 +1,52 @@
+import { InternalPrimitiveConstraint } from "../constraint.js";
+import { implementNode } from "../shared/implement.js";
+import { $ark } from "../shared/registry.js";
+const implementation = implementNode({
+    kind: "pattern",
+    collapsibleKey: "rule",
+    keys: {
+        rule: {},
+        flags: {}
+    },
+    normalize: schema => typeof schema === "string" ? { rule: schema }
+        : schema instanceof RegExp ?
+            schema.flags ?
+                { rule: schema.source, flags: schema.flags }
+                : { rule: schema.source }
+            : schema,
+    obviatesBasisDescription: true,
+    obviatesBasisExpression: true,
+    hasAssociatedError: true,
+    intersectionIsOpen: true,
+    defaults: {
+        description: node => `matched by ${node.rule}`
+    },
+    intersections: {
+        // for now, non-equal regex are naively intersected:
+        // https://github.com/arktypeio/arktype/issues/853
+        pattern: () => null
+    }
+});
+export class PatternNode extends InternalPrimitiveConstraint {
+    instance = new RegExp(this.rule, this.flags);
+    expression = `${this.instance}`;
+    traverseAllows = this.instance.test.bind(this.instance);
+    compiledCondition = `${this.expression}.test(data)`;
+    compiledNegation = `!${this.compiledCondition}`;
+    impliedBasis = $ark.intrinsic.string.internal;
+    reduceJsonSchema(base, ctx) {
+        if (base.pattern) {
+            return ctx.fallback.patternIntersection({
+                code: "patternIntersection",
+                base: base,
+                pattern: this.rule
+            });
+        }
+        base.pattern = this.rule;
+        return base;
+    }
+}
+export const Pattern = {
+    implementation,
+    Node: PatternNode
+};

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

@@ -0,0 +1,106 @@
+import { type array, type propValueOf, type satisfy } from "@ark/util";
+import { InternalPrimitiveConstraint } from "../constraint.ts";
+import type { Declaration, nodeOfKind, NodeSchema, NormalizedSchema } from "../kinds.ts";
+import type { BaseNodeDeclaration, BaseNormalizedSchema } from "../shared/declare.ts";
+import type { keySchemaDefinitions } from "../shared/implement.ts";
+import type { RangeKind } from "./kinds.ts";
+export interface BaseRangeDeclaration extends BaseNodeDeclaration {
+    kind: RangeKind;
+    inner: BaseRangeInner;
+    normalizedSchema: UnknownExpandedRangeSchema;
+}
+export declare abstract class BaseRange<d extends BaseRangeDeclaration> extends InternalPrimitiveConstraint<d> {
+    readonly exclusive?: true;
+    readonly boundOperandKind: OperandKindsByBoundKind[d["kind"]];
+    readonly compiledActual: string;
+    readonly comparator: RelativeComparator;
+    readonly numericLimit: number;
+    readonly expression: string;
+    readonly compiledCondition: string;
+    readonly compiledNegation: string;
+    readonly stringLimit: string;
+    readonly limitKind: LimitKind;
+    isStricterThan(r: nodeOfKind<d["kind"] | pairedRangeKind<d["kind"]>>): boolean;
+    overlapsRange(r: nodeOfKind<pairedRangeKind<d["kind"]>>): boolean;
+    overlapIsUnit(r: nodeOfKind<pairedRangeKind<d["kind"]>>): boolean;
+}
+export interface BaseRangeInner {
+    readonly rule: LimitValue;
+}
+export type LimitValue = Date | number;
+export type LimitSchemaValue = Date | number | string;
+export type LimitInnerValue<kind extends RangeKind = RangeKind> = kind extends "before" | "after" ? Date : number;
+export interface UnknownExpandedRangeSchema extends BaseNormalizedSchema {
+    readonly rule: LimitSchemaValue;
+    readonly exclusive?: boolean;
+}
+export interface UnknownNormalizedRangeSchema extends BaseNormalizedSchema {
+    readonly rule: LimitSchemaValue;
+}
+export type UnknownRangeSchema = LimitSchemaValue | UnknownExpandedRangeSchema;
+export interface ExclusiveExpandedDateRangeSchema extends BaseNormalizedSchema {
+    rule: LimitSchemaValue;
+    exclusive?: true;
+}
+export type ExclusiveDateRangeSchema = LimitSchemaValue | ExclusiveExpandedDateRangeSchema;
+export interface InclusiveExpandedDateRangeSchema extends BaseNormalizedSchema {
+    rule: LimitSchemaValue;
+    exclusive?: false;
+}
+export type InclusiveDateRangeSchema = LimitSchemaValue | InclusiveExpandedDateRangeSchema;
+export interface ExclusiveNormalizedNumericRangeSchema extends BaseNormalizedSchema {
+    rule: number;
+    exclusive?: true;
+}
+export type ExclusiveNumericRangeSchema = number | ExclusiveNormalizedNumericRangeSchema;
+export interface InclusiveNormalizedNumericRangeSchema extends BaseNormalizedSchema {
+    rule: number;
+    exclusive?: false;
+}
+export type InclusiveNumericRangeSchema = number | InclusiveNormalizedNumericRangeSchema;
+export type LimitKind = "lower" | "upper";
+export type RelativeComparator<kind extends LimitKind = LimitKind> = {
+    lower: ">" | ">=";
+    upper: "<" | "<=";
+}[kind];
+export declare const boundKindPairsByLower: BoundKindPairsByLower;
+type BoundKindPairsByLower = {
+    min: "max";
+    minLength: "maxLength";
+    after: "before";
+};
+type BoundKindPairsByUpper = {
+    max: "min";
+    maxLength: "minLength";
+    before: "after";
+};
+export type pairedRangeKind<kind extends RangeKind> = kind extends LowerBoundKind ? BoundKindPairsByLower[kind] : BoundKindPairsByUpper[kind & UpperBoundKind];
+export type LowerBoundKind = keyof typeof boundKindPairsByLower;
+export type LowerNode = nodeOfKind<LowerBoundKind>;
+export type UpperBoundKind = propValueOf<typeof boundKindPairsByLower>;
+export type UpperNode = nodeOfKind<UpperBoundKind>;
+export type NumericallyBoundable = string | number | array;
+export type Boundable = NumericallyBoundable | Date;
+export declare const parseExclusiveKey: keySchemaDefinitions<Declaration<"min" | "max">>["exclusive"];
+export declare const createLengthSchemaNormalizer: <kind extends "minLength" | "maxLength">(kind: kind) => (schema: NodeSchema<kind>) => NormalizedSchema<kind>;
+export declare const createDateSchemaNormalizer: <kind extends DateRangeKind>(kind: kind) => (schema: NodeSchema<kind>) => NormalizedSchema<kind>;
+export declare const parseDateLimit: (limit: LimitSchemaValue) => Date;
+export type LengthBoundKind = "minLength" | "maxLength" | "exactLength";
+export declare const writeInvalidLengthBoundMessage: (kind: LengthBoundKind, limit: number) => string;
+export declare const createLengthRuleParser: (kind: LengthBoundKind) => (limit: number) => number | undefined;
+type OperandKindsByBoundKind = satisfy<Record<RangeKind, BoundOperandKind>, {
+    min: "value";
+    max: "value";
+    minLength: "length";
+    maxLength: "length";
+    after: "date";
+    before: "date";
+}>;
+export declare const compileComparator: (kind: RangeKind, exclusive: boolean | undefined) => RelativeComparator;
+export type BoundOperandKind = "value" | "length" | "date";
+export type LengthBoundableData = string | array;
+export type DateRangeKind = "before" | "after";
+export declare const dateLimitToString: (limit: LimitSchemaValue) => string;
+export declare const writeUnboundableMessage: <root extends string>(root: root) => writeUnboundableMessage<root>;
+export type writeUnboundableMessage<root extends string> = `Bounded expression ${root} must be exactly one of number, string, Array, or Date`;
+export {};