@blade-hq/agent-client 1.1.1 → 1.1.2

package/node_modules/@ark/util/out/records.js

@@ -0,0 +1,63 @@
+import { noSuggest, ZeroWidthSpace } from "./errors.js";
+import { flatMorph } from "./flatMorph.js";
+/**
+ * Object.entries wrapper providing narrowed types for objects with known sets
+ * of keys, e.g. those defined internally as configs
+ */
+export const entriesOf = Object.entries;
+export const fromEntries = (entries) => Object.fromEntries(entries);
+export const keysOf = (o) => Object.keys(o);
+export const isKeyOf = (k, o) => k in o;
+export const hasKey = (o, k) => k in o;
+// must be defined this way to avoid https://github.com/microsoft/TypeScript/issues/55049
+export const hasDefinedKey = (o, k) => o[k] !== undefined;
+export const InnerDynamicBase = class {
+};
+export class DynamicBase {
+    constructor(properties) {
+        Object.assign(this, properties);
+    }
+}
+export const NoopBase = class {
+};
+/** @ts-ignore (needed to extend `t`) **/
+export class CastableBase extends NoopBase {
+}
+export const splitByKeys = (o, leftKeys) => {
+    const l = {};
+    const r = {};
+    let k;
+    for (k in o) {
+        if (k in leftKeys)
+            l[k] = o[k];
+        else
+            r[k] = o[k];
+    }
+    return [l, r];
+};
+export const pick = (o, keys) => splitByKeys(o, keys)[0];
+export const omit = (o, keys) => splitByKeys(o, keys)[1];
+export const isEmptyObject = (o) => Object.keys(o).length === 0;
+export const stringAndSymbolicEntriesOf = (o) => [
+    ...Object.entries(o),
+    ...Object.getOwnPropertySymbols(o).map(k => [k, o[k]])
+];
+/** Like Object.assign, but it will preserve getters instead of evaluating them. */
+export const defineProperties = (base, merged) => 
+// declared like this to avoid https://github.com/microsoft/TypeScript/issues/55049
+Object.defineProperties(base, Object.getOwnPropertyDescriptors(merged));
+/** Copies enumerable keys of o to a new object in alphabetical order */
+export const withAlphabetizedKeys = (o) => {
+    const keys = Object.keys(o).sort();
+    const result = {};
+    for (let i = 0; i < keys.length; i++)
+        result[keys[i]] = o[keys[i]];
+    return result;
+};
+export const invert = (t) => flatMorph(t, (k, v) => [v, k]);
+export const unset = noSuggest(`unset${ZeroWidthSpace}`);
+export const enumValues = (tsEnum) => Object.values(tsEnum).filter(v => {
+    if (typeof v === "number")
+        return true;
+    return typeof tsEnum[v] !== "number";
+});

package/node_modules/@ark/util/out/registry.d.ts

@@ -0,0 +1,21 @@
+export declare const arkUtilVersion = "0.56.0";
+export declare const initialRegistryContents: {
+    version: string;
+    filename: string;
+    FileConstructor: typeof import("buffer").File;
+};
+export type InitialRegistryContents = typeof initialRegistryContents;
+export interface ArkRegistry extends InitialRegistryContents {
+    [k: string]: unknown;
+}
+export declare const registry: ArkRegistry;
+declare global {
+    export interface ArkEnv {
+        prototypes(): never;
+    }
+    export namespace ArkEnv {
+        type prototypes = ReturnType<ArkEnv["prototypes"]>;
+    }
+}
+export declare const register: (value: object | symbol) => string;
+export declare const isDotAccessible: (keyName: string) => boolean;

package/node_modules/@ark/util/out/registry.js

@@ -0,0 +1,49 @@
+import { domainOf } from "./domain.js";
+import { throwInternalError } from "./errors.js";
+import { isomorphic } from "./isomorphic.js";
+import { FileConstructor, objectKindOf } from "./objectKinds.js";
+// Eventually we can just import from package.json in the source itself
+// but for now, import assertions are too unstable and it wouldn't support
+// recent node versions (https://nodejs.org/api/esm.html#json-modules).
+// For now, we assert this matches the package.json version via a unit test.
+export const arkUtilVersion = "0.56.0";
+export const initialRegistryContents = {
+    version: arkUtilVersion,
+    filename: isomorphic.fileName(),
+    FileConstructor
+};
+export const registry = initialRegistryContents;
+const namesByResolution = new Map();
+const nameCounts = Object.create(null);
+export const register = (value) => {
+    const existingName = namesByResolution.get(value);
+    if (existingName)
+        return existingName;
+    let name = baseNameFor(value);
+    if (nameCounts[name])
+        name = `${name}${nameCounts[name]++}`;
+    else
+        nameCounts[name] = 1;
+    registry[name] = value;
+    namesByResolution.set(value, name);
+    return name;
+};
+export const isDotAccessible = (keyName) => /^[$A-Z_a-z][\w$]*$/.test(keyName);
+const baseNameFor = (value) => {
+    switch (typeof value) {
+        case "object": {
+            if (value === null)
+                break;
+            const prefix = objectKindOf(value) ?? "object";
+            // convert to camelCase
+            return prefix[0].toLowerCase() + prefix.slice(1);
+        }
+        case "function":
+            return isDotAccessible(value.name) ? value.name : "fn";
+        case "symbol":
+            return value.description && isDotAccessible(value.description) ?
+                value.description
+                : "symbol";
+    }
+    return throwInternalError(`Unexpected attempt to register serializable value of type ${domainOf(value)}`);
+};

package/node_modules/@ark/util/out/scanner.d.ts

@@ -0,0 +1,44 @@
+import type { KeySet } from "./records.ts";
+import { Backslash, type WhitespaceChar } from "./strings.ts";
+export declare class Scanner<lookahead extends string = string> {
+    chars: string[];
+    i: number;
+    def: string;
+    constructor(def: string);
+    /** Get lookahead and advance scanner by one */
+    shift(): this["lookahead"];
+    get lookahead(): lookahead;
+    get nextLookahead(): string;
+    get length(): number;
+    shiftUntil(condition: Scanner.UntilCondition): string;
+    shiftUntilEscapable(condition: Scanner.UntilCondition): string;
+    shiftUntilLookahead(charOrSet: string | KeySet): string;
+    shiftUntilNonWhitespace(): string;
+    jumpToIndex(i: number): void;
+    jumpForward(count: number): void;
+    get location(): number;
+    get unscanned(): string;
+    get scanned(): string;
+    sliceChars(start: number, end?: number): string;
+    lookaheadIs<char extends lookahead>(char: char): this is Scanner<char>;
+    lookaheadIsIn<keySet extends KeySet>(tokens: keySet): this is Scanner<Extract<keyof keySet, string>>;
+}
+export declare namespace Scanner {
+    type UntilCondition = (scanner: Scanner, shifted: string) => boolean;
+    type shift<lookahead extends string, unscanned extends string> = `${lookahead}${unscanned}`;
+    type shiftUntil<unscanned extends string, terminator extends string, appendTo extends string = ""> = unscanned extends shift<infer lookahead, infer nextUnscanned> ? lookahead extends terminator ? [
+        appendTo,
+        unscanned
+    ] : shiftUntil<nextUnscanned, terminator, `${appendTo}${lookahead}`> : [appendTo, ""];
+    type shiftUntilEscapable<unscanned extends string, terminator extends string, escapeEscape extends Backslash | "", appendTo extends string = ""> = unscanned extends shift<infer lookahead, infer nextUnscanned> ? lookahead extends terminator ? [appendTo, unscanned] : lookahead extends Backslash ? nextUnscanned extends (shift<infer nextLookahead, infer postEscapedUnscanned>) ? shiftUntilEscapable<postEscapedUnscanned, terminator, escapeEscape, `${appendTo}${nextLookahead extends terminator ? "" : nextLookahead extends Backslash ? escapeEscape : Backslash}${nextLookahead}`> : [`${appendTo}${Backslash}`, ""] : shiftUntilEscapable<nextUnscanned, terminator, escapeEscape, `${appendTo}${lookahead}`> : [appendTo, ""];
+    type shiftUntilNot<unscanned extends string, nonTerminator extends string, appendTo extends string = ""> = unscanned extends shift<infer lookahead, infer nextUnscanned> ? lookahead extends nonTerminator ? shiftUntilNot<nextUnscanned, nonTerminator, `${appendTo}${lookahead}`> : [appendTo, unscanned] : [appendTo, ""];
+    type skipWhitespace<unscanned extends string> = shiftUntilNot<unscanned, WhitespaceChar>[1];
+    type shiftResult<scanned extends string, unscanned extends string> = [
+        scanned,
+        unscanned
+    ];
+}
+export declare const writeUnmatchedGroupCloseMessage: <char extends string, unscanned extends string>(char: char, unscanned: unscanned) => writeUnmatchedGroupCloseMessage<char, unscanned>;
+export type writeUnmatchedGroupCloseMessage<char extends string, unscanned extends string> = `Unmatched ${char}${unscanned extends "" ? "" : ` before ${unscanned}`}`;
+export declare const writeUnclosedGroupMessage: <missingChar extends string>(missingChar: missingChar) => writeUnclosedGroupMessage<missingChar>;
+export type writeUnclosedGroupMessage<missingChar extends string> = `Missing ${missingChar}`;

package/node_modules/@ark/util/out/scanner.js

@@ -0,0 +1,87 @@
+import { Backslash, whitespaceChars } from "./strings.js";
+export class Scanner {
+    chars;
+    i;
+    def;
+    constructor(def) {
+        this.def = def;
+        this.chars = [...def];
+        this.i = 0;
+    }
+    /** Get lookahead and advance scanner by one */
+    shift() {
+        return (this.chars[this.i++] ?? "");
+    }
+    get lookahead() {
+        return (this.chars[this.i] ?? "");
+    }
+    get nextLookahead() {
+        return this.chars[this.i + 1] ?? "";
+    }
+    get length() {
+        return this.chars.length;
+    }
+    shiftUntil(condition) {
+        let shifted = "";
+        while (this.lookahead) {
+            if (condition(this, shifted))
+                break;
+            else
+                shifted += this.shift();
+        }
+        return shifted;
+    }
+    shiftUntilEscapable(condition) {
+        let shifted = "";
+        while (this.lookahead) {
+            if (this.lookahead === Backslash) {
+                this.shift();
+                if (condition(this, shifted))
+                    shifted += this.shift();
+                else if (this.lookahead === Backslash)
+                    shifted += this.shift();
+                else
+                    shifted += `${Backslash}${this.shift()}`;
+            }
+            else if (condition(this, shifted))
+                break;
+            else
+                shifted += this.shift();
+        }
+        return shifted;
+    }
+    shiftUntilLookahead(charOrSet) {
+        return typeof charOrSet === "string" ?
+            this.shiftUntil(s => s.lookahead === charOrSet)
+            : this.shiftUntil(s => s.lookahead in charOrSet);
+    }
+    shiftUntilNonWhitespace() {
+        return this.shiftUntil(() => !(this.lookahead in whitespaceChars));
+    }
+    jumpToIndex(i) {
+        this.i = i < 0 ? this.length + i : i;
+    }
+    jumpForward(count) {
+        this.i += count;
+    }
+    get location() {
+        return this.i;
+    }
+    get unscanned() {
+        return this.chars.slice(this.i, this.length).join("");
+    }
+    get scanned() {
+        return this.chars.slice(0, this.i).join("");
+    }
+    sliceChars(start, end) {
+        return this.chars.slice(start, end).join("");
+    }
+    lookaheadIs(char) {
+        return this.lookahead === char;
+    }
+    lookaheadIsIn(tokens) {
+        return this.lookahead in tokens;
+    }
+}
+export const writeUnmatchedGroupCloseMessage = (char, unscanned) => `Unmatched ${char}${(unscanned === "" ? "" : ` before ${unscanned}`)}`;
+export const writeUnclosedGroupMessage = (missingChar) => `Missing ${missingChar}`;

package/node_modules/@ark/util/out/serialize.d.ts

@@ -0,0 +1,34 @@
+import type { array } from "./arrays.ts";
+import { type Primitive } from "./domain.ts";
+export type SerializationOptions = {
+    onCycle?: (value: object) => string;
+    onSymbol?: (value: symbol) => string;
+    onFunction?: (value: Function) => string;
+    onUndefined?: string;
+    onBigInt?: (value: bigint) => string;
+};
+export type JsonStructure = JsonObject | JsonArray;
+export interface JsonObject {
+    [k: string]: Json;
+}
+export type JsonArray = Json[];
+export type JsonPrimitive = string | boolean | number | null;
+export type Json = JsonStructure | JsonPrimitive;
+export declare const snapshot: <t>(data: t, opts?: SerializationOptions) => snapshot<t>;
+export type snapshot<t, depth extends 1[] = []> = unknown extends t ? unknown : t extends Primitive ? snapshotPrimitive<t> : t extends {
+    toJSON: () => infer serialized;
+} ? serialized : t extends Function ? `Function(${string})` : t extends Date ? string : depth["length"] extends 10 ? unknown : t extends array<infer item> ? array<snapshot<item, [...depth, 1]>> : {
+    [k in keyof t as snapshotPrimitive<k>]: snapshot<t[k], [...depth, 1]>;
+};
+type snapshotPrimitive<t> = t extends symbol ? `Symbol(${string})` : t;
+export type PrintableOptions = {
+    indent?: number;
+    quoteKeys?: boolean;
+};
+export declare const print: (data: unknown, opts?: PrintableOptions) => void;
+export declare const printable: (data: unknown, opts?: PrintableOptions) => string;
+/**
+ * Converts a Date instance to a human-readable description relative to its precision
+ */
+export declare const describeCollapsibleDate: (date: Date) => string;
+export {};

package/node_modules/@ark/util/out/serialize.js

@@ -0,0 +1,150 @@
+import { domainOf } from "./domain.js";
+import { serializePrimitive } from "./primitive.js";
+import { stringAndSymbolicEntriesOf } from "./records.js";
+import { isDotAccessible, register } from "./registry.js";
+export const snapshot = (data, opts = {}) => _serialize(data, {
+    onUndefined: `$ark.undefined`,
+    onBigInt: n => `$ark.bigint-${n}`,
+    ...opts
+}, []);
+export const print = (data, opts) => console.log(printable(data, opts));
+export const printable = (data, opts) => {
+    switch (domainOf(data)) {
+        case "object":
+            const o = data;
+            const ctorName = o.constructor?.name ?? "Object";
+            return (ctorName === "Object" || ctorName === "Array" ?
+                opts?.quoteKeys === false ?
+                    stringifyUnquoted(o, opts?.indent ?? 0, "")
+                    : JSON.stringify(_serialize(o, printableOpts, []), null, opts?.indent)
+                : stringifyUnquoted(o, opts?.indent ?? 0, ""));
+        case "symbol":
+            return printableOpts.onSymbol(data);
+        default:
+            return serializePrimitive(data);
+    }
+};
+const stringifyUnquoted = (value, indent, currentIndent) => {
+    if (typeof value === "function")
+        return printableOpts.onFunction(value);
+    if (typeof value !== "object" || value === null)
+        return serializePrimitive(value);
+    const nextIndent = currentIndent + " ".repeat(indent);
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return "[]";
+        const items = value
+            .map(item => stringifyUnquoted(item, indent, nextIndent))
+            .join(",\n" + nextIndent);
+        return indent ? `[\n${nextIndent}${items}\n${currentIndent}]` : `[${items}]`;
+    }
+    const ctorName = value.constructor?.name ?? "Object";
+    if (ctorName === "Object") {
+        const keyValues = stringAndSymbolicEntriesOf(value).map(([key, val]) => {
+            const stringifiedKey = typeof key === "symbol" ? printableOpts.onSymbol(key)
+                : isDotAccessible(key) ? key
+                    : JSON.stringify(key);
+            const stringifiedValue = stringifyUnquoted(val, indent, nextIndent);
+            return `${nextIndent}${stringifiedKey}: ${stringifiedValue}`;
+        });
+        if (keyValues.length === 0)
+            return "{}";
+        return indent ?
+            `{\n${keyValues.join(",\n")}\n${currentIndent}}`
+            : `{${keyValues.join(", ")}}`;
+    }
+    if (value instanceof Date)
+        return describeCollapsibleDate(value);
+    if ("expression" in value && typeof value.expression === "string")
+        return value.expression;
+    return ctorName;
+};
+const printableOpts = {
+    onCycle: () => "(cycle)",
+    onSymbol: v => `Symbol(${register(v)})`,
+    onFunction: v => `Function(${register(v)})`
+};
+const _serialize = (data, opts, seen) => {
+    switch (domainOf(data)) {
+        case "object": {
+            const o = data;
+            if ("toJSON" in o && typeof o.toJSON === "function")
+                return o.toJSON();
+            if (typeof o === "function")
+                return printableOpts.onFunction(o);
+            if (seen.includes(o))
+                return "(cycle)";
+            const nextSeen = [...seen, o];
+            if (Array.isArray(o))
+                return o.map(item => _serialize(item, opts, nextSeen));
+            if (o instanceof Date)
+                return o.toDateString();
+            const result = {};
+            for (const k in o)
+                result[k] = _serialize(o[k], opts, nextSeen);
+            for (const s of Object.getOwnPropertySymbols(o)) {
+                result[opts.onSymbol?.(s) ?? s.toString()] = _serialize(o[s], opts, nextSeen);
+            }
+            return result;
+        }
+        case "symbol":
+            return printableOpts.onSymbol(data);
+        case "bigint":
+            return opts.onBigInt?.(data) ?? `${data}n`;
+        case "undefined":
+            return opts.onUndefined ?? "undefined";
+        case "string":
+            return data.replace(/\\/g, "\\\\");
+        default:
+            return data;
+    }
+};
+/**
+ * Converts a Date instance to a human-readable description relative to its precision
+ */
+export const describeCollapsibleDate = (date) => {
+    const year = date.getFullYear();
+    const month = date.getMonth();
+    const dayOfMonth = date.getDate();
+    const hours = date.getHours();
+    const minutes = date.getMinutes();
+    const seconds = date.getSeconds();
+    const milliseconds = date.getMilliseconds();
+    if (month === 0 &&
+        dayOfMonth === 1 &&
+        hours === 0 &&
+        minutes === 0 &&
+        seconds === 0 &&
+        milliseconds === 0)
+        return `${year}`;
+    const datePortion = `${months[month]} ${dayOfMonth}, ${year}`;
+    if (hours === 0 && minutes === 0 && seconds === 0 && milliseconds === 0)
+        return datePortion;
+    let timePortion = date.toLocaleTimeString();
+    const suffix = timePortion.endsWith(" AM") || timePortion.endsWith(" PM") ?
+        timePortion.slice(-3)
+        : "";
+    if (suffix)
+        timePortion = timePortion.slice(0, -suffix.length);
+    if (milliseconds)
+        timePortion += `.${pad(milliseconds, 3)}`;
+    else if (timeWithUnnecessarySeconds.test(timePortion))
+        timePortion = timePortion.slice(0, -3);
+    return `${timePortion + suffix}, ${datePortion}`;
+};
+const months = [
+    "January",
+    "February",
+    "March",
+    "April",
+    "May",
+    "June",
+    "July",
+    "August",
+    "September",
+    "October",
+    "November",
+    "December"
+];
+const timeWithUnnecessarySeconds = /:\d\d:00$/;
+const pad = (value, length) => String(value).padStart(length, "0");

package/node_modules/@ark/util/out/strings.d.ts

@@ -0,0 +1,33 @@
+export declare const capitalize: <s extends string>(s: s) => Capitalize<s>;
+export declare const uncapitalize: <s extends string>(s: s) => Uncapitalize<s>;
+export type firstChar<s extends string> = s extends `${infer head}${string}` ? head : "";
+export type charsAfterFirst<s extends string> = s extends `${string}${infer tail}` ? tail : "";
+export type lastChar<s extends string> = s extends `${infer head}${infer tail}` ? tail extends "" ? head : lastChar<tail> : s;
+export type charsBeforeLast<s extends string> = s extends `${infer head}${infer tail}` ? tail extends "" ? "" : `${head}${charsBeforeLast<tail>}` : "";
+export type contains<s extends string, sub extends string> = s extends `${string}${sub}${string}` ? true : false;
+export declare const anchoredRegex: (regex: RegExp | string) => RegExp;
+export declare const deanchoredRegex: (regex: RegExp | string) => RegExp;
+export declare const anchoredSource: (regex: RegExp | string) => string;
+export declare const deanchoredSource: (regex: RegExp | string) => string;
+export declare const RegexPatterns: {
+    negativeLookahead: (pattern: string) => `(?!${string})`;
+    nonCapturingGroup: (pattern: string) => `(?:${string})`;
+};
+export declare const Backslash = "\\";
+export type Backslash = typeof Backslash;
+export declare const whitespaceChars: {
+    readonly " ": 1;
+    readonly "\n": 1;
+    readonly "\t": 1;
+};
+export type WhitespaceChar = keyof typeof whitespaceChars;
+export type trim<s extends string> = trimEnd<trimStart<s>>;
+export type trimStart<s extends string> = s extends `${WhitespaceChar}${infer tail}` ? trimEnd<tail> : s;
+export type trimEnd<s extends string> = s extends `${infer init}${WhitespaceChar}` ? trimEnd<init> : s;
+export type isStringLiteral<t> = [
+    t
+] extends [string] ? [
+    string
+] extends [t] ? false : Uppercase<t> extends Uppercase<Lowercase<t>> ? Lowercase<t> extends Lowercase<Uppercase<t>> ? true : false : false : false;
+export declare const emojiToUnicode: (emoji: string) => string;
+export declare const alphabet: readonly ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];

package/node_modules/@ark/util/out/strings.js

@@ -0,0 +1,59 @@
+export const capitalize = (s) => (s[0].toUpperCase() + s.slice(1));
+export const uncapitalize = (s) => (s[0].toLowerCase() + s.slice(1));
+export const anchoredRegex = (regex) => new RegExp(anchoredSource(regex), typeof regex === "string" ? "" : regex.flags);
+export const deanchoredRegex = (regex) => new RegExp(deanchoredSource(regex), typeof regex === "string" ? "" : regex.flags);
+export const anchoredSource = (regex) => {
+    const source = typeof regex === "string" ? regex : regex.source;
+    return `^(?:${source})$`;
+};
+export const deanchoredSource = (regex) => {
+    const source = typeof regex === "string" ? regex : regex.source;
+    if (source.startsWith("^(?:") && source.endsWith(")$"))
+        return source.slice(4, -2);
+    return source.slice(source[0] === "^" ? 1 : 0, source[source.length - 1] === "$" ? -1 : undefined);
+};
+export const RegexPatterns = {
+    negativeLookahead: (pattern) => `(?!${pattern})`,
+    nonCapturingGroup: (pattern) => `(?:${pattern})`
+};
+export const Backslash = "\\";
+export const whitespaceChars = {
+    " ": 1,
+    "\n": 1,
+    "\t": 1
+};
+export const emojiToUnicode = (emoji) => emoji
+    .split("")
+    .map(char => {
+    const codePoint = char.codePointAt(0);
+    return codePoint ? `\\u${codePoint.toString(16).padStart(4, "0")}` : "";
+})
+    .join("");
+export const alphabet = [
+    "a",
+    "b",
+    "c",
+    "d",
+    "e",
+    "f",
+    "g",
+    "h",
+    "i",
+    "j",
+    "k",
+    "l",
+    "m",
+    "n",
+    "o",
+    "p",
+    "q",
+    "r",
+    "s",
+    "t",
+    "u",
+    "v",
+    "w",
+    "x",
+    "y",
+    "z"
+];

package/node_modules/@ark/util/out/traits.d.ts

@@ -0,0 +1,89 @@
+import type { array } from "./arrays.ts";
+import type { conform, satisfy, show } from "./generics.ts";
+import type { intersectParameters } from "./intersections.ts";
+import { type Constructor } from "./objectKinds.ts";
+import { NoopBase } from "./records.ts";
+export type TraitImplementation = <traits extends TraitConstructor[], implementation extends implementationOf<s>, s extends CompositionState = composeTraits<[
+    ...traits,
+    implementation
+], "implementation">, cls extends TraitConstructor = TraitConstructor<s["params"], s["implemented"], s["statics"], s["abstractMethods"], s["abstractProps"], s["abstractStatics"]>>(...args: [...traits, implementation & ThisType<InstanceType<cls>>]) => cls;
+export type TraitComposition = <traits extends TraitConstructor[], s extends CompositionState = composeTraits<traits, "abstract">>(...traits: conform<traits, s["validated"]>) => TraitConstructor<s["params"], s["implemented"], s["statics"], s["abstractMethods"], s["abstractProps"], s["abstractStatics"]>;
+export declare const hasTrait: (traitClass: Constructor) => (o: unknown) => boolean;
+export type TraitDeclaration = {
+    abstractMethods?: object;
+    abstractProps?: object;
+    abstractStatics?: object;
+    dynamicBase?: object;
+};
+/** @ts-ignore required to extend NoopBase */
+export declare abstract class Trait<d extends TraitDeclaration = {}, abstractMethods extends object = d["abstractMethods"] & {}, abstractProps extends object = d["abstractProps"] & {}, abstractStatics extends object = d["abstractStatics"] & {}, dynamicBase extends object = d["dynamicBase"] & {}> extends NoopBase<abstractMethods & abstractProps & dynamicBase> {
+    abstractMethods: abstractMethods;
+    abstractProps: abstractProps;
+    abstractStatic: abstractStatics;
+    static get [Symbol.hasInstance](): (o: unknown) => boolean;
+    traitsOf(): readonly TraitConstructor[];
+}
+export declare const compose: TraitComposition;
+export declare const implement: TraitImplementation;
+export type TraitConstructor<params extends array = any[], instance extends object = {}, statics = {}, abstractMethods extends object = {}, abstractProps extends object = {}, abstractStatics extends object = {}> = statics & (new (...args: params) => Trait<{
+    abstractMethods: abstractMethods;
+    abstractProps: abstractProps;
+    abstractStatics: abstractStatics;
+}> & instance);
+type CompositionState = {
+    validated: array;
+    remaining: array;
+    params: array;
+    kind: TraitCompositionKind;
+    implemented: object;
+    abstractMethods: object;
+    abstractProps: object;
+    abstractStatics: object;
+    statics: object;
+};
+export type TraitCompositionKind = "abstract" | "implementation";
+export type composeTraits<traits extends array, kind extends TraitCompositionKind> = _compose<{
+    validated: [];
+    remaining: traits;
+    kind: kind;
+    params: [];
+    implemented: {};
+    abstractMethods: {};
+    abstractProps: {};
+    abstractStatics: {};
+    statics: {};
+}>;
+type intersectImplementations<l, r> = {
+    [k in keyof l]: k extends keyof r ? l[k] extends (...args: infer lArgs) => infer lReturn ? r[k] extends (...args: infer rArgs) => infer rReturn ? (...args: intersectParameters<lArgs, rArgs>) => lReturn & rReturn : l[k] & r[k] : l[k] & r[k] : l[k];
+} & Omit<r, keyof l>;
+type _compose<s extends CompositionState> = s["remaining"] extends (readonly [
+    TraitConstructor<infer params, infer instance, infer statics, infer abstractMethods, infer abstractProps, infer abstractStatics>,
+    ...infer tail
+]) ? _compose<{
+    validated: [...s["validated"], s["remaining"][0]];
+    remaining: tail;
+    kind: s["kind"];
+    params: intersectParameters<s["params"], params>;
+    implemented: intersectImplementations<s["implemented"], Omit<instance, keyof abstractMethods | keyof abstractProps>>;
+    statics: intersectImplementations<s["statics"], Omit<statics, keyof abstractStatics>>;
+    abstractMethods: intersectImplementations<s["abstractMethods"], abstractMethods>;
+    abstractProps: intersectImplementations<s["abstractProps"], abstractProps>;
+    abstractStatics: intersectImplementations<s["abstractStatics"], abstractStatics>;
+}> : finalizeState<s>;
+type finalizeState<s extends CompositionState> = satisfy<CompositionState, {
+    params: s["params"];
+    validated: s["validated"];
+    remaining: s["remaining"];
+    kind: s["kind"];
+    implemented: show<s["implemented"]>;
+    statics: show<Omit<s["statics"], keyof typeof Trait>>;
+    abstractMethods: show<Omit<s["abstractMethods"], keyof s["implemented"]>>;
+    abstractProps: show<Omit<s["abstractProps"], keyof s["implemented"]>>;
+    abstractStatics: show<Omit<s["abstractStatics"], keyof s["statics"]>>;
+}>;
+export type implementationOf<s extends CompositionState> = s["abstractMethods"] & ({} extends s["abstractProps"] ? {} : {
+    construct: (...args: s["params"]) => s["abstractProps"];
+}) & ({} extends s["abstractStatics"] ? {} : {
+    statics: s["abstractStatics"];
+});
+export {};