@blade-hq/agent-client 1.1.1 → 1.1.2

package/node_modules/@ark/schema/out/shared/toJsonSchema.d.ts

@@ -0,0 +1,139 @@
+import { type Constructor, type Domain, type Json, type requireKeys, type satisfy } from "@ark/util";
+import type { Predicate } from "../predicate.ts";
+import type { ConstraintKind } from "./implement.ts";
+import type { JsonSchema } from "./jsonSchema.ts";
+import type { StandardJSONSchemaV1 } from "./standardSchema.ts";
+declare class ToJsonSchemaError<code extends ToJsonSchema.Code = ToJsonSchema.Code> extends Error {
+    readonly name = "ToJsonSchemaError";
+    readonly code: code;
+    readonly context: ToJsonSchema.ContextByCode[code];
+    constructor(code: code, context: ToJsonSchema.ContextByCode[code]);
+    hasCode<code extends ToJsonSchema.Code>(code: code): this is ToJsonSchemaError<code>;
+}
+export declare const ToJsonSchema: {
+    Error: typeof ToJsonSchemaError;
+    throw: (code: keyof ToJsonSchema.ContextByCode, context: ToJsonSchema.MorphContext | ToJsonSchema.UnitContext | ToJsonSchema.ProtoContext | ToJsonSchema.DomainContext | ToJsonSchema.PredicateContext | ToJsonSchema.DateContext | ToJsonSchema.ArrayObjectContext | ToJsonSchema.ArrayPostfixContext | ToJsonSchema.DefaultValueContext | ToJsonSchema.PatternIntersectionContext | ToJsonSchema.SymbolKeyContext) => never;
+    throwInternalOperandError: (kind: ConstraintKind, schema: JsonSchema) => never;
+    defaultConfig: ToJsonSchema.Context;
+};
+export declare namespace ToJsonSchema {
+    type Unjsonifiable = object | symbol | bigint | undefined;
+    type Error = InstanceType<typeof ToJsonSchema.Error>;
+    interface BaseContext<code extends Code, base extends JsonSchema = JsonSchema> {
+        code: code;
+        base: base;
+    }
+    interface ArrayObjectContext extends BaseContext<"arrayObject", JsonSchema.Array> {
+        object: JsonSchema.Object;
+    }
+    interface ArrayPostfixContext extends BaseContext<"arrayPostfix", VariadicArraySchema> {
+        elements: readonly JsonSchema[];
+    }
+    interface DefaultValueContext extends BaseContext<"defaultValue", JsonSchema> {
+        value: Unjsonifiable;
+    }
+    interface DomainContext extends BaseContext<"domain", JsonSchema> {
+        domain: satisfy<Domain, "symbol" | "bigint" | "undefined">;
+    }
+    interface MorphContext extends BaseContext<"morph", JsonSchema> {
+        out: JsonSchema | null;
+    }
+    interface PatternIntersectionContext extends BaseContext<"patternIntersection", StringSchemaWithPattern> {
+        pattern: string;
+    }
+    interface PredicateContext extends BaseContext<"predicate", JsonSchema> {
+        predicate: Predicate;
+    }
+    interface ProtoContext extends BaseContext<"proto", JsonSchema> {
+        proto: Constructor;
+    }
+    type SymbolKeyContext = IndexSymbolKeyContext | RequiredSymbolKeyContext | OptionalSymbolKeyContext;
+    interface IndexSymbolKeyContext extends BaseContext<"symbolKey", JsonSchema.Object> {
+        key: null;
+        value: JsonSchema;
+        optional: false;
+    }
+    interface RequiredSymbolKeyContext extends BaseContext<"symbolKey", JsonSchema.Object> {
+        key: symbol;
+        value: JsonSchema;
+        optional: false;
+    }
+    interface OptionalSymbolKeyContext extends BaseContext<"symbolKey", JsonSchema.Object> {
+        key: symbol;
+        value: JsonSchema;
+        optional: true;
+        default?: Json;
+    }
+    interface UnitContext extends BaseContext<"unit", JsonSchema> {
+        unit: Unjsonifiable;
+    }
+    interface DateContext extends BaseContext<"date", JsonSchema> {
+        before?: Date;
+        after?: Date;
+    }
+    interface ContextByCode {
+        arrayObject: ArrayObjectContext;
+        arrayPostfix: ArrayPostfixContext;
+        defaultValue: DefaultValueContext;
+        domain: DomainContext;
+        morph: MorphContext;
+        patternIntersection: PatternIntersectionContext;
+        predicate: PredicateContext;
+        proto: ProtoContext;
+        symbolKey: SymbolKeyContext;
+        unit: UnitContext;
+        date: DateContext;
+    }
+    type Code = keyof ContextByCode;
+    type FallbackContext = ContextByCode[Code];
+    type HandlerByCode = satisfy<{
+        [code in Code]: (ctx: ContextByCode[code]) => unknown;
+    }, {
+        arrayObject: (ctx: ArrayObjectContext) => JsonSchema.Structure;
+        arrayPostfix: (ctx: ArrayPostfixContext) => VariadicArraySchema;
+        defaultValue: (ctx: DefaultValueContext) => JsonSchema;
+        domain: (ctx: DomainContext) => JsonSchema;
+        morph: (ctx: MorphContext) => JsonSchema;
+        patternIntersection: (ctx: PatternIntersectionContext) => JsonSchema.String;
+        predicate: (ctx: PredicateContext) => JsonSchema;
+        proto: (ctx: ProtoContext) => JsonSchema;
+        symbolKey: (ctx: SymbolKeyContext) => JsonSchema.Object;
+        unit: (ctx: UnitContext) => JsonSchema;
+        date: (ctx: DateContext) => JsonSchema;
+    }>;
+    type VariadicArraySchema = requireKeys<JsonSchema.Array, "items">;
+    type StringSchemaWithPattern = requireKeys<JsonSchema.String, "pattern">;
+    type UniversalFallback = (ctx: FallbackContext) => JsonSchema;
+    interface FallbackObject extends Partial<HandlerByCode> {
+        default?: UniversalFallback;
+    }
+    type FallbackOption = UniversalFallback | FallbackObject;
+    type Target = satisfy<StandardJSONSchemaV1.Target, "draft-2020-12" | "draft-07">;
+    interface Options {
+        /** value to assign to the generated $schema key
+         *
+         *  - set to `null` to omit the `$schema` key
+         *  - does not affect the contents of the generated schema
+         *  - if `target` is also specified, `dialect` takes precedence
+         *
+         * @default "https://json-schema.org/draft/2020-12/schema"
+         */
+        dialect?: string | null;
+        /**
+         * Shorthand for specifying the target JSON Schema version.
+         * Maps to the appropriate `dialect` URL.
+         *
+         *  - "draft-2020-12" -> "https://json-schema.org/draft/2020-12/schema"
+         *  - "draft-07" -> "http://json-schema.org/draft-07/schema#"
+         *
+         * If `dialect` is also specified, `dialect` takes precedence.
+         */
+        target?: Target;
+        useRefs?: boolean;
+        fallback?: FallbackOption;
+    }
+    interface Context extends Required<Options> {
+        fallback: HandlerByCode;
+    }
+}
+export {};

package/node_modules/@ark/schema/out/shared/toJsonSchema.js

@@ -0,0 +1,40 @@
+import { printable, throwInternalError } from "@ark/util";
+class ToJsonSchemaError extends Error {
+    name = "ToJsonSchemaError";
+    code;
+    context;
+    constructor(code, context) {
+        super(printable(context, { quoteKeys: false, indent: 4 }));
+        this.code = code;
+        this.context = context;
+    }
+    hasCode(code) {
+        return this.code === code;
+    }
+}
+const defaultConfig = {
+    target: "draft-2020-12",
+    dialect: "https://json-schema.org/draft/2020-12/schema",
+    useRefs: false,
+    fallback: {
+        arrayObject: ctx => ToJsonSchema.throw("arrayObject", ctx),
+        arrayPostfix: ctx => ToJsonSchema.throw("arrayPostfix", ctx),
+        defaultValue: ctx => ToJsonSchema.throw("defaultValue", ctx),
+        domain: ctx => ToJsonSchema.throw("domain", ctx),
+        morph: ctx => ToJsonSchema.throw("morph", ctx),
+        patternIntersection: ctx => ToJsonSchema.throw("patternIntersection", ctx),
+        predicate: ctx => ToJsonSchema.throw("predicate", ctx),
+        proto: ctx => ToJsonSchema.throw("proto", ctx),
+        symbolKey: ctx => ToJsonSchema.throw("symbolKey", ctx),
+        unit: ctx => ToJsonSchema.throw("unit", ctx),
+        date: ctx => ToJsonSchema.throw("date", ctx)
+    }
+};
+export const ToJsonSchema = {
+    Error: ToJsonSchemaError,
+    throw: (...args) => {
+        throw new ToJsonSchema.Error(...args);
+    },
+    throwInternalOperandError: (kind, schema) => throwInternalError(`Unexpected JSON Schema input for ${kind}: ${printable(schema)}`),
+    defaultConfig
+};

package/node_modules/@ark/schema/out/shared/traversal.d.ts

@@ -0,0 +1,117 @@
+import { ReadonlyPath, type array } from "@ark/util";
+import type { ResolvedConfig } from "../config.ts";
+import type { Morph } from "../roots/morph.ts";
+import { ArkError, ArkErrors, type ArkErrorCode, type ArkErrorInput, type NodeErrorContextInput } from "./errors.ts";
+export type MorphsAtPath = {
+    path: ReadonlyPath;
+    morphs: array<Morph>;
+};
+export type BranchTraversal = {
+    error: ArkError | undefined;
+    queuedMorphs: MorphsAtPath[];
+};
+export type InternalTraversal = Omit<Traversal, "error" | "mustBe" | "reject">;
+export declare class Traversal {
+    /**
+     * #### the path being validated or morphed
+     *
+     * ✅ array indices represented as numbers
+     * ⚠️ mutated during traversal - use `path.slice(0)` to snapshot
+     * 🔗 use {@link propString} for a stringified version
+     */
+    path: PropertyKey[];
+    /**
+     * #### {@link ArkErrors} that will be part of this traversal's finalized result
+     *
+     * ✅ will always be an empty array for a valid traversal
+     */
+    errors: ArkErrors;
+    /**
+     * #### the original value being traversed
+     */
+    root: unknown;
+    /**
+     * #### configuration for this traversal
+     *
+     * ✅ options can affect traversal results and error messages
+     * ✅ defaults < global config < scope config
+     * ✅ does not include options configured on individual types
+     */
+    config: ResolvedConfig;
+    queuedMorphs: MorphsAtPath[];
+    branches: BranchTraversal[];
+    seen: {
+        [id in string]?: unknown[];
+    };
+    constructor(root: unknown, config: ResolvedConfig);
+    /**
+     * #### the data being validated or morphed
+     *
+     * ✅ extracted from {@link root} at {@link path}
+     */
+    get data(): unknown;
+    /**
+     * #### a string representing {@link path}
+     *
+     * ✅ uses `.access` {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Property_accessors#dot_notation | where allowed by JS}, falling back to `[indexAccess]`
+     * @example
+     * const path = ["key1", Symbol("key2"), "key3", 4, "~key5"]
+     * const propString = 'key1[Symbol(key2)].key3[4]["~key5"]'
+     */
+    get propString(): string;
+    /**
+     * #### add an {@link ArkError} and return `false`
+     *
+     * ✅ useful for predicates like `.narrow`
+     */
+    reject(input: ArkErrorInput): false;
+    /**
+     * #### add an {@link ArkError} from a description and return `false`
+     *
+     * ✅ useful for predicates like `.narrow`
+     * 🔗 equivalent to {@link reject}({ expected })
+     */
+    mustBe(expected: string): false;
+    /**
+     * #### add and return an {@link ArkError}
+     *
+     * ✅ useful for morphs like `.pipe`
+     */
+    error<input extends ArkErrorInput>(input: input): ArkError<input extends {
+        code: ArkErrorCode;
+    } ? input["code"] : "predicate">;
+    /**
+     * #### whether {@link currentBranch} (or the traversal root, outside a union) has one or more errors
+     */
+    hasError(): boolean;
+    get currentBranch(): BranchTraversal | undefined;
+    queueMorphs(morphs: array<Morph>): void;
+    finalize(onFail?: ArkErrors.Handler | null): unknown;
+    get currentErrorCount(): number;
+    get failFast(): boolean;
+    pushBranch(): void;
+    popBranch(): BranchTraversal | undefined;
+    /**
+     * @internal
+     * Convenience for casting from InternalTraversal to Traversal
+     * for cases where the extra methods on the external type are expected, e.g.
+     * a morph or predicate.
+     */
+    get external(): this;
+    /**
+     * @internal
+     */
+    errorFromNodeContext<input extends NodeErrorContextInput>(input: input): ArkError<input["code"]>;
+    private errorFromContext;
+    private applyQueuedMorphs;
+    private applyMorphsAtPath;
+}
+export declare const traverseKey: <result>(key: PropertyKey, fn: () => result, ctx: InternalTraversal | undefined) => result;
+export type TraversalMethodsByKind<input = unknown> = {
+    Allows: TraverseAllows<input>;
+    Apply: TraverseApply<input>;
+    Optimistic: TraverseApply<input>;
+};
+export type TraversalKind = keyof TraversalMethodsByKind & {};
+export type TraverseAllows<data = unknown> = (data: data, ctx: InternalTraversal) => boolean;
+export type TraverseApply<data = unknown> = (data: data, ctx: InternalTraversal) => void;

package/node_modules/@ark/schema/out/shared/traversal.js

@@ -0,0 +1,226 @@
+import { ReadonlyPath, stringifyPath } from "@ark/util";
+import { ArkError, ArkErrors } from "./errors.js";
+import { isNode } from "./utils.js";
+export class Traversal {
+    /**
+     * #### the path being validated or morphed
+     *
+     * ✅ array indices represented as numbers
+     * ⚠️ mutated during traversal - use `path.slice(0)` to snapshot
+     * 🔗 use {@link propString} for a stringified version
+     */
+    path = [];
+    /**
+     * #### {@link ArkErrors} that will be part of this traversal's finalized result
+     *
+     * ✅ will always be an empty array for a valid traversal
+     */
+    errors = new ArkErrors(this);
+    /**
+     * #### the original value being traversed
+     */
+    root;
+    /**
+     * #### configuration for this traversal
+     *
+     * ✅ options can affect traversal results and error messages
+     * ✅ defaults < global config < scope config
+     * ✅ does not include options configured on individual types
+     */
+    config;
+    queuedMorphs = [];
+    branches = [];
+    seen = {};
+    constructor(root, config) {
+        this.root = root;
+        this.config = config;
+    }
+    /**
+     * #### the data being validated or morphed
+     *
+     * ✅ extracted from {@link root} at {@link path}
+     */
+    get data() {
+        let result = this.root;
+        for (const segment of this.path)
+            result = result?.[segment];
+        return result;
+    }
+    /**
+     * #### a string representing {@link path}
+     *
+     * @propString
+     */
+    get propString() {
+        return stringifyPath(this.path);
+    }
+    /**
+     * #### add an {@link ArkError} and return `false`
+     *
+     * ✅ useful for predicates like `.narrow`
+     */
+    reject(input) {
+        this.error(input);
+        return false;
+    }
+    /**
+     * #### add an {@link ArkError} from a description and return `false`
+     *
+     * ✅ useful for predicates like `.narrow`
+     * 🔗 equivalent to {@link reject}({ expected })
+     */
+    mustBe(expected) {
+        this.error(expected);
+        return false;
+    }
+    error(input) {
+        const errCtx = typeof input === "object" ?
+            input.code ?
+                input
+                : { ...input, code: "predicate" }
+            : { code: "predicate", expected: input };
+        return this.errorFromContext(errCtx);
+    }
+    /**
+     * #### whether {@link currentBranch} (or the traversal root, outside a union) has one or more errors
+     */
+    hasError() {
+        return this.currentErrorCount !== 0;
+    }
+    get currentBranch() {
+        return this.branches[this.branches.length - 1];
+    }
+    queueMorphs(morphs) {
+        const input = {
+            path: new ReadonlyPath(...this.path),
+            morphs
+        };
+        if (this.currentBranch)
+            this.currentBranch.queuedMorphs.push(input);
+        else
+            this.queuedMorphs.push(input);
+    }
+    finalize(onFail) {
+        if (this.queuedMorphs.length) {
+            if (typeof this.root === "object" &&
+                this.root !== null &&
+                this.config.clone)
+                this.root = this.config.clone(this.root);
+            this.applyQueuedMorphs();
+        }
+        if (this.hasError())
+            return onFail ? onFail(this.errors) : this.errors;
+        return this.root;
+    }
+    get currentErrorCount() {
+        return (this.currentBranch ?
+            this.currentBranch.error ?
+                1
+                : 0
+            : this.errors.count);
+    }
+    get failFast() {
+        return this.branches.length !== 0;
+    }
+    pushBranch() {
+        this.branches.push({
+            error: undefined,
+            queuedMorphs: []
+        });
+    }
+    popBranch() {
+        return this.branches.pop();
+    }
+    /**
+     * @internal
+     * Convenience for casting from InternalTraversal to Traversal
+     * for cases where the extra methods on the external type are expected, e.g.
+     * a morph or predicate.
+     */
+    get external() {
+        return this;
+    }
+    errorFromNodeContext(input) {
+        return this.errorFromContext(input);
+    }
+    errorFromContext(errCtx) {
+        const error = new ArkError(errCtx, this);
+        if (this.currentBranch)
+            this.currentBranch.error = error;
+        else
+            this.errors.add(error);
+        return error;
+    }
+    applyQueuedMorphs() {
+        // invoking morphs that are Nodes will reuse this context, potentially
+        // adding additional morphs, so we have to continue looping until
+        // queuedMorphs is empty rather than iterating over the list once
+        while (this.queuedMorphs.length) {
+            const queuedMorphs = this.queuedMorphs;
+            this.queuedMorphs = [];
+            for (const { path, morphs } of queuedMorphs) {
+                // even if we already have an error, apply morphs that are not at a path
+                // with errors to capture potential validation errors
+                if (this.errors.affectsPath(path))
+                    continue;
+                this.applyMorphsAtPath(path, morphs);
+            }
+        }
+    }
+    applyMorphsAtPath(path, morphs) {
+        const key = path[path.length - 1];
+        let parent;
+        if (key !== undefined) {
+            // find the object on which the key to be morphed exists
+            parent = this.root;
+            for (let pathIndex = 0; pathIndex < path.length - 1; pathIndex++)
+                parent = parent[path[pathIndex]];
+        }
+        for (const morph of morphs) {
+            // ensure morphs are applied relative to the correct path
+            // in case previous operations modified this.path
+            this.path = [...path];
+            const morphIsNode = isNode(morph);
+            const result = morph((parent === undefined ? this.root : parent[key]), this);
+            if (result instanceof ArkError) {
+                // if an ArkError was returned, ensure it has been added to errors
+                // (it may have already been added via ctx.error() within the morph)
+                // Only add if it's not already in the errors collection
+                if (!this.errors.includes(result))
+                    this.errors.add(result);
+                // skip any remaining morphs at the current path
+                break;
+            }
+            if (result instanceof ArkErrors) {
+                // if the morph was a direct reference to another node,
+                // errors will have been added directly via this piped context
+                if (!morphIsNode) {
+                    // otherwise, we have to ensure each error has been added
+                    this.errors.merge(result);
+                }
+                // skip any remaining morphs at the current path
+                this.queuedMorphs = [];
+                break;
+            }
+            // if the morph was successful, assign the result to the
+            // corresponding property, or to root if path is empty
+            if (parent === undefined)
+                this.root = result;
+            else
+                parent[key] = result;
+            // if the current morph queued additional morphs,
+            // applying them before subsequent morphs
+            this.applyQueuedMorphs();
+        }
+    }
+}
+export const traverseKey = (key, fn, 
+// ctx will be undefined if this node isn't context-dependent
+ctx) => {
+    if (!ctx)
+        return fn();
+    ctx.path.push(key);
+    const result = fn();
+    ctx.path.pop();
+    return result;
+};

package/node_modules/@ark/schema/out/shared/utils.d.ts

@@ -0,0 +1,34 @@
+import { type array, type mutable, type show, type Thunk } from "@ark/util";
+import type { BaseConstraint } from "../constraint.ts";
+import type { GenericRoot } from "../generic.ts";
+import type { InternalModule } from "../module.ts";
+import type { BaseNode } from "../node.ts";
+import type { BaseParseContext } from "../parse.ts";
+import type { BaseRoot } from "../roots/root.ts";
+import type { BaseScope } from "../scope.ts";
+import type { ArkError, ArkErrors } from "./errors.ts";
+export declare const makeRootAndArrayPropertiesMutable: <o extends object>(o: o) => makeRootAndArrayPropertiesMutable<o>;
+export type makeRootAndArrayPropertiesMutable<inner> = {
+    -readonly [k in keyof inner]: inner[k] extends array | undefined ? mutable<inner[k]> : inner[k];
+} & unknown;
+export type internalImplementationOf<external, typeOnlyKey extends keyof external = never> = {
+    [k in Exclude<keyof external, typeOnlyKey>]: external[k] extends ((...args: infer args) => unknown) ? (...args: {
+        [i in keyof args]: never;
+    }) => unknown : unknown;
+};
+export type arkKind = typeof arkKind;
+export declare const arkKind: " arkKind";
+export interface ArkKinds {
+    constraint: BaseConstraint;
+    root: BaseRoot;
+    scope: BaseScope;
+    generic: GenericRoot;
+    module: InternalModule;
+    error: ArkError;
+    errors: ArkErrors;
+    context: BaseParseContext;
+}
+export type ArkKind = show<keyof ArkKinds>;
+export declare const hasArkKind: <kind extends ArkKind>(value: unknown, kind: kind) => value is ArkKinds[kind];
+export declare const isNode: (value: unknown) => value is BaseNode;
+export type unwrapDefault<thunkableValue> = thunkableValue extends Thunk<infer returnValue> ? returnValue : thunkableValue;

package/node_modules/@ark/schema/out/shared/utils.js

@@ -0,0 +1,8 @@
+import { flatMorph, isArray, noSuggest } from "@ark/util";
+export const makeRootAndArrayPropertiesMutable = (o) => 
+// this cast should not be required, but it seems TS is referencing
+// the wrong parameters here?
+flatMorph(o, (k, v) => [k, isArray(v) ? [...v] : v]);
+export const arkKind = noSuggest("arkKind");
+export const hasArkKind = (value, kind) => value?.[arkKind] === kind;
+export const isNode = (value) => hasArkKind(value, "root") || hasArkKind(value, "constraint");

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

@@ -0,0 +1,46 @@
+import { BaseConstraint } from "../constraint.ts";
+import type { RootSchema, nodeOfKind } from "../kinds.ts";
+import { type BaseNode, type DeepNodeTransformContext, type DeepNodeTransformation } from "../node.ts";
+import type { BaseRoot } from "../roots/root.ts";
+import type { BaseNormalizedSchema, declareNode } from "../shared/declare.ts";
+import { type RootKind, type nodeImplementationOf } from "../shared/implement.ts";
+import { type TraverseAllows, type TraverseApply } from "../shared/traversal.ts";
+export declare namespace Index {
+    type KeyKind = Exclude<RootKind, "unit">;
+    type KeyNode = nodeOfKind<KeyKind>;
+    interface Schema extends BaseNormalizedSchema {
+        readonly signature: RootSchema<KeyKind>;
+        readonly value: RootSchema;
+    }
+    interface Inner {
+        readonly signature: KeyNode;
+        readonly value: BaseRoot;
+    }
+    interface Declaration extends declareNode<{
+        kind: "index";
+        schema: Schema;
+        normalizedSchema: Schema;
+        inner: Inner;
+        prerequisite: object;
+        intersectionIsOpen: true;
+        childKind: RootKind;
+    }> {
+    }
+    type Node = IndexNode;
+}
+export declare class IndexNode extends BaseConstraint<Index.Declaration> {
+    impliedBasis: BaseRoot;
+    expression: string;
+    flatRefs: import("../node.ts").FlatRef<BaseRoot<import("../roots/root.ts").InternalRootDeclaration>>[];
+    traverseAllows: TraverseAllows<object>;
+    traverseApply: TraverseApply<object>;
+    protected _transform(mapper: DeepNodeTransformation, ctx: DeepNodeTransformContext): BaseNode | null;
+    compile(): void;
+}
+export declare const Index: {
+    implementation: nodeImplementationOf<Index.Declaration>;
+    Node: typeof IndexNode;
+};
+export declare const writeEnumerableIndexBranches: (keys: string[]) => string;
+export declare const writeInvalidPropertyKeyMessage: <indexSchema extends string>(indexSchema: indexSchema) => writeInvalidPropertyKeyMessage<indexSchema>;
+export type writeInvalidPropertyKeyMessage<indexSchema extends string> = `Indexed key definition '${indexSchema}' must be a string or symbol`;