@blade-hq/agent-client 1.1.1 → 1.1.3

package/node_modules/arktype/out/type.js

@@ -0,0 +1,55 @@
+import { ArkErrors, BaseRoot, GenericRoot } from "@ark/schema";
+import { Callable, Hkt } from "@ark/util";
+export class InternalTypeParser extends Callable {
+    constructor($) {
+        const attach = Object.assign({
+            errors: ArkErrors,
+            hkt: Hkt,
+            $: $,
+            raw: $.parse,
+            module: $.constructor.module,
+            scope: $.constructor.scope,
+            declare: $.declare,
+            define: $.define,
+            match: $.match,
+            generic: $.generic,
+            schema: $.schema,
+            // this won't be defined during bootstrapping, but externally always will be
+            keywords: $.ambient,
+            unit: $.unit,
+            enumerated: $.enumerated,
+            instanceOf: $.instanceOf,
+            valueOf: $.valueOf,
+            or: $.or,
+            and: $.and,
+            merge: $.merge,
+            pipe: $.pipe,
+            fn: $.fn
+        }, 
+        // also won't be defined during bootstrapping
+        $.ambientAttachments);
+        super((...args) => {
+            if (args.length === 1) {
+                // treat as a simple definition
+                return $.parse(args[0]);
+            }
+            if (args.length === 2 &&
+                typeof args[0] === "string" &&
+                args[0][0] === "<" &&
+                args[0][args[0].length - 1] === ">") {
+                // if there are exactly two args, the first of which looks like <${string}>,
+                // treat as a generic
+                const paramString = args[0].slice(1, -1);
+                const params = $.parseGenericParams(paramString, {});
+                return new GenericRoot(params, args[1], $, $, null);
+            }
+            // otherwise, treat as a tuple expression. technically, this also allows
+            // non-expression tuple definitions to be parsed, but it's not a supported
+            // part of the API as specified by the associated types
+            return $.parse(args);
+        }, {
+            attach
+        });
+    }
+}
+export const Type = BaseRoot;

package/node_modules/arktype/out/variants/array.d.ts

@@ -0,0 +1,12 @@
+import type { ExactLength, ExclusiveNumericRangeSchema, InclusiveNumericRangeSchema } from "@ark/schema";
+import type { ObjectType } from "./object.ts";
+interface Type<
+/** @ts-ignore cast variance */
+out t extends readonly unknown[] = readonly unknown[], $ = {}> extends ObjectType<t, $> {
+    atLeastLength(schema: InclusiveNumericRangeSchema): this;
+    atMostLength(schema: InclusiveNumericRangeSchema): this;
+    moreThanLength(schema: ExclusiveNumericRangeSchema): this;
+    lessThanLength(schema: ExclusiveNumericRangeSchema): this;
+    exactlyLength(schema: ExactLength.Schema): this;
+}
+export type { Type as ArrayType };

package/node_modules/arktype/out/variants/array.js

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

package/node_modules/arktype/out/variants/base.d.ts

@@ -0,0 +1,542 @@
+import type { BaseNode, BaseRoot, Disjoint, JsonSchema, NodeSelector, Predicate, StandardSchemaV1, ToJsonSchema, TypeMeta, UndeclaredKeyBehavior } from "@ark/schema";
+import type { anyOrNever, array, Callable, ErrorMessage, inferred, JsonStructure, unset } from "@ark/util";
+import type { defaultFor, distill, inferIntersection, inferPipe, InferredMorph, Out, To } from "../attributes.ts";
+import type { ArkAmbient } from "../config.ts";
+import type { type } from "../keywords/keywords.ts";
+import type { NaryPipeParser } from "../nary.ts";
+import type { Scope } from "../scope.ts";
+import type { ArrayType } from "./array.ts";
+import type { instantiateType } from "./instantiate.ts";
+/** @ts-ignore cast variance */
+export interface Inferred<out t = unknown, $ = {}> {
+    internal: BaseRoot;
+    [inferred]: t;
+    /**
+     * precompiled JS used to optimize validation
+     *
+     * ⚠️ will be `undefined` in [jitless](https://arktype.io/docs/configuration#jitless) mode
+     */
+    precompilation: string | undefined;
+    /**
+     * generic parameter representing this Type
+     *
+     * 🥸 inference-only property that will be `undefined` at runtime
+     *
+     * ⚠️ May contain types representing morphs or default values that would
+     * be inaccurate if used directly for runtime values. In those cases,
+     * you should use {@link infer} or {@link inferIn} on this object instead.
+     */
+    t: t;
+    /**
+     * #### {@link Scope} in which chained methods are parsed
+     */
+    $: Scope<$>;
+    /**
+     * #### type of output this returns
+     *
+     * 🥸 inference-only property that will be `undefined` at runtime
+     *
+     * @example
+     * const parseNumber = type("string").pipe(s => Number.parseInt(s))
+     * type ParsedNumber = typeof parseNumber.infer // number
+     */
+    infer: this["inferOut"];
+    /**
+     * type of output this returns
+     *
+     * 🔗 alias of {@link infer}
+     * 🥸 inference-only property that will be `undefined` at runtime
+     *
+     *
+     * @example
+     * const parseNumber = type("string").pipe(s => Number.parseInt(s))
+     * type ParsedNumber = typeof parseNumber.infer // number
+     */
+    inferOut: distill.Out<t>;
+    /**
+     * type of output that can be introspected at runtime (e.g. via {@link out})
+     *
+     * ⚠️ If your Type contains morphs, they will be inferred as `unknown` unless
+     * they are an ArkType keyword or have an explicitly defined output validator.
+     *
+     * 🥸 inference-only property that will be `undefined` at runtime
+     *
+     * @example
+     * const Unmorphed = type("string")
+     * // with no morphs, we can introspect the input and output as a single Type
+     * type UnmorphedOut = typeof Unmorphed.inferIntrospectableOut // string
+     *
+     * const Morphed = type("string").pipe(s => s.length)
+     * // with a standard user-defined morph, TypeScript can infer a
+     * // return type from your function, but we have no way to
+     * // know the shape at runtime
+     * type MorphOut = typeof Morphed.inferIntrospectableOut  // unknown
+     *
+     * const Validated = type("string").pipe(s => s.length).to("number")
+     * // morphs with validated output, including all morph keywords, are introspectable
+     * type ValidatedMorphOut = typeof Validated.inferIntrospectableOut
+     */
+    inferIntrospectableOut: distill.introspectable.Out<t>;
+    /**
+     * #### type of input this allows
+     *
+     * 🥸 inference-only property that will be `undefined` at runtime
+     *
+     * @example
+     * const parseNumber = type("string").pipe(s => Number.parseInt(s))
+     * type UnparsedNumber = typeof parseNumber.inferIn // string
+     */
+    inferIn: distill.In<t>;
+    /**
+     * #### internal JSON representation
+     */
+    json: JsonStructure;
+    /**
+     * alias of {@link json} for `JSON.stringify` compatibility
+     */
+    toJSON(): JsonStructure;
+    /**
+     * #### generate a JSON Schema
+     *
+     * @throws {ToJsonSchema.Error} if this cannot be converted to JSON Schema
+     */
+    toJsonSchema(options?: ToJsonSchema.Options): JsonSchema;
+    /**
+     * #### metadata like custom descriptions and error messages
+     *
+     * ✅ type {@link https://arktype.io/docs/configuration#custom | can be customized} for your project
+     */
+    meta: ArkAmbient.meta;
+    /**
+     * #### human-readable English description
+     *
+     * ✅ works best for primitive values
+     *
+     * @example
+     * const N = type("0 < number <= 100")
+     * console.log(N.description) // positive and at most 100
+     */
+    description: string;
+    /**
+     * #### syntax string similar to native TypeScript
+     *
+     * ✅ works well for both primitives and structures
+     *
+     * @example
+     * const Loc = type({ coords: ["number", "number"] })
+     * console.log(Loc.expression) // { coords: [number, number] }
+     */
+    expression: string;
+    /**
+     * #### validate and return transformed data or throw
+     *
+     * ✅ sugar to avoid checking for {@link type.errors} if they are unrecoverable
+     *
+     * @example
+     * const CriticalPayload = type({
+     *     superImportantValue: "string"
+     * })
+     * // throws TraversalError: superImportantValue must be a string (was missing)
+     * const data = CriticalPayload.assert({ irrelevantValue: "whoops" })
+     * console.log(data.superImportantValue) // valid output can be accessed directly
+     *
+     * @throws {TraversalError}
+     */
+    assert: (data: unknown) => this["infer"];
+    /**
+     * #### check input without applying morphs
+     *
+     * ✅ good for stuff like filtering that doesn't benefit from detailed errors
+     *
+     * @example
+     * const Numeric = type("number | bigint")
+     * // [0, 2n]
+     * const numerics = [0, "one", 2n].filter(Numeric.allows)
+     */
+    allows: (data: unknown) => data is this["inferIn"];
+    /**
+     * #### add metadata to shallow references
+     *
+     * ⚠️ does not affect error messages within properties of an object
+     *
+     * @example
+     * const NotOdd = type("number % 2").configure({ description: "not odd" })
+     * // all constraints at the root are affected
+     * const odd = NotOdd(3) // must be not odd (was 3)
+     * const nonNumber = NotOdd("two") // must be not odd (was "two")
+     *
+     * const NotOddBox = type({
+     *    // we should have referenced notOdd or added meta here
+     *    notOdd: "number % 2",
+     * // but instead chained from the root object
+     * }).configure({ description: "not odd" })
+     * // error message at path notOdd is not affected
+     * const oddProp = NotOddBox({ notOdd: 3 }) // notOdd must be even (was 3)
+     * // error message at root is affected, leading to a misleading description
+     * const nonObject = NotOddBox(null) // must be not odd (was null)
+     */
+    configure: NodeSelector.SelectableFn<TypeMeta.MappableInput, this>;
+    /**
+     * #### add description to shallow references
+     *
+     * 🔗 equivalent to `.configure({ description })` (see {@link configure})
+     * ⚠️ does not affect error messages within properties of an object
+     *
+     * @example
+     * const AToZ = type(/^a.*z$/).describe("a string like 'a...z'")
+     * const good = AToZ("alcatraz") // "alcatraz"
+     * // ArkErrors: must be a string like 'a...z' (was "albatross")
+     * const badPattern = AToZ("albatross")
+     */
+    describe: NodeSelector.SelectableFn<string, this>;
+    /**
+     * #### apply undeclared key behavior
+     *
+     * - `"ignore"` (default) - allow and preserve extra properties
+     * - `"reject"` - disallow extra properties
+     * - `"delete"` - clone and remove extra properties from output
+     */
+    onUndeclaredKey(behavior: UndeclaredKeyBehavior): this;
+    /**
+     * #### deeply apply undeclared key behavior
+     *
+     * - `"ignore"` (default) - allow and preserve extra properties
+     * - `"reject"` - disallow extra properties
+     * - `"delete"` - clone and remove extra properties from output
+     */
+    onDeepUndeclaredKey(behavior: UndeclaredKeyBehavior): this;
+    /**
+     * #### alias for {@link assert} with typed input
+     *
+     * @example
+     * const T = type({ foo: "string" });
+     * // TypeScript: foo must be a string (was 5)
+     * const data = T.from({ foo: 5 });
+     */
+    from(literal: this["inferIn"]): this["infer"];
+    /**
+     * #### deeply extract inputs
+     *
+     * ✅ will never include morphs
+     * ✅ good for generating JSON Schema or other non-transforming formats
+     *
+     * @example
+     * const User = type({
+     *    age: "string.numeric.parse"
+     * })
+     * // { age: 25 } (age parsed to a number)
+     * const out = User({ age: "25" })
+     * // { age: "25" } (age is still a string)
+     * const inOut = User.in({ age: "25" })
+     */
+    get in(): instantiateType<this["inferIn"], $>;
+    /**
+     * #### deeply extract outputs
+     *
+     * ✅ will never include morphs
+     * ⚠️ if your type includes morphs, their output will likely be unknown unless they
+     * were defined with an explicit output validator via `.to(outputDef)` or `.pipe(morph, outputType)`
+     *
+     * @example
+     * const join = type("string[]").pipe(a => a.join(","))
+     *
+     * const T = type({
+     *    // all keywords have introspectable output
+     *    keyword: "string.numeric.parse",
+     *    // TypeScript knows this returns a string, but we can't introspect that at runtime
+     *    unvalidated: join,
+     *    // if needed, it can be made introspectable with an output validator
+     *    validated: join.to("string")
+     * })
+     *
+     * // Type<{ keyword: number; unvalidated: unknown; validated: string }>
+     * const baseOut = base.out
+     */
+    get out(): instantiateType<this["inferIntrospectableOut"], $>;
+    /**
+     * #### add a compile-time brand to output
+     *
+     * 🥸 inference-only function that does nothing runtime
+     *
+     * @example
+     * const Palindrome = type("string")
+     *     .narrow(s => s === [...s].reverse().join(""))
+     *     .brand("palindrome")
+     * // Brand<string, "palindrome">
+     * const out = Palindrome.assert("racecar")
+     */
+    brand<const name extends string, r = instantiateType<type.brand<t, name>, $>>(name: name): r extends infer _ ? _ : never;
+    /**
+     * #### an array of this
+     *
+     * @example
+     * // Type<{ rebmun: number }[]>
+     * const T = type({ rebmun: "number" }).array();
+     */
+    array(): ArrayType<t[], $>;
+    /**
+     * #### {@link https://arktype.io/docs/objects#properties-optional | optional definition}
+     *
+     * ⚠️ unlike most other methods, this creates a definition rather than a Type (read why)
+     *
+     * @example
+     * const Prop = type({ foo: "number" })
+     * // Type<{ bar?: { foo: number } }>
+     * const Obj = type({ bar: Prop.optional() })
+     */
+    optional(): [this, "?"];
+    /**
+     * #### {@link https://arktype.io/docs/objects#properties-defaultable | defaultable definition}
+     *
+     * ✅ object defaults can be returned from a function
+     * ⚠️ throws if the default value is not allowed
+     * ⚠️ unlike most other methods, this creates a definition rather than a Type (read why)
+     *
+     * @example
+     * // Type<{ count: Default<number, 0> }>
+     * const State = type({ count: type.number.default(0) })
+     * const Prop = type({ nested: "boolean" })
+     * const ForObj = type({
+     *     key: Prop.default(() => ({ nested: false }))
+     * })
+     */
+    default<const value extends defaultFor<this["inferIn"]>>(value: value): [this, "=", value];
+    /**
+     * #### apply a predicate function to input
+     *
+     * ⚠️ the behavior of {@link narrow}, this method's output counterpart, is usually more desirable
+     * ✅ most useful for morphs with input types that are re-used externally
+     * 🥸 {@link https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates | Type predicates} can be used as casts
+     *
+     * @example
+     * const stringifyUser = type({ name: "string" }).pipe(user => JSON.stringify(user))
+     * const stringifySafe = stringifyUser.filter(user => user.name !== "Bobby Tables")
+     * // Type<(In: `${string}Z`) => To<Date>>
+     * const WithPredicate = type("string.date.parse").filter((s): s is `${string}Z` =>
+     *     s.endsWith("Z")
+     * )
+     */
+    filter<narrowed extends this["inferIn"] = never, r = instantiateType<[
+        narrowed
+    ] extends [never] ? t : t extends InferredMorph<never, infer o> ? (In: narrowed) => o : narrowed, $>>(predicate: Predicate.Castable<this["inferIn"], narrowed>): r extends infer _ ? _ : never;
+    /**
+     * #### apply a predicate function to output
+     *
+     * ✅ go-to fallback for validation not composable via built-in types and operators
+     * ✅ runs after all other validators and morphs, if present
+     * 🥸 {@link https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates | Type predicates} can be used as casts
+     *
+     * @example
+     * const Palindrome = type("string").narrow(s => s === [...s].reverse().join(""))
+     *
+     * const PalindromicEmail = type("string.date.parse").narrow((date, ctx) =>
+     * 		date.getFullYear() === 2025 || ctx.mustBe("the current year")
+     * )
+     * // Type<`${string}.tsx`>
+     * const WithPredicate = type("string").narrow((s): s is `${string}.tsx` => /\.tsx?$/.test(s))
+     */
+    narrow<narrowed extends this["infer"] = never, r = instantiateType<[
+        narrowed
+    ] extends [never] ? t : t extends InferredMorph<infer i, infer o> ? o extends To ? (In: i) => To<narrowed> : (In: i) => Out<narrowed> : narrowed, $>>(predicate: Predicate.Castable<this["infer"], narrowed>): r extends infer _ ? _ : never;
+    /**
+     * #### pipe output through arbitrary transformations or other Types
+     *
+     * @example
+     * const User = type({ name: "string" })
+     *
+     * // parse a string and validate that the result as a user
+     * const parseUser = type("string").pipe(s => JSON.parse(s), user)
+     */
+    pipe: ChainedPipeParser<$, t>;
+    /**
+     * #### parse a definition as an output validator
+     *
+     * 🔗 `to({ name: "string" })` is equivalent to `.pipe(type({ name: "string" }))`
+     *
+     * @example
+     * // parse a string and validate that the result as a user
+     * const parseUser = type("string").pipe(s => JSON.parse(s)).to({ name: "string" })
+     */
+    to<const def, r = instantiateType<inferPipe<t, type.infer<def, $>>, $>>(def: type.validate<def, $>): r extends infer _ ? _ : never;
+    /**
+     * #### query internal node references
+     *
+     * @experimental filters and returns the Type's internal representation from `@ark/schema`
+     *
+     * @example
+     * // ["blue", "red"]
+     * const values = type("'red' | 'blue'").select("unit").map(u => u.unit)
+     */
+    select: BaseNode["select"];
+}
+/** @ts-ignore cast variance */
+interface Type<out t = unknown, $ = {}> extends Callable<(data: unknown) => distill.Out<t> | ArkEnv.onFail>, Inferred<t, $> {
+    /**
+     * #### cast the way this is inferred
+     *
+     * 🥸 inference-only function that does nothing runtime
+     *
+     * @example
+     * // Type<`LEEEEEEEE${string}ROY`>
+     * const Leeroy = type(/^LE{8,}ROY$/).as<`LEEEEEEEE${string}ROY`>()
+     */
+    as<castTo = unset>(...args: validateChainedAsArgs<castTo>): instantiateType<castTo, $>;
+    /**
+     * #### intersect the parsed Type, throwing if the result is unsatisfiable
+     *
+     * @example
+     * // Type<{ foo: number; bar: string }>
+     * const T = type({ foo: "number" }).and({ bar: "string" })
+     * // ParseError: Intersection at foo of number and string results in an unsatisfiable type
+     * const Bad = type({ foo: "number" }).and({ foo: "string" })
+     */
+    and<const def, r = instantiateType<inferIntersection<t, type.infer<def, $>>, $>>(def: type.validate<def, $>): r extends infer _ ? _ : never;
+    /**
+     * #### union with the parsed Type
+     *
+     * ⚠️ a union that could apply different morphs to the same data is a ParseError ({@link https://arktype.io/docs/expressions#union-morphs | docs})
+     *
+     * @example
+     * // Type<string | { box: string }>
+     * const T = type("string").or({ box: "string" })
+     */
+    or<const def, r = instantiateType<t | type.infer<def, $>, $>>(def: type.validate<def, $>): r extends infer _ ? _ : never;
+    /**
+     * #### intersect the parsed Type, returning an introspectable {@link Disjoint} if the result is unsatisfiable
+     *
+     * @example
+     * // Type<{ foo: number; bar: string }>
+     * const T = type({ foo: "number" }).intersect({ bar: "string" })
+     * const Bad = type("number > 10").intersect("number < 5")
+     * // logs "Intersection of > 10 and < 5 results in an unsatisfiable type"
+     * if (Bad instanceof Disjoint) console.log(`${bad.summary}`)
+     */
+    intersect<const def, r = instantiateType<inferIntersection<t, type.infer<def, $>>, $>>(def: type.validate<def, $>): r extends infer _ ? _ | Disjoint : never;
+    /**
+     * #### check if the parsed Type's constraints are identical
+     *
+     * ✅ equal types have identical input and output constraints and transforms
+     * ✅ ignores associated {@link meta}, which does not affect the set of allowed values
+     *
+     * @example
+     * const DivisibleBy6 = type.number.divisibleBy(6).moreThan(0)
+     * // false (left side must also be positive)
+     * DivisibleBy6.equals("number % 6")
+     * // false (right side has an additional <100 constraint)
+     * console.log(DivisibleBy6.equals("0 < (number % 6) < 100"))
+     * const ThirdTry = type("(number % 2) > 0").divisibleBy(3)
+     * // true (types are normalized and reduced)
+     * console.log(DivisibleBy6.equals(ThirdTry))
+     */
+    equals<const def>(def: type.validate<def, $>): boolean;
+    /**
+     * #### narrow this based on an {@link equals} check
+     *
+     * ✅ ignores associated {@link meta}, which does not affect the set of allowed values
+     *
+     * @example
+     * const N = type.raw(`${Math.random()}`)
+     * // Type<0.5> | undefined
+     * const Ez = N.ifEquals("0.5")
+     */
+    ifEquals<const def, r = type.instantiate<def, $>>(def: type.validate<def, $>): r extends infer _ ? _ | undefined : never;
+    /**
+     * #### check if this is a subtype of the parsed Type
+     *
+     * ✅ a subtype must include all constraints from the base type
+     * ✅ unlike {@link equals}, additional constraints may be present
+     * ✅ ignores associated {@link meta}, which does not affect the set of allowed values
+     *
+     * @example
+     * type.string.extends("unknown") // true
+     * type.string.extends(/^a.*z$/) // false
+     */
+    extends<const def>(other: type.validate<def, $>): boolean;
+    /**
+     * #### narrow this based on an {@link extends} check
+     *
+     * ✅ ignores associated {@link meta}, which does not affect the set of allowed values
+     *
+     * @example
+     * const N = type(Math.random() > 0.5 ? "true" : "0") // Type<0 | true>
+     * const Ez = N.ifExtends("boolean") // Type<true> | undefined
+     */
+    ifExtends<const def, r = type.instantiate<def, $>>(other: type.validate<def, $>): r extends infer _ ? _ | undefined : never;
+    /**
+     * #### check if a value could satisfy this and the parsed Type
+     *
+     * ⚠️ will return true unless a {@link Disjoint} can be proven
+     *
+     * @example
+     * type.string.overlaps("string | number") // true (e.g. "foo")
+     * type("string | number").overlaps("1") // true (1)
+     * type("number > 0").overlaps("number < 0") // false (no values exist)
+     *
+     * const NoAt = type("string").narrow(s => !s.includes("@"))
+     * NoAt.overlaps("string.email") // true (no values exist, but not provable)
+     */
+    overlaps<const def>(r: type.validate<def, $>): boolean;
+    /**
+     * #### extract branches {@link extend}ing the parsed Type
+     *
+     * @example
+     * // Type<true | 0 | 2>
+     * const T = type("boolean | 0 | 'one' | 2 | bigint").extract("number | 0n | true")
+     */
+    extract<const def, r = instantiateType<t extends type.infer<def, $> ? t : never, $>>(r: type.validate<def, $>): r extends infer _ extends r ? _ : never;
+    /**
+     * #### exclude branches {@link extend}ing the parsed Type
+     *
+     * @example
+     *
+     * // Type<false | 'one' | bigint>
+     * const T = type("boolean | 0 | 'one' | 2 | bigint").exclude("number | 0n | true")
+     */
+    exclude<const def, r = instantiateType<t extends type.infer<def, $> ? never : t, $>>(r: type.validate<def, $>): r extends infer _ ? _ : never;
+    /**
+     * @experimental
+     * Map and optionally reduce branches of a union. Types that are not unions
+     * are treated as a single branch.
+     *
+     * @param mapBranch - the mapping function, accepting a branch Type
+     *     Returning another `Type` is common, but any value can be returned and
+     *     inferred as part of the output.
+     *
+     * @param [reduceMapped] - an operation to perform on the mapped branches
+     *     Can be used to e.g. merge an array of returned Types representing
+     *     branches back to a single union.
+     */
+    distribute<mapOut, reduceOut = mapOut[]>(mapBranch: (branch: Type, i: number, branches: array<Type>) => mapOut, reduceMapped?: (mappedBranches: mapOut[]) => reduceOut): reduceOut;
+    /** The Type's [StandardSchema](https://github.com/standard-schema/standard-schema) properties */
+    "~standard": StandardSchemaV1.ArkTypeProps<this["inferIn"] extends infer _ ? _ : never, this["inferOut"] extends infer _ ? _ : never>;
+    /** @deprecated */
+    apply: Function["apply"];
+    /** @deprecated */
+    bind: Function["bind"];
+    /** @deprecated */
+    call: Function["call"];
+    /** @deprecated */
+    caller: Function;
+    /** @deprecated */
+    length: number;
+    /** @deprecated */
+    name: string;
+    /** @deprecated */
+    prototype: Function["prototype"];
+    /** @deprecated */
+    arguments: Function["arguments"];
+    /** @deprecated */
+    Symbol: never;
+}
+export interface ChainedPipeParser<$, t> extends NaryPipeParser<$, t> {
+    try: NaryPipeParser<$, t>;
+}
+type validateChainedAsArgs<t> = [
+    t
+] extends [unset] ? [
+    t
+] extends [anyOrNever] ? [
+] : [
+    ErrorMessage<"as requires an explicit type parameter like myType.as<t>()">
+] : [];
+export type { Type as BaseType };

package/node_modules/arktype/out/variants/base.js

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

package/node_modules/arktype/out/variants/date.d.ts

@@ -0,0 +1,10 @@
+import type { ExclusiveDateRangeSchema, InclusiveDateRangeSchema } from "@ark/schema";
+import type { ObjectType } from "./object.ts";
+/** @ts-ignore cast variance */
+interface Type<out t extends globalThis.Date = globalThis.Date, $ = {}> extends ObjectType<t, $> {
+    atOrAfter(schema: InclusiveDateRangeSchema): this;
+    atOrBefore(schema: InclusiveDateRangeSchema): this;
+    laterThan(schema: ExclusiveDateRangeSchema): this;
+    earlierThan(schema: ExclusiveDateRangeSchema): this;
+}
+export type { Type as DateType };

package/node_modules/arktype/out/variants/date.js

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

package/node_modules/arktype/out/variants/instantiate.d.ts

@@ -0,0 +1,12 @@
+import type { anyOrNever, array } from "@ark/util";
+import type { ArrayType } from "./array.ts";
+import type { BaseType } from "./base.ts";
+import type { DateType } from "./date.ts";
+import type { NumberType } from "./number.ts";
+import type { ObjectType } from "./object.ts";
+import type { StringType } from "./string.ts";
+export type instantiateType<t, $> = [
+    t
+] extends [anyOrNever] ? BaseType<t, $> : [t] extends [object] ? [
+    t
+] extends [array] ? ArrayType<t, $> : [t] extends [Date] ? DateType<t, $> : ObjectType<t, $> : [t] extends [string] ? StringType<t, $> : [t] extends [number] ? NumberType<t, $> : BaseType<t, $>;

package/node_modules/arktype/out/variants/instantiate.js

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

package/node_modules/arktype/out/variants/number.d.ts

@@ -0,0 +1,11 @@
+import type { Divisor, ExclusiveNumericRangeSchema, InclusiveNumericRangeSchema } from "@ark/schema";
+import type { BaseType } from "./base.ts";
+/** @ts-ignore cast variance */
+interface Type<out t extends number = number, $ = {}> extends BaseType<t, $> {
+    divisibleBy(schema: Divisor.Schema): this;
+    atLeast(schema: InclusiveNumericRangeSchema): this;
+    atMost(schema: InclusiveNumericRangeSchema): this;
+    moreThan(schema: ExclusiveNumericRangeSchema): this;
+    lessThan(schema: ExclusiveNumericRangeSchema): this;
+}
+export type { Type as NumberType };

package/node_modules/arktype/out/variants/number.js

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