@blade-hq/agent-client 1.1.1 → 1.1.3

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

@@ -0,0 +1,205 @@
+import type { DescribeOptions } from "./describe.ts";
+import { type domainDescriptions, domainOf } from "./domain.ts";
+import type { Fn } from "./functions.ts";
+import type { satisfy } from "./generics.ts";
+export declare const ecmascriptConstructors: {
+    Array: ArrayConstructor;
+    Boolean: BooleanConstructor;
+    Date: DateConstructor;
+    Error: ErrorConstructor;
+    Function: FunctionConstructor;
+    Map: MapConstructor;
+    Number: NumberConstructor;
+    Promise: PromiseConstructor;
+    RegExp: RegExpConstructor;
+    Set: SetConstructor;
+    String: StringConstructor;
+    WeakMap: WeakMapConstructor;
+    WeakSet: WeakSetConstructor;
+};
+export type ecmascriptConstructors = typeof ecmascriptConstructors;
+export type EcmascriptObjects = satisfy<instantiateConstructors<keyof ecmascriptConstructors>, {
+    Array: Array<unknown>;
+    Boolean: Boolean;
+    Date: Date;
+    Error: Error;
+    Function: Function;
+    Map: Map<unknown, unknown>;
+    Number: Number;
+    RegExp: RegExp;
+    Set: Set<unknown>;
+    String: String;
+    WeakMap: WeakMap<object, unknown>;
+    WeakSet: WeakSet<object>;
+    Promise: Promise<unknown>;
+}>;
+/** Node18 */
+export declare const FileConstructor: typeof import("buffer").File;
+export type platformConstructors = {
+    ArrayBuffer: ArrayBufferConstructor;
+    Blob: typeof Blob;
+    File: typeof File;
+    FormData: typeof FormData;
+    Headers: typeof Headers;
+    Request: typeof Request;
+    Response: typeof Response;
+    URL: typeof URL;
+};
+export declare const platformConstructors: platformConstructors;
+export type PlatformObjects = instantiateConstructors<keyof platformConstructors>;
+export declare const typedArrayConstructors: {
+    Int8Array: Int8ArrayConstructor;
+    Uint8Array: Uint8ArrayConstructor;
+    Uint8ClampedArray: Uint8ClampedArrayConstructor;
+    Int16Array: Int16ArrayConstructor;
+    Uint16Array: Uint16ArrayConstructor;
+    Int32Array: Int32ArrayConstructor;
+    Uint32Array: Uint32ArrayConstructor;
+    Float32Array: Float32ArrayConstructor;
+    Float64Array: Float64ArrayConstructor;
+    BigInt64Array: BigInt64ArrayConstructor;
+    BigUint64Array: BigUint64ArrayConstructor;
+};
+export type typedArrayConstructors = typeof typedArrayConstructors;
+export type TypedArrayObjects = instantiateConstructors<keyof typedArrayConstructors>;
+export declare const builtinConstructors: {
+    String: StringConstructor;
+    Number: NumberConstructor;
+    Boolean: BooleanConstructor;
+    Int8Array: Int8ArrayConstructor;
+    Uint8Array: Uint8ArrayConstructor;
+    Uint8ClampedArray: Uint8ClampedArrayConstructor;
+    Int16Array: Int16ArrayConstructor;
+    Uint16Array: Uint16ArrayConstructor;
+    Int32Array: Int32ArrayConstructor;
+    Uint32Array: Uint32ArrayConstructor;
+    Float32Array: Float32ArrayConstructor;
+    Float64Array: Float64ArrayConstructor;
+    BigInt64Array: BigInt64ArrayConstructor;
+    BigUint64Array: BigUint64ArrayConstructor;
+    ArrayBuffer: ArrayBufferConstructor;
+    Blob: typeof Blob;
+    File: typeof File;
+    FormData: typeof FormData;
+    Headers: typeof Headers;
+    Request: typeof Request;
+    Response: typeof Response;
+    URL: typeof URL;
+    Array: ArrayConstructor;
+    Date: DateConstructor;
+    Error: ErrorConstructor;
+    Function: FunctionConstructor;
+    Map: MapConstructor;
+    Promise: PromiseConstructor;
+    RegExp: RegExpConstructor;
+    Set: SetConstructor;
+    WeakMap: WeakMapConstructor;
+    WeakSet: WeakSetConstructor;
+};
+export type builtinConstructors = typeof builtinConstructors;
+export type BuiltinObjectKind = keyof builtinConstructors;
+export type GlobalName = keyof typeof globalThis;
+type instantiateConstructors<kind extends BuiltinObjectKind> = {
+    [k in kind]: k extends GlobalName ? InstanceType<(typeof globalThis)[k]> : `${k}Constructor` extends GlobalName ? InstanceType<(typeof globalThis)[`${k}Constructor`]> : never;
+};
+export type BuiltinObjects = instantiateConstructors<BuiltinObjectKind>;
+export type objectKindOf<data extends object> = object extends data ? keyof builtinConstructors | undefined : data extends Fn ? "Function" : instantiableObjectKind<data> extends never ? undefined : instantiableObjectKind<data>;
+export type describeObject<o extends object, opts extends DescribeOptions = {}> = objectKindOf<o> extends string ? [
+    opts["includeArticles"]
+] extends [true] ? objectKindDescriptions[objectKindOf<o>] : objectKindOf<o> : [opts["includeArticles"]] extends [true] ? domainDescriptions["object"] : "object";
+type instantiableObjectKind<data extends object> = {
+    [kind in keyof builtinConstructors]: data extends (InstanceType<builtinConstructors[kind]>) ? kind : never;
+}[keyof builtinConstructors];
+export declare const objectKindOf: <data extends object>(data: data) => objectKindOf<data> | undefined;
+export declare const objectKindOrDomainOf: <data>(data: data) => (objectKindOf<data & object> & {}) | domainOf<data>;
+export type objectKindOrDomainOf<data> = data extends object ? objectKindOf<data> extends undefined ? "object" : objectKindOf<data> : domainOf<data>;
+export declare const hasObjectKind: <kind extends keyof builtinConstructors>(data: object, kind: kind) => data is InstanceType<builtinConstructors[kind]>;
+export declare const isArray: (data: unknown) => data is readonly unknown[];
+export declare const ecmascriptDescriptions: {
+    readonly Array: "an array";
+    readonly Function: "a function";
+    readonly Date: "a Date";
+    readonly RegExp: "a RegExp";
+    readonly Error: "an Error";
+    readonly Map: "a Map";
+    readonly Set: "a Set";
+    readonly String: "a String object";
+    readonly Number: "a Number object";
+    readonly Boolean: "a Boolean object";
+    readonly Promise: "a Promise";
+    readonly WeakMap: "a WeakMap";
+    readonly WeakSet: "a WeakSet";
+};
+export declare const platformDescriptions: {
+    ArrayBuffer: string;
+    Blob: string;
+    File: string;
+    FormData: string;
+    Headers: string;
+    Request: string;
+    Response: string;
+    URL: string;
+};
+export declare const typedArrayDescriptions: {
+    readonly Int8Array: "an Int8Array";
+    readonly Uint8Array: "a Uint8Array";
+    readonly Uint8ClampedArray: "a Uint8ClampedArray";
+    readonly Int16Array: "an Int16Array";
+    readonly Uint16Array: "a Uint16Array";
+    readonly Int32Array: "an Int32Array";
+    readonly Uint32Array: "a Uint32Array";
+    readonly Float32Array: "a Float32Array";
+    readonly Float64Array: "a Float64Array";
+    readonly BigInt64Array: "a BigInt64Array";
+    readonly BigUint64Array: "a BigUint64Array";
+};
+/** Each defaultObjectKind's completion for the phrase "must be _____" */
+export declare const objectKindDescriptions: {
+    readonly Int8Array: "an Int8Array";
+    readonly Uint8Array: "a Uint8Array";
+    readonly Uint8ClampedArray: "a Uint8ClampedArray";
+    readonly Int16Array: "an Int16Array";
+    readonly Uint16Array: "a Uint16Array";
+    readonly Int32Array: "an Int32Array";
+    readonly Uint32Array: "a Uint32Array";
+    readonly Float32Array: "a Float32Array";
+    readonly Float64Array: "a Float64Array";
+    readonly BigInt64Array: "a BigInt64Array";
+    readonly BigUint64Array: "a BigUint64Array";
+    readonly ArrayBuffer: string;
+    readonly Blob: string;
+    readonly File: string;
+    readonly FormData: string;
+    readonly Headers: string;
+    readonly Request: string;
+    readonly Response: string;
+    readonly URL: string;
+    readonly Array: "an array";
+    readonly Function: "a function";
+    readonly Date: "a Date";
+    readonly RegExp: "a RegExp";
+    readonly Error: "an Error";
+    readonly Map: "a Map";
+    readonly Set: "a Set";
+    readonly String: "a String object";
+    readonly Number: "a Number object";
+    readonly Boolean: "a Boolean object";
+    readonly Promise: "a Promise";
+    readonly WeakMap: "a WeakMap";
+    readonly WeakSet: "a WeakSet";
+};
+export type objectKindDescriptions = typeof objectKindDescriptions;
+/**
+ * this will only return an object kind if it's the root constructor
+ * example TypeError would return null not 'Error'
+ **/
+export declare const getBuiltinNameOfConstructor: (ctor: Function) => BuiltinObjectKind | null;
+export type Constructor<instance = {}> = abstract new (...args: never[]) => instance;
+export type instanceOf<constructor> = constructor extends Constructor<infer instance> ? instance : never;
+/**
+ * Returns an array of constructors for all ancestors (i.e., prototypes) of a given object.
+ */
+export declare const ancestorsOf: (o: object) => Function[];
+export type normalizedKeyOf<t> = keyof t extends infer k ? k extends number ? `${k}` : k : never;
+export declare const constructorExtends: (ctor: Constructor, base: Constructor) => boolean;
+export {};

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

@@ -0,0 +1,150 @@
+import { domainOf } from "./domain.js";
+import { isKeyOf } from "./records.js";
+// ECMAScript Objects
+// See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
+export const ecmascriptConstructors = {
+    Array,
+    Boolean,
+    Date,
+    Error,
+    Function,
+    Map,
+    Number,
+    Promise,
+    RegExp,
+    Set,
+    String,
+    WeakMap,
+    WeakSet
+};
+/** Node18 */
+export const FileConstructor = globalThis.File ?? Blob;
+// Platform APIs
+// See https://developer.mozilla.org/en-US/docs/Web/API
+// Must be implemented in Node etc. as well as the browser to include here
+export const platformConstructors = {
+    ArrayBuffer,
+    Blob,
+    File: FileConstructor,
+    FormData,
+    Headers,
+    Request,
+    Response,
+    URL
+};
+export const typedArrayConstructors = {
+    Int8Array,
+    Uint8Array,
+    Uint8ClampedArray,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    Float32Array,
+    Float64Array,
+    BigInt64Array,
+    BigUint64Array
+};
+// Built-in object constructors based on a subset of:
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
+export const builtinConstructors = {
+    ...ecmascriptConstructors,
+    ...platformConstructors,
+    ...typedArrayConstructors,
+    String,
+    Number,
+    Boolean
+};
+export const objectKindOf = (data) => {
+    let prototype = Object.getPrototypeOf(data);
+    while (prototype?.constructor &&
+        (!isKeyOf(prototype.constructor.name, builtinConstructors) ||
+            !(data instanceof builtinConstructors[prototype.constructor.name])))
+        prototype = Object.getPrototypeOf(prototype);
+    const name = prototype?.constructor?.name;
+    if (name === undefined || name === "Object")
+        return undefined;
+    return name;
+};
+export const objectKindOrDomainOf = (data) => (typeof data === "object" && data !== null ?
+    (objectKindOf(data) ?? "object")
+    : domainOf(data));
+export const hasObjectKind = (data, kind) => objectKindOf(data) === kind;
+export const isArray = Array.isArray;
+export const ecmascriptDescriptions = {
+    Array: "an array",
+    Function: "a function",
+    Date: "a Date",
+    RegExp: "a RegExp",
+    Error: "an Error",
+    Map: "a Map",
+    Set: "a Set",
+    String: "a String object",
+    Number: "a Number object",
+    Boolean: "a Boolean object",
+    Promise: "a Promise",
+    WeakMap: "a WeakMap",
+    WeakSet: "a WeakSet"
+};
+export const platformDescriptions = {
+    ArrayBuffer: "an ArrayBuffer instance",
+    Blob: "a Blob instance",
+    File: "a File instance",
+    FormData: "a FormData instance",
+    Headers: "a Headers instance",
+    Request: "a Request instance",
+    Response: "a Response instance",
+    URL: "a URL instance"
+};
+export const typedArrayDescriptions = {
+    Int8Array: "an Int8Array",
+    Uint8Array: "a Uint8Array",
+    Uint8ClampedArray: "a Uint8ClampedArray",
+    Int16Array: "an Int16Array",
+    Uint16Array: "a Uint16Array",
+    Int32Array: "an Int32Array",
+    Uint32Array: "a Uint32Array",
+    Float32Array: "a Float32Array",
+    Float64Array: "a Float64Array",
+    BigInt64Array: "a BigInt64Array",
+    BigUint64Array: "a BigUint64Array"
+};
+/** Each defaultObjectKind's completion for the phrase "must be _____" */
+export const objectKindDescriptions = {
+    ...ecmascriptDescriptions,
+    ...platformDescriptions,
+    ...typedArrayDescriptions
+};
+/**
+ * this will only return an object kind if it's the root constructor
+ * example TypeError would return null not 'Error'
+ **/
+export const getBuiltinNameOfConstructor = (ctor) => {
+    const constructorName = Object(ctor).name ?? null;
+    return (constructorName &&
+        isKeyOf(constructorName, builtinConstructors) &&
+        builtinConstructors[constructorName] === ctor) ?
+        constructorName
+        : null;
+};
+/**
+ * Returns an array of constructors for all ancestors (i.e., prototypes) of a given object.
+ */
+export const ancestorsOf = (o) => {
+    let proto = Object.getPrototypeOf(o);
+    const result = [];
+    while (proto !== null) {
+        result.push(proto.constructor);
+        proto = Object.getPrototypeOf(proto);
+    }
+    return result;
+};
+export const constructorExtends = (ctor, base) => {
+    let current = ctor.prototype;
+    while (current !== null) {
+        if (current === base.prototype)
+            return true;
+        current = Object.getPrototypeOf(current);
+    }
+    return false;
+};

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

@@ -0,0 +1,22 @@
+import { ReadonlyArray, type array } from "./arrays.ts";
+import type { requireKeys } from "./records.ts";
+import { type JsonArray } from "./serialize.ts";
+export type StringifyPathOptions<stringifiable = PropertyKey> = requireKeys<{
+    stringifySymbol?: (s: symbol) => string;
+    stringifyNonKey?: (o: Exclude<stringifiable, PropertyKey>) => string;
+}, stringifiable extends PropertyKey ? never : "stringifyNonKey">;
+export type StringifyPathFn = <stringifiable>(path: array<stringifiable>, ...[opts]: [stringifiable] extends [PropertyKey] ? [
+    opts?: StringifyPathOptions
+] : NoInfer<[opts: StringifyPathOptions<stringifiable>]>) => string;
+export type AppendStringifiedKeyFn = <stringifiable>(path: string, prop: stringifiable, ...[opts]: [stringifiable] extends [PropertyKey] ? [
+    opts?: StringifyPathOptions
+] : NoInfer<[opts: StringifyPathOptions<stringifiable>]>) => string;
+export declare const appendStringifiedKey: AppendStringifiedKeyFn;
+export declare const stringifyPath: StringifyPathFn;
+export declare class ReadonlyPath extends ReadonlyArray<PropertyKey> {
+    private cache;
+    constructor(...items: array<PropertyKey>);
+    toJSON(): JsonArray;
+    stringify(): string;
+    stringifyAncestors(): readonly string[];
+}

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

@@ -0,0 +1,65 @@
+import { ReadonlyArray } from "./arrays.js";
+import { throwParseError } from "./errors.js";
+import { isDotAccessible } from "./registry.js";
+import { printable } from "./serialize.js";
+export const appendStringifiedKey = (path, prop, ...[opts]) => {
+    const stringifySymbol = opts?.stringifySymbol ?? printable;
+    let propAccessChain = path;
+    switch (typeof prop) {
+        case "string":
+            propAccessChain =
+                isDotAccessible(prop) ?
+                    path === "" ?
+                        prop
+                        : `${path}.${prop}`
+                    : `${path}[${JSON.stringify(prop)}]`;
+            break;
+        case "number":
+            propAccessChain = `${path}[${prop}]`;
+            break;
+        case "symbol":
+            propAccessChain = `${path}[${stringifySymbol(prop)}]`;
+            break;
+        default:
+            if (opts?.stringifyNonKey)
+                propAccessChain = `${path}[${opts.stringifyNonKey(prop)}]`;
+            else {
+                throwParseError(`${printable(prop)} must be a PropertyKey or stringifyNonKey must be passed to options`);
+            }
+    }
+    return propAccessChain;
+};
+export const stringifyPath = (path, ...opts) => path.reduce((s, k) => appendStringifiedKey(s, k, ...opts), "");
+export class ReadonlyPath extends ReadonlyArray {
+    // alternate strategy for caching since the base object is frozen
+    cache = {};
+    constructor(...items) {
+        super();
+        this.push(...items);
+    }
+    toJSON() {
+        if (this.cache.json)
+            return this.cache.json;
+        this.cache.json = [];
+        for (let i = 0; i < this.length; i++) {
+            this.cache.json.push(typeof this[i] === "symbol" ? printable(this[i]) : this[i]);
+        }
+        return this.cache.json;
+    }
+    stringify() {
+        if (this.cache.stringify)
+            return this.cache.stringify;
+        return (this.cache.stringify = stringifyPath(this));
+    }
+    stringifyAncestors() {
+        if (this.cache.stringifyAncestors)
+            return this.cache.stringifyAncestors;
+        let propString = "";
+        const result = [propString];
+        for (const path of this) {
+            propString = appendStringifiedKey(propString, path);
+            result.push(propString);
+        }
+        return (this.cache.stringifyAncestors = result);
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { inferDomain } from "./domain.ts";
+import type { BigintLiteral } from "./numbers.ts";
+type SerializedString<value extends string = string> = `"${value}"`;
+export type SerializedPrimitives = {
+    string: SerializedString;
+    number: `${number}`;
+    bigint: BigintLiteral;
+    boolean: "true" | "false";
+    null: "null";
+    undefined: "undefined";
+};
+export type SerializedPrimitive = SerializedPrimitives[keyof SerializedPrimitives];
+export type SerializablePrimitive = inferDomain<keyof SerializedPrimitives>;
+export declare const serializePrimitive: <value extends SerializablePrimitive>(value: value) => serializePrimitive<value>;
+export type serializePrimitive<value extends SerializablePrimitive> = value extends string ? `"${value}"` : value extends bigint ? `${value}n` : `${value}`;
+export {};

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

@@ -0,0 +1,3 @@
+export const serializePrimitive = (value) => (typeof value === "string" ? JSON.stringify(value)
+    : typeof value === "bigint" ? `${value}n`
+        : `${value}`);

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

@@ -0,0 +1,183 @@
+import type { array } from "./arrays.ts";
+import type { Primitive } from "./domain.ts";
+import type { Fn } from "./functions.ts";
+import type { defined, show } from "./generics.ts";
+import type { Key } from "./keys.ts";
+import type { intersectUnion } from "./unionToTuple.ts";
+export type Dict<k extends string = string, v = unknown> = {
+    readonly [_ in k]: v;
+};
+export type dict<v = unknown, k extends string = string> = {
+    [_ in k]: v;
+};
+/** Either:
+ * A, with all properties of B undefined
+ * OR
+ * B, with all properties of A undefined
+ **/
+export type propwiseXor<a, b> = show<a & {
+    [k in keyof b]?: undefined;
+}> | show<b & {
+    [k in keyof a]?: undefined;
+}>;
+export type unionToPropwiseXor<props extends object, branchKey extends PropertyKey = keyof intersectUnion<props>> = props extends infer distributed ? show<distributed & {
+    [k in branchKey]?: k extends keyof distributed ? unknown : undefined;
+}> : never;
+export type requireKeys<o, key extends keyof o> = o & {
+    [requiredKey in key]-?: defined<o[requiredKey]>;
+};
+export type require<o, maxDepth extends number = 1> = _require<o, [], maxDepth>;
+type _require<o, depth extends 1[], maxDepth extends number> = depth["length"] extends maxDepth ? o : o extends object ? o extends Fn ? o : {
+    [k in keyof o]-?: _require<o[k], [...depth, 1], maxDepth>;
+} : o;
+export type PartialRecord<k extends PropertyKey = PropertyKey, v = unknown> = {
+    [_ in k]?: v;
+};
+/** Returns true if a type can be homomorphically mapped without losing information.
+ * Useful for avoiding e.g. classes with private properties while mapping.
+ */
+export type isSafelyMappable<t> = {
+    [k in keyof t]: t[k];
+} extends t ? true : false;
+export type KeySet<key extends string = string> = {
+    readonly [_ in key]?: 1;
+};
+export type keySetOf<o extends object> = KeySet<Extract<keyof o, string>>;
+export type mutable<o, maxDepth extends number = 1> = _mutable<o, [], maxDepth>;
+type _mutable<o, depth extends 1[], maxDepth extends number> = depth["length"] extends maxDepth ? o : o extends Primitive ? o : o extends Fn ? o : {
+    -readonly [k in keyof o]: _mutable<o[k], [...depth, 1], maxDepth>;
+};
+/**
+ * extracts entries mimicking Object.entries, accounting for whether the
+ * object is an array
+ **/
+export type entryOf<o> = {
+    [k in keyof o]-?: [k, o[k] & ({} | null)];
+}[o extends readonly unknown[] ? keyof o & number : keyof o] & unknown;
+export type entriesOf<o extends object> = entryOf<o>[];
+/**
+ * Object.entries wrapper providing narrowed types for objects with known sets
+ * of keys, e.g. those defined internally as configs
+ */
+export declare const entriesOf: <o extends object>(o: o) => entryOf<o>[];
+export type Entry<key extends PropertyKey = PropertyKey, value = unknown> = readonly [key: key, value: value];
+export type fromEntries<entries extends readonly Entry[]> = show<{
+    [entry in entries[number] as entry[0]]: entry[1];
+}>;
+export declare const fromEntries: <const entries extends readonly Entry[]>(entries: entries) => fromEntries<entries>;
+/** Mimics the result of Object.keys(...) */
+export type keyOf<o> = o extends array ? number extends o["length"] ? `${number}` : keyof o & `${number}` : keyof o extends infer k ? k extends string ? k : k extends number ? `${k}` : never : never;
+export declare const keysOf: <o extends object>(o: o) => keyOf<o>[];
+export declare const isKeyOf: <k extends string | number | symbol, o extends object>(k: k, o: o) => k is Extract<keyof o, k>;
+/** Coalesce keys that exist on one or more branches of a union */
+export type unionKeyOf<t> = t extends unknown ? keyof t : never;
+export type extractKeyed<o extends object, k extends unionKeyOf<o>> = Extract<o, {
+    [_ in k]?: unknown;
+}>;
+export declare const hasKey: <o extends object, k extends unionKeyOf<o>>(o: o, k: k) => o is extractKeyed<o, k>;
+export type extractDefinedKey<o extends object, k extends unionKeyOf<o>> = show<extractKeyed<o, k> & {
+    [_ in k]: {} | null;
+}>;
+export declare const hasDefinedKey: <o extends object, k extends unionKeyOf<o>>(o: o, k: k) => o is extractDefinedKey<o, k>;
+export type requiredKeyOf<o> = keyof o extends infer k ? k extends keyof o ? o extends {
+    [_ in k]-?: o[k];
+} ? k : never : never : never;
+export type optionalKeyOf<o> = Exclude<keyof o, requiredKeyOf<o>>;
+export type merge<base, props> = base extends unknown ? props extends unknown ? keyof base & keyof props extends never ? show<base & props> : show<omit<base, keyof props & keyof base> & props> : never : never;
+export type override<base, merged extends {
+    [k in keyof base]?: unknown;
+}> = merge<base, merged>;
+export type propValueOf<o> = o[keyof o];
+export declare const InnerDynamicBase: new <t extends object>(base: t) => t;
+export declare class Covariant<t> {
+    /**
+     * Patterns of the form `interface Example<T> extends T {}` don't count as using `T`.
+     * From tsc's point of view when calculating variance it may as well look like `interface Example<T> {}`.
+     * Fundamentally this ordinarily means `Example<T>` will always be assignable to `Example<U>` and
+     * vice versa.
+     *
+     * Obviously this is a problem, so `Covariant` exists to add an unobtrusive covariant usage of the type
+     * parameter, making `Example<T>` assignable to `Example<U>` only if `T` is a subtype of `U`.
+     */
+    private " covariant"?;
+}
+/** @ts-ignore (needed to extend `t`) **/
+export interface DynamicBase<t extends object> extends t, Covariant<t> {
+}
+export declare class DynamicBase<t extends object> {
+    constructor(properties: t);
+}
+export declare const NoopBase: new <t extends object>() => t;
+/** @ts-ignore (needed to extend `t`) **/
+export declare class CastableBase<t extends object> extends NoopBase<t> {
+    private " covariant"?;
+}
+export declare const splitByKeys: <o extends object, leftKeys extends keySetOf<o>>(o: o, leftKeys: leftKeys) => [show<Pick<o, keyof leftKeys & keyof o>>, show<Omit<o, keyof leftKeys & keyof o>>];
+/** Homomorphic implementation of the builtin Pick.
+ *
+ * Gives different results for certain union expressions like the following:
+ *
+ * @example
+ * // flattens result to { a?: 1 | 2; b?: 1 | 2 }
+ * type PickResult = Pick<{ a: 1; b?: 1 } | { a?: 2; b: 2 }, "a" | "b">
+ *
+ * @example
+ * // preserves original type w/ modifier groupings
+ * type pickResult = pick<{ a: 1; b?: 1 } | { a?: 2; b: 2 }, "a" | "b">
+ */
+export type pick<o, key extends keyof o> = o extends unknown ? {
+    [k in keyof o as k extends key ? k : never]: o[k];
+} : never;
+export declare const pick: <o extends object, keys extends keySetOf<o>>(o: o, keys: keys) => pick<o, keyof keys & keyof o>;
+/** Homomorphic implementation of the builtin Omit.
+ *
+ * Gives different results for many union expressions like the following:
+ *
+ * @example
+ * // {}
+ * type OmitResult = Omit<{ a: 1 } | { b: 2 }, never>
+ *
+ * @example
+ * // preserves original type w/ modifier groupings
+ * type omitResult = omit<{ a: 1 } | { b: 2 }, never>
+ */
+export type omit<o, key extends keyof o> = {
+    [k in keyof o as k extends key ? never : k]: o[k];
+};
+export declare const omit: <o extends object, keys extends keySetOf<o>>(o: o, keys: keys) => omit<o, keyof keys & keyof o>;
+/** Returns onTrue if the type is exactly `{}` and onFalse otherwise*/
+export type ifEmptyObjectLiteral<t, onTrue = true, onFalse = false> = [
+    unknown,
+    t & (null | undefined)
+] extends [t | null | undefined, never] ? onTrue : onFalse;
+export type EmptyObject = Record<PropertyKey, never>;
+export declare const isEmptyObject: (o: object) => o is EmptyObject;
+export declare const stringAndSymbolicEntriesOf: (o: object) => Entry<Key>[];
+/** Like Object.assign, but it will preserve getters instead of evaluating them. */
+export declare const defineProperties: <base extends object, merged extends object>(base: base, merged: merged) => merge<base, merged>;
+/** Copies enumerable keys of o to a new object in alphabetical order */
+export declare const withAlphabetizedKeys: <o extends object>(o: o) => o;
+export type invert<t extends Record<PropertyKey, PropertyKey>> = {
+    [k in t[keyof t]]: {
+        [k2 in keyof t]: t[k2] extends k ? k2 : never;
+    }[keyof t];
+} & unknown;
+export declare const invert: <t extends Record<PropertyKey, PropertyKey>>(t: t) => invert<t>;
+export declare const unset: " unset​";
+export type unset = typeof unset;
+/**
+ *  For each keyof o that also exists on jsDocSource, add associated JsDoc annotations to o.
+ *  Does not preserve modifiers on o like optionality.
+ */
+export type withJsDoc<o, jsDocSource> = show<keyof o extends keyof jsDocSource ? keyof jsDocSource extends keyof o ? _withJsDoc<o, jsDocSource> : Pick<_withJsDoc<o, jsDocSource>, keyof o & keyof jsDocSource> : Pick<_withJsDoc<o, jsDocSource>, keyof o & keyof jsDocSource> & {
+    [k in Exclude<keyof o, keyof jsDocSource>]: o[k];
+}>;
+type _withJsDoc<o, jsDocSource> = {
+    [k in keyof jsDocSource]-?: o[k & keyof o];
+};
+export type propertyDescriptorsOf<o extends object> = {
+    [k in keyof o]: TypedPropertyDescriptor<o[k]>;
+};
+export type keyWithValue<t, constraint> = keyof t extends infer k ? k extends keyof t ? t[k] extends constraint ? k : never : never : never;
+export declare const enumValues: <tsEnum extends object>(tsEnum: tsEnum) => tsEnum[keyof tsEnum][];
+export {};