@blade-hq/agent-client 1.1.1 → 1.1.2

package/node_modules/@ark/schema/out/roots/union.d.ts

@@ -0,0 +1,99 @@
+import { type JsonStructure, type SerializedPrimitive, type array, type show } from "@ark/util";
+import type { NodeSchema, RootSchema, nodeOfKind } from "../kinds.ts";
+import type { BaseNode } from "../node.ts";
+import { type NodeCompiler } from "../shared/compile.ts";
+import type { BaseErrorContext, BaseNormalizedSchema, declareNode } from "../shared/declare.ts";
+import { Disjoint } from "../shared/disjoint.ts";
+import type { ArkError } from "../shared/errors.ts";
+import { type IntersectionContext, type RootKind, type UnionChildKind, type nodeImplementationOf } from "../shared/implement.ts";
+import type { JsonSchema } from "../shared/jsonSchema.ts";
+import { type RegisteredReference } from "../shared/registry.ts";
+import type { ToJsonSchema } from "../shared/toJsonSchema.ts";
+import { type TraverseAllows, type TraverseApply } from "../shared/traversal.ts";
+import type { Domain } from "./domain.ts";
+import type { Morph } from "./morph.ts";
+import { BaseRoot } from "./root.ts";
+export declare namespace Union {
+    type ChildKind = UnionChildKind;
+    type ChildSchema = NodeSchema<ChildKind>;
+    type ChildNode = nodeOfKind<ChildKind>;
+    type Schema = NormalizedSchema | readonly RootSchema[];
+    interface NormalizedSchema extends BaseNormalizedSchema {
+        readonly branches: array<RootSchema>;
+        readonly ordered?: true;
+    }
+    interface Inner {
+        readonly branches: readonly ChildNode[];
+        readonly ordered?: true;
+    }
+    interface ErrorContext extends BaseErrorContext<"union"> {
+        errors: readonly ArkError[];
+    }
+    interface Declaration extends declareNode<{
+        kind: "union";
+        schema: Schema;
+        normalizedSchema: NormalizedSchema;
+        inner: Inner;
+        errorContext: ErrorContext;
+        reducibleTo: RootKind;
+        childKind: UnionChildKind;
+    }> {
+    }
+    type Node = UnionNode;
+}
+export declare class UnionNode extends BaseRoot<Union.Declaration> {
+    isBoolean: boolean;
+    get branchGroups(): BaseRoot[];
+    unitBranches: (import("./morph.ts").MorphNode | import("./unit.ts").UnitNode)[];
+    discriminant: Discriminant<DiscriminantKind> | null;
+    discriminantJson: JsonStructure | null;
+    expression: string;
+    createBranchedOptimisticRootApply(): BaseNode["rootApply"];
+    get shallowMorphs(): array<Morph>;
+    get defaultShortDescription(): string;
+    protected innerToJsonSchema(ctx: ToJsonSchema.Context): JsonSchema;
+    traverseAllows: TraverseAllows;
+    traverseApply: TraverseApply;
+    traverseOptimistic: (data: unknown) => unknown;
+    compile(js: NodeCompiler): void;
+    private compileIndiscriminable;
+    get nestableExpression(): string;
+    discriminate(): Discriminant | null;
+}
+export declare const Union: {
+    implementation: nodeImplementationOf<Union.Declaration>;
+    Node: typeof UnionNode;
+};
+type DescribeBranchesOptions = {
+    delimiter?: string;
+    finalDelimiter?: string;
+};
+export declare const describeBranches: (descriptions: string[], opts?: DescribeBranchesOptions) => string;
+export declare const intersectBranches: (l: readonly Union.ChildNode[], r: readonly Union.ChildNode[], ctx: IntersectionContext) => readonly Union.ChildNode[] | Disjoint;
+export declare const reduceBranches: ({ branches, ordered }: Union.Inner) => readonly Union.ChildNode[];
+export type CaseKey<kind extends DiscriminantKind = DiscriminantKind> = DiscriminantKind extends kind ? string : DiscriminantKinds[kind] | "default";
+type DiscriminantLocation<kind extends DiscriminantKind = DiscriminantKind> = {
+    path: PropertyKey[];
+    optionallyChainedPropString: string;
+    kind: kind;
+};
+export interface Discriminant<kind extends DiscriminantKind = DiscriminantKind> extends DiscriminantLocation<kind> {
+    cases: DiscriminatedCases<kind>;
+}
+export type CaseContext = {
+    branchIndices: number[];
+    condition: nodeOfKind<DiscriminantKind> | Domain.Enumerable;
+};
+export type CaseDiscriminant = nodeOfKind<DiscriminantKind> | Domain.Enumerable;
+export type DiscriminatedCases<kind extends DiscriminantKind = DiscriminantKind> = {
+    [caseKey in CaseKey<kind>]: BaseRoot | true;
+};
+export type DiscriminantKinds = {
+    domain: Domain;
+    unit: SerializedPrimitive | RegisteredReference;
+};
+export type DiscriminantKind = show<keyof DiscriminantKinds>;
+export declare const pruneDiscriminant: (discriminantBranch: BaseRoot, discriminantCtx: DiscriminantLocation) => BaseRoot | null;
+export declare const writeIndiscriminableMorphMessage: (lDescription: string, rDescription: string) => string;
+export declare const writeOrderedIntersectionMessage: (lDescription: string, rDescription: string) => string;
+export {};