@blade-hq/agent-client 1.1.1 → 1.1.2

package/node_modules/@ark/schema/out/structure/index.js

@@ -0,0 +1,89 @@
+import { append, printable, stringAndSymbolicEntriesOf, throwParseError } from "@ark/util";
+import { BaseConstraint } from "../constraint.js";
+import { flatRef } from "../node.js";
+import { Disjoint } from "../shared/disjoint.js";
+import { implementNode } from "../shared/implement.js";
+import { intersectOrPipeNodes } from "../shared/intersections.js";
+import { $ark } from "../shared/registry.js";
+import { traverseKey } from "../shared/traversal.js";
+const implementation = implementNode({
+    kind: "index",
+    hasAssociatedError: false,
+    intersectionIsOpen: true,
+    keys: {
+        signature: {
+            child: true,
+            parse: (schema, ctx) => {
+                const key = ctx.$.parseSchema(schema);
+                if (!key.extends($ark.intrinsic.key)) {
+                    return throwParseError(writeInvalidPropertyKeyMessage(key.expression));
+                }
+                const enumerableBranches = key.branches.filter(b => b.hasKind("unit"));
+                if (enumerableBranches.length) {
+                    return throwParseError(writeEnumerableIndexBranches(enumerableBranches.map(b => printable(b.unit))));
+                }
+                return key;
+            }
+        },
+        value: {
+            child: true,
+            parse: (schema, ctx) => ctx.$.parseSchema(schema)
+        }
+    },
+    normalize: schema => schema,
+    defaults: {
+        description: node => `[${node.signature.expression}]: ${node.value.description}`
+    },
+    intersections: {
+        index: (l, r, ctx) => {
+            if (l.signature.equals(r.signature)) {
+                const valueIntersection = intersectOrPipeNodes(l.value, r.value, ctx);
+                const value = valueIntersection instanceof Disjoint ?
+                    $ark.intrinsic.never.internal
+                    : valueIntersection;
+                return ctx.$.node("index", { signature: l.signature, value });
+            }
+            // if r constrains all of l's keys to a subtype of l's value, r is a subtype of l
+            if (l.signature.extends(r.signature) && l.value.subsumes(r.value))
+                return r;
+            // if l constrains all of r's keys to a subtype of r's value, l is a subtype of r
+            if (r.signature.extends(l.signature) && r.value.subsumes(l.value))
+                return l;
+            // other relationships between index signatures can't be generally reduced
+            return null;
+        }
+    }
+});
+export class IndexNode extends BaseConstraint {
+    impliedBasis = $ark.intrinsic.object.internal;
+    expression = `[${this.signature.expression}]: ${this.value.expression}`;
+    flatRefs = append(this.value.flatRefs.map(ref => flatRef([this.signature, ...ref.path], ref.node)), flatRef([this.signature], this.value));
+    traverseAllows = (data, ctx) => stringAndSymbolicEntriesOf(data).every(entry => {
+        if (this.signature.traverseAllows(entry[0], ctx)) {
+            return traverseKey(entry[0], () => this.value.traverseAllows(entry[1], ctx), ctx);
+        }
+        return true;
+    });
+    traverseApply = (data, ctx) => {
+        for (const entry of stringAndSymbolicEntriesOf(data)) {
+            if (this.signature.traverseAllows(entry[0], ctx)) {
+                traverseKey(entry[0], () => this.value.traverseApply(entry[1], ctx), ctx);
+            }
+        }
+    };
+    _transform(mapper, ctx) {
+        ctx.path.push(this.signature);
+        const result = super._transform(mapper, ctx);
+        ctx.path.pop();
+        return result;
+    }
+    compile() {
+        // this is currently handled by StructureNode
+    }
+}
+export const Index = {
+    implementation,
+    Node: IndexNode
+};
+export const writeEnumerableIndexBranches = (keys) => `Index keys ${keys.join(", ")} should be specified as named props.`;
+export const writeInvalidPropertyKeyMessage = (indexSchema) => `Indexed key definition '${indexSchema}' must be a string or symbol`;

package/node_modules/@ark/schema/out/structure/optional.d.ts

@@ -0,0 +1,49 @@
+import { type requireKeys } from "@ark/util";
+import type { Morph } from "../roots/morph.ts";
+import type { BaseRoot } from "../roots/root.ts";
+import type { declareNode } from "../shared/declare.ts";
+import { type nodeImplementationOf } from "../shared/implement.ts";
+import { BaseProp, type Prop } from "./prop.ts";
+export declare namespace Optional {
+    interface Schema extends Prop.Schema {
+        default?: unknown;
+    }
+    interface Inner extends Prop.Inner {
+        default?: unknown;
+    }
+    type Declaration = declareNode<Prop.Declaration<"optional"> & {
+        schema: Schema;
+        normalizedSchema: Schema;
+        inner: Inner;
+    }>;
+    type Node = OptionalNode;
+    namespace Node {
+        type withDefault = requireKeys<Node, "default" | "defaultValueMorph" | "defaultValueMorphRef">;
+    }
+}
+export declare class OptionalNode extends BaseProp<"optional"> {
+    constructor(...args: ConstructorParameters<typeof BaseProp>);
+    get rawIn(): OptionalNode;
+    get outProp(): Prop.Node;
+    expression: string;
+    defaultValueMorph: Morph | undefined;
+    defaultValueMorphRef: string | undefined;
+}
+export declare const Optional: {
+    implementation: nodeImplementationOf<{
+        reducibleTo: "optional";
+        errorContext: null;
+        kind: "optional";
+        prerequisite: object;
+        intersectionIsOpen: true;
+        childKind: import("../shared/implement.ts").RootKind;
+        schema: Optional.Schema;
+        normalizedSchema: Optional.Schema;
+        inner: Optional.Inner;
+    }>;
+    Node: typeof OptionalNode;
+};
+export declare const computeDefaultValueMorph: (key: PropertyKey, value: BaseRoot, defaultInput: unknown) => Morph<any>;
+export declare const assertDefaultValueAssignability: (node: BaseRoot, value: unknown, key: PropertyKey | null) => unknown;
+export type writeUnassignableDefaultValueMessage<baseDef extends string, defaultValue extends string> = `Default value ${defaultValue} must be assignable to ${baseDef}`;
+export declare const writeNonPrimitiveNonFunctionDefaultValueMessage: (key: PropertyKey | null) => string;

package/node_modules/@ark/schema/out/structure/optional.js

@@ -0,0 +1,127 @@
+import { hasDomain, isThunk, omit, printable, throwParseError } from "@ark/util";
+import { intrinsic } from "../intrinsic.js";
+import { compileSerializedValue } from "../shared/compile.js";
+import { ArkErrors } from "../shared/errors.js";
+import { defaultValueSerializer, implementNode } from "../shared/implement.js";
+import { registeredReference } from "../shared/registry.js";
+import { traverseKey } from "../shared/traversal.js";
+import { BaseProp, intersectProps } from "./prop.js";
+const implementation = implementNode({
+    kind: "optional",
+    hasAssociatedError: false,
+    intersectionIsOpen: true,
+    keys: {
+        key: {},
+        value: {
+            child: true,
+            parse: (schema, ctx) => ctx.$.parseSchema(schema)
+        },
+        default: {
+            preserveUndefined: true
+        }
+    },
+    normalize: schema => schema,
+    reduce: (inner, $) => {
+        if ($.resolvedConfig.exactOptionalPropertyTypes === false) {
+            if (!inner.value.allows(undefined)) {
+                return $.node("optional", { ...inner, value: inner.value.or(intrinsic.undefined) }, { prereduced: true });
+            }
+        }
+    },
+    defaults: {
+        description: node => `${node.compiledKey}?: ${node.value.description}`
+    },
+    intersections: {
+        optional: intersectProps
+    }
+});
+export class OptionalNode extends BaseProp {
+    constructor(...args) {
+        super(...args);
+        if ("default" in this.inner)
+            assertDefaultValueAssignability(this.value, this.inner.default, this.key);
+    }
+    get rawIn() {
+        const baseIn = super.rawIn;
+        if (!this.hasDefault())
+            return baseIn;
+        return this.$.node("optional", omit(baseIn.inner, { default: true }), {
+            prereduced: true
+        });
+    }
+    get outProp() {
+        if (!this.hasDefault())
+            return this;
+        const { default: defaultValue, ...requiredInner } = this.inner;
+        return this.cacheGetter("outProp", this.$.node("required", requiredInner, { prereduced: true }));
+    }
+    expression = this.hasDefault() ?
+        `${this.compiledKey}: ${this.value.expression} = ${printable(this.inner.default)}`
+        : `${this.compiledKey}?: ${this.value.expression}`;
+    defaultValueMorph = getDefaultableMorph(this);
+    defaultValueMorphRef = this.defaultValueMorph && registeredReference(this.defaultValueMorph);
+}
+export const Optional = {
+    implementation,
+    Node: OptionalNode
+};
+const defaultableMorphCache = {};
+const getDefaultableMorph = (node) => {
+    if (!node.hasDefault())
+        return;
+    const cacheKey = `{${node.compiledKey}: ${node.value.id} = ${defaultValueSerializer(node.default)}}`;
+    return (defaultableMorphCache[cacheKey] ??= computeDefaultValueMorph(node.key, node.value, node.default));
+};
+export const computeDefaultValueMorph = (key, value, defaultInput) => {
+    if (typeof defaultInput === "function") {
+        // if the value has a morph, pipe context through it
+        return value.includesTransform ?
+            (data, ctx) => {
+                traverseKey(key, () => value((data[key] = defaultInput()), ctx), ctx);
+                return data;
+            }
+            : data => {
+                data[key] = defaultInput();
+                return data;
+            };
+    }
+    // non-functional defaults can be safely cached as long as the morph is
+    // guaranteed to be pure and the output is primitive
+    const precomputedMorphedDefault = value.includesTransform ? value.assert(defaultInput) : defaultInput;
+    return hasDomain(precomputedMorphedDefault, "object") ?
+        // the type signature only allows this if the value was morphed
+        (data, ctx) => {
+            traverseKey(key, () => value((data[key] = defaultInput), ctx), ctx);
+            return data;
+        }
+        : data => {
+            data[key] = precomputedMorphedDefault;
+            return data;
+        };
+};
+export const assertDefaultValueAssignability = (node, value, key) => {
+    const wrapped = isThunk(value);
+    if (hasDomain(value, "object") && !wrapped)
+        throwParseError(writeNonPrimitiveNonFunctionDefaultValueMessage(key));
+    // if the node has a default value, finalize it and apply JIT optimizations
+    // if applicable to ensure behavior + error logging is externally consistent
+    // (using .in here insead of .rawIn triggers finalization)
+    const out = node.in(wrapped ? value() : value);
+    if (out instanceof ArkErrors) {
+        if (key === null) {
+            // e.g. "Default must be assignable to number (was string)"
+            throwParseError(`Default ${out.summary}`);
+        }
+        const atPath = out.transform(e => e.transform(input => ({ ...input, prefixPath: [key] })));
+        // e.g. "Default for bar must be assignable to number (was string)"
+        // e.g. "Default for value at [0] must be assignable to number (was string)"
+        throwParseError(`Default for ${atPath.summary}`);
+    }
+    return value;
+};
+export const writeNonPrimitiveNonFunctionDefaultValueMessage = (key) => {
+    const keyDescription = key === null ? ""
+        : typeof key === "number" ? `for value at [${key}] `
+            : `for ${compileSerializedValue(key)} `;
+    return `Non-primitive default ${keyDescription}must be specified as a function like () => ({my: 'object'})`;
+};

package/node_modules/@ark/schema/out/structure/prop.d.ts

@@ -0,0 +1,45 @@
+import { type Key } from "@ark/util";
+import { BaseConstraint } from "../constraint.ts";
+import type { nodeOfKind, RootSchema } from "../kinds.ts";
+import { type BaseNode, type DeepNodeTransformation, type DeepNodeTransformContext, type FlatRef } from "../node.ts";
+import type { BaseRoot } from "../roots/root.ts";
+import { type NodeCompiler } from "../shared/compile.ts";
+import type { BaseNormalizedSchema } from "../shared/declare.ts";
+import { Disjoint } from "../shared/disjoint.ts";
+import type { IntersectionContext, RootKind } from "../shared/implement.ts";
+import { type TraverseAllows, type TraverseApply } from "../shared/traversal.ts";
+import type { Optional } from "./optional.ts";
+import type { Required } from "./required.ts";
+export declare namespace Prop {
+    type Kind = "required" | "optional";
+    type Node = nodeOfKind<Kind>;
+    interface Schema extends BaseNormalizedSchema {
+        readonly key: Key;
+        readonly value: RootSchema;
+    }
+    interface Inner {
+        readonly key: Key;
+        readonly value: BaseRoot;
+    }
+    interface Declaration<kind extends Kind = Kind> {
+        kind: kind;
+        prerequisite: object;
+        intersectionIsOpen: true;
+        childKind: RootKind;
+    }
+}
+export declare const intersectProps: (l: nodeOfKind<Prop.Kind>, r: nodeOfKind<Prop.Kind>, ctx: IntersectionContext) => nodeOfKind<Prop.Kind> | Disjoint | null;
+export declare abstract class BaseProp<kind extends Prop.Kind = Prop.Kind> extends BaseConstraint<kind extends "required" ? Required.Declaration : Optional.Declaration> {
+    required: boolean;
+    optional: boolean;
+    impliedBasis: BaseRoot;
+    serializedKey: string;
+    compiledKey: string;
+    flatRefs: FlatRef[];
+    protected _transform(mapper: DeepNodeTransformation, ctx: DeepNodeTransformContext): BaseNode | null;
+    hasDefault(): this is Optional.Node.withDefault;
+    traverseAllows: TraverseAllows<object>;
+    traverseApply: TraverseApply<object>;
+    compile(js: NodeCompiler): void;
+}
+export declare const writeDefaultIntersectionMessage: (lValue: unknown, rValue: unknown) => string;

package/node_modules/@ark/schema/out/structure/prop.js

@@ -0,0 +1,85 @@
+import { append, printable, throwParseError, unset } from "@ark/util";
+import { BaseConstraint } from "../constraint.js";
+import { flatRef } from "../node.js";
+import { compileSerializedValue } from "../shared/compile.js";
+import { Disjoint } from "../shared/disjoint.js";
+import { intersectOrPipeNodes } from "../shared/intersections.js";
+import { $ark } from "../shared/registry.js";
+import { traverseKey } from "../shared/traversal.js";
+export const intersectProps = (l, r, ctx) => {
+    if (l.key !== r.key)
+        return null;
+    const key = l.key;
+    let value = intersectOrPipeNodes(l.value, r.value, ctx);
+    const kind = l.required || r.required ? "required" : "optional";
+    if (value instanceof Disjoint) {
+        if (kind === "optional")
+            value = $ark.intrinsic.never.internal;
+        else {
+            // if either operand was optional, the Disjoint has to be treated as optional
+            return value.withPrefixKey(l.key, l.required && r.required ? "required" : "optional");
+        }
+    }
+    if (kind === "required") {
+        return ctx.$.node("required", {
+            key,
+            value
+        });
+    }
+    const defaultIntersection = l.hasDefault() ?
+        r.hasDefault() ?
+            l.default === r.default ?
+                l.default
+                : throwParseError(writeDefaultIntersectionMessage(l.default, r.default))
+            : l.default
+        : r.hasDefault() ? r.default
+            : unset;
+    return ctx.$.node("optional", {
+        key,
+        value,
+        // unset is stripped during parsing
+        default: defaultIntersection
+    });
+};
+export class BaseProp extends BaseConstraint {
+    required = this.kind === "required";
+    optional = this.kind === "optional";
+    impliedBasis = $ark.intrinsic.object.internal;
+    serializedKey = compileSerializedValue(this.key);
+    compiledKey = typeof this.key === "string" ? this.key : this.serializedKey;
+    flatRefs = append(this.value.flatRefs.map(ref => flatRef([this.key, ...ref.path], ref.node)), flatRef([this.key], this.value));
+    _transform(mapper, ctx) {
+        ctx.path.push(this.key);
+        const result = super._transform(mapper, ctx);
+        ctx.path.pop();
+        return result;
+    }
+    hasDefault() {
+        return "default" in this.inner;
+    }
+    traverseAllows = (data, ctx) => {
+        if (this.key in data) {
+            // ctx will be undefined if this node isn't context-dependent
+            return traverseKey(this.key, () => this.value.traverseAllows(data[this.key], ctx), ctx);
+        }
+        return this.optional;
+    };
+    traverseApply = (data, ctx) => {
+        if (this.key in data) {
+            traverseKey(this.key, () => this.value.traverseApply(data[this.key], ctx), ctx);
+        }
+        else if (this.hasKind("required"))
+            ctx.errorFromNodeContext(this.errorContext);
+    };
+    compile(js) {
+        js.if(`${this.serializedKey} in data`, () => js.traverseKey(this.serializedKey, `data${js.prop(this.key)}`, this.value));
+        if (this.hasKind("required")) {
+            js.else(() => js.traversalKind === "Apply" ?
+                js.line(`ctx.errorFromNodeContext(${this.compiledErrorContext})`)
+                : js.return(false));
+        }
+        if (js.traversalKind === "Allows")
+            js.return(true);
+    }
+}
+export const writeDefaultIntersectionMessage = (lValue, rValue) => `Invalid intersection of default values ${printable(lValue)} & ${printable(rValue)}`;

package/node_modules/@ark/schema/out/structure/required.d.ts

@@ -0,0 +1,39 @@
+import type { BaseErrorContext, declareNode } from "../shared/declare.ts";
+import type { NodeErrorContextInput } from "../shared/errors.ts";
+import { type nodeImplementationOf } from "../shared/implement.ts";
+import { BaseProp, type Prop } from "./prop.ts";
+export declare namespace Required {
+    interface ErrorContext extends BaseErrorContext<"required"> {
+        missingValueDescription: string;
+    }
+    interface Schema extends Prop.Schema {
+    }
+    interface Inner extends Prop.Inner {
+    }
+    type Declaration = declareNode<Prop.Declaration<"required"> & {
+        schema: Schema;
+        normalizedSchema: Schema;
+        inner: Inner;
+        errorContext: ErrorContext;
+    }>;
+    type Node = RequiredNode;
+}
+export declare class RequiredNode extends BaseProp<"required"> {
+    expression: string;
+    errorContext: NodeErrorContextInput<"required">;
+    compiledErrorContext: string;
+}
+export declare const Required: {
+    implementation: nodeImplementationOf<{
+        reducibleTo: "required";
+        kind: "required";
+        prerequisite: object;
+        intersectionIsOpen: true;
+        childKind: import("../shared/implement.ts").RootKind;
+        schema: Required.Schema;
+        normalizedSchema: Required.Schema;
+        inner: Required.Inner;
+        errorContext: Required.ErrorContext;
+    }>;
+    Node: typeof RequiredNode;
+};

package/node_modules/@ark/schema/out/structure/required.js

@@ -0,0 +1,38 @@
+import { compileObjectLiteral, implementNode } from "../shared/implement.js";
+import { BaseProp, intersectProps } from "./prop.js";
+const implementation = implementNode({
+    kind: "required",
+    hasAssociatedError: true,
+    intersectionIsOpen: true,
+    keys: {
+        key: {},
+        value: {
+            child: true,
+            parse: (schema, ctx) => ctx.$.parseSchema(schema)
+        }
+    },
+    normalize: schema => schema,
+    defaults: {
+        description: node => `${node.compiledKey}: ${node.value.description}`,
+        expected: ctx => ctx.missingValueDescription,
+        actual: () => "missing"
+    },
+    intersections: {
+        required: intersectProps,
+        optional: intersectProps
+    }
+});
+export class RequiredNode extends BaseProp {
+    expression = `${this.compiledKey}: ${this.value.expression}`;
+    errorContext = Object.freeze({
+        code: "required",
+        missingValueDescription: this.value.defaultShortDescription,
+        relativePath: [this.key],
+        meta: this.meta
+    });
+    compiledErrorContext = compileObjectLiteral(this.errorContext);
+}
+export const Required = {
+    implementation,
+    Node: RequiredNode
+};

package/node_modules/@ark/schema/out/structure/sequence.d.ts

@@ -0,0 +1,110 @@
+import { type array, type satisfy } from "@ark/util";
+import { BaseConstraint } from "../constraint.ts";
+import type { RootSchema } from "../kinds.ts";
+import { type BaseNode, type DeepNodeTransformContext, type DeepNodeTransformation, type FlatRef } from "../node.ts";
+import type { ExactLengthNode } from "../refinements/exactLength.ts";
+import type { MaxLengthNode } from "../refinements/maxLength.ts";
+import type { MinLengthNode } from "../refinements/minLength.ts";
+import type { Morph } from "../roots/morph.ts";
+import type { BaseRoot } from "../roots/root.ts";
+import type { NodeCompiler } from "../shared/compile.ts";
+import type { BaseNormalizedSchema, declareNode } from "../shared/declare.ts";
+import { type RootKind, type nodeImplementationOf } from "../shared/implement.ts";
+import type { JsonSchema } from "../shared/jsonSchema.ts";
+import type { ToJsonSchema } from "../shared/toJsonSchema.ts";
+import { type TraverseAllows, type TraverseApply } from "../shared/traversal.ts";
+export declare namespace Sequence {
+    interface NormalizedSchema extends BaseNormalizedSchema {
+        readonly prefix?: array<RootSchema>;
+        readonly defaultables?: array<DefaultableSchema>;
+        readonly optionals?: array<RootSchema>;
+        readonly variadic?: RootSchema;
+        readonly minVariadicLength?: number;
+        readonly postfix?: array<RootSchema>;
+    }
+    type Schema = NormalizedSchema | RootSchema;
+    type DefaultableSchema = [schema: RootSchema, defaultValue: unknown];
+    type DefaultableElement = [node: BaseRoot, defaultValue: unknown];
+    interface Inner {
+        readonly prefix?: array<BaseRoot>;
+        readonly defaultables?: array<DefaultableElement>;
+        readonly optionals?: array<BaseRoot>;
+        readonly variadic?: BaseRoot;
+        readonly minVariadicLength?: number;
+        readonly postfix?: array<BaseRoot>;
+    }
+    interface Declaration extends declareNode<{
+        kind: "sequence";
+        schema: Schema;
+        normalizedSchema: NormalizedSchema;
+        inner: Inner;
+        prerequisite: array;
+        reducibleTo: "sequence";
+        childKind: RootKind;
+    }> {
+    }
+    type Node = SequenceNode;
+}
+export declare class SequenceNode extends BaseConstraint<Sequence.Declaration> {
+    impliedBasis: BaseRoot;
+    tuple: SequenceTuple;
+    prefixLength: number;
+    defaultablesLength: number;
+    optionalsLength: number;
+    postfixLength: number;
+    defaultablesAndOptionals: BaseRoot[];
+    prevariadic: array<PrevariadicSequenceElement>;
+    variadicOrPostfix: array<BaseRoot>;
+    flatRefs: FlatRef[];
+    protected addFlatRefs(): FlatRef[];
+    isVariadicOnly: boolean;
+    minVariadicLength: number;
+    minLength: number;
+    minLengthNode: MinLengthNode | null;
+    maxLength: number | null;
+    maxLengthNode: MaxLengthNode | ExactLengthNode | null;
+    impliedSiblings: array<MaxLengthNode | MinLengthNode | ExactLengthNode>;
+    defaultValueMorphs: Morph[];
+    defaultValueMorphsReference: `$ark.${string}` | `$ark0.${string}` | `$ark${`2${string}` & `${bigint}`}.${string}` | `$ark${`1${string}` & `${bigint}`}.${string}` | `$ark${`3${string}` & `${bigint}`}.${string}` | `$ark${`4${string}` & `${bigint}`}.${string}` | `$ark${`5${string}` & `${bigint}`}.${string}` | `$ark${`6${string}` & `${bigint}`}.${string}` | `$ark${`7${string}` & `${bigint}`}.${string}` | `$ark${`8${string}` & `${bigint}`}.${string}` | `$ark${`9${string}` & `${bigint}`}.${string}` | undefined;
+    protected elementAtIndex(data: array, index: number): SequenceElement;
+    traverseAllows: TraverseAllows<array>;
+    traverseApply: TraverseApply<array>;
+    get element(): BaseRoot;
+    compile(js: NodeCompiler): void;
+    protected _transform(mapper: DeepNodeTransformation, ctx: DeepNodeTransformContext): BaseNode | null;
+    expression: string;
+    reduceJsonSchema(schema: JsonSchema.Array, ctx: ToJsonSchema.Context): JsonSchema.Array;
+}
+export declare const Sequence: {
+    implementation: nodeImplementationOf<Sequence.Declaration>;
+    Node: typeof SequenceNode;
+};
+export declare const postfixAfterOptionalOrDefaultableMessage = "A postfix required element cannot follow an optional or defaultable element";
+export type postfixAfterOptionalOrDefaultableMessage = typeof postfixAfterOptionalOrDefaultableMessage;
+export declare const postfixWithoutVariadicMessage = "A postfix element requires a variadic element";
+export type postfixWithoutVariadicMessage = typeof postfixWithoutVariadicMessage;
+export type SequenceElement = PrevariadicSequenceElement | VariadicSequenceElement | PostfixSequenceElement;
+export type SequenceElementKind = satisfy<keyof Sequence.Inner, SequenceElement["kind"]>;
+export type PrevariadicSequenceElement = PrefixSequenceElement | DefaultableSequenceElement | OptionalSequenceElement;
+export type PrefixSequenceElement = {
+    kind: "prefix";
+    node: BaseRoot;
+};
+export type OptionalSequenceElement = {
+    kind: "optionals";
+    node: BaseRoot;
+};
+export type PostfixSequenceElement = {
+    kind: "postfix";
+    node: BaseRoot;
+};
+export type VariadicSequenceElement = {
+    kind: "variadic";
+    node: BaseRoot;
+};
+export type DefaultableSequenceElement = {
+    kind: "defaultables";
+    node: BaseRoot;
+    default: unknown;
+};
+export type SequenceTuple = array<SequenceElement>;