@milaboratories/milaboratories.pool-explorer 1.2.65 → 1.2.67

package/dist/AGENTS.d.ts

@@ -0,0 +1,4582 @@
+//#region ../../../../lib/model/common/dist/author_marker.d.ts
+//#region src/author_marker.d.ts
+/** Structure to help resolve conflicts if multiple participants writes to
+ * the same state */
+interface AuthorMarker {
+  /** Unique identifier of client or even a specific window that sets this
+   * particular state */
+  authorId: string;
+  /** Sequential version of the state local to the author */
+  localVersion: number;
+} //#endregion
+//#endregion
+//#region ../../../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/typeAliases.d.cts
+type Primitive = string | number | symbol | bigint | boolean | null | undefined;
+//#endregion
+//#region ../../../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/util.d.cts
+declare namespace util {
+  type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends (<V>() => V extends U ? 1 : 2) ? true : false;
+  export type isAny<T> = 0 extends 1 & T ? true : false;
+  export const assertEqual: <A, B>(_: AssertEqual<A, B>) => void;
+  export function assertIs<T>(_arg: T): void;
+  export function assertNever(_x: never): never;
+  export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+  export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
+  export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+  export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
+  export type InexactPartial<T> = { [k in keyof T]?: T[k] | undefined };
+  export const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k };
+  export const getValidEnumValues: (obj: any) => any[];
+  export const objectValues: (obj: any) => any[];
+  export const objectKeys: ObjectConstructor["keys"];
+  export const find: <T>(arr: T[], checker: (arg: T) => any) => T | undefined;
+  export type identity<T> = objectUtil.identity<T>;
+  export type flatten<T> = objectUtil.flatten<T>;
+  export type noUndefined<T> = T extends undefined ? never : T;
+  export const isInteger: NumberConstructor["isInteger"];
+  export function joinValues<T extends any[]>(array: T, separator?: string): string;
+  export const jsonStringifyReplacer: (_: string, value: any) => any;
+  export {};
+}
+declare namespace objectUtil {
+  export type MergeShapes<U, V> = keyof U & keyof V extends never ? U & V : { [k in Exclude<keyof U, keyof V>]: U[k] } & V;
+  type optionalKeys<T extends object> = { [k in keyof T]: undefined extends T[k] ? k : never }[keyof T];
+  type requiredKeys<T extends object> = { [k in keyof T]: undefined extends T[k] ? never : k }[keyof T];
+  export type addQuestionMarks<T extends object, _O = any> = { [K in requiredKeys<T>]: T[K] } & { [K in optionalKeys<T>]?: T[K] } & { [k in keyof T]?: unknown };
+  export type identity<T> = T;
+  export type flatten<T> = identity<{ [k in keyof T]: T[k] }>;
+  export type noNeverKeys<T> = { [k in keyof T]: [T[k]] extends [never] ? never : k }[keyof T];
+  export type noNever<T> = identity<{ [k in noNeverKeys<T>]: k extends keyof T ? T[k] : never }>;
+  export const mergeShapes: <U, T>(first: U, second: T) => T & U;
+  export type extendShape<A extends object, B extends object> = keyof A & keyof B extends never ? A & B : { [K in keyof A as K extends keyof B ? never : K]: A[K] } & { [K in keyof B]: B[K] };
+  export {};
+}
+declare const ZodParsedType: {
+  string: "string";
+  nan: "nan";
+  number: "number";
+  integer: "integer";
+  float: "float";
+  boolean: "boolean";
+  date: "date";
+  bigint: "bigint";
+  symbol: "symbol";
+  function: "function";
+  undefined: "undefined";
+  null: "null";
+  array: "array";
+  object: "object";
+  unknown: "unknown";
+  promise: "promise";
+  void: "void";
+  never: "never";
+  map: "map";
+  set: "set";
+};
+type ZodParsedType = keyof typeof ZodParsedType;
+//#endregion
+//#region ../../../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/ZodError.d.cts
+type allKeys<T> = T extends any ? keyof T : never;
+type typeToFlattenedError<T, U = string> = {
+  formErrors: U[];
+  fieldErrors: { [P in allKeys<T>]?: U[] };
+};
+declare const ZodIssueCode: {
+  invalid_type: "invalid_type";
+  invalid_literal: "invalid_literal";
+  custom: "custom";
+  invalid_union: "invalid_union";
+  invalid_union_discriminator: "invalid_union_discriminator";
+  invalid_enum_value: "invalid_enum_value";
+  unrecognized_keys: "unrecognized_keys";
+  invalid_arguments: "invalid_arguments";
+  invalid_return_type: "invalid_return_type";
+  invalid_date: "invalid_date";
+  invalid_string: "invalid_string";
+  too_small: "too_small";
+  too_big: "too_big";
+  invalid_intersection_types: "invalid_intersection_types";
+  not_multiple_of: "not_multiple_of";
+  not_finite: "not_finite";
+};
+type ZodIssueCode = keyof typeof ZodIssueCode;
+type ZodIssueBase = {
+  path: (string | number)[];
+  message?: string | undefined;
+};
+interface ZodInvalidTypeIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_type;
+  expected: ZodParsedType;
+  received: ZodParsedType;
+}
+interface ZodInvalidLiteralIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_literal;
+  expected: unknown;
+  received: unknown;
+}
+interface ZodUnrecognizedKeysIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.unrecognized_keys;
+  keys: string[];
+}
+interface ZodInvalidUnionIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_union;
+  unionErrors: ZodError[];
+}
+interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_union_discriminator;
+  options: Primitive[];
+}
+interface ZodInvalidEnumValueIssue extends ZodIssueBase {
+  received: string | number;
+  code: typeof ZodIssueCode.invalid_enum_value;
+  options: (string | number)[];
+}
+interface ZodInvalidArgumentsIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_arguments;
+  argumentsError: ZodError;
+}
+interface ZodInvalidReturnTypeIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_return_type;
+  returnTypeError: ZodError;
+}
+interface ZodInvalidDateIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_date;
+}
+type StringValidation = "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "cidr" | "base64" | "jwt" | "base64url" | {
+  includes: string;
+  position?: number | undefined;
+} | {
+  startsWith: string;
+} | {
+  endsWith: string;
+};
+interface ZodInvalidStringIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_string;
+  validation: StringValidation;
+}
+interface ZodTooSmallIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.too_small;
+  minimum: number | bigint;
+  inclusive: boolean;
+  exact?: boolean;
+  type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+interface ZodTooBigIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.too_big;
+  maximum: number | bigint;
+  inclusive: boolean;
+  exact?: boolean;
+  type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.invalid_intersection_types;
+}
+interface ZodNotMultipleOfIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.not_multiple_of;
+  multipleOf: number | bigint;
+}
+interface ZodNotFiniteIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.not_finite;
+}
+interface ZodCustomIssue extends ZodIssueBase {
+  code: typeof ZodIssueCode.custom;
+  params?: {
+    [k: string]: any;
+  };
+}
+type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
+type ZodIssue = ZodIssueOptionalMessage & {
+  fatal?: boolean | undefined;
+  message: string;
+};
+type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? { [K in keyof T]?: ZodFormattedError<T[K]> } : T extends any[] ? {
+  [k: number]: ZodFormattedError<T[number]>;
+} : T extends object ? { [K in keyof T]?: ZodFormattedError<T[K]> } : unknown;
+type ZodFormattedError<T, U = string> = {
+  _errors: U[];
+} & recursiveZodFormattedError<NonNullable<T>>;
+declare class ZodError<T = any> extends Error {
+  issues: ZodIssue[];
+  get errors(): ZodIssue[];
+  constructor(issues: ZodIssue[]);
+  format(): ZodFormattedError<T>;
+  format<U>(mapper: (issue: ZodIssue) => U): ZodFormattedError<T, U>;
+  static create: (issues: ZodIssue[]) => ZodError<any>;
+  static assert(value: unknown): asserts value is ZodError;
+  toString(): string;
+  get message(): string;
+  get isEmpty(): boolean;
+  addIssue: (sub: ZodIssue) => void;
+  addIssues: (subs?: ZodIssue[]) => void;
+  flatten(): typeToFlattenedError<T>;
+  flatten<U>(mapper?: (issue: ZodIssue) => U): typeToFlattenedError<T, U>;
+  get formErrors(): typeToFlattenedError<T, string>;
+}
+type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
+type IssueData = stripPath<ZodIssueOptionalMessage> & {
+  path?: (string | number)[];
+  fatal?: boolean | undefined;
+};
+type ErrorMapCtx = {
+  defaultError: string;
+  data: any;
+};
+type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
+  message: string;
+};
+//#endregion
+//#region ../../../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.d.cts
+type ParseParams = {
+  path: (string | number)[];
+  errorMap: ZodErrorMap;
+  async: boolean;
+};
+type ParsePathComponent = string | number;
+type ParsePath = ParsePathComponent[];
+interface ParseContext {
+  readonly common: {
+    readonly issues: ZodIssue[];
+    readonly contextualErrorMap?: ZodErrorMap | undefined;
+    readonly async: boolean;
+  };
+  readonly path: ParsePath;
+  readonly schemaErrorMap?: ZodErrorMap | undefined;
+  readonly parent: ParseContext | null;
+  readonly data: any;
+  readonly parsedType: ZodParsedType;
+}
+type ParseInput = {
+  data: any;
+  path: (string | number)[];
+  parent: ParseContext;
+};
+declare class ParseStatus {
+  value: "aborted" | "dirty" | "valid";
+  dirty(): void;
+  abort(): void;
+  static mergeArray(status: ParseStatus, results: SyncParseReturnType<any>[]): SyncParseReturnType;
+  static mergeObjectAsync(status: ParseStatus, pairs: {
+    key: ParseReturnType<any>;
+    value: ParseReturnType<any>;
+  }[]): Promise<SyncParseReturnType<any>>;
+  static mergeObjectSync(status: ParseStatus, pairs: {
+    key: SyncParseReturnType<any>;
+    value: SyncParseReturnType<any>;
+    alwaysSet?: boolean;
+  }[]): SyncParseReturnType;
+}
+type INVALID = {
+  status: "aborted";
+};
+declare const INVALID: INVALID;
+type DIRTY<T> = {
+  status: "dirty";
+  value: T;
+};
+declare const DIRTY: <T>(value: T) => DIRTY<T>;
+type OK<T> = {
+  status: "valid";
+  value: T;
+};
+declare const OK: <T>(value: T) => OK<T>;
+type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
+type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
+type ParseReturnType<T> = SyncParseReturnType<T> | AsyncParseReturnType<T>;
+//#endregion
+//#region ../../../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/enumUtil.d.cts
+declare namespace enumUtil {
+  type UnionToIntersectionFn<T> = (T extends unknown ? (k: () => T) => void : never) extends ((k: infer Intersection) => void) ? Intersection : never;
+  type GetUnionLast<T> = UnionToIntersectionFn<T> extends (() => infer Last) ? Last : never;
+  type UnionToTuple<T, Tuple extends unknown[] = []> = [T] extends [never] ? Tuple : UnionToTuple<Exclude<T, GetUnionLast<T>>, [GetUnionLast<T>, ...Tuple]>;
+  type CastToStringTuple<T> = T extends [string, ...string[]] ? T : never;
+  export type UnionToTupleString<T> = CastToStringTuple<UnionToTuple<T>>;
+  export {};
+}
+//#endregion
+//#region ../../../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/errorUtil.d.cts
+declare namespace errorUtil {
+  type ErrMessage = string | {
+    message?: string | undefined;
+  };
+  const errToObj: (message?: ErrMessage) => {
+    message?: string | undefined;
+  };
+  const toString: (message?: ErrMessage) => string | undefined;
+}
+//#endregion
+//#region ../../../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/partialUtil.d.cts
+declare namespace partialUtil {
+  type DeepPartial<T extends ZodTypeAny> = T extends ZodObject<ZodRawShape> ? ZodObject<{ [k in keyof T["shape"]]: ZodOptional<DeepPartial<T["shape"][k]>> }, T["_def"]["unknownKeys"], T["_def"]["catchall"]> : T extends ZodArray<infer Type, infer Card> ? ZodArray<DeepPartial<Type>, Card> : T extends ZodOptional<infer Type> ? ZodOptional<DeepPartial<Type>> : T extends ZodNullable<infer Type> ? ZodNullable<DeepPartial<Type>> : T extends ZodTuple<infer Items> ? { [k in keyof Items]: Items[k] extends ZodTypeAny ? DeepPartial<Items[k]> : never } extends infer PI ? PI extends ZodTupleItems ? ZodTuple<PI> : never : never : T;
+}
+//#endregion
+//#region ../../../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/standard-schema.d.cts
+/**
+ * The Standard Schema interface.
+ */
+type StandardSchemaV1<Input = unknown, Output = Input> = {
+  /**
+   * The Standard Schema properties.
+   */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+};
+declare namespace StandardSchemaV1 {
+  /**
+   * The Standard Schema properties interface.
+   */
+  export interface Props<Input = unknown, Output = Input> {
+    /**
+     * The version number of the standard.
+     */
+    readonly version: 1;
+    /**
+     * The vendor name of the schema library.
+     */
+    readonly vendor: string;
+    /**
+     * Validates unknown input values.
+     */
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    /**
+     * Inferred types associated with the schema.
+     */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /**
+   * The result interface of the validate function.
+   */
+  export type Result<Output> = SuccessResult<Output> | FailureResult;
+  /**
+   * The result interface if validation succeeds.
+   */
+  export interface SuccessResult<Output> {
+    /**
+     * The typed output value.
+     */
+    readonly value: Output;
+    /**
+     * The non-existent issues.
+     */
+    readonly issues?: undefined;
+  }
+  /**
+   * The result interface if validation fails.
+   */
+  export interface FailureResult {
+    /**
+     * The issues of failed validation.
+     */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /**
+   * The issue interface of the failure output.
+   */
+  export interface Issue {
+    /**
+     * The error message of the issue.
+     */
+    readonly message: string;
+    /**
+     * The path of the issue, if any.
+     */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /**
+   * The path segment interface of the issue.
+   */
+  export interface PathSegment {
+    /**
+     * The key representing a path segment.
+     */
+    readonly key: PropertyKey;
+  }
+  /**
+   * The Standard Schema types interface.
+   */
+  export interface Types<Input = unknown, Output = Input> {
+    /**
+     * The input type of the schema.
+     */
+    readonly input: Input;
+    /**
+     * The output type of the schema.
+     */
+    readonly output: Output;
+  }
+  /**
+   * Infers the input type of a Standard Schema.
+   */
+  export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /**
+   * Infers the output type of a Standard Schema.
+   */
+  export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+  export {};
+}
+//#endregion
+//#region ../../../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.d.cts
+interface RefinementCtx {
+  addIssue: (arg: IssueData) => void;
+  path: (string | number)[];
+}
+type ZodRawShape = {
+  [k: string]: ZodTypeAny;
+};
+type ZodTypeAny = ZodType<any, any, any>;
+type TypeOf<T extends ZodType<any, any, any>> = T["_output"];
+type input<T extends ZodType<any, any, any>> = T["_input"];
+type output<T extends ZodType<any, any, any>> = T["_output"];
+type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
+interface ZodTypeDef {
+  errorMap?: ZodErrorMap | undefined;
+  description?: string | undefined;
+}
+type RawCreateParams = {
+  errorMap?: ZodErrorMap | undefined;
+  invalid_type_error?: string | undefined;
+  required_error?: string | undefined;
+  message?: string | undefined;
+  description?: string | undefined;
+} | undefined;
+type SafeParseSuccess<Output> = {
+  success: true;
+  data: Output;
+  error?: never;
+};
+type SafeParseError<Input> = {
+  success: false;
+  error: ZodError<Input>;
+  data?: never;
+};
+type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
+declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
+  readonly _type: Output;
+  readonly _output: Output;
+  readonly _input: Input;
+  readonly _def: Def;
+  get description(): string | undefined;
+  "~standard": StandardSchemaV1.Props<Input, Output>;
+  abstract _parse(input: ParseInput): ParseReturnType<Output>;
+  _getType(input: ParseInput): string;
+  _getOrReturnCtx(input: ParseInput, ctx?: ParseContext | undefined): ParseContext;
+  _processInputParams(input: ParseInput): {
+    status: ParseStatus;
+    ctx: ParseContext;
+  };
+  _parseSync(input: ParseInput): SyncParseReturnType<Output>;
+  _parseAsync(input: ParseInput): AsyncParseReturnType<Output>;
+  parse(data: unknown, params?: util.InexactPartial<ParseParams>): Output;
+  safeParse(data: unknown, params?: util.InexactPartial<ParseParams>): SafeParseReturnType<Input, Output>;
+  "~validate"(data: unknown): StandardSchemaV1.Result<Output> | Promise<StandardSchemaV1.Result<Output>>;
+  parseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<Output>;
+  safeParseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
+  /** Alias of safeParseAsync */
+  spa: (data: unknown, params?: util.InexactPartial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;
+  refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, Input>;
+  refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
+  refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, Input>;
+  refinement(check: (arg: Output) => boolean, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, Output, Input>;
+  _refinement(refinement: RefinementEffect<Output>["refinement"]): ZodEffects<this, Output, Input>;
+  superRefine<RefinedOutput extends Output>(refinement: (arg: Output, ctx: RefinementCtx) => arg is RefinedOutput): ZodEffects<this, RefinedOutput, Input>;
+  superRefine(refinement: (arg: Output, ctx: RefinementCtx) => void): ZodEffects<this, Output, Input>;
+  superRefine(refinement: (arg: Output, ctx: RefinementCtx) => Promise<void>): ZodEffects<this, Output, Input>;
+  constructor(def: Def);
+  optional(): ZodOptional<this>;
+  nullable(): ZodNullable<this>;
+  nullish(): ZodOptional<ZodNullable<this>>;
+  array(): ZodArray<this>;
+  promise(): ZodPromise<this>;
+  or<T extends ZodTypeAny>(option: T): ZodUnion<[this, T]>;
+  and<T extends ZodTypeAny>(incoming: T): ZodIntersection<this, T>;
+  transform<NewOut>(transform: (arg: Output, ctx: RefinementCtx) => NewOut | Promise<NewOut>): ZodEffects<this, NewOut>;
+  default(def: util.noUndefined<Input>): ZodDefault<this>;
+  default(def: () => util.noUndefined<Input>): ZodDefault<this>;
+  brand<B extends string | number | symbol>(brand?: B): ZodBranded<this, B>;
+  catch(def: Output): ZodCatch<this>;
+  catch(def: (ctx: {
+    error: ZodError;
+    input: Input;
+  }) => Output): ZodCatch<this>;
+  describe(description: string): this;
+  pipe<T extends ZodTypeAny>(target: T): ZodPipeline<this, T>;
+  readonly(): ZodReadonly<this>;
+  isOptional(): boolean;
+  isNullable(): boolean;
+}
+type IpVersion = "v4" | "v6";
+type ZodStringCheck = {
+  kind: "min";
+  value: number;
+  message?: string | undefined;
+} | {
+  kind: "max";
+  value: number;
+  message?: string | undefined;
+} | {
+  kind: "length";
+  value: number;
+  message?: string | undefined;
+} | {
+  kind: "email";
+  message?: string | undefined;
+} | {
+  kind: "url";
+  message?: string | undefined;
+} | {
+  kind: "emoji";
+  message?: string | undefined;
+} | {
+  kind: "uuid";
+  message?: string | undefined;
+} | {
+  kind: "nanoid";
+  message?: string | undefined;
+} | {
+  kind: "cuid";
+  message?: string | undefined;
+} | {
+  kind: "includes";
+  value: string;
+  position?: number | undefined;
+  message?: string | undefined;
+} | {
+  kind: "cuid2";
+  message?: string | undefined;
+} | {
+  kind: "ulid";
+  message?: string | undefined;
+} | {
+  kind: "startsWith";
+  value: string;
+  message?: string | undefined;
+} | {
+  kind: "endsWith";
+  value: string;
+  message?: string | undefined;
+} | {
+  kind: "regex";
+  regex: RegExp;
+  message?: string | undefined;
+} | {
+  kind: "trim";
+  message?: string | undefined;
+} | {
+  kind: "toLowerCase";
+  message?: string | undefined;
+} | {
+  kind: "toUpperCase";
+  message?: string | undefined;
+} | {
+  kind: "jwt";
+  alg?: string;
+  message?: string | undefined;
+} | {
+  kind: "datetime";
+  offset: boolean;
+  local: boolean;
+  precision: number | null;
+  message?: string | undefined;
+} | {
+  kind: "date";
+  message?: string | undefined;
+} | {
+  kind: "time";
+  precision: number | null;
+  message?: string | undefined;
+} | {
+  kind: "duration";
+  message?: string | undefined;
+} | {
+  kind: "ip";
+  version?: IpVersion | undefined;
+  message?: string | undefined;
+} | {
+  kind: "cidr";
+  version?: IpVersion | undefined;
+  message?: string | undefined;
+} | {
+  kind: "base64";
+  message?: string | undefined;
+} | {
+  kind: "base64url";
+  message?: string | undefined;
+};
+interface ZodStringDef extends ZodTypeDef {
+  checks: ZodStringCheck[];
+  typeName: ZodFirstPartyTypeKind.ZodString;
+  coerce: boolean;
+}
+declare class ZodString extends ZodType<string, ZodStringDef, string> {
+  _parse(input: ParseInput): ParseReturnType<string>;
+  protected _regex(regex: RegExp, validation: StringValidation, message?: errorUtil.ErrMessage): ZodEffects<this, string, string>;
+  _addCheck(check: ZodStringCheck): ZodString;
+  email(message?: errorUtil.ErrMessage): ZodString;
+  url(message?: errorUtil.ErrMessage): ZodString;
+  emoji(message?: errorUtil.ErrMessage): ZodString;
+  uuid(message?: errorUtil.ErrMessage): ZodString;
+  nanoid(message?: errorUtil.ErrMessage): ZodString;
+  cuid(message?: errorUtil.ErrMessage): ZodString;
+  cuid2(message?: errorUtil.ErrMessage): ZodString;
+  ulid(message?: errorUtil.ErrMessage): ZodString;
+  base64(message?: errorUtil.ErrMessage): ZodString;
+  base64url(message?: errorUtil.ErrMessage): ZodString;
+  jwt(options?: {
+    alg?: string;
+    message?: string | undefined;
+  }): ZodString;
+  ip(options?: string | {
+    version?: IpVersion;
+    message?: string | undefined;
+  }): ZodString;
+  cidr(options?: string | {
+    version?: IpVersion;
+    message?: string | undefined;
+  }): ZodString;
+  datetime(options?: string | {
+    message?: string | undefined;
+    precision?: number | null;
+    offset?: boolean;
+    local?: boolean;
+  }): ZodString;
+  date(message?: string): ZodString;
+  time(options?: string | {
+    message?: string | undefined;
+    precision?: number | null;
+  }): ZodString;
+  duration(message?: errorUtil.ErrMessage): ZodString;
+  regex(regex: RegExp, message?: errorUtil.ErrMessage): ZodString;
+  includes(value: string, options?: {
+    message?: string;
+    position?: number;
+  }): ZodString;
+  startsWith(value: string, message?: errorUtil.ErrMessage): ZodString;
+  endsWith(value: string, message?: errorUtil.ErrMessage): ZodString;
+  min(minLength: number, message?: errorUtil.ErrMessage): ZodString;
+  max(maxLength: number, message?: errorUtil.ErrMessage): ZodString;
+  length(len: number, message?: errorUtil.ErrMessage): ZodString;
+  /**
+   * Equivalent to `.min(1)`
+   */
+  nonempty(message?: errorUtil.ErrMessage): ZodString;
+  trim(): ZodString;
+  toLowerCase(): ZodString;
+  toUpperCase(): ZodString;
+  get isDatetime(): boolean;
+  get isDate(): boolean;
+  get isTime(): boolean;
+  get isDuration(): boolean;
+  get isEmail(): boolean;
+  get isURL(): boolean;
+  get isEmoji(): boolean;
+  get isUUID(): boolean;
+  get isNANOID(): boolean;
+  get isCUID(): boolean;
+  get isCUID2(): boolean;
+  get isULID(): boolean;
+  get isIP(): boolean;
+  get isCIDR(): boolean;
+  get isBase64(): boolean;
+  get isBase64url(): boolean;
+  get minLength(): number | null;
+  get maxLength(): number | null;
+  static create: (params?: RawCreateParams & {
+    coerce?: true;
+  }) => ZodString;
+}
+type ZodNumberCheck = {
+  kind: "min";
+  value: number;
+  inclusive: boolean;
+  message?: string | undefined;
+} | {
+  kind: "max";
+  value: number;
+  inclusive: boolean;
+  message?: string | undefined;
+} | {
+  kind: "int";
+  message?: string | undefined;
+} | {
+  kind: "multipleOf";
+  value: number;
+  message?: string | undefined;
+} | {
+  kind: "finite";
+  message?: string | undefined;
+};
+interface ZodNumberDef extends ZodTypeDef {
+  checks: ZodNumberCheck[];
+  typeName: ZodFirstPartyTypeKind.ZodNumber;
+  coerce: boolean;
+}
+declare class ZodNumber extends ZodType<number, ZodNumberDef, number> {
+  _parse(input: ParseInput): ParseReturnType<number>;
+  static create: (params?: RawCreateParams & {
+    coerce?: boolean;
+  }) => ZodNumber;
+  gte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+  min: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
+  gt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+  lte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+  max: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
+  lt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+  protected setLimit(kind: "min" | "max", value: number, inclusive: boolean, message?: string): ZodNumber;
+  _addCheck(check: ZodNumberCheck): ZodNumber;
+  int(message?: errorUtil.ErrMessage): ZodNumber;
+  positive(message?: errorUtil.ErrMessage): ZodNumber;
+  negative(message?: errorUtil.ErrMessage): ZodNumber;
+  nonpositive(message?: errorUtil.ErrMessage): ZodNumber;
+  nonnegative(message?: errorUtil.ErrMessage): ZodNumber;
+  multipleOf(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+  step: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
+  finite(message?: errorUtil.ErrMessage): ZodNumber;
+  safe(message?: errorUtil.ErrMessage): ZodNumber;
+  get minValue(): number | null;
+  get maxValue(): number | null;
+  get isInt(): boolean;
+  get isFinite(): boolean;
+}
+interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  type: T;
+  typeName: ZodFirstPartyTypeKind.ZodArray;
+  exactLength: {
+    value: number;
+    message?: string | undefined;
+  } | null;
+  minLength: {
+    value: number;
+    message?: string | undefined;
+  } | null;
+  maxLength: {
+    value: number;
+    message?: string | undefined;
+  } | null;
+}
+type ArrayCardinality = "many" | "atleastone";
+type arrayOutputType<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = Cardinality extends "atleastone" ? [T["_output"], ...T["_output"][]] : T["_output"][];
+declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> extends ZodType<arrayOutputType<T, Cardinality>, ZodArrayDef<T>, Cardinality extends "atleastone" ? [T["_input"], ...T["_input"][]] : T["_input"][]> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get element(): T;
+  min(minLength: number, message?: errorUtil.ErrMessage): this;
+  max(maxLength: number, message?: errorUtil.ErrMessage): this;
+  length(len: number, message?: errorUtil.ErrMessage): this;
+  nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
+  static create: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
+}
+type UnknownKeysParam = "passthrough" | "strict" | "strip";
+interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodObject;
+  shape: () => T;
+  catchall: Catchall;
+  unknownKeys: UnknownKeys;
+}
+type objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<objectUtil.addQuestionMarks<baseObjectOutputType<Shape>>> & CatchallOutput<Catchall> & PassthroughType<UnknownKeys>;
+type baseObjectOutputType<Shape extends ZodRawShape> = { [k in keyof Shape]: Shape[k]["_output"] };
+type objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<baseObjectInputType<Shape>> & CatchallInput<Catchall> & PassthroughType<UnknownKeys>;
+type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.addQuestionMarks<{ [k in keyof Shape]: Shape[k]["_input"] }>;
+type CatchallOutput<T extends ZodType> = ZodType extends T ? unknown : {
+  [k: string]: T["_output"];
+};
+type CatchallInput<T extends ZodType> = ZodType extends T ? unknown : {
+  [k: string]: T["_input"];
+};
+type PassthroughType<T extends UnknownKeysParam> = T extends "passthrough" ? {
+  [k: string]: unknown;
+} : unknown;
+type deoptional<T extends ZodTypeAny> = T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T;
+declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall, UnknownKeys>, Input = objectInputType<T, Catchall, UnknownKeys>> extends ZodType<Output, ZodObjectDef<T, UnknownKeys, Catchall>, Input> {
+  private _cached;
+  _getCached(): {
+    shape: T;
+    keys: string[];
+  };
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get shape(): T;
+  strict(message?: errorUtil.ErrMessage): ZodObject<T, "strict", Catchall>;
+  strip(): ZodObject<T, "strip", Catchall>;
+  passthrough(): ZodObject<T, "passthrough", Catchall>;
+  /**
+   * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
+   * If you want to pass through unknown properties, use `.passthrough()` instead.
+   */
+  nonstrict: () => ZodObject<T, "passthrough", Catchall>;
+  extend<Augmentation extends ZodRawShape>(augmentation: Augmentation): ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;
+  /**
+   * @deprecated Use `.extend` instead
+   *  */
+  augment: <Augmentation extends ZodRawShape>(augmentation: Augmentation) => ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;
+  /**
+   * Prior to zod@1.0.12 there was a bug in the
+   * inferred type of merged objects. Please
+   * upgrade if you are experiencing issues.
+   */
+  merge<Incoming extends AnyZodObject, Augmentation extends Incoming["shape"]>(merging: Incoming): ZodObject<objectUtil.extendShape<T, Augmentation>, Incoming["_def"]["unknownKeys"], Incoming["_def"]["catchall"]>;
+  setKey<Key extends string, Schema extends ZodTypeAny>(key: Key, schema: Schema): ZodObject<T & { [k in Key]: Schema }, UnknownKeys, Catchall>;
+  catchall<Index extends ZodTypeAny>(index: Index): ZodObject<T, UnknownKeys, Index>;
+  pick<Mask extends util.Exactly<{ [k in keyof T]?: true }, Mask>>(mask: Mask): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
+  omit<Mask extends util.Exactly<{ [k in keyof T]?: true }, Mask>>(mask: Mask): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
+  /**
+   * @deprecated
+   */
+  deepPartial(): partialUtil.DeepPartial<this>;
+  partial(): ZodObject<{ [k in keyof T]: ZodOptional<T[k]> }, UnknownKeys, Catchall>;
+  partial<Mask extends util.Exactly<{ [k in keyof T]?: true }, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{ [k in keyof T]: k extends keyof Mask ? ZodOptional<T[k]> : T[k] }>, UnknownKeys, Catchall>;
+  required(): ZodObject<{ [k in keyof T]: deoptional<T[k]> }, UnknownKeys, Catchall>;
+  required<Mask extends util.Exactly<{ [k in keyof T]?: true }, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{ [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k] }>, UnknownKeys, Catchall>;
+  keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;
+  static create: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;
+  static strictCreate: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;
+  static lazycreate: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;
+}
+type AnyZodObject = ZodObject<any, any, any>;
+type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
+interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>> extends ZodTypeDef {
+  options: T;
+  typeName: ZodFirstPartyTypeKind.ZodUnion;
+}
+declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get options(): T;
+  static create: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
+}
+interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  left: T;
+  right: U;
+  typeName: ZodFirstPartyTypeKind.ZodIntersection;
+}
+declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extends ZodType<T["_output"] & U["_output"], ZodIntersectionDef<T, U>, T["_input"] & U["_input"]> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;
+}
+type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
+type AssertArray<T> = T extends any[] ? T : never;
+type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{ [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_output"] : never }>;
+type OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...OutputTypeOfTuple<T>, ...Rest["_output"][]] : OutputTypeOfTuple<T>;
+type InputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{ [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_input"] : never }>;
+type InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...InputTypeOfTuple<T>, ...Rest["_input"][]] : InputTypeOfTuple<T>;
+interface ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodTypeDef {
+  items: T;
+  rest: Rest;
+  typeName: ZodFirstPartyTypeKind.ZodTuple;
+}
+declare class ZodTuple<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get items(): T;
+  rest<RestSchema extends ZodTypeAny>(rest: RestSchema): ZodTuple<T, RestSchema>;
+  static create: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;
+}
+interface ZodLiteralDef<T = any> extends ZodTypeDef {
+  value: T;
+  typeName: ZodFirstPartyTypeKind.ZodLiteral;
+}
+declare class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>, T> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get value(): T;
+  static create: <Value extends Primitive>(value: Value, params?: RawCreateParams) => ZodLiteral<Value>;
+}
+type EnumValues<T extends string = string> = readonly [T, ...T[]];
+type Values<T extends EnumValues> = { [k in T[number]]: k };
+interface ZodEnumDef<T extends EnumValues = EnumValues> extends ZodTypeDef {
+  values: T;
+  typeName: ZodFirstPartyTypeKind.ZodEnum;
+}
+type Writeable<T> = { -readonly [P in keyof T]: T[P] };
+type FilterEnum<Values, ToExclude> = Values extends [] ? [] : Values extends [infer Head, ...infer Rest] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [Head, ...FilterEnum<Rest, ToExclude>] : never;
+type typecast<A, T> = A extends T ? A : never;
+declare function createZodEnum<U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: RawCreateParams): ZodEnum<Writeable<T>>;
+declare function createZodEnum<U extends string, T extends [U, ...U[]]>(values: T, params?: RawCreateParams): ZodEnum<T>;
+declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[number], ZodEnumDef<T>, T[number]> {
+  _cache: Set<T[number]> | undefined;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get options(): T;
+  get enum(): Values<T>;
+  get Values(): Values<T>;
+  get Enum(): Values<T>;
+  extract<ToExtract extends readonly [T[number], ...T[number][]]>(values: ToExtract, newDef?: RawCreateParams): ZodEnum<Writeable<ToExtract>>;
+  exclude<ToExclude extends readonly [T[number], ...T[number][]]>(values: ToExclude, newDef?: RawCreateParams): ZodEnum<typecast<Writeable<FilterEnum<T, ToExclude[number]>>, [string, ...string[]]>>;
+  static create: typeof createZodEnum;
+}
+interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  type: T;
+  typeName: ZodFirstPartyTypeKind.ZodPromise;
+}
+declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_output"]>, ZodPromiseDef<T>, Promise<T["_input"]>> {
+  unwrap(): T;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
+}
+type RefinementEffect<T> = {
+  type: "refinement";
+  refinement: (arg: T, ctx: RefinementCtx) => any;
+};
+type TransformEffect<T> = {
+  type: "transform";
+  transform: (arg: T, ctx: RefinementCtx) => any;
+};
+type PreprocessEffect<T> = {
+  type: "preprocess";
+  transform: (arg: T, ctx: RefinementCtx) => any;
+};
+type Effect<T> = RefinementEffect<T> | TransformEffect<T> | PreprocessEffect<T>;
+interface ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  schema: T;
+  typeName: ZodFirstPartyTypeKind.ZodEffects;
+  effect: Effect<any>;
+}
+declare class ZodEffects<T extends ZodTypeAny, Output = output<T>, Input = input<T>> extends ZodType<Output, ZodEffectsDef<T>, Input> {
+  innerType(): T;
+  sourceType(): T;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;
+  static createWithPreprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
+}
+interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  innerType: T;
+  typeName: ZodFirstPartyTypeKind.ZodOptional;
+}
+declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  unwrap(): T;
+  static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;
+}
+interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  innerType: T;
+  typeName: ZodFirstPartyTypeKind.ZodNullable;
+}
+declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  unwrap(): T;
+  static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;
+}
+interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  innerType: T;
+  defaultValue: () => util.noUndefined<T["_input"]>;
+  typeName: ZodFirstPartyTypeKind.ZodDefault;
+}
+declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUndefined<T["_output"]>, ZodDefaultDef<T>, T["_input"] | undefined> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  removeDefault(): T;
+  static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
+    default: Inner["_input"] | (() => util.noUndefined<Inner["_input"]>);
+  }) => ZodDefault<Inner>;
+}
+interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  innerType: T;
+  catchValue: (ctx: {
+    error: ZodError;
+    input: unknown;
+  }) => T["_input"];
+  typeName: ZodFirstPartyTypeKind.ZodCatch;
+}
+declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCatchDef<T>, unknown> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  removeCatch(): T;
+  static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
+    catch: Inner["_output"] | (() => Inner["_output"]);
+  }) => ZodCatch<Inner>;
+}
+interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {
+  type: T;
+  typeName: ZodFirstPartyTypeKind.ZodBranded;
+}
+declare const BRAND: unique symbol;
+type BRAND<T extends string | number | symbol> = {
+  [BRAND]: { [k in T]: true };
+};
+declare class ZodBranded<T extends ZodTypeAny, B extends string | number | symbol> extends ZodType<T["_output"] & BRAND<B>, ZodBrandedDef<T>, T["_input"]> {
+  _parse(input: ParseInput): ParseReturnType<any>;
+  unwrap(): T;
+}
+interface ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodTypeDef {
+  in: A;
+  out: B;
+  typeName: ZodFirstPartyTypeKind.ZodPipeline;
+}
+declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodType<B["_output"], ZodPipelineDef<A, B>, A["_input"]> {
+  _parse(input: ParseInput): ParseReturnType<any>;
+  static create<ASchema extends ZodTypeAny, BSchema extends ZodTypeAny>(a: ASchema, b: BSchema): ZodPipeline<ASchema, BSchema>;
+}
+type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
+  readonly [Symbol.toStringTag]: string;
+} | Date | Error | Generator | Promise<unknown> | RegExp;
+type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
+interface ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  innerType: T;
+  typeName: ZodFirstPartyTypeKind.ZodReadonly;
+}
+declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReadonly<T["_output"]>, ZodReadonlyDef<T>, MakeReadonly<T["_input"]>> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodReadonly<Inner>;
+  unwrap(): T;
+}
+declare enum ZodFirstPartyTypeKind {
+  ZodString = "ZodString",
+  ZodNumber = "ZodNumber",
+  ZodNaN = "ZodNaN",
+  ZodBigInt = "ZodBigInt",
+  ZodBoolean = "ZodBoolean",
+  ZodDate = "ZodDate",
+  ZodSymbol = "ZodSymbol",
+  ZodUndefined = "ZodUndefined",
+  ZodNull = "ZodNull",
+  ZodAny = "ZodAny",
+  ZodUnknown = "ZodUnknown",
+  ZodNever = "ZodNever",
+  ZodVoid = "ZodVoid",
+  ZodArray = "ZodArray",
+  ZodObject = "ZodObject",
+  ZodUnion = "ZodUnion",
+  ZodDiscriminatedUnion = "ZodDiscriminatedUnion",
+  ZodIntersection = "ZodIntersection",
+  ZodTuple = "ZodTuple",
+  ZodRecord = "ZodRecord",
+  ZodMap = "ZodMap",
+  ZodSet = "ZodSet",
+  ZodFunction = "ZodFunction",
+  ZodLazy = "ZodLazy",
+  ZodLiteral = "ZodLiteral",
+  ZodEnum = "ZodEnum",
+  ZodEffects = "ZodEffects",
+  ZodNativeEnum = "ZodNativeEnum",
+  ZodOptional = "ZodOptional",
+  ZodNullable = "ZodNullable",
+  ZodDefault = "ZodDefault",
+  ZodCatch = "ZodCatch",
+  ZodPromise = "ZodPromise",
+  ZodBranded = "ZodBranded",
+  ZodPipeline = "ZodPipeline",
+  ZodReadonly = "ZodReadonly"
+}
+//#endregion
+//#region ../../../../lib/model/pl-error-like/dist/error_like_shape.d.ts
+//#region src/error_like_shape.d.ts
+declare const BasePlErrorLike: ZodObject<{
+  type: ZodLiteral<"PlError">;
+  name: ZodString;
+  message: ZodString; /** The message with all details needed for SDK developers. */
+  fullMessage: ZodOptional<ZodString>;
+  stack: ZodOptional<ZodString>;
+}, "strip", ZodTypeAny, {
+  type: "PlError";
+  message: string;
+  name: string;
+  fullMessage?: string | undefined;
+  stack?: string | undefined;
+}, {
+  type: "PlError";
+  message: string;
+  name: string;
+  fullMessage?: string | undefined;
+  stack?: string | undefined;
+}>;
+/** Known Pl backend and ML errors. */
+type PlErrorLike = TypeOf<typeof BasePlErrorLike> & {
+  cause?: ErrorLike;
+  errors?: ErrorLike[];
+};
+declare const PlErrorLike: ZodType<PlErrorLike>;
+declare const BaseStandardErrorLike: ZodObject<{
+  type: ZodLiteral<"StandardError">;
+  name: ZodString;
+  message: ZodString;
+  stack: ZodOptional<ZodString>;
+}, "strip", ZodTypeAny, {
+  type: "StandardError";
+  message: string;
+  name: string;
+  stack?: string | undefined;
+}, {
+  type: "StandardError";
+  message: string;
+  name: string;
+  stack?: string | undefined;
+}>;
+/** Others unknown errors that could be thrown by the client. */
+type StandardErrorLike = TypeOf<typeof BaseStandardErrorLike> & {
+  cause?: ErrorLike;
+  errors?: ErrorLike[];
+};
+declare const StandardErrorLike: ZodType<StandardErrorLike>;
+declare const ErrorLike: ZodUnion<[ZodType<StandardErrorLike, ZodTypeDef, StandardErrorLike>, ZodType<PlErrorLike, ZodTypeDef, PlErrorLike>]>;
+type ErrorLike = TypeOf<typeof ErrorLike>;
+/** Converts everything into ErrorLike. */
+//#endregion
+//#region ../../../../lib/model/common/dist/common_types.d.ts
+type OutputWithStatus<T> = {
+  ok: true;
+  value: T;
+  stable: boolean;
+} | {
+  ok: false;
+  errors: ErrorLike[];
+  moreErrors: boolean;
+};
+/** Base type for block outputs */
+type BlockOutputsBase = Record<string, OutputWithStatus<unknown>>;
+//#endregion
+//#region ../../../../lib/model/common/dist/navigation.d.ts
+/**
+ * Part of the block state, representing current navigation information
+ * (i.e. currently selected section)
+ */
+type NavigationState<Href extends `/${string}` = `/${string}`> = {
+  readonly href: Href;
+};
+//#endregion
+//#region ../../../../lib/model/common/dist/json.d.ts
+//#region src/json.d.ts
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+type NotAssignableToJson = bigint | symbol | Function;
+type JsonCompatible<T> = unknown extends T ? unknown : [T] extends [JsonValue] ? T : [T] extends [NotAssignableToJson] ? never : { [P in keyof T]: [Exclude<T[P], undefined>] extends [JsonValue] ? T[P] : [Exclude<T[P], undefined>] extends [NotAssignableToJson] ? never : JsonCompatible<T[P]> };
+type StringifiedJson<T = unknown> = JsonCompatible<T> extends never ? never : string & {
+  __json_stringified: T;
+};
+type CanonicalizedJson<T = unknown> = JsonCompatible<T> extends never ? never : string & {
+  __json_canonicalized: T;
+};
+//#endregion
+//#region ../../../../lib/model/common/dist/block_state.d.ts
+//#region src/block_state.d.ts
+/**
+ * @template Args    sets type of block arguments passed to the workflow
+ * @template Outputs type of the outputs returned by the workflow and rendered
+ *                   according to the output configuration specified for the block
+ * @template UiState data that stores only UI related state, that is not passed
+ *                   to the workflow
+ * @template Href    typed href to represent navigation state
+ */
+type BlockState<Args = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, UiState = unknown, Href extends `/${string}` = `/${string}`> = {
+  /** Block arguments passed to the workflow */args: Args;
+  /** UI State persisted in the block state but not passed to the backend
+   * template */
+  ui: UiState; /** Outputs rendered with block config */
+  outputs: Outputs; /** Current navigation state */
+  navigationState: NavigationState<Href>;
+  readonly author: AuthorMarker | undefined;
+};
+type BlockStateV3<_Data = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, Href extends `/${string}` = `/${string}`> = {
+  /** Block storage persisted in the block state */blockStorage: StringifiedJson; /** Outputs rendered with block config */
+  outputs: Outputs; /** Current navigation state */
+  navigationState: NavigationState<Href>;
+  readonly author: AuthorMarker | undefined;
+}; //#endregion
+//#endregion
+//#region ../../../../lib/model/common/dist/branding.d.ts
+//#region src/branding.d.ts
+type Brand<B, K extends string = "__pl_model_brand__"> = { [key in K]: B };
+type Branded$1<T, B, K extends string = "__pl_model_brand__"> = T & Brand<B, K>; //#endregion
+//#endregion
+//#region ../../../../lib/model/common/dist/dialog/index.d.ts
+//#region src/dialog/index.d.ts
+/**
+ * File filter passed to the native save dialog. Matches Electron's
+ * `FileFilter` shape so desktop runtimes can forward it verbatim.
+ */
+interface FileFilter {
+  name: string;
+  extensions: string[];
+}
+/**
+ * Options accepted by `Dialog.showSaveDialog`. The UI supplies only a
+ * default file name; the main-process handler decides the default
+ * directory (e.g. `~/Downloads`).
+ */
+interface ShowSaveDialogOptions {
+  defaultFileName?: string;
+  filters?: FileFilter[];
+  title?: string;
+}
+/** Result of `Dialog.showSaveDialog`. */
+interface ShowSaveDialogResult {
+  canceled: boolean;
+  path?: string;
+}
+/**
+ * UI-facing save-dialog service. Implemented by desktop runtimes that
+ * can open a native file picker; absent in web/preview environments.
+ */
+interface DialogService {
+  showSaveDialog(options: ShowSaveDialogOptions): Promise<ShowSaveDialogResult>;
+} //#endregion
+//#endregion
+//#region ../../../../lib/model/common/dist/pool_entry.d.ts
+//#region src/pool_entry.d.ts
+interface PoolEntry<K extends string = string, R extends {} = {}> extends Disposable {
+  /** Resource key, calculated using provided `calculateParamsKey` function */
+  readonly key: K;
+  /** Resource itself created by `createNewResource` function */
+  readonly resource: R;
+  /**
+   * Release the reference. Idempotent.
+   * Same as `[Symbol.dispose]()` — provided as a named function
+   * for use in callbacks (e.g. `addOnDestroy(entry.unref)`).
+   */
+  readonly unref: () => void;
+}
+/**
+ * Wraps a PoolEntry for use with `using`. Auto-calls `unref()` at end of scope
+ * unless `keep()` is called to transfer ownership to the caller.
+ */
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/pframe/table_common.d.ts
+//#region src/drivers/pframe/table_common.d.ts
+type PTableColumnSpecAxis = {
+  type: "axis";
+  id: AxisId;
+  spec: AxisSpec;
+};
+type PTableColumnSpecColumn = {
+  type: "column";
+  /**
+   * Leaf column id as it appears in the SpecQuery — may be a rich
+   * {@link ColumnUniversalId} (Discovered / Overridden / Filtered) or a bare
+   * {@link PObjectId}. The host resolver strips to bare via `extractPObjectId`
+   * before physical lookup.
+   */
+  id: ColumnUniversalId;
+  spec: PColumnSpec;
+};
+/** Unified spec object for axes and columns */
+type PTableColumnSpec = PTableColumnSpecAxis | PTableColumnSpecColumn;
+type PTableColumnIdAxis = {
+  type: "axis";
+  id: AxisId;
+};
+type PTableColumnIdColumn = {
+  type: "column"; /** @see PTableColumnSpecColumn.id */
+  id: ColumnUniversalId;
+};
+/** Unified PTable column identifier */
+type PTableColumnId = PTableColumnIdAxis | PTableColumnIdColumn;
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/pframe/data_types.d.ts
+//#region src/drivers/pframe/data_types.d.ts
+type PVectorDataInt = Int32Array;
+type PVectorDataLong = BigInt64Array;
+type PVectorDataFloat = Float32Array;
+type PVectorDataDouble = Float64Array;
+type PVectorDataString = (null | string)[];
+type PVectorDataBytes = (null | Uint8Array)[];
+type PVectorDataTyped<DataType extends ValueType> = DataType extends typeof ValueType.Int ? PVectorDataInt : DataType extends typeof ValueType.Long ? PVectorDataLong : DataType extends typeof ValueType.Float ? PVectorDataFloat : DataType extends typeof ValueType.Double ? PVectorDataDouble : DataType extends typeof ValueType.String ? PVectorDataString : DataType extends typeof ValueType.Bytes ? PVectorDataBytes : never;
+type PTableVectorTyped<DataType extends ValueType> = {
+  /** Stored data type */readonly type: DataType; /** Values for present positions */
+  readonly data: PVectorDataTyped<DataType>;
+  /**
+   * Encoded bit array marking some elements of this vector as NA,
+   * call {@link bitSet} to read the data.
+   * In old desktop versions NA values are encoded as magic values in data array.
+   * */
+  readonly isNA?: Uint8Array; /** @deprecated Always empty. Kept for backwards compatibility with old blocks. */
+  readonly absent?: Uint8Array;
+};
+/** Table column data */
+type PTableVector = PTableVectorTyped<ValueType>;
+/** Used in requests to partially retrieve table's data */
+type TableRange = {
+  /** Index of the first record to retrieve */readonly offset: number; /** Block length */
+  readonly length: number;
+};
+/** Unified information about table shape */
+type PTableShape = {
+  /** Number of unified table columns, including all axes and PColumn values */columns: number; /** Number of rows */
+  rows: number;
+};
+/** Supported formats for PTable file download. */
+type PTableDownloadFormat = "csv" | "tsv";
+/** Compression applied to the written file. */
+/** Options for downloading PTable data to a file. */
+interface WritePTableToFsOptions {
+  path: string;
+  format: PTableDownloadFormat;
+  columnIndices: number[];
+  /**
+   * Optional header names aligned 1:1 with {@link columnIndices}. When provided,
+   * each is written verbatim — letting callers supply disambiguated labels the
+   * spec's intrinsic `pl7.app/label` may not carry. When omitted (or an
+   * individual entry is empty), the header falls back to the column's
+   * spec-derived label.
+   *
+   * Additive on purpose: the UI (ui-vue) and the desktop-app runtime version
+   * independently, so a newer UI must not send a shape an older runtime cannot
+   * read. Older runtimes ignore this field and use {@link columnIndices} alone.
+   */
+  headerNames?: string[];
+  range?: TableRange;
+  chunkSize?: number;
+  includeHeader?: boolean;
+  bom?: boolean;
+  compression?: {
+    type: "gzip";
+    level?: number;
+  };
+  signal?: AbortSignal;
+}
+/** Result of a PTable file download. */
+interface WritePTableToFsResult {
+  path: string;
+  rowsWritten: number;
+  bytesWritten: number;
+}
+/**
+ * Maximum number of data rows allowed per sheet in an `xlsx` export, kept below
+ * Excel's hard limit of 1,048,576. The driver rejects oversized `xlsx` exports
+ * (see {@link PFrameDriver.exportPTable}); UIs use it to gate the `xlsx` option.
+ */
+/** Options for {@link PFrameDriver.exportPTable}. */
+interface ExportPTableOptions {
+  /** Destination file path; its extension selects the output format
+   * (`csv`/`tsv`/`parquet`/`xlsx`). */
+  path: string;
+  /** Unified indices of the columns to export, in output order
+   * (axes first, then data columns). */
+  columnIndices: number[];
+  /**
+   * Optional header names aligned 1:1 with {@link columnIndices}. When provided,
+   * each is written verbatim — letting callers supply disambiguated labels the
+   * spec's intrinsic `pl7.app/label` may not carry. When omitted (or an
+   * individual entry is empty), the header falls back to the column's
+   * spec-derived label.
+   *
+   * Additive on purpose: the UI (ui-vue) and the desktop-app runtime version
+   * independently, so a newer UI must not send a shape an older runtime cannot
+   * read. Older runtimes ignore this field and use {@link columnIndices} alone.
+   */
+  headerNames?: string[];
+} //#endregion
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/pframe/data_info.d.ts
+//#region src/drivers/pframe/data_info.d.ts
+/**
+ * Represents a JavaScript representation of a value in a PColumn. Can be null, a number, or a string.
+ * These are the primitive types that can be stored directly in PColumns.
+ *
+ * Note: Actual columns can hold more value types, which are converted to these JavaScript types
+ * once they enter the JavaScript runtime.
+ */
+type PColumnValue = null | number | string;
+/**
+ * Represents a key for a PColumn value.
+ * Can be an array of strings or numbers.
+ */
+type PColumnKey = (number | string)[];
+/**
+ * Represents a single entry in a PColumn's data structure.
+ * Contains a key and a value.
+ */
+/**
+ * Represents column data stored as a simple JSON structure.
+ * Used for small datasets that can be efficiently stored directly in memory.
+ */
+type JsonDataInfo = {
+  /** Identifier for this data format ('Json') */type: "Json"; /** Number of axes that make up the complete key (tuple length) */
+  keyLength: number;
+  /**
+   * Key-value pairs where keys are stringified tuples of axis values
+   * and values are the column values for those coordinates
+   */
+  data: Record<string, PColumnValue>;
+};
+/**
+ * Represents column data partitioned across multiple JSON blobs.
+ * Used for larger datasets that need to be split into manageable chunks.
+ */
+type JsonPartitionedDataInfo<Blob> = {
+  /** Identifier for this data format ('JsonPartitioned') */type: "JsonPartitioned"; /** Number of leading axes used for partitioning */
+  partitionKeyLength: number; /** Map of stringified partition keys to blob references */
+  parts: Record<string, Blob>;
+};
+/**
+ * Represents a binary format chunk containing index and values as separate blobs.
+ * Used for efficient storage and retrieval of column data in binary format.
+ */
+type BinaryChunk<Blob> = {
+  /** Binary blob containing structured index information */index: Blob; /** Binary blob containing the actual values */
+  values: Blob;
+};
+/**
+ * Represents column data partitioned across multiple binary chunks.
+ * Optimized for efficient storage and retrieval of large datasets.
+ */
+type BinaryPartitionedDataInfo<Blob> = {
+  /** Identifier for this data format ('BinaryPartitioned') */type: "BinaryPartitioned"; /** Number of leading axes used for partitioning */
+  partitionKeyLength: number; /** Map of stringified partition keys to binary chunks */
+  parts: Record<string, BinaryChunk<Blob>>;
+};
+type ParquetPartitionedDataInfo<Blob> = {
+  /** Identifier for this data format ('ParquetPartitioned') */type: "ParquetPartitioned"; /** Number of leading axes used for partitioning */
+  partitionKeyLength: number; /** Map of stringified partition keys to parquet files */
+  parts: Record<string, Blob>;
+};
+/**
+ * Union type representing all possible data storage formats for PColumn data.
+ * The specific format used depends on data size, access patterns, and performance requirements.
+ *
+ * @template Blob - Type parameter representing the storage reference type (could be ResourceInfo, PFrameBlobId, etc.)
+ */
+type DataInfo<Blob> = JsonDataInfo | JsonPartitionedDataInfo<Blob> | BinaryPartitionedDataInfo<Blob> | ParquetPartitionedDataInfo<Blob>;
+/**
+ * Type guard function that checks if the given value is a valid DataInfo.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a valid DataInfo, false otherwise
+ */
+/**
+ * Represents a single key-value entry in a column's explicit data structure.
+ * Used when directly instantiating PColumns with explicit data.
+ */
+type PColumnValuesEntry = {
+  key: PColumnKey;
+  val: PColumnValue;
+};
+/**
+ * Array of key-value entries representing explicit column data.
+ * Used for lightweight explicit instantiation of PColumns.
+ */
+type PColumnValues = PColumnValuesEntry[];
+/**
+ * Entry-based representation of JsonDataInfo
+ */
+//#endregion
+//#region ../../../../lib/util/helpers/dist/types/brand.d.ts
+//#region src/types/brand.d.ts
+/**
+ * Phantom-property brand. The key is a plain string literal rather than a
+ * `unique symbol` so the resulting type stays fully nameable across packages.
+ *
+ * A `unique symbol` key forces TS, when forced to expand `Branded<T, B>` into
+ * its structural form (e.g. inside `Record<BrandedUnion, V>` index signatures
+ * during dts emit), to write out `typeof __brand` — a value-level reference
+ * to the symbol. If the symbol's declaring module isn't reachable from the
+ * compilation root, dts emit fails with TS4023 ("cannot be named"). Using a
+ * string key sidesteps this entirely: `{ __brand: B }` is a plain structural
+ * type, nameable from anywhere.
+ *
+ * Phantom keys provide compile-time discrimination only — two different brand
+ * tags `B1 ≠ B2` make `Branded<T, B1>` and `Branded<T, B2>` mutually
+ * incompatible regardless of whether the key is a symbol or a string.
+ */
+type Branded<T, B> = T & {
+  readonly __brand: B;
+};
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/pframe/spec/overridden.d.ts
+//#region src/drivers/pframe/spec/overridden.d.ts
+type SpecOverrides = Pick<PColumnSpec, "domain" | "contextDomain" | "annotations"> & {
+  axesSpec?: AxisPatches;
+};
+/**
+ * `source` can reference a leaf or a Filtered/Discovered id, but never another
+ * Overridden id — there is no `Overridden<Overridden<...>>`. Repeated overrides
+ * merge at the outer wrapper via {@link mergeSpecOverrides}.
+ */
+interface ColumnOverriddenKey {
+  __isOverridden: true;
+  source: Exclude<ColumnUniversalId, ColumnOverriddenId>;
+  specOverrides: SpecOverrides;
+}
+type ColumnOverriddenId = Branded<CanonicalizedJson<ColumnOverriddenKey>, "ColumnOverriddenId">;
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/pframe/query/query_common.d.ts
+//#region src/drivers/pframe/query/query_common.d.ts
+/**
+ * Structural type information for a single column: the axis value types (in
+ * order) and the single column value type. Mirrors the self-contained
+ * `typeSpec` shape carried by the data layer (`{ axes, column }`).
+ */
+type ColumnTypeSpec = {
+  /** List of axis value types defining the dimensions of the data */axes: AxisValueType[]; /** The single column value type */
+  column: ColumnValueType;
+};
+/**
+ * Unary mathematical operation kinds.
+ *
+ * These operations take a single numeric input and produce a numeric output.
+ * **Null handling**: If input is null, result is null.
+ *
+ * Operations:
+ * - `abs` - Absolute value: |x|
+ * - `ceil` - Round up to nearest integer
+ * - `floor` - Round down to nearest integer
+ * - `round` - Round to nearest integer (banker's rounding)
+ * - `sqrt` - Square root (returns NaN for negative inputs)
+ * - `log` - Natural logarithm (ln)
+ * - `log2` - Base-2 logarithm
+ * - `log10` - Base-10 logarithm
+ * - `exp` - Exponential function (e^x)
+ * - `negate` - Negation (-x)
+ */
+type NumericUnaryOperand = "abs" | "ceil" | "floor" | "round" | "sqrt" | "log" | "log2" | "log10" | "exp" | "negate";
+/**
+ * Binary mathematical operation kinds.
+ *
+ * These operations take two numeric inputs and produce a numeric result.
+ * **Null handling**: If either operand is null, result is null.
+ *
+ * Operations:
+ * - `add` - Addition: left + right
+ * - `sub` - Subtraction: left - right
+ * - `mul` - Multiplication: left * right
+ * - `div` - Division: left / right (division by zero returns Infinity or NaN)
+ * - `mod` - Modulo: left % right
+ * - `power` - Exponentiation: left ** right
+ */
+type NumericBinaryOperand = "add" | "sub" | "mul" | "div" | "mod" | "power";
+/**
+ * Numeric comparison operation kinds.
+ *
+ * These operations compare two numeric inputs and produce a boolean result.
+ * **Null handling**: If either operand is null, result is null.
+ *
+ * Operations:
+ * - `eq` - Equal: left == right
+ * - `ne` - Not equal: left != right
+ * - `lt` - Less than: left < right
+ * - `le` - Less or equal: left <= right
+ * - `gt` - Greater than: left > right
+ * - `ge` - Greater or equal: left >= right
+ */
+type NumericComparisonOperand = "eq" | "ne" | "lt" | "le" | "gt" | "ge";
+/**
+ * Constant value expression.
+ *
+ * Represents a literal constant value in an expression tree.
+ * The value can be a string, number, or boolean.
+ *
+ * @example
+ * // Constant number
+ * { type: 'constant', value: 42 }
+ *
+ * // Constant string
+ * { type: 'constant', value: 'hello' }
+ *
+ * // Constant boolean
+ * { type: 'constant', value: true }
+ */
+type ExprConstant = {
+  type: "constant";
+  value: string | number | boolean;
+};
+/**
+ * Null check expression.
+ *
+ * Tests if an expression evaluates to null.
+ * **Input**: Any expression.
+ * **Output**: Boolean (true if input is null, false otherwise).
+ *
+ * @template I - The expression type (for recursion)
+ *
+ * @example
+ * // Check if column value is null
+ * { type: 'isNull', input: columnRef }
+ *
+ * // Combine with NOT to check for non-null
+ * { type: 'not', input: { type: 'isNull', input: columnRef } }
+ */
+interface ExprIsNull<I> {
+  type: "isNull";
+  /** Input expression to check for null */
+  input: I;
+}
+/**
+ * Null coalescing expression.
+ *
+ * Returns the input value if it is not null, otherwise returns the replacement value.
+ * Equivalent to SQL's `IFNULL(input, replacement)` or `COALESCE(input, replacement)`.
+ * **Input**: Any expression.
+ * **Output**: Same type as input/replacement.
+ * **Null handling**: If input is null, returns replacement; otherwise returns input.
+ *
+ * The Rust runtime also accepts the legacy `"ifNull"` tag as a serde
+ * alias; new code should emit `"fillNull"`.
+ *
+ * @template I - The expression type (for recursion)
+ *
+ * @example
+ * // Replace null values with 0
+ * { type: 'fillNull', input: columnRef, replacement: { type: 'constant', value: 0 } }
+ *
+ * // Replace null strings with 'unknown'
+ * { type: 'fillNull', input: nameColumn, replacement: { type: 'constant', value: 'unknown' } }
+ */
+interface ExprFillNull<I> {
+  type: "fillNull";
+  /** Value to check for null */
+  input: I;
+  /** Replacement value if input is null */
+  replacement: I;
+}
+/**
+ * Unary mathematical expression.
+ *
+ * Applies a unary mathematical function to a single input expression.
+ * **Input**: One expression that evaluates to a numeric value.
+ * **Output**: Numeric value.
+ * **Null handling**: If input is null, result is null.
+ *
+ * @template I - The expression type (for recursion)
+ *
+ * @example
+ * // Absolute value of column "value"
+ * { type: 'unaryMath', operand: 'abs', input: columnRef }
+ *
+ * // Natural log of expression
+ * { type: 'unaryMath', operand: 'log', input: someExpr }
+ *
+ * @see NumericUnaryOperand for available operations
+ */
+interface ExprNumericUnary<I> {
+  type: "numericUnary";
+  /** The mathematical operation to apply */
+  operand: NumericUnaryOperand;
+  /** Input expression (must evaluate to numeric) */
+  input: I;
+}
+/**
+ * Binary mathematical expression.
+ *
+ * Applies a binary arithmetic operation to two input expressions.
+ * **Input**: Two expressions that evaluate to numeric values.
+ * **Output**: Numeric value.
+ * **Null handling**: If either operand is null, result is null.
+ *
+ * @template I - The expression type (for recursion)
+ *
+ * @example
+ * // Addition: col_a + col_b
+ * { type: 'binaryMath', operand: 'add', left: colA, right: colB }
+ *
+ * // Division: col_a / 2
+ * { type: 'binaryMath', operand: 'div', left: colA, right: { type: 'constant', value: 2 } }
+ *
+ * @see NumericBinaryOperand for available operations
+ */
+interface ExprNumericBinary<I> {
+  type: "numericBinary";
+  /** The arithmetic operation to apply */
+  operand: NumericBinaryOperand;
+  /** Left operand expression */
+  left: I;
+  /** Right operand expression */
+  right: I;
+}
+/**
+ * Numeric comparison expression.
+ *
+ * Compares two numeric expressions and produces a boolean result.
+ * **Input**: Two expressions that evaluate to numeric values.
+ * **Output**: Boolean.
+ * **Null handling**: If either operand is null, result is null.
+ *
+ * @template I - The expression type (for recursion)
+ *
+ * @example
+ * // Greater than: col_a > 10
+ * { type: 'numericComparison', operand: 'gt', left: colA, right: { type: 'constant', value: 10 } }
+ *
+ * // Equality: col_a == col_b
+ * { type: 'numericComparison', operand: 'eq', left: colA, right: colB }
+ *
+ * // Range check (combine with logical AND): 0 <= x && x < 100
+ * // { type: 'logical', operand: 'and', input: [
+ * //   { type: 'numericComparison', operand: 'ge', left: colX, right: { type: 'constant', value: 0 } },
+ * //   { type: 'numericComparison', operand: 'lt', left: colX, right: { type: 'constant', value: 100 } }
+ * // ]}
+ *
+ * @see NumericComparisonOperand for available operations
+ */
+interface ExprNumericComparison<I> {
+  type: "numericComparison";
+  /** The comparison operation to apply */
+  operand: NumericComparisonOperand;
+  /** Left operand expression */
+  left: I;
+  /** Right operand expression */
+  right: I;
+}
+/**
+ * String equality check.
+ *
+ * Compares input string to a reference value.
+ * **Input**: Expression evaluating to a string.
+ * **Output**: Boolean.
+ * **Null handling**: Returns false if input is null.
+ *
+ * @template I - The expression type (for recursion)
+ *
+ * @example
+ * // Check if name equals "John" (case-sensitive)
+ * // Matches only: "John"
+ * { type: 'stringEquals', input: nameColumn, value: 'John' }
+ *
+ * @example
+ * // Check if name equals "John" (case-insensitive)
+ * // Matches: "john", "JOHN", "John", "jOhN"
+ * { type: 'stringEquals', input: nameColumn, value: 'John', caseInsensitive: true }
+ */
+interface ExprStringEquals<I> {
+  type: "stringEquals";
+  /** Input expression (must evaluate to string) */
+  input: I;
+  /** Reference string to compare against */
+  value: string;
+  /** If true, comparison ignores case */
+  caseInsensitive: boolean;
+}
+/**
+ * Regular expression match check.
+ *
+ * Tests if input string matches a regular expression pattern.
+ * **Input**: Expression evaluating to a string.
+ * **Output**: Boolean (true if pattern matches).
+ * **Null handling**: Returns false if input is null.
+ *
+ * @template I - The expression type (for recursion)
+ *
+ * @example
+ * // Check if value matches email pattern
+ * { type: 'stringRegex', input: emailColumn, value: '^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$' }
+ *
+ * // Check if starts with "prefix"
+ * { type: 'stringRegex', input: valueColumn, value: '^prefix' }
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions | MDN Regular Expressions Guide}
+ */
+interface ExprStringRegex<I> {
+  type: "stringRegex";
+  /** Input expression (must evaluate to string) */
+  input: I;
+  /** Regular expression pattern */
+  value: string;
+}
+/**
+ * Substring containment check.
+ *
+ * Tests if input string contains a specified substring.
+ * **Input**: Expression evaluating to a string.
+ * **Output**: Boolean (true if substring is found).
+ * **Null handling**: Returns false if input is null.
+ *
+ * @template I - The expression type (for recursion)
+ *
+ * @example
+ * // Case-sensitive contains
+ * { type: 'stringContains', input: descColumn, value: 'error', caseInsensitive: false }
+ *
+ * // Case-insensitive contains
+ * { type: 'stringContains', input: descColumn, value: 'ERROR', caseInsensitive: true }
+ */
+interface ExprStringContains<I> {
+  type: "stringContains";
+  /** Input expression (must evaluate to string) */
+  input: I;
+  /** Substring to search for */
+  value: string;
+  /** If true, comparison ignores case */
+  caseInsensitive: boolean;
+}
+/**
+ * Fuzzy string containment check with edit distance.
+ *
+ * Tests if input string approximately matches a pattern within a specified edit distance.
+ * Uses Levenshtein distance (or substitution-only distance) for fuzzy matching.
+ * **Input**: Expression evaluating to a string.
+ * **Output**: Boolean (true if approximate match found within maxEdits).
+ * **Null handling**: Returns false if input is null.
+ *
+ * @template I - The expression type (for recursion)
+ *
+ * @example
+ * // Match "color" with up to 1 edit (catches "colour", "colr", etc.)
+ * {
+ *   type: 'stringContainsFuzzy',
+ *   input: textColumn,
+ *   value: 'color',
+ *   maxEdits: 1,
+ *   caseInsensitive: true,
+ *   substitutionsOnly: false,
+ *   wildcard: null
+ * }
+ *
+ * // Match with wildcard (? matches any single character)
+ * {
+ *   type: 'stringContainsFuzzy',
+ *   input: textColumn,
+ *   value: 'te?t',
+ *   maxEdits: 0,
+ *   caseInsensitive: false,
+ *   substitutionsOnly: false,
+ *   wildcard: '?'
+ * }
+ */
+interface ExprStringContainsFuzzy<I> {
+  type: "stringContainsFuzzy";
+  /** Input expression (must evaluate to string) */
+  input: I;
+  /** Pattern to match against */
+  value: string;
+  /**
+   * Maximum edit distance (Levenshtein distance).
+   * 0 = exact match only, 1 = one edit allowed, etc.
+   */
+  maxEdits: number;
+  /** If true, comparison ignores case */
+  caseInsensitive: boolean;
+  /**
+   * If true, only substitutions count as edits (no insertions/deletions).
+   * Useful when you want to match strings of same length with typos.
+   */
+  substitutionsOnly: boolean;
+  /**
+   * Optional wildcard character that matches any single character.
+   * Example: '?' in "te?t" matches "test", "text", "tent", etc.
+   * Set to null to disable wildcard matching.
+   */
+  wildcard: null | string;
+}
+/**
+ * Logical NOT expression.
+ *
+ * Negates a boolean expression.
+ * **Input**: Expression evaluating to boolean.
+ * **Output**: Boolean (inverted).
+ * **Null handling**: NOT null = null.
+ *
+ * @template I - The expression type (for recursion)
+ *
+ * @example
+ * // NOT (value > 10)
+ * { type: 'not', input: comparisonExpr }
+ */
+interface ExprLogicalUnary<I> {
+  type: "not";
+  /** Input boolean expression to negate */
+  input: I;
+}
+/**
+ * Logical AND/OR expression.
+ *
+ * Combines multiple boolean expressions using AND or OR logic.
+ * **Input**: Array of expressions evaluating to boolean (minimum 2).
+ * **Output**: Boolean.
+ *
+ * **Null handling**
+ * - AND: null AND true = null, null AND false = false
+ * - OR: null OR true = true, null OR false = null
+ *
+ * @template I - The expression type (for recursion)
+ *
+ * @example
+ * // (a > 0) AND (b < 100)
+ * { type: 'and', input: [exprA, exprB] }
+ *
+ * // (status == 'active') OR (status == 'pending')
+ * { type: 'or', input: [statusActive, statusPending] }
+ */
+interface ExprLogicalVariadic<I> {
+  /** Logical operation: 'and' or 'or' */
+  type: "and" | "or";
+  /** Array of boolean expressions to combine (minimum 2 elements) */
+  input: I[];
+}
+/**
+ * Set membership check expression.
+ *
+ * Tests if a value is present in a predefined set of values.
+ * **Input**: Expression evaluating to string or number.
+ * **Output**: Boolean.
+ * **Null handling**: Returns false if input is null.
+ *
+ * @template I - The expression type (for recursion)
+ * @template T - The type of set elements (string or number)
+ *
+ * @example
+ * // Check if status is in ['active', 'pending', 'review']
+ * {
+ *   type: 'isIn',
+ *   input: statusColumn,
+ *   set: ['active', 'pending', 'review']
+ * }
+ */
+interface ExprIsIn<I, T extends string | number> {
+  type: "isIn";
+  /** Input expression to test */
+  input: I;
+  /** Set of allowed values */
+  set: T[];
+  /** If true, the predicate is inverted (true for values NOT in `set`). */
+  negate: boolean;
+}
+/**
+ * Type cast expression.
+ *
+ * Converts the input value to a different column value type. Mirrors
+ * SQL `CAST(input AS U)`.
+ *
+ * **Input**: any expression.
+ * **Output**: a value of `targetType`.
+ * **Null handling**: null in → null out.
+ *
+ * @template I - The expression type (for recursion)
+ */
+interface ExprCast<I> {
+  type: "cast";
+  /** Expression to cast. */
+  input: I;
+  /** Target column value type. */
+  targetType: ColumnValueType;
+}
+/**
+ * A single `when → then` case in a {@link ExprConditional} expression.
+ *
+ * @template I - The expression type (for recursion)
+ */
+interface ExprConditionalCase<I> {
+  /** Boolean predicate that selects this branch. */
+  when: I;
+  /** Value produced when `when` evaluates to true. */
+  then: I;
+}
+/**
+ * Conditional (CASE WHEN) expression.
+ *
+ * Evaluates `cases` in order; the value of the first case whose `when`
+ * is true is returned. If no case matches, `otherwise` is used (or
+ * null when omitted).
+ *
+ * **Result type**: the type of the first case's `then`; subsequent
+ * `then`s and `otherwise` are cast to it.
+ *
+ * @template I - The expression type (for recursion)
+ *
+ * @example
+ * {
+ *   type: 'conditional',
+ *   cases: [
+ *     { when: gtTwenty, then: { type: 'constant', value: 'high' } },
+ *     { when: gtTen,    then: { type: 'constant', value: 'mid'  } }
+ *   ],
+ *   otherwise: { type: 'constant', value: 'low' }
+ * }
+ */
+interface ExprConditional<I> {
+  type: "conditional";
+  /** Cases evaluated in order; first matching wins. At least one. */
+  cases: [ExprConditionalCase<I>, ...ExprConditionalCase<I>[]];
+  /** Fallback value when no case matches. */
+  otherwise?: I;
+}
+/** Ranking function kind. */
+type RankingKind = "rank" | "denseRank" | "rowNumber";
+/**
+ * Ranking expression (always a window function).
+ *
+ * Orders rows by `orderBy` within each partition and assigns ranks
+ * according to `kind`. Output is always `Long`.
+ *
+ * @template I - The expression type (for recursion)
+ * @template A - Axis selector type
+ * @template C - Column selector type
+ */
+interface ExprRanking<I, A, C> {
+  type: "ranking";
+  /** Ranking semantics. */
+  kind: RankingKind;
+  /** Expression to order by within each partition. */
+  orderBy: I;
+  /** If true (default), sort ascending; if false, descending. */
+  ascending?: boolean;
+  /** Partition specification — at least one entry when supplied. */
+  partitionBy?: [QuerySelector<A, C>, ...QuerySelector<A, C>[]];
+}
+/**
+ * Axis reference expression.
+ *
+ * References an axis value for use in expressions (filtering, sorting, etc.).
+ * The axis identifier type varies by context (spec vs data layer).
+ *
+ * @template A - Axis identifier type (e.g., SingleAxisSelector for spec, number for data)
+ *
+ * @example
+ * // Reference axis by selector (spec layer)
+ * { type: 'axisRef', value: { name: 'sample' } }
+ *
+ * // Reference axis by index (data layer)
+ * { type: 'axisRef', value: 0 }
+ */
+interface ExprAxisRef<A> {
+  type: "axisRef";
+  /** Axis identifier (selector or index depending on context) */
+  value: A;
+}
+/**
+ * Column reference expression.
+ *
+ * References a column value for use in expressions (filtering, arithmetic, etc.).
+ * The column identifier type varies by context (spec vs data layer).
+ *
+ * @template C - Column identifier type (e.g., PObjectId for spec, number for data)
+ *
+ * @example
+ * // Reference column by ID (spec layer)
+ * { type: 'columnRef', value: 'col_abc123' }
+ *
+ * // Reference column by index (data layer)
+ * { type: 'columnRef', value: 0 }
+ */
+interface ExprColumnRef<C> {
+  type: "columnRef";
+  /** Column identifier (ID or index depending on context) */
+  value: C;
+}
+type InferBooleanExpressionUnion<E> = [E extends ExprNumericComparison<unknown> ? Extract<E, {
+  type: "numericComparison";
+}> : never, E extends ExprStringEquals<unknown> ? Extract<E, {
+  type: "stringEquals";
+}> : never, E extends ExprStringContains<unknown> ? Extract<E, {
+  type: "stringContains";
+}> : never, E extends ExprStringContainsFuzzy<unknown> ? Extract<E, {
+  type: "stringContainsFuzzy";
+}> : never, E extends ExprStringRegex<unknown> ? Extract<E, {
+  type: "stringRegex";
+}> : never, E extends ExprIsNull<unknown> ? Extract<E, {
+  type: "isNull";
+}> : never, E extends ExprLogicalUnary<unknown> ? Extract<E, {
+  type: "not";
+}> : never, E extends ExprLogicalVariadic<unknown> ? Extract<E, {
+  type: "and" | "or";
+}> : never, E extends ExprIsIn<unknown, string | number> ? Extract<E, {
+  type: "isIn";
+}> : never][number];
+/**
+ * Selector for referencing an axis in queries.
+ *
+ * Used to identify a specific axis dimension in operations like:
+ * - Sorting by axis values
+ * - Partitioning for window functions
+ * - Filtering/slicing axes
+ *
+ * @template A - Axis identifier type (typically string name or numeric index)
+ *
+ * @example
+ * // Select axis by name
+ * { type: 'axis', id: 'sample' }
+ *
+ * // Select axis by index
+ * { type: 'axis', id: 0 }
+ */
+interface QueryAxisSelector<A> {
+  type: "axis";
+  /** Axis identifier (name or index depending on context) */
+  id: A;
+}
+/**
+ * Selector for referencing a column in queries.
+ *
+ * Used to identify a specific column in operations like:
+ * - Sorting by column values
+ * - Partitioning for window functions
+ * - Aggregation expressions
+ *
+ * @template C - Column identifier type (typically string name or numeric index)
+ *
+ * @example
+ * // Select column by name
+ * { type: 'column', id: 'expression_value' }
+ *
+ * // Select column by index
+ * { type: 'column', id: 0 }
+ */
+interface QueryColumnSelector<C> {
+  type: "column";
+  /** Column identifier (name or index depending on context) */
+  id: C;
+}
+/**
+ * Axis-or-column selector — mirrors the Rust `Selector<AxisSelector,
+ * ColumnSelector>` enum
+ * (`packages/bridge/src/query/query_sort.rs`). Used for the
+ * `partitionBy` / `over` fields of window expressions where either an
+ * axis or a column can drive the partition.
+ */
+type QuerySelector<A, C> = QueryAxisSelector<A> | QueryColumnSelector<C>;
+/**
+ * Left outer join query operation.
+ *
+ * Joins a primary query with one or more secondary queries using left outer join semantics.
+ * All records from the primary are preserved; matching records from secondaries are joined,
+ * non-matching positions are filled with nulls.
+ *
+ * **Join behavior**:
+ * - All records from `primary` are preserved
+ * - For each secondary, matching records (by axis keys) are joined
+ * - Missing matches from secondaries are filled with null values
+ * - Empty `secondary` array acts as identity (returns primary unchanged)
+ *
+ * **Null handling**: Null join keys don't match; positions without matches get null values.
+ *
+ * @template JE - Join entry type
+ *
+ * @example
+ * // Left join samples with optional annotations
+ * {
+ *   type: 'outerJoin',
+ *   primary: samplesQuery,
+ *   secondary: [annotationsQuery, metadataQuery]
+ * }
+ * // Result has all samples; annotations/metadata are null where not available
+ */
+interface QueryOuterJoin<JE extends QueryJoinEntry<unknown>> {
+  type: "outerJoin";
+  /** Primary query - all its records are preserved */
+  primary: JE;
+  /** Secondary queries - joined where keys match, null where they don't */
+  secondary: JE[];
+}
+/**
+ * Axis slicing query operation.
+ *
+ * Filters data by fixing one or more axes to specific constant values.
+ * Each filtered axis is removed from the resulting data shape (reduces dimensionality).
+ *
+ * **Behavior**:
+ * - Each axis filter selects records where that axis equals the constant
+ * - Filtered axes are removed from the output spec
+ * - Multiple filters apply conjunctively (AND)
+ *
+ * @template Q - Input query type
+ * @template A - Axis selector type
+ *
+ * @example
+ * // Spec layer: axisSelector is a SingleAxisSelector.
+ * {
+ *   type: 'sliceAxes',
+ *   input: fullDataQuery,
+ *   axisFilters: [
+ *     { axisSelector: { name: 'sample' }, constant: 'Sample1' },
+ *     { axisSelector: { name: 'condition' }, constant: 'Treatment' }
+ *   ]
+ * }
+ *
+ * @example
+ * // Data layer: axisSelector is the axis index.
+ * {
+ *   type: 'sliceAxes',
+ *   input: fullDataQuery,
+ *   axisFilters: [{ axisSelector: 0, constant: 'Sample1' }]
+ * }
+ */
+interface QuerySliceAxes<Q, A> {
+  type: "sliceAxes";
+  /** Input query to slice */
+  input: Q;
+  /** List of axis filters to apply (at least one required) */
+  axisFilters: {
+    /** Axis to filter. `SingleAxisSelector` at the spec layer; axis index at the data layer. */axisSelector: A; /** The constant value to filter the axis to */
+    constant: string | number;
+  }[];
+}
+/**
+ * Sort query operation.
+ *
+ * Reorders records by one or more axes or columns.
+ * Does not change data shape or values, only record order.
+ *
+ * **Behavior**:
+ * - Sort entries are applied in priority order (first entry = primary sort key)
+ * - Ties in first sort key are broken by second, etc.
+ * - All axes and columns pass through unchanged
+ * - Only the physical ordering of records changes
+ *
+ * @template Q - Input query type
+ * @template SE - Sort entry type
+ *
+ * @example
+ * // Sort by score descending, then by name ascending for ties
+ * {
+ *   type: 'sort',
+ *   input: dataQuery,
+ *   sortBy: [
+ *     { expression: { type: 'columnRef', value: 'score' }, ascending: false, nullsFirst: false },
+ *     { expression: { type: 'axisRef', value: { name: 'name' } }, ascending: true, nullsFirst: false }
+ *   ]
+ * }
+ */
+interface QuerySort<Q, E> {
+  type: "sort";
+  /** Input query to sort */
+  input: Q;
+  /** Sort criteria in priority order (at least one required) */
+  sortBy: {
+    expression: E; /** If true, sort ascending (A-Z, 0-9); if false, descending */
+    ascending: boolean;
+    /**
+     * Null placement control:
+     * - true: nulls sort before non-null values
+     * - false: nulls sort after non-null values
+     */
+    nullsFirst: boolean;
+  }[];
+}
+/**
+ * Filter query operation.
+ *
+ * Filters records based on a boolean predicate expression.
+ * Only records where predicate evaluates to true are kept.
+ *
+ * **Behavior**:
+ * - Evaluates predicate for each record
+ * - Keeps records where predicate is true
+ * - Discards records where predicate is false or null
+ * - Data shape (axes, columns) is preserved
+ *
+ * **Null handling**: Records with null predicate result are excluded (null ≠ true).
+ *
+ * @template Q - Input query type
+ * @template E - Expression type
+ *
+ * @example
+ * // Filter to records where value > 10 AND status == 'active'
+ * {
+ *   type: 'filter',
+ *   input: dataQuery,
+ *   predicate: {
+ *     type: 'logical',
+ *     operand: 'and',
+ *     input: [
+ *       { type: 'numericComparison', operand: 'gt', left: valueRef, right: { type: 'constant', value: 10 } },
+ *       { type: 'stringEquals', input: statusRef, value: 'active' }
+ *     ]
+ *   }
+ * }
+ */
+interface QueryFilter<Q, E> {
+  type: "filter";
+  /** Input query to filter */
+  input: Q;
+  /** Boolean predicate expression - only true records pass */
+  predicate: E;
+}
+/**
+ * Column reference query (leaf node).
+ *
+ * References an existing column by its unique identifier.
+ * This is a leaf node in the query tree that retrieves actual data.
+ *
+ * The column must exist in the dataset and its spec (axes, value type)
+ * becomes the output spec of this query node.
+ *
+ * @example
+ * // Reference column by ID
+ * { type: 'column', column: 'col_abc123' }
+ *
+ * @template C - Column reference type (e.g., PObjectId for spec, full PColumn for rich queries)
+ */
+interface QueryColumn<C = PObjectId> {
+  type: "column";
+  /** Column reference (ID or full column object depending on context) */
+  column: C;
+}
+/**
+ * Inline column query (leaf node).
+ *
+ * Creates a column with inline/embedded data and type specification.
+ * Useful for creating constant columns or injecting computed data.
+ *
+ * The data is provided via dataInfo which contains the actual values
+ * or reference to where data is stored.
+ *
+ * @template T - Type spec type
+ *
+ * @example
+ * // Create inline column with constant values
+ * {
+ *   type: 'inlineColumn',
+ *   spec: { axes: ['sample'], columns: ['Int'] },
+ *   dataInfo: { ... } // JsonDataInfo object
+ * }
+ */
+interface QueryInlineColumn<T> {
+  type: "inlineColumn";
+  /** Type specification defining axes and column types */
+  spec: T;
+  /** Data information containing or referencing the actual values */
+  dataInfo: JsonDataInfo;
+}
+/**
+ * Sparse to dense column query operation.
+ *
+ * Densifies a sparse column over the Cartesian product of distinct
+ * axis values: `axes` partitions the column's own axes into two sets
+ * (the listed axes on one side, the rest on the other); both sides
+ * contribute their distinct values, and the cross product fills in
+ * the missing tuples (null on rows that have no underlying value).
+ *
+ * **Use case**: graph-maker and other UI surfaces that need a dense
+ * grid to plot.
+ *
+ * **Behavior**:
+ * - Output axes = input axes (no axes are added).
+ * - Missing axis-tuple combinations become null in the output (or
+ *   filled later via `pl7.app/graph/isDenseAxis` /
+ *   `treatAbsentValuesAs` annotations).
+ *
+ * @template C - Column reference type
+ * @template A - Axis selector type (named selectors at the spec layer,
+ *   numeric axis indices at the data layer)
+ * @template SO - Spec override type
+ *
+ * @example
+ * // Spec layer: name the axis to expand across.
+ * {
+ *   type: 'sparseToDenseColumn',
+ *   column: 'col_abc123',
+ *   axes: [{ name: 'sample' }],
+ *   specOverride: { ... } // optional spec modifications
+ * }
+ *
+ * @example
+ * // Data layer: the same query after spec→data lowering.
+ * {
+ *   type: 'sparseToDenseColumn',
+ *   column: 'col_abc123',
+ *   axes: [0],
+ *   specOverride: { ... }
+ * }
+ */
+interface QuerySparseToDenseColumn<C, A, SO> {
+  type: "sparseToDenseColumn";
+  /** Column reference (ID or full column object depending on context) */
+  column: C;
+  /** Optional override for the column specification */
+  specOverride?: SO;
+  /**
+   * Axes that participate in the cartesian-product densification.
+   * Named selectors at the spec layer; resolved to numeric axis
+   * indices during spec→data lowering. The Rust runtime also accepts
+   * the legacy field name `axesIndices` as a serde alias.
+   */
+  axes: [A, ...A[]];
+}
+/**
+ * Symmetric join query operation (inner join or full outer join).
+ *
+ * Joins multiple queries symmetrically (order doesn't affect result semantics).
+ *
+ * **Inner Join** (`type: 'innerJoin'`):
+ * - Returns only records that exist in ALL entries
+ * - Null join keys don't match, so records with null keys are excluded
+ * - Result contains intersection of all entries by axis keys
+ *
+ * **Full Join** (`type: 'fullJoin'`):
+ * - Returns all records from ALL entries
+ * - Missing values are filled with nulls
+ * - Null join keys create separate groups
+ * - Result contains union of all entries by axis keys
+ *
+ * **Single entry**: Acts as identity (returns entry unchanged).
+ *
+ * @template JE - Join entry type
+ *
+ * @example
+ * // Inner join: only records present in all queries
+ * {
+ *   type: 'innerJoin',
+ *   entries: [query1Entry, query2Entry, query3Entry]
+ * }
+ *
+ * // Full join: all records from all queries, nulls for missing
+ * {
+ *   type: 'fullJoin',
+ *   entries: [query1Entry, query2Entry]
+ * }
+ */
+interface QuerySymmetricJoin<JE extends QueryJoinEntry<unknown>> {
+  /** 'innerJoin' for intersection, 'fullJoin' for union with nulls */
+  type: "innerJoin" | "fullJoin";
+  /** Queries to join (at least one required) */
+  entries: JE[];
+}
+/**
+ * Join entry wrapper.
+ *
+ * Wraps a query to be used as an entry in join operations.
+ * The wrapper allows for additional metadata or configuration
+ * on each joined query (e.g., specifying join keys, aliases).
+ *
+ * @template Q - Query type
+ *
+ * @example
+ * // Wrap a query for use in join
+ * { entry: someQuery }
+ */
+interface QueryJoinEntry<Q> {
+  /** The query to be joined */
+  entry: Q;
+}
+/**
+ * Linker-join query operation.
+ *
+ * Inner-joins a linker column (`linker`) with one or more secondary subqueries,
+ * then projects out the linker's one-side axes from the joined result. Used to
+ * traverse a linker relationship: rows on the secondary side are "lifted" onto
+ * the linker's many-side axes, with one-side axes collapsed away.
+ *
+ * Mirrors {@link QueryOuterJoin}'s `{ primary, secondary }` shape (with
+ * `secondary` as an array), but the linker side is a specialized sub-struct —
+ * a plain column reference rather than a full join entry.
+ *
+ * **Join behavior**:
+ * - The linker column is inner-joined with all `secondary` entries
+ * - After the join, the linker's one-side axes are projected out
+ * - Result axes = joined axes minus the linker's one-side axes
+ *
+ * **Note**: `secondary` must contain at least one entry (empty has no
+ * well-defined meaning for linker-join).
+ *
+ * @template L - Linker sub-struct type (layer-specific)
+ * @template JE - Join entry type for the secondary side
+ *
+ * @example
+ * // Traverse linker l1 and read rest data lifted onto l1's many-side
+ * {
+ *   type: 'linkerJoin',
+ *   linker: { column: 'l1' },
+ *   secondary: [{ entry: restQuery, ... }]
+ * }
+ */
+interface QueryLinkerJoin<L, JE extends QueryJoinEntry<unknown>> {
+  type: "linkerJoin";
+  /** Linker side — column reference plus layer-specific integration data. */
+  linker: L;
+  /** Rest side — one or more subqueries joined with the linker (at least one). */
+  secondary: JE[];
+}
+/**
+ * `transformColumns` mode.
+ *
+ * - `"append"` — existing columns pass through; the new columns are
+ *   appended.
+ * - `"replace"` — only the listed columns are kept; everything else is
+ *   dropped.
+ *
+ * The Rust runtime accepts the legacy `"add"` tag as a serde alias;
+ * new code should emit `"append"`.
+ */
+type TransformColumnsMode = "append" | "replace";
+/**
+ * Single column entry for {@link QueryTransformColumns}.
+ *
+ * @template E - Expression type
+ * @template SO - Spec override type (typically `PColumnIdAndSpec` at
+ *   the spec layer, or layer-specific id+typespec at the data layer)
+ */
+interface TransformColumnEntry<E, SO> {
+  /** Expression computing the column values. */
+  expression: E;
+  /**
+   * Optional spec override. If omitted, the runtime auto-derives the
+   * column's spec from the host's input and the expression.
+   * `valueType` is always inferred from the expression.
+   */
+  specOverride?: SO;
+}
+/**
+ * Transform-columns query operation.
+ *
+ * Computes one or more derived columns from `input`. Axes are
+ * preserved.
+ *
+ * @template Q - Input query type
+ * @template E - Expression type
+ * @template SO - Spec override type
+ */
+interface QueryTransformColumns<Q, E, SO> {
+  type: "transformColumns";
+  /** Input query. */
+  input: Q;
+  /** `"append"` to add new columns; `"replace"` to keep only listed columns. */
+  mode: TransformColumnsMode;
+  /** Derived columns to compute (at least one). */
+  columns: [TransformColumnEntry<E, SO>, ...TransformColumnEntry<E, SO>[]];
+}
+/**
+ * Spec-override query operation — client-side-only structural node.
+ *
+ * Overlays a {@link SpecOverrides} patch on top of the inner query's spec.
+ * Carries no topological change — it is collapsed at the host boundary
+ * (`resolvePColumn`) before the query reaches pframe-engine. The engine
+ * never sees this node.
+ *
+ * Emitted by `ColumnOverriddenRecipe.getQuery()`; the only currently
+ * supported shape is `specOverride{ input: <plain column ref>, override }`
+ * (i.e. `Overridden<Lazy>`). More complex projections under Overridden are
+ * a future engine work item.
+ *
+ * @template Q - Input query type
+ * @template SO - Spec override type
+ */
+interface QuerySpecOverride<Q, SO> {
+  type: "specOverride";
+  /** Input query whose spec is to be overridden. */
+  input: Q;
+  /** Spec override patch to overlay on the inner spec. */
+  override: SO;
+} //#endregion
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/pframe/query/query_data.d.ts
+//#region src/drivers/pframe/query/query_data.d.ts
+/**
+ * Column identifier with type specification.
+ *
+ * Pairs a column ID with its full type specification (axes and column types).
+ * Used in data layer to carry type information alongside column references.
+ */
+type ColumnIdAndTypeSpec = {
+  /** Unique identifier of the column */id: PObjectId; /** Type specification defining the axes and the single column value type */
+  spec: ColumnTypeSpec;
+};
+/**
+ * Join entry for data layer queries.
+ *
+ * Extends the base join entry with axes mapping information.
+ * The mapping specifies how axes from this entry align with the joined result.
+ *
+ * @example
+ * // Join entry with axes mapping [0, 2] means:
+ * // - This entry's axis 0 maps to result axis 0
+ * // - This entry's axis 1 maps to result axis 2
+ * { entry: queryData, axesMapping: [0, 2] }
+ */
+interface DataQueryJoinEntry extends QueryJoinEntry<DataQuery> {
+  /** Maps this entry's axes to the result axes by index */
+  axesMapping: number[];
+}
+/** @see QueryColumn */
+type DataQueryColumn = QueryColumn;
+/** @see QueryInlineColumn */
+type DataQueryInlineColumn = QueryInlineColumn<ColumnIdAndTypeSpec>;
+/** @see QuerySparseToDenseColumn */
+type DataQuerySparseToDenseColumn = QuerySparseToDenseColumn<PObjectId, number, ColumnIdAndTypeSpec>;
+/** @see QuerySymmetricJoin */
+type DataQuerySymmetricJoin = QuerySymmetricJoin<DataQueryJoinEntry>;
+/** @see QueryOuterJoin */
+type DataQueryOuterJoin = QueryOuterJoin<DataQueryJoinEntry>;
+/**
+ * Linker side of a data-layer linker-join.
+ *
+ * Carries the linker column id along with integration-derived artifacts needed
+ * for execution:
+ * - `axesMapping` — how the linker's axes map into the joined result
+ * - `oneSideAxesIndices` — which axis indices in the joined result to project out
+ */
+type DataQueryLinkerJoinLinker = {
+  /** Linker column reference. */column: PObjectId; /** Linker's axes mapped into the joined result. */
+  axesMapping: number[]; /** Axis indices (in the joined result) to project out — the linker's one-side axes. */
+  oneSideAxesIndices: number[];
+};
+/** @see QueryLinkerJoin */
+type DataQueryLinkerJoin = QueryLinkerJoin<DataQueryLinkerJoinLinker, DataQueryJoinEntry>;
+/** @see QuerySliceAxes */
+type DataQuerySliceAxes = QuerySliceAxes<DataQuery, number>;
+/** @see QuerySort */
+type DataQuerySort = QuerySort<DataQuery, DataQueryExpression>;
+/** @see QueryFilter */
+type DataQueryFilter = QueryFilter<DataQuery, DataQueryBooleanExpression>;
+/** @see QueryTransformColumns */
+type DataQueryTransformColumns = QueryTransformColumns<DataQuery, DataQueryExpression, ColumnIdAndTypeSpec>;
+/**
+ * Union of all data layer query types.
+ *
+ * The data layer operates with numeric indices for axes and columns,
+ * making it suitable for runtime query execution and optimization.
+ *
+ * Includes:
+ * - Leaf nodes: column, inlineColumn, sparseToDenseColumn
+ * - Join operations: innerJoin, fullJoin, outerJoin, linkerJoin
+ * - Transformations: sliceAxes, sort, filter, transformColumns
+ */
+type DataQuery = DataQueryColumn | DataQueryInlineColumn | DataQuerySparseToDenseColumn | DataQuerySymmetricJoin | DataQueryOuterJoin | DataQueryLinkerJoin | DataQuerySliceAxes | DataQuerySort | DataQueryFilter | DataQueryTransformColumns;
+/** @see ExprAxisRef */
+type DataExprAxisRef = ExprAxisRef<number>;
+/** @see ExprColumnRef */
+type DataExprColumnRef = ExprColumnRef<number>;
+type DataQueryExpression = DataExprColumnRef | DataExprAxisRef | ExprConstant | ExprNumericBinary<DataQueryExpression> | ExprNumericComparison<DataQueryExpression> | ExprNumericUnary<DataQueryExpression> | ExprStringEquals<DataQueryExpression> | ExprStringContains<DataQueryExpression> | ExprStringRegex<DataQueryExpression> | ExprStringContainsFuzzy<DataQueryExpression> | ExprIsNull<DataQueryExpression> | ExprFillNull<DataQueryExpression> | ExprLogicalUnary<DataQueryExpression> | ExprLogicalVariadic<DataQueryExpression> | ExprIsIn<DataQueryExpression, string> | ExprIsIn<DataQueryExpression, number> | ExprCast<DataQueryExpression> | ExprConditional<DataQueryExpression> | ExprRanking<DataQueryExpression, number, number>;
+type DataQueryBooleanExpression = InferBooleanExpressionUnion<DataQueryExpression>; //#endregion
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/pframe/spec_driver.d.ts
+//#region src/drivers/pframe/spec_driver.d.ts
+/** Matches a string value either exactly or by regex pattern */
+type StringMatcher = {
+  type: "exact";
+  value: string;
+} | {
+  type: "regex";
+  value: string;
+};
+/** Map of key to array of string matchers (OR-ed per key, AND-ed across keys) */
+type MatcherMap = Record<string, StringMatcher[]>;
+/** Selector for matching axes by various criteria */
+interface MultiAxisSelector {
+  /** Match any of the axis types listed here */
+  readonly type?: AxisValueType[];
+  /** Match any of the axis names listed here */
+  readonly name?: StringMatcher[];
+  /** Match requires all the domains listed here */
+  readonly domain?: MatcherMap;
+  /** Match requires all the context domains listed here */
+  readonly contextDomain?: MatcherMap;
+  /** Match requires all the annotations listed here */
+  readonly annotations?: MatcherMap;
+}
+/** Column selector for discover columns request, matching columns by various criteria.
+ * Multiple selectors are OR-ed: a column matches if it satisfies any selector. */
+interface MultiColumnSelector {
+  /** Match any of the value types listed here */
+  readonly type?: ColumnValueType[];
+  /** Match any of the names listed here */
+  readonly name?: StringMatcher[];
+  /** Match requires all the domains listed here */
+  readonly domain?: MatcherMap;
+  /** Match requires all the context domains listed here */
+  readonly contextDomain?: MatcherMap;
+  /** Match requires all the annotations listed here */
+  readonly annotations?: MatcherMap;
+  /** Match any of the axis selectors listed here */
+  readonly axes?: MultiAxisSelector[];
+  /** When true (default), allows matching if only a subset of axes match */
+  readonly partialAxesMatch?: boolean;
+}
+/** Qualifications needed for both query (already-integrated) columns and the hit column. */
+interface ColumnAxesWithQualifications {
+  /** Already integrated (query) columns with their qualifications. */
+  axesSpec: AxisSpec[];
+  /** Qualifications for each already integrated (query) column. */
+  qualifications: AxisQualification[];
+}
+/** Fine-grained constraints controlling axes matching and qualification behavior */
+interface DiscoverColumnsConstraints {
+  /** Allow source (query) axes that have no match in the hit column */
+  allowFloatingSourceAxes: boolean;
+  /** Allow hit column axes that have no match in the source (query) */
+  allowFloatingHitAxes: boolean;
+  /** Allow source (query) axes to be qualified (contextDomain extended) */
+  allowSourceQualifications: boolean;
+  /** Allow hit column axes to be qualified (contextDomain extended) */
+  allowHitQualifications: boolean;
+}
+/** Request for discovering columns compatible with a given axes integration */
+interface DiscoverColumnsRequest {
+  /** Include columns matching these selectors (OR-ed); empty or omitted matches all columns */
+  includeColumns?: MultiColumnSelector[];
+  /** Exclude columns matching these selectors (OR-ed); applied after include filter */
+  excludeColumns?: MultiColumnSelector[];
+  /** Already integrated axes with qualifications */
+  axes: ColumnAxesWithQualifications[];
+  /** Maximum number of hops allowed between provided axes integration and returned hits (0 = direct only) */
+  maxHops?: number;
+  /** Constraints controlling axes matching and qualification behavior */
+  constraints: DiscoverColumnsConstraints;
+}
+/** Linker step: traversal through a linker column */
+interface DiscoverColumnsLinkerStep {
+  type: "linker";
+  /** The linker column traversed in this step */
+  linker: PColumnIdAndSpec;
+}
+/**
+ * Filter step: intersects the current subquery with a filter column on shared
+ * axes. Filter columns carry `pl7.app/isSubset: "true"` with axes ⊆ dataset
+ * axes, so the inner-join narrows the key space to rows where the filter is
+ * present.
+ */
+interface DiscoverColumnsFilterStep {
+  type: "filter";
+  /** The filter column applied in this step */
+  filter: PColumnIdAndSpec;
+}
+/** A step traversed during path-based column discovery. Discriminated by `type`. */
+type DiscoverColumnsStepInfo = DiscoverColumnsLinkerStep | DiscoverColumnsFilterStep;
+/**
+ * Input to `buildQuery`: a terminal column plus an ordered
+ * path of wrapping steps (linker hops, filter joins). Produces a
+ * {@link SpecQueryJoinEntry} ready to be plugged into an
+ * `innerJoin`/`fullJoin`/`outerJoin` entry list.
+ *
+ * Path ordering: `path[0]` is outermost (first applied), `path[N-1]` is
+ * closest to `column`. Omit or pass `[]` for a direct column with no
+ * wrapping.
+ *
+ * Columns are referenced by id — specs are resolved later at
+ * `evaluateQuery` against the registered specs of the PFrame, so the
+ * caller cannot disagree with the frame about spec content.
+ *
+ * Qualifications annotate the resulting outermost entry; they do not
+ * propagate into the inner query.
+ */
+type BuildQueryInput = {
+  /** Shape version marker — bumped only on breaking structural changes. */readonly version: "v1"; /** Terminal column id — the column actually returning data. */
+  readonly column: PObjectId; /** Ordered path from source integration to `column`. Outermost first. */
+  readonly path?: DiscoverColumnsStepInfo[]; /** Axis qualifications attached to the resulting join entry. */
+  readonly qualifications?: AxisQualification[];
+};
+/** Qualifications info for a discover columns response mapping variant */
+interface DiscoverColumnsResponseQualifications {
+  /** Qualifications for each query (already-integrated) column set */
+  forQueries: AxisQualification[][];
+  /** Qualifications for the hit column */
+  forHit: AxisQualification[];
+}
+/** A single mapping variant describing how a hit column can be integrated */
+interface DiscoverColumnsMappingVariant {
+  /** Full qualifications needed for integration */
+  qualifications: DiscoverColumnsResponseQualifications;
+  /** Distinctive (minimal) qualifications needed for integration */
+  distinctiveQualifications: DiscoverColumnsResponseQualifications;
+}
+/** A single hit in the discover columns response */
+interface DiscoverColumnsResponseHit {
+  /** The column that was found compatible */
+  hit: PColumnIdAndSpec;
+  /** Linker steps traversed to reach this hit; empty for direct matches */
+  path: DiscoverColumnsStepInfo[];
+  /** Possible ways to integrate this column with the existing set */
+  mappingVariants: DiscoverColumnsMappingVariant[];
+}
+/** Response from discover columns */
+interface DiscoverColumnsResponse {
+  /** Columns that could be integrated and possible ways to integrate them */
+  hits: DiscoverColumnsResponseHit[];
+}
+/** Request for deleting an entry from a given axes integration */
+interface DeleteColumnRequest {
+  /** Already integrated axes with qualifications */
+  axes: ColumnAxesWithQualifications[];
+  /** Zero based index of the entry to be deleted */
+  delete: number;
+}
+/** Response from delete column */
+interface DeleteColumnResponse {
+  axes: ColumnAxesWithQualifications[];
+}
+/** Response from evaluating a query against a PFrame. */
+type EvaluateQueryResponse = {
+  /**
+   * The table specification describing the structure of the query result,
+   * including all axes and columns that will be present in the output.
+   */
+  tableSpec: PTableColumnSpec[];
+  /**
+   * The data layer query representation with numeric indices,
+   * suitable for execution by the data processing engine.
+   */
+  dataQuery: DataQuery;
+};
+/** Handle to a spec-only PFrame (no data, synchronous operations). */
+type SpecFrameHandle = Branded<string, "SpecFrameHandle">;
+/**
+ * Synchronous driver for spec-level PFrame operations.
+ *
+ * Unlike the async PFrameDriver (which works with data), this driver
+ * operates on column specifications only. All methods are synchronous
+ * because the underlying WASM PFrame computes results immediately.
+ */
+interface PFrameSpecDriver {
+  /** Create a spec-only PFrame from column specs. Returns a pool entry with handle and unref. */
+  createSpecFrame(specs: Record<string, PColumnSpec>): PoolEntry<SpecFrameHandle>;
+  /** List all columns currently registered in the frame. */
+  listColumns(handle: SpecFrameHandle): PColumnIdAndSpec[];
+  /** Discover columns compatible with given axes integration. */
+  discoverColumns(handle: SpecFrameHandle, request: DiscoverColumnsRequest): DiscoverColumnsResponse;
+  /** Delete an entry from a given axes integration */
+  deleteColumn(handle: SpecFrameHandle, request: DeleteColumnRequest): DeleteColumnResponse;
+  /** Evaluates a query specification against this PFrame */
+  evaluateQuery(handle: SpecFrameHandle, request: SpecQuery): EvaluateQueryResponse;
+  /**
+   * Assembles a {@link SpecQueryJoinEntry} from a terminal column plus an
+   * ordered path of wrapping steps (linker hops, filter joins).
+   *
+   * Pure over its input — no frame handle is needed. Column ids are resolved
+   * later at {@link evaluateQuery} against the registered specs.
+   */
+  buildQuery(input: BuildQueryInput): SpecQueryJoinEntry;
+  /** Expand index-based parentAxes in AxesSpec to resolved AxisId parents in AxesId. */
+  expandAxes(spec: AxesSpec): AxesId;
+  /** Collapse resolved AxisId parents back to index-based parentAxes in AxesSpec. */
+  collapseAxes(ids: AxesId): AxesSpec;
+  /** Find the index of an axis matching the given selector. Returns -1 if not found. */
+  findAxis(spec: AxesSpec, selector: SingleAxisSelector): number;
+  /** Find the flat index of a table column matching the given selector. Returns -1 if not found. */
+  findTableColumn(tableSpec: PTableColumnSpec[], selector: PTableColumnId): number;
+  /**
+   * Upgrades selector-based legacy record filters into index-based data-layer
+   * boolean expressions, resolved against the provided unified table spec
+   * (axes first, then columns).
+   */
+  rewriteLegacyFilters(request: {
+    tableSpec: PTableColumnSpec[];
+    filters: PTableRecordFilter[];
+  }): DataQueryBooleanExpression[];
+} //#endregion
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/pframe/spec/selectors.d.ts
+/** Single axis selector */
+interface SingleAxisSelector {
+  /** Axis name (required) */
+  name: string;
+  /** Axis type (optional) */
+  type?: AxisValueType;
+  /** Domain requirements (optional) */
+  domain?: Domain;
+  /** Context-domain requirements (optional) */
+  contextDomain?: Domain;
+  /** Parent axes requirements (optional) */
+  parentAxes?: SingleAxisSelector[];
+}
+/** Qualification applied to a single axis to make it compatible during integration. */
+interface AxisQualification {
+  /** Axis selector identifying which axis is qualified. */
+  readonly axis: SingleAxisSelector;
+  /** Additional context domain entries applied to the axis. */
+  readonly contextDomain: Record<string, string>;
+}
+/**
+ * Reference to an axis by its numerical index within the anchor column's axes array
+ * Format: [anchorId, axisIndex]
+ */
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/pframe/query/query_spec.d.ts
+//#region src/drivers/pframe/query/query_spec.d.ts
+/**
+ * Join entry for spec-layer queries — the base join entry extended with
+ * per-axis domain constraints. Absent `qualifications` is equivalent to `[]`.
+ *
+ * @example
+ * {
+ *   entry: querySpec,
+ *   qualifications: [{ axis: { name: 'sample' }, contextDomain: { ... } }]
+ * }
+ */
+type SpecQueryJoinEntry<C = ColumnUniversalId> = QueryJoinEntry<SpecQuery<C>> & {
+  qualifications?: readonly {
+    /** Axis to qualify. */axis: SingleAxisSelector; /** Additional domain constraints for this axis. */
+    contextDomain: Domain;
+  }[];
+};
+/** @see QueryColumn */
+type SpecQueryColumn<C = ColumnUniversalId> = QueryColumn<C>;
+/** @see QueryInlineColumn */
+type SpecQueryInlineColumn = QueryInlineColumn<PColumnIdAndSpec>;
+/** @see QuerySparseToDenseColumn */
+type SpecQuerySparseToDenseColumn<C = ColumnUniversalId> = QuerySparseToDenseColumn<C, SingleAxisSelector, PColumnIdAndSpec>;
+/** @see QuerySymmetricJoin */
+type SpecQuerySymmetricJoin<C = ColumnUniversalId> = QuerySymmetricJoin<SpecQueryJoinEntry<C>>;
+/** @see QueryOuterJoin */
+type SpecQueryOuterJoin<C = ColumnUniversalId> = QueryOuterJoin<SpecQueryJoinEntry<C>>;
+/** @see QueryLinkerJoin */
+type SpecQueryLinkerJoin<C = ColumnUniversalId> = QueryLinkerJoin<SpecQuery<C>, SpecQueryJoinEntry<C>>;
+/** @see QuerySliceAxes */
+type SpecQuerySliceAxes<C = ColumnUniversalId> = QuerySliceAxes<SpecQuery<C>, SingleAxisSelector>;
+/** @see QuerySort */
+type SpecQuerySort<C = ColumnUniversalId> = QuerySort<SpecQuery<C>, SpecQueryExpression>;
+/** @see QueryFilter */
+type SpecQueryFilter<C = ColumnUniversalId> = QueryFilter<SpecQuery<C>, SpecQueryBooleanExpression>;
+/** @see QueryTransformColumns */
+type SpecQueryTransformColumns<C = ColumnUniversalId> = QueryTransformColumns<SpecQuery<C>, SpecQueryExpression, PColumnIdAndSpec>;
+/**
+ * Client-side spec-override node — collapsed at the host boundary, never
+ * sent to pframe-engine.
+ *
+ * @see QuerySpecOverride
+ */
+type SpecQuerySpecOverride<C = ColumnUniversalId> = QuerySpecOverride<SpecQuery<C>, SpecOverrides>;
+/**
+ * Union of all spec layer query types.
+ *
+ * The spec layer operates with named selectors and column IDs,
+ * making it suitable for user-facing query construction and validation.
+ *
+ * @template C - Column reference type. Defaults to PObjectId (ID-only).
+ *   Can be parameterized with richer types (e.g., PColumn<Data>) to carry
+ *   full column data directly in the query tree.
+ *
+ * Includes:
+ * - Leaf nodes: column, inlineColumn, sparseToDenseColumn
+ * - Join operations: innerJoin, fullJoin, outerJoin, linkerJoin
+ * - Transformations: sliceAxes, sort, filter, transformColumns
+ * - Client-side overlays: specOverride (collapsed before reaching the engine)
+ */
+type SpecQuery<C = ColumnUniversalId> = SpecQueryColumn<C> | SpecQueryInlineColumn | SpecQuerySparseToDenseColumn<C> | SpecQuerySymmetricJoin<C> | SpecQueryOuterJoin<C> | SpecQueryLinkerJoin<C> | SpecQuerySliceAxes<C> | SpecQuerySort<C> | SpecQueryFilter<C> | SpecQueryTransformColumns<C> | SpecQuerySpecOverride<C>;
+/** @see ExprAxisRef */
+type SpecExprAxisRef = ExprAxisRef<SingleAxisSelector>;
+/** @see ExprColumnRef */
+type SpecExprColumnRef = ExprColumnRef<ColumnUniversalId>;
+type SpecQueryExpression = SpecExprColumnRef | SpecExprAxisRef | ExprConstant | ExprNumericBinary<SpecQueryExpression> | ExprNumericComparison<SpecQueryExpression> | ExprNumericUnary<SpecQueryExpression> | ExprStringEquals<SpecQueryExpression> | ExprStringContains<SpecQueryExpression> | ExprStringRegex<SpecQueryExpression> | ExprStringContainsFuzzy<SpecQueryExpression> | ExprIsNull<SpecQueryExpression> | ExprFillNull<SpecQueryExpression> | ExprLogicalUnary<SpecQueryExpression> | ExprLogicalVariadic<SpecQueryExpression> | ExprIsIn<SpecQueryExpression, string> | ExprIsIn<SpecQueryExpression, number> | ExprCast<SpecQueryExpression> | ExprConditional<SpecQueryExpression> | ExprRanking<SpecQueryExpression, SingleAxisSelector, PObjectId>;
+type SpecQueryBooleanExpression = InferBooleanExpressionUnion<SpecQueryExpression>; //#endregion
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/pframe/table_calculate.d.ts
+//#region src/drivers/pframe/table_calculate.d.ts
+/** Defines a terminal column node in the join request tree */
+interface ColumnJoinEntry<Col> {
+  /** Node type discriminator */
+  readonly type: "column";
+  /** Local column */
+  readonly column: Col;
+}
+/**
+ * Axis filter slicing target axis from column axes.
+ * If the axis has parents or is a parent, slicing cannot be applied (an error will be thrown).
+ * */
+interface ConstantAxisFilter {
+  /** Filter type discriminator */
+  readonly type: "constant";
+  /** Index of axis to slice (zero-based) */
+  readonly axisIndex: number;
+  /** Equality filter reference value, see {@link SingleValueEqualPredicate} */
+  readonly constant: string | number;
+}
+/** Defines a terminal column node in the join request tree */
+interface SlicedColumnJoinEntry<Col> {
+  /** Node type discriminator */
+  readonly type: "slicedColumn";
+  /** Local column */
+  readonly column: Col;
+  /** New column id */
+  readonly newId: PObjectId;
+  /** Non-empty list of axis filters */
+  readonly axisFilters: ConstantAxisFilter[];
+}
+interface ArtificialColumnJoinEntry<Col> {
+  /** Node type discriminator */
+  readonly type: "artificialColumn";
+  /** Column definition */
+  readonly column: Col;
+  /** New column id */
+  readonly newId: PObjectId;
+  /** Indices of axes to pick from the column (zero-based) */
+  readonly axesIndices: number[];
+}
+/** Defines a terminal column node in the join request tree */
+interface InlineColumnJoinEntry {
+  /** Node type discriminator */
+  readonly type: "inlineColumn";
+  /** Column definition */
+  readonly column: PColumn<PColumnValues>;
+}
+/**
+ * Defines a join request tree node that will output only records present in
+ * all child nodes ({@link entries}).
+ * */
+interface InnerJoin<Col> {
+  /** Node type discriminator */
+  readonly type: "inner";
+  /** Child nodes to be inner joined */
+  readonly entries: JoinEntry<Col>[];
+}
+/**
+ * Defines a join request tree node that will output all records present at
+ * least in one of the child nodes ({@link entries}), values for those PColumns
+ * that lack corresponding combinations of axis values will be null.
+ * */
+interface FullJoin<Col> {
+  /** Node type discriminator */
+  readonly type: "full";
+  /** Child nodes to be fully outer joined */
+  readonly entries: JoinEntry<Col>[];
+}
+/**
+ * Defines a join request tree node that will output all records present in
+ * {@link primary} child node, and records from the {@link secondary} nodes will
+ * be added to the output only if present, values for those PColumns from the
+ * {@link secondary} list, that lack corresponding combinations of axis values
+ * will be null.
+ *
+ * This node can be thought as a chain of SQL LEFT JOIN operations starting from
+ * the {@link primary} node and adding {@link secondary} nodes one by one.
+ * */
+interface OuterJoin<Col> {
+  /** Node type discriminator */
+  readonly type: "outer";
+  /** Primes the join operation. Left part of LEFT JOIN. */
+  readonly primary: JoinEntry<Col>;
+  /** Driven nodes, giving their values only if primary node have corresponding
+   * nodes. Right parts of LEFT JOIN chain. */
+  readonly secondary: JoinEntry<Col>[];
+}
+/**
+ * Base type of all join request tree nodes. Join request tree allows to combine
+ * information from multiple PColumns into a PTable. Correlation between records
+ * is performed by looking for records with the same values in common axis between
+ * the PColumns. Common axis are those axis which have equal {@link AxisId} derived
+ * from the columns axes spec.
+ * */
+type JoinEntry<Col> = ColumnJoinEntry<Col> | SlicedColumnJoinEntry<Col> | ArtificialColumnJoinEntry<Col> | InlineColumnJoinEntry | InnerJoin<Col> | FullJoin<Col> | OuterJoin<Col>;
+/** Container representing whole data stored in specific PTable column. */
+interface FullPTableColumnData {
+  /** Unified spec */
+  readonly spec: PTableColumnSpec;
+  /** Data */
+  readonly data: PTableVector;
+}
+interface SingleValueIsNAPredicate {
+  /** Comparison operator */
+  readonly operator: "IsNA";
+}
+interface SingleValueEqualPredicate {
+  /** Comparison operator */
+  readonly operator: "Equal";
+  /** Reference value, NA values will not match */
+  readonly reference: string | number;
+}
+interface SingleValueInSetPredicate {
+  /** Comparison operator */
+  readonly operator: "InSet";
+  /** Reference values, NA values will not match */
+  readonly references: (string | number)[];
+}
+interface SingleValueIEqualPredicate {
+  /** Comparison operator (case insensitive) */
+  readonly operator: "IEqual";
+  /** Reference value, NA values will not match */
+  readonly reference: string;
+}
+interface SingleValueLessPredicate {
+  /** Comparison operator */
+  readonly operator: "Less";
+  /** Reference value, NA values will not match */
+  readonly reference: string | number;
+}
+interface SingleValueLessOrEqualPredicate {
+  /** Comparison operator */
+  readonly operator: "LessOrEqual";
+  /** Reference value, NA values will not match */
+  readonly reference: string | number;
+}
+interface SingleValueGreaterPredicate {
+  /** Comparison operator */
+  readonly operator: "Greater";
+  /** Reference value, NA values will not match */
+  readonly reference: string | number;
+}
+interface SingleValueGreaterOrEqualPredicate {
+  /** Comparison operator */
+  readonly operator: "GreaterOrEqual";
+  /** Reference value, NA values will not match */
+  readonly reference: string | number;
+}
+interface SingleValueStringContainsPredicate {
+  /** Comparison operator */
+  readonly operator: "StringContains";
+  /** Reference substring, NA values are skipped */
+  readonly substring: string;
+}
+interface SingleValueStringIContainsPredicate {
+  /** Comparison operator (case insensitive) */
+  readonly operator: "StringIContains";
+  /** Reference substring, NA values are skipped */
+  readonly substring: string;
+}
+interface SingleValueMatchesPredicate {
+  /** Comparison operator */
+  readonly operator: "Matches";
+  /** Regular expression, NA values are skipped */
+  readonly regex: string;
+}
+interface SingleValueStringContainsFuzzyPredicate {
+  /** Comparison operator */
+  readonly operator: "StringContainsFuzzy";
+  /** Reference value, NA values are skipped */
+  readonly reference: string;
+  /**
+   * Integer specifying the upper bound of edit distance between
+   * reference and actual value.
+   * When {@link substitutionsOnly} is not defined or set to false
+   * Levenshtein distance is used (substitutions and indels)
+   * @see https://en.wikipedia.org/wiki/Levenshtein_distance
+   * When {@link substitutionsOnly} is set to true
+   * Hamming distance is used (substitutions only)
+   * @see https://en.wikipedia.org/wiki/Hamming_distance
+   */
+  readonly maxEdits: number;
+  /** Changes the type of edit distance in {@link maxEdits} */
+  readonly substitutionsOnly?: boolean;
+  /**
+   * Some character in {@link reference} that will match any
+   * single character in searched text.
+   */
+  readonly wildcard?: string;
+}
+interface SingleValueStringIContainsFuzzyPredicate {
+  /** Comparison operator (case insensitive) */
+  readonly operator: "StringIContainsFuzzy";
+  /** Reference value, NA values are skipped */
+  readonly reference: string;
+  /**
+   * Integer specifying the upper bound of edit distance between
+   * reference and actual value.
+   * When {@link substitutionsOnly} is not defined or set to false
+   * Levenshtein distance is used (substitutions and indels)
+   * @see https://en.wikipedia.org/wiki/Levenshtein_distance
+   * When {@link substitutionsOnly} is set to true
+   * Hamming distance is used (substitutions only)
+   * @see https://en.wikipedia.org/wiki/Hamming_distance
+   */
+  readonly maxEdits: number;
+  /** Changes the type of edit distance in {@link maxEdits} */
+  readonly substitutionsOnly?: boolean;
+  /**
+   * Some character in {@link reference} that will match any
+   * single character in searched text.
+   */
+  readonly wildcard?: string;
+}
+interface SingleValueNotPredicateV2 {
+  /** Comparison operator */
+  readonly operator: "Not";
+  /** Operand to negate */
+  readonly operand: SingleValuePredicateV2;
+}
+interface SingleValueAndPredicateV2 {
+  /** Comparison operator */
+  readonly operator: "And";
+  /** Operands to combine */
+  readonly operands: SingleValuePredicateV2[];
+}
+interface SingleValueOrPredicateV2 {
+  /** Comparison operator */
+  readonly operator: "Or";
+  /** Operands to combine */
+  readonly operands: SingleValuePredicateV2[];
+}
+/** Filtering predicate for a single axis or column value */
+type SingleValuePredicateV2 = SingleValueIsNAPredicate | SingleValueEqualPredicate | SingleValueInSetPredicate | SingleValueLessPredicate | SingleValueLessOrEqualPredicate | SingleValueGreaterPredicate | SingleValueGreaterOrEqualPredicate | SingleValueStringContainsPredicate | SingleValueMatchesPredicate | SingleValueStringContainsFuzzyPredicate | SingleValueNotPredicateV2 | SingleValueAndPredicateV2 | SingleValueOrPredicateV2 | SingleValueIEqualPredicate | SingleValueStringIContainsPredicate | SingleValueStringIContainsFuzzyPredicate;
+/**
+ * Filter PTable records based on specific axis or column value. If this is an
+ * axis value filter and the axis is part of a partitioning key in some of the
+ * source PColumns, the filter will be pushed down to those columns, so only
+ * specific partitions will be retrieved from the remote storage.
+ * */
+interface PTableRecordSingleValueFilterV2 {
+  /** Filter type discriminator */
+  readonly type: "bySingleColumnV2";
+  /** Target axis selector to examine values from */
+  readonly column: PTableColumnId;
+  /** Value predicate */
+  readonly predicate: SingleValuePredicateV2;
+}
+/** Generic PTable records filter */
+type PTableRecordFilter = PTableRecordSingleValueFilterV2;
+/** Sorting parameters for a PTable.  */
+type PTableSorting = {
+  /** Unified column identifier */readonly column: PTableColumnId; /** Sorting order */
+  readonly ascending: boolean; /** Sorting in respect to NA and absent values */
+  readonly naAndAbsentAreLeastValues: boolean;
+};
+/** Information required to instantiate a PTable. */
+interface PTableDef<Col> {
+  /** Join tree to populate the PTable */
+  readonly src: JoinEntry<Col>;
+  /** Partition filters */
+  readonly partitionFilters: PTableRecordFilter[];
+  /** Record filters */
+  readonly filters: PTableRecordFilter[];
+  /** Table sorting */
+  readonly sorting: PTableSorting[];
+}
+/** Information required to instantiate a PTable (V2, query-based). */
+interface PTableDefV2<Col> {
+  /** Pre-built query spec describing joins, filters and sorting */
+  readonly query: SpecQuery<Col>;
+}
+/** Request to create and retrieve entirety of data of PTable. */
+type CalculateTableDataRequest<Col> = {
+  /** Join tree to populate the PTable */readonly src: JoinEntry<Col>; /** Record filters */
+  readonly filters: PTableRecordFilter[]; /** Table sorting */
+  readonly sorting: PTableSorting[];
+};
+/** Response for {@link CalculateTableDataRequest} */
+type CalculateTableDataResponse = FullPTableColumnData[];
+//#endregion
+//#region ../../../../lib/model/common/dist/ref.d.ts
+//#region src/ref.d.ts
+declare const PlRef: ZodReadonly<ZodObject<{
+  __isRef: ZodLiteral<true>;
+  blockId: ZodString;
+  name: ZodString;
+  requireEnrichments: ZodOptional<ZodLiteral<true>>;
+}, "strip", ZodTypeAny, {
+  __isRef: true;
+  blockId: string;
+  name: string;
+  requireEnrichments?: true | undefined;
+}, {
+  __isRef: true;
+  blockId: string;
+  name: string;
+  requireEnrichments?: true | undefined;
+}>>;
+type PlRef = TypeOf<typeof PlRef>;
+/** @deprecated use {@link PlRef} */
+//#endregion
+//#region ../../../../lib/model/common/dist/pool/spec.d.ts
+//#region src/pool/spec.d.ts
+/** Any object exported into the result pool by the block always have spec attached to it */
+type PObjectSpec = {
+  /** PObject kind discriminator */readonly kind: string; /** Name is common part of PObject identity */
+  readonly name: string; /** Domain is a set of key-value pairs that can be used to identify the object */
+  readonly domain?: Record<string, string>;
+  /** Context domain provides additional axis/column identity that is matched
+   * by kinship rules (subset/superset/overlap) rather than exact equality */
+  readonly contextDomain?: Record<string, string>; /** Additional information attached to the object */
+  readonly annotations?: Record<string, string>;
+};
+type LocalPObjectKey = {
+  resolvePath: string[];
+  name: string;
+};
+type LocalPObjectId = Branded<CanonicalizedJson<LocalPObjectKey>, "LocalPObjectId">;
+type GlobalPObjectKey = PlRef;
+type GlobalPObjectId = Branded<CanonicalizedJson<GlobalPObjectKey>, "GlobalPObjectId">;
+/** Stable PObject id */
+type PObjectId = LocalPObjectId | GlobalPObjectId;
+/**
+ * Full PObject representation.
+ *
+ * @template Data type of the object referencing or describing the "data" part of the PObject
+ * */
+interface PObject<Data> {
+  /** Fully rendered PObjects are assigned a stable identifier. */
+  readonly id: PObjectId;
+  /** PObject spec, allowing it to be found among other PObjects */
+  readonly spec: PObjectSpec;
+  /** A handle to data object */
+  readonly data: Data;
+}
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/pframe/spec/spec.d.ts
+//#region src/drivers/pframe/spec/spec.d.ts
+declare const ValueType: {
+  readonly Int: "Int";
+  readonly Long: "Long";
+  readonly Float: "Float";
+  readonly Double: "Double";
+  readonly String: "String";
+  readonly Bytes: "Bytes";
+};
+type AxisValueType = Extract<ValueType, "Int" | "Long" | "String">;
+type ColumnValueType = ValueType;
+/** PFrame columns and axes within them may store one of these types. */
+type ValueType = (typeof ValueType)[keyof typeof ValueType];
+type Metadata = Record<string, string>;
+declare const Domain: {
+  readonly Alphabet: "pl7.app/alphabet";
+  readonly BlockId: "pl7.app/blockId";
+  readonly VDJ: {
+    readonly Clustering: {
+      readonly BlockId: "pl7.app/vdj/clustering/blockId";
+    };
+    readonly ScClonotypeChain: {
+      readonly Index: "pl7.app/vdj/scClonotypeChain/index";
+    };
+  };
+};
+type Domain = Metadata & Partial<{
+  [Domain.Alphabet]: "nucleotide" | "aminoacid" | (string & {});
+  [Domain.BlockId]: string;
+  [Domain.VDJ.ScClonotypeChain.Index]: "primary" | "secondary" | (string & {});
+}>;
+/**
+ * Specification of an individual axis.
+ *
+ * Each axis is a part of a composite key that addresses data inside the PColumn.
+ *
+ * Each record inside a PColumn is addressed by a unique tuple of values set for
+ * all the axes specified in the column spec.
+ */
+type AxisSpec = {
+  /** Type of the axis value. Should not use non-key types like float or double. */readonly type: AxisValueType; /** Name of the axis */
+  readonly name: string;
+  /** Adds auxiliary information to the axis name, type and parents to form a
+   * unique identifier */
+  readonly domain?: Record<string, string>;
+  /** Context domain provides additional axis identity that is matched
+   * by kinship rules (subset/superset/overlap) rather than exact equality */
+  readonly contextDomain?: Record<string, string>;
+  /** Any additional information attached to the axis that does not affect its
+   * identifier */
+  readonly annotations?: Record<string, string>;
+  /**
+   * Parent axes provide contextual grouping for the axis in question, establishing
+   * a hierarchy where the current axis is dependent on one or more axes for its
+   * full definition and meaning. For instance, in a data structure where each
+   * "container" axis may contain multiple "item" axes, the `item` axis would
+   * list the index of the `container` axis in this field to denote its dependency.
+   *
+   * This means that the identity or significance of the `item` axis is only
+   * interpretable when combined with its parent `container` axis. An `item` axis
+   * index by itself may be non-unique and only gains uniqueness within the context
+   * of its parent `container`. Therefore, the `parentAxes` field is essential for
+   * mapping these relationships and ensuring data coherence across nested or
+   * multi-level data models.
+   *
+   * A list of zero-based indices of parent axes in the overall axes specification
+   * from the column spec. Each index corresponds to the position of a parent axis
+   * in the list that defines the structure of the data model.
+   */
+  readonly parentAxes?: number[];
+};
+/** Parents are specs, not indexes; normalized axis can be used considering its parents independently from column */
+/** Common type representing spec for all the axes in a column */
+type AxesSpec = AxisSpec[];
+/**
+ * Full column specification including all axes specs and specs of the column
+ * itself.
+ *
+ * A PColumn in its essence represents a mapping from a fixed size, explicitly
+ * typed tuple to an explicitly typed value.
+ *
+ * (axis1Value1, axis2Value1, ...) -> columnValue
+ *
+ * Each element in tuple correspond to the axis having the same index in axesSpec.
+ */
+type PUniversalColumnSpec = PObjectSpec & {
+  /** Defines specific type of BObject, the most generic type of unit of
+   * information in Platforma Project. */
+  readonly kind: "PColumn"; /** Type of column values */
+  readonly valueType: string; /** Column name */
+  readonly name: string;
+  /** Adds auxiliary information to the axis name, type and parents to form a
+   * unique identifier */
+  readonly domain?: Record<string, string>;
+  /** Context domain provides additional column identity that is matched
+   * by kinship rules (subset/superset/overlap) rather than exact equality */
+  readonly contextDomain?: Record<string, string>;
+  /** Any additional information attached to the column that does not affect its
+   * identifier */
+  readonly annotations?: Record<string, string>; /** A list of zero-based indices of parent axes from the {@link axesSpec} array. */
+  readonly parentAxes?: number[]; /** Axes specifications */
+  readonly axesSpec: AxesSpec;
+};
+/**
+ * Specification of a data column.
+ *
+ * Data column is a specialized type of PColumn that stores only simple values (strings and numbers)
+ * addressed by multiple keys. This is in contrast to other PColumn variants that can store more complex
+ * values like files or other abstract data types. Data columns are optimized for storing and processing
+ * basic tabular data.
+ */
+type PDataColumnSpec = PUniversalColumnSpec & {
+  /** Type of column values */readonly valueType: ValueType;
+};
+type PColumnSpec = PDataColumnSpec;
+/** Unique PColumnSpec identifier */
+interface PColumn<Data> extends PObject<Data> {
+  /** PColumn spec, allowing it to be found among other PObjects */
+  readonly spec: PColumnSpec;
+}
+/** Columns in a PFrame also have internal identifier, this object represents
+ * combination of specs and such id */
+interface PColumnIdAndSpec {
+  /** Internal column id within the PFrame */
+  readonly columnId: PObjectId;
+  /** Column spec */
+  readonly spec: PColumnSpec;
+}
+/** Get column id and spec from a column */
+interface AxisId {
+  /** Type of the axis or column value. For an axis should not use non-key
+   * types like float or double. */
+  readonly type: AxisValueType;
+  /** Name of the axis or column */
+  readonly name: string;
+  /** Adds auxiliary information to the axis or column name and type to form a
+   * unique identifier */
+  readonly domain?: Record<string, string>;
+  /** Context domain provides additional axis identity that is matched
+   * by kinship rules (subset/superset/overlap) rather than exact equality */
+  readonly contextDomain?: Record<string, string>;
+}
+/** Array of axis ids */
+type AxesId = AxisId[];
+/** Extracts axis ids from axis spec */
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/pframe/spec/filtered_column.d.ts
+//#region src/drivers/pframe/spec/filtered_column.d.ts
+/** Value of an axis filter */
+type AxisFilterValue = number | string;
+/** Axis filter by index */
+type AxisFilterByIdx = [number, AxisFilterValue];
+/** Axis filter by name */
+/**
+ * `source` is either a leaf {@link PObjectId} or a {@link ColumnDiscoveredId}.
+ * Filtered never nests inside Filtered (flat-merge invariant), and Filtered is
+ * never the outer wrapper around Overridden — Overridden is always outermost.
+ */
+interface ColumnFilteredKey {
+  __isFiltered: true;
+  source: ColumnUniversalId;
+  axisFilters: AxisFilterByIdx[];
+}
+type ColumnFilteredId = Branded<CanonicalizedJson<ColumnFilteredKey>, "ColumnFilteredId">;
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/pframe/spec/ids.d.ts
+//#region src/drivers/pframe/spec/ids.d.ts
+/**
+ * Per-axis patches keyed by positional index in the base spec's `axesSpec`.
+ *
+ * Using position rather than `name` lets us disambiguate linker-style specs
+ * that carry multiple axes with the same `name` differentiated by `domain` /
+ * `contextDomain` (e.g. a `group`, `group/primary`, `group/secondary` triple).
+ *
+ * A patch at index `>= base.axesSpec.length` appends a new axis at that slot.
+ */
+type AxisPatches = Record<number, Partial<AxisSpec>>;
+/**
+ * Universal column identifier optionally anchored and optionally filtered.
+ * @deprecated use {@link ColumnUniversalKey}
+ */
+type ColumnUniversalId = LocalPObjectId | GlobalPObjectId | ColumnFilteredId | ColumnDiscoveredId | ColumnOverriddenId;
+/**
+ * Canonically serializes a column key to a branded string id. Accepts both
+ * the new {@link ColumnUniversalKey} and the deprecated {@link UniversalPColumnId}
+ * (anchored / old filtered object form).
+ */
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/pframe/spec/discovered_column.d.ts
+//#region src/drivers/pframe/spec/discovered_column.d.ts
+interface ColumnDiscoveredKey {
+  __isDiscovered: true;
+  column: ColumnUniversalId;
+  path?: PathItem[];
+  columnQualifications?: AxisQualification[];
+  queriesQualifications?: Record<PObjectId, AxisQualification[]>;
+}
+type ColumnDiscoveredId = Branded<CanonicalizedJson<ColumnDiscoveredKey>, "ColumnDiscoveredId">;
+type PathItem = {
+  type: "linker";
+  column: ColumnUniversalId;
+};
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/interfaces.d.ts
+//#region src/drivers/interfaces.d.ts
+/**
+ * Intended to match web.Blob, node.Blob, node-fetch.Blob, etc.
+ */
+interface BlobLike {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/size) */
+  readonly size: number;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/type) */
+  readonly type: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/text) */
+  text(): Promise<string>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/slice) */
+  slice(start?: number, end?: number): BlobLike;
+}
+/**
+ * Intended to match web.File, node.File, node-fetch.File, etc.
+ */
+interface FileLike extends BlobLike {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/lastModified) */
+  readonly lastModified: number;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/name) */
+  readonly name: string;
+} //#endregion
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/blob.d.ts
+//#region src/drivers/blob.d.ts
+/** Handle of locally downloaded blob. This handle is issued only after the
+ * blob's content is downloaded locally, and ready for quick access. */
+type LocalBlobHandle = Branded$1<string, "LocalBlobHandle">;
+/** Handle of remote blob. This handle is issued as soon as the data becomes
+ * available on the remote server. */
+type RemoteBlobHandle = Branded$1<string, "RemoteBlobHandle">;
+/** Being configured inside the output structure provides information about
+ * blob's content and means to retrieve it when needed. */
+/** Range in bytes, from should be less than to. */
+declare const RangeBytes: ZodObject<{
+  /** Included left border. */from: ZodNumber; /** Excluded right border. */
+  to: ZodNumber;
+}, "strip", ZodTypeAny, {
+  from: number;
+  to: number;
+}, {
+  from: number;
+  to: number;
+}>;
+type RangeBytes = TypeOf<typeof RangeBytes>;
+/** Defines API of blob driver as it is seen from the block UI code. */
+interface BlobDriver {
+  /**
+   * Given the blob handle returns its content.
+   * Depending on the handle type, content will be served from locally downloaded file,
+   * or directly from remote platforma storage.
+   */
+  getContent(handle: LocalBlobHandle | RemoteBlobHandle, range?: RangeBytes): Promise<Uint8Array>;
+}
+/**
+ * Operational metrics of the blob download driver.
+ */
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/log.d.ts
+//#region src/drivers/log.d.ts
+/** Prefix constants — single source of truth for handle format. */
+declare const LIVE_LOG_PREFIX = "log+live://log/";
+declare const READY_LOG_PREFIX = "log+ready://log/";
+/** Handle of the live logs of a program.
+ * The resource that represents a log can be deleted,
+ * in this case the handle should be refreshed. */
+type LiveLogHandle = Branded$1<`${typeof LIVE_LOG_PREFIX}${string}`, "LiveLogHandle">;
+/** Handle of the ready logs of a program. */
+type ReadyLogHandle = Branded$1<`${typeof READY_LOG_PREFIX}${string}`, "ReadyLogHandle">;
+/** Handle of logs. This handle should be passed
+ * to the driver for retrieving logs. */
+type AnyLogHandle = LiveLogHandle | ReadyLogHandle;
+/** Type guard to check if a value is any kind of log handle. */
+/** Driver to retrieve logs given log handle */
+interface LogsDriver {
+  lastLines(/** A handle that was issued previously. */
+
+  handle: AnyLogHandle, /** Allows client to limit total data sent from server. */
+
+  lineCount: number,
+  /** Makes streamer to perform seek operation to given offset before sending the contents.
+   * Client can just use the <new_offset> value of the last response from server to continue streaming after reconnection.
+   * If undefined, then starts from the end. */
+
+  offsetBytes?: number,
+  /** Is substring for line search pattern.
+   * This option makes controller to send to the client only lines, that
+   * have given substring. */
+
+  searchStr?: string): Promise<StreamingApiResponse>;
+  readText(/** A handle that was issued previously. */
+
+  handle: AnyLogHandle, /** Allows client to limit total data sent from server. */
+
+  lineCount: number,
+  /** Makes streamer to perform seek operation to given offset before sending the contents.
+   * Client can just use the <new_offset> value of the last response from server to continue streaming after reconnection.
+   * If undefined of 0, then starts from the beginning. */
+
+  offsetBytes?: number,
+  /** Is substring for line search pattern.
+   * This option makes controller to send to the client only lines, that
+   * have given substring. */
+
+  searchStr?: string): Promise<StreamingApiResponse>;
+}
+/** Response of the driver.
+ * The caller should give a handle to retrieve it.
+ * It can be OK or outdated, in which case the handle
+ * should be issued again. */
+type StreamingApiResponse = StreamingApiResponseOk | StreamingApiResponseHandleOutdated;
+type StreamingApiResponseOk = {
+  /** The handle don't have to be updated,
+   * the response is OK. */
+  shouldUpdateHandle: false; /** Whether the log can still grow or it's in a final state. */
+  live: boolean; /** Data of the response, in bytes. */
+  data: Uint8Array; /** Current size of the file. It can grow if it's still live. */
+  size: number; /** Offset in bytes from the beginning of a file. */
+  newOffset: number;
+};
+/** The handle should be issued again, this one is done. */
+type StreamingApiResponseHandleOutdated = {
+  shouldUpdateHandle: true;
+};
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/pframe/column_filter.d.ts
+//#region src/drivers/pframe/column_filter.d.ts
+/** Allows to search multiple columns in different contexts. */
+interface ColumnFilter {
+  /** Match any of the types listed here. If undefined, will be ignored during
+   * matching. */
+  readonly type?: ValueType[];
+  /** Match any of the names listed here. If undefined, will be ignored during
+   * matching. */
+  readonly name?: string[];
+  /** Match requires all the domains listed here to have corresponding values. */
+  readonly domainValue?: Record<string, string>;
+  /** Match requires all the annotations listed here to have corresponding values. */
+  readonly annotationValue?: Record<string, string>;
+  /** Match requires all the annotations listed here to match corresponding regex
+   * pattern. */
+  readonly annotationPattern?: Record<string, string>;
+} //#endregion
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/pframe/find_columns.d.ts
+//#region src/drivers/pframe/find_columns.d.ts
+/**
+ * Request to search among existing columns in the PFrame. Two filtering
+ * criteria can be used: (1) column ашдеук, to search for columns with
+ * specific properties like name, annotations and domains, and (2) being
+ * compatible with the given list of axis ids.
+ * */
+interface FindColumnsRequest {
+  /** Basic column filter */
+  readonly columnFilter: ColumnFilter;
+  /** Will only search for columns compatible with these list of axis ids */
+  readonly compatibleWith: AxisId[];
+  /**
+   * Defines what level of compatibility with provided list of axis ids is required.
+   *
+   * If true will search only for such columns which axes completely maps onto the
+   * axes listed in the {@link compatibleWith} list.
+   * */
+  readonly strictlyCompatible: boolean;
+}
+/** Response for {@link FindColumnsRequest} */
+interface FindColumnsResponse {
+  /** Array of column ids found using request criteria. */
+  readonly hits: PColumnIdAndSpec[];
+} //#endregion
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/pframe/unique_values.d.ts
+//#region src/drivers/pframe/unique_values.d.ts
+/** Calculate set of unique values for a specific axis for the filtered set of records */
+interface UniqueValuesRequest {
+  /** Target axis id */
+  readonly columnId: PObjectId;
+  /** Target axis id, if not specified calculates unique column values */
+  readonly axis?: AxisId;
+  /** Filters to apply before calculating unique values */
+  readonly filters: PTableRecordFilter[];
+  /** Max number of values to return, if reached response will contain overflow flag */
+  readonly limit: number;
+}
+interface UniqueValuesResponse {
+  /** Unique values */
+  readonly values: PTableVector;
+  /** True if limit was reached and response contain non-exhaustive list of values. */
+  readonly overflow: boolean;
+} //#endregion
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/pframe/pframe.d.ts
+/** Information required to instantiate a PFrame. */
+type PFrameDef<Col> = Col[]; //#endregion
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/pframe/driver.d.ts
+//#region src/drivers/pframe/driver.d.ts
+/** PFrame handle */
+type PFrameHandle = Branded$1<string, "PFrame">;
+/** PFrame handle */
+type PTableHandle = Branded$1<string, "PTable">;
+/** Model-side PFrame service — creates frames/tables from column definitions. */
+interface PFrameModelDriver<Col = PColumn<string | PColumnValues | DataInfo<string>>> {
+  createPFrame(def: PFrameDef<Col>): PFrameHandle;
+  createPTable(def: PTableDef<Col>): PTableHandle;
+  createPTableV2(def: PTableDefV2<Col>): PTableHandle;
+}
+/** Allows to access main data layer features of platforma */
+interface PFrameDriver {
+  /**
+   * Finds columns given filtering criteria on column name, annotations etc.
+   * and a set of axes ids to find only columns with compatible specs.
+   * */
+  findColumns(handle: PFrameHandle, request: FindColumnsRequest): Promise<FindColumnsResponse>;
+  /** Retrieve single column spec */
+  getColumnSpec(handle: PFrameHandle, columnId: PObjectId): Promise<PColumnSpec | null>;
+  /** Retrieve information about all columns currently added to the PFrame */
+  listColumns(handle: PFrameHandle): Promise<PColumnIdAndSpec[]>;
+  /** Calculates data for the table and returns complete data representation of it */
+  calculateTableData(handle: PFrameHandle, request: CalculateTableDataRequest<PObjectId>, range?: TableRange): Promise<CalculateTableDataResponse>;
+  /** Calculate set of unique values for a specific axis for the filtered set of records */
+  getUniqueValues(handle: PFrameHandle, request: UniqueValuesRequest): Promise<UniqueValuesResponse>;
+  /** Unified table shape */
+  getShape(handle: PTableHandle): Promise<PTableShape>;
+  /**
+   * Returns ordered array of table axes specs (primary key "columns" in SQL
+   * terms) and data column specs (regular "columns" in SQL terms).
+   *
+   * Data for a specific table column can be retrieved using unified indexing
+   * corresponding to elements in this array.
+   *
+   * Axes are always listed first.
+   * */
+  getSpec(handle: PTableHandle): Promise<PTableColumnSpec[]>;
+  /**
+   * Retrieve the data from the table. To retrieve only data required, it can be
+   * sliced both horizontally ({@link columnIndices}) and vertically
+   * ({@link range}).
+   *
+   * @param columnIndices unified indices of columns to be retrieved
+   * @param range optionally limit the range of records to retrieve
+   * */
+  getData(handle: PTableHandle, columnIndices: number[], range?: TableRange): Promise<PTableVector[]>;
+  /**
+   * Stream the table to a file at the given path. Caller is responsible
+   * for producing the destination path (e.g. via the `Dialog` service).
+   */
+  writePTableToFs(handle: PTableHandle, options: WritePTableToFsOptions): Promise<WritePTableToFsResult>;
+  /**
+   * Export the table to a file. The output format is selected from the file
+   * extension of `options.path` (`csv`, `tsv`, `parquet`, or `xlsx`).
+   *
+   * `options.columnIndices` selects the columns to export (output order). Column
+   * headers are derived on the driver side from each field's label annotation
+   * (falling back to its spec name), so the caller supplies only the path and
+   * the columns.
+   *
+   * For `xlsx` the driver rejects tables whose row count would exceed the
+   * 1,000,000-row per-sheet limit (below Excel's hard cap of 1,048,576).
+   */
+  exportPTable(handle: PTableHandle, options: ExportPTableOptions): Promise<void>;
+} //#endregion
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/ls.d.ts
+//#region src/drivers/ls.d.ts
+type ImportFileHandleUpload = `upload://upload/${string}`;
+type ImportFileHandleIndex = `index://index/${string}`;
+type ImportFileHandle = ImportFileHandleUpload | ImportFileHandleIndex;
+type LocalImportFileHandle = Branded$1<ImportFileHandle, "Local">;
+/** Results in upload */
+type StorageHandleLocal = `local://${string}`;
+/** Results in index */
+type StorageHandleRemote = `remote://${string}`;
+type StorageHandle = StorageHandleLocal | StorageHandleRemote;
+type StorageEntry = {
+  /** Stable machine identifier (e.g. "library", "root", "local"). Used for filtering. */id: string; /** Human-readable display name. */
+  name: string;
+  handle: StorageHandle;
+  initialFullPath: string;
+};
+type ListFilesResult = {
+  parent?: string;
+  entries: LsEntry[];
+};
+type LsEntry = {
+  type: "dir";
+  name: string;
+  fullPath: string;
+} | {
+  type: "file";
+  name: string;
+  fullPath: string; /** This handle should be set to args... */
+  handle: ImportFileHandle;
+};
+type OpenDialogFilter = {
+  /** Human-readable file type name */readonly name: string; /** File extensions */
+  readonly extensions: string[];
+};
+type OpenDialogOps = {
+  /** Open dialog window title */readonly title?: string; /** Custom label for the confirmation button, when left empty the default label will be used. */
+  readonly buttonLabel?: string; /** Limits of file types user can select */
+  readonly filters?: OpenDialogFilter[];
+};
+type OpenSingleFileResponse = {
+  /** Contains local file handle, allowing file importing or content reading. If user canceled
+   * the dialog, field will be undefined. */
+  readonly file?: LocalImportFileHandle;
+};
+type OpenMultipleFilesResponse = {
+  /** Contains local file handles, allowing file importing or content reading. If user canceled
+   * the dialog, field will be undefined. */
+  readonly files?: LocalImportFileHandle[];
+};
+/** Can be used to limit request for local file content to a certain bytes range */
+interface LsDriver {
+  /** remote and local storages */
+  getStorageList(): Promise<StorageEntry[]>;
+  listFiles(storage: StorageHandle, fullPath: string): Promise<ListFilesResult>;
+  /** Opens system file open dialog allowing to select single file and awaits user action */
+  showOpenSingleFileDialog(ops: OpenDialogOps): Promise<OpenSingleFileResponse>;
+  /** Opens system file open dialog allowing to multiple files and awaits user action */
+  showOpenMultipleFilesDialog(ops: OpenDialogOps): Promise<OpenMultipleFilesResponse>;
+  /** Given a handle to a local file, allows to get file size */
+  getLocalFileSize(file: LocalImportFileHandle): Promise<number>;
+  /** Given a handle to a local file, allows to get its content */
+  getLocalFileContent(file: LocalImportFileHandle, range?: TableRange): Promise<Uint8Array>;
+  /**
+   * Resolves browser's File object into platforma's import file handle.
+   *
+   * This method is useful among other things for implementation of UI
+   * components, that handle file Drag&Drop.
+   * */
+  fileToImportHandle(file: FileLike): Promise<ImportFileHandle>;
+  /** Saves currently opened block webview as a PDF. */
+  exportToPdf?(): Promise<void>;
+}
+/** Gets a file path from an import handle. */
+//#endregion
+//#region ../../../../lib/model/common/dist/columns/column_selector.d.ts
+//#region src/columns/column_selector.d.ts
+/** Relaxed string matcher input: plain string, single matcher, or array of mixed. */
+type RelaxedStringMatchers = string | StringMatcher | (string | StringMatcher)[];
+/** Relaxed record matcher: values can be plain strings or relaxed matchers. */
+type RelaxedRecord = Record<string, RelaxedStringMatchers>;
+/** Relaxed axis selector — accepts plain strings where strict requires StringMatcher[]. */
+interface RelaxedAxisSelector {
+  name?: RelaxedStringMatchers;
+  type?: AxisValueType | AxisValueType[];
+  domain?: RelaxedRecord;
+  contextDomain?: RelaxedRecord;
+  annotations?: RelaxedRecord;
+}
+/** Relaxed column selector — convenient hand-written form. */
+interface RelaxedColumnSelector {
+  name?: RelaxedStringMatchers;
+  type?: ColumnValueType | ColumnValueType[];
+  domain?: RelaxedRecord;
+  contextDomain?: RelaxedRecord;
+  annotations?: RelaxedRecord;
+  axes?: RelaxedAxisSelector[];
+  partialAxesMatch?: boolean;
+}
+/** One or many relaxed column selectors; normalizes to MultiColumnSelector[]. */
+type ColumnSelector = RelaxedColumnSelector | RelaxedColumnSelector[];
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/columns/discover_columns_options.d.ts
+//#region src/drivers/columns/discover_columns_options.d.ts
+/**
+ * Axis matching behaviour applied to `discover` requests.
+ *
+ * - `enrichment` (default) — anchor axes may float over un-mapped hit axes;
+ *   used by tooling that "extends" a query.
+ * - `related` — both source and hit axes may float; widest match.
+ * - `exact` — no floating, no qualifications; strict equality.
+ */
+type MatchingMode = "enrichment" | "related" | "exact";
+/**
+ * Single entry accepted by `DiscoverColumnsOptions.anchors`. All variants are
+ * trivially JSON-serialisable so the option carrier crosses the
+ * sandbox/host VM bridge unchanged.
+ */
+type AnchorEntry = PlRef | PObjectId | PColumnSpec | RelaxedColumnSelector;
+/** Qualifications needed for both already-integrated anchor columns and the hit column. */
+/**
+ * Options object accepted by sandbox `discoverColumns()` and by the host
+ * `ColumnsCollectionDriver.discover` / `.filter` methods. Pure JSON shape —
+ * no class instances, no closures.
+ */
+interface DiscoverColumnsOptions {
+  /** Include columns matching these selectors. If omitted, includes all. */
+  include?: ColumnSelector;
+  /** Exclude columns matching these selectors. */
+  exclude?: ColumnSelector;
+  /** Axis matching behavior. Default: 'enrichment'. Ignored if no anchors. */
+  mode?: MatchingMode;
+  /** Anchors enable axis-aware discovery + linker traversal. */
+  anchors?: Record<string, AnchorEntry>;
+  /** Maximum linker hops. Default: 4 when anchors present, 0 otherwise. */
+  maxHops?: number;
+}
+/**
+ * Options accepted by `ColumnsCollection.discover` / driver `.discover`.
+ * Traversal scope (`mode`, `maxHops`) must be specified explicitly — the
+ * defaults from {@link DiscoverColumnsOptions} are intentionally surfaced as
+ * required choices at the discovery entrypoint.
+ */
+type ColumnsDiscoverOptions = DiscoverColumnsOptions;
+/**
+ * Options accepted by `ColumnsCollection.filter` / driver `.filter`. Traversal
+ * scope is fixed by the source collection, so `mode` / `maxHops` are not part
+ * of the filter surface — only `include` / `exclude` / `anchors`.
+ */
+type ColumnsFilterOptions = Omit<DiscoverColumnsOptions, "mode" | "maxHops">;
+/** Translate a {@link MatchingMode} into the boolean-flag form the spec driver consumes. */
+//#endregion
+//#region ../../../../lib/model/common/dist/columns/types.d.ts
+//#region src/columns/types.d.ts
+/**
+ * Opaque sandbox/host accessor handle.
+ *
+ * Both the sandbox `TreeNodeAccessor.handle` and the host-issued accessor
+ * keys alias this brand — `sdk/model` re-exports the same type so the two
+ * sides stay structurally identical.
+ */
+type AccessorHandle = Branded$1<string, "AccessorHandle">;
+/**
+ * Structural subset of {@link FieldTraversalStep} (from `@platforma-sdk/model`)
+ * needed by the host/sandbox column-providers traversal.
+ *
+ * Defined locally so this module does not depend on the sandbox `render`
+ * subtree. Both `TreeNodeAccessor.traverse` (sandbox) and
+ * `PlTreeNodeAccessor.traverse` (host) accept a superset of these fields, so
+ * structural compatibility is preserved.
+ */
+interface FieldTraversalStepLike {
+  /** Field name */
+  readonly field: string;
+  /** Asserted field type — used by `accessor.traverse` to validate. */
+  readonly assertFieldType?: "Input" | "Output" | "Service" | "OTW" | "Dynamic" | "MTW";
+  /** Don't terminate chain if current resource or field has an error associated. */
+  readonly ignoreError?: true;
+}
+/**
+ * Raw entry returned by {@link GlobalCfgRenderCtxMethods.getUpstreamBlockCtx}
+ * on the sandbox side, or by `collectUpstreamBlockCtx` on the host side.
+ * Carries handle ids only — providers wrap them into accessor instances as
+ * needed.
+ *
+ * Generic over the handle type so the same shape backs both:
+ * - sandbox (`AHandle = AccessorHandle`, a `Branded<string, "AccessorHandle">`)
+ * - host (`AHandle = PlTreeNodeAccessor`, the resolved accessor instance)
+ *
+ * Default `AHandle = string` since `AccessorHandle` is a brand on `string` —
+ * the default is safe for the sandbox case.
+ */
+interface UpstreamBlockCtx<AHandle = string> {
+  blockId: string;
+  prodCtx?: AHandle;
+  stagingCtx?: AHandle;
+  /** True when the `prodCtx` ctx-holder exists but `prodUiCtx` is still rendering. */
+  prodIncomplete?: boolean;
+  /** True when the `stagingCtx` ctx-holder exists but `stagingUiCtx` is still rendering. */
+  stagingIncomplete?: boolean;
+}
+/**
+ * Minimal accessor surface used by column-providers / column-registry
+ * traversal.
+ *
+ * Both sandbox `TreeNodeAccessor` and host `PlTreeNodeAccessor` satisfy this
+ * contract directly — `traverse(step)` is defined on both, and the other
+ * members already match by shape. No `resolvePath` member: when canonical
+ * `PObjectId`s are required (local-id construction inside the
+ * outputs/prerun branch), the traversal helpers thread the path explicitly.
+ */
+interface AccessorLike<Self extends AccessorLike<Self>> {
+  /** Resource type carried by the underlying node (only `.name` is used). */
+  readonly resourceType: {
+    readonly name: string;
+  };
+  /**
+   * Single-step field traversal. Returns `undefined` when the field is
+   * absent / unresolved (with `ignoreError`). Same shape on sandbox and host —
+   * sandbox `TreeNodeAccessor.traverse` is an alias for `resolveAny` and host
+   * `PlTreeNodeAccessor.traverse` is the canonical method.
+   */
+  traverse(step: FieldTraversalStepLike): Self | undefined;
+  /** List input-field names on this node. */
+  listInputFields(): string[];
+  /** Whether the input-field collection on this node is finalized. */
+  getInputsLocked(): boolean;
+  /** Whether this node has a data payload attached. */
+  hasData(): boolean;
+  /** Decode the data payload as JSON. Returns `undefined` if no data. */
+  getDataAsJson<T = unknown>(): T | undefined;
+}
+/**
+ * One indexed column — the canonical record produced by every traversal.
+ * Carries everything needed to read spec/data/status under a stable id.
+ *
+ * Generic over the accessor flavour so the same record shape works for both
+ * the sandbox `TreeNodeAccessor` and the host `PlTreeNodeAccessor`.
+ */
+//#endregion
+//#region ../../../../lib/model/common/dist/drivers/columns/columns_collection_driver.d.ts
+//#region src/drivers/columns/columns_collection_driver.d.ts
+/**
+ * Opaque host-owned handle for a `ColumnsCollection` instance. Issued by
+ * {@link ColumnsCollectionDriver.create}, refcounted by the driver, and
+ * pinned to the active render ctx via the VM injector — sandbox never
+ * sees raw refcounting.
+ */
+type CollectionHandle = Branded$1<string, "CollectionHandle">;
+/**
+ * JSON descriptor crossing the VM bridge in place of a sandbox
+ * `ColumnsSource`. Always plain data — no closures, no class instances.
+ *
+ * - `"collection"`  – reference another driver-managed collection by handle
+ *   (chaining, splicing).
+ * - `"result_pool"` – fan-out into the host's current render ctx upstream
+ *   block ctxes. Carries no payload — the host always uses its own pool.
+ * - `"accessor"`    – walk the host tree starting at the given accessor
+ *   handle from a `path` prefix.
+ * - `"ids"`         – pre-resolved id list (sandbox-materialised provider).
+ */
+type SerializedColumnsSource = {
+  readonly kind: "collection";
+  readonly handle: CollectionHandle;
+} | {
+  readonly kind: "result_pool";
+} | {
+  readonly kind: "accessor";
+  readonly accessor: AccessorHandle;
+  readonly path: string[];
+} | {
+  readonly kind: "ids";
+  readonly ids: ColumnUniversalId[];
+  readonly isFinal: boolean;
+};
+/**
+ * Per-call host bindings the driver needs to resolve sources whose
+ * shape references render-ctx state (`"accessor"`, `"result_pool"`).
+ *
+ * The VM injector inside `pl-middle-layer` supplies these on every call;
+ * UI-side direct callers that only build collections out of `"ids"` /
+ * `"collection"` sources may omit the bindings entirely.
+ *
+ * Parameterised on the concrete accessor flavour so host implementations
+ * keep their static types (e.g. `PlTreeNodeAccessor`) without leaking that
+ * dependency into `@milaboratories/pl-model-common`.
+ */
+interface ColumnsCollectionDriverHost<A extends AccessorLike<A> = AccessorLike<any>> {
+  /** Resolve an {@link AccessorHandle} to the host's concrete accessor. */
+  resolveAccessor(handle: AccessorHandle): A;
+  /** Snapshot of upstream-block ctx pairs from the current render ctx. */
+  getUpstreamBlockCtxes(): ReadonlyArray<UpstreamBlockCtx<A>>;
+  /**
+   * Per-call spec driver. The injector supplies the active render ctx's
+   * `PFrameSpec` service; `discover` / `filter` use it to build a spec
+   * frame and run a single discovery query.
+   */
+  getSpecDriver(): PFrameSpecDriver;
+  /**
+   * Resolve the canonical {@link PColumnSpec} for a leaf {@link PObjectId}.
+   * Returns `undefined` when the id is not present in the active registry
+   * (e.g. handed to the driver via a `{kind:"ids"}` source whose underlying
+   * column has since left the visible scope). Override-wrapped ids are
+   * unwrapped by the caller — this method only resolves the underlying leaf.
+   */
+  resolveSpec(id: PObjectId): PColumnSpec | undefined;
+}
+/**
+ * Sandbox / UI view of the `ColumnsCollection` driver. Same methods as
+ * {@link ColumnsCollectionDriver}, but the `host` parameters are dropped —
+ * the VM bridge / UI wrapper supplies them on every call so callers only
+ * pass plain data (handles + source descriptors + option objects).
+ *
+ * `getService("columnsCollection")` returns a value of this shape on both
+ * sandbox and UI sides.
+ */
+interface ColumnsCollectionDriverModel {
+  /** Build a fresh collection from the supplied source descriptors. */
+  create(sources: ReadonlyArray<SerializedColumnsSource>): CollectionHandle;
+  /** Whether the collection currently exposes zero columns. */
+  isEmpty(handle: CollectionHandle): boolean;
+  /** Whether enumeration is finalised across every contributing source. */
+  isFinal(handle: CollectionHandle): boolean;
+  /** Canonical id list for the columns visible through this collection. */
+  getColumns(handle: CollectionHandle): ColumnUniversalId[];
+  /** Append one or more sources and return a fresh collection handle. */
+  addSource(handle: CollectionHandle, sources: ReadonlyArray<SerializedColumnsSource>): CollectionHandle;
+  /** Anchored/selector-driven discovery. Returns a fresh handle. */
+  discover(handle: CollectionHandle, options: ColumnsDiscoverOptions): CollectionHandle;
+  /** Selector-only filter (no anchor traversal). Returns a fresh handle. */
+  filter(handle: CollectionHandle, options: ColumnsFilterOptions): CollectionHandle;
+}
+/**
+ * Synchronous host-side driver for `ColumnsCollection` operations. All
+ * collection state lives on the host side, addressable through opaque
+ * {@link CollectionHandle}s. Every handle-minting method returns a
+ * {@link PoolEntry} so callers can wire the refcount into their own
+ * lifecycle; the VM bridge pins each entry to the active render ctx and
+ * forwards only the handle string to sandbox.
+ *
+ * Sandbox / UI callers consume {@link ColumnsCollectionDriverModel}
+ * instead; the bridge maps that surface onto this one by injecting
+ * {@link ColumnsCollectionDriverHost} bindings.
+ */
+interface ColumnsCollectionDriver {
+  create(sources: ReadonlyArray<SerializedColumnsSource>, host: ColumnsCollectionDriverHost): PoolEntry<CollectionHandle>;
+  isEmpty(handle: CollectionHandle): boolean;
+  isFinal(handle: CollectionHandle): boolean;
+  getColumns(handle: CollectionHandle, host: ColumnsCollectionDriverHost): ColumnUniversalId[];
+  addSource(handle: CollectionHandle, sources: ReadonlyArray<SerializedColumnsSource>, host: ColumnsCollectionDriverHost): PoolEntry<CollectionHandle>;
+  discover(handle: CollectionHandle, options: ColumnsDiscoverOptions, host: ColumnsCollectionDriverHost): PoolEntry<CollectionHandle>;
+  filter(handle: CollectionHandle, options: ColumnsFilterOptions, host: ColumnsCollectionDriverHost): PoolEntry<CollectionHandle>;
+} //#endregion
+//#endregion
+//#region ../../../../lib/model/common/dist/services/service_types.d.ts
+//#region src/services/service_types.d.ts
+type ServiceTypesLike<Model = unknown, Ui = unknown, Kind extends ServiceType = ServiceType, ModelHost = Model, UiHost = Ui> = {
+  readonly __types?: {
+    model: Model;
+    ui: Ui;
+    kind: Kind;
+    modelHost: ModelHost;
+    uiHost: UiHost;
+  };
+};
+type InferServiceUi<S extends ServiceTypesLike> = S extends ServiceTypesLike<unknown, infer U, ServiceType, unknown, unknown> ? U : unknown;
+type ServiceName<S extends ServiceTypesLike = ServiceTypesLike> = Branded$1<string, S>;
+type ServiceType = "node" | "wasm" | "main";
+type ServiceBrand<T> = T extends Branded$1<string, infer S extends ServiceTypesLike> ? S : never;
+/** Contract between any service provider and any service consumer. */
+interface ServiceDispatch {
+  getServiceNames(): ServiceName[];
+  getServiceMethods(serviceId: ServiceName): string[];
+  callServiceMethod(serviceId: ServiceName, method: string, ...args: unknown[]): unknown;
+}
+type TServices = typeof Services;
+type ExtractServiceName<T> = T extends Branded$1<infer N extends string, any> ? N : never;
+/** Model-side service interfaces keyed by service name literal. */
+/** UI-side service interfaces keyed by service name literal. */
+type UiServices$1 = { [K in keyof TServices as ExtractServiceName<TServices[K]>]: InferServiceUi<ServiceBrand<TServices[K]>> };
+/** Map from Services keys to their unbranded string name literals. */
+type ServiceNameLiterals = { [K in keyof TServices]: ExtractServiceName<TServices[K]> };
+/** Auto-derived requires* feature flags from Services keys. */
+type ServiceRequireFlags = { [K in keyof TServices as `requires${K & string}`]?: boolean };
+//#endregion
+//#region ../../../../lib/model/common/dist/services/service_declarations.d.ts
+//#region src/services/service_declarations.d.ts
+declare const Services: {
+  PFrameSpec: Branded$1<"pframeSpec", ServiceTypesLike<PFrameSpecDriver, PFrameSpecDriver, "wasm", PFrameSpecDriver, PFrameSpecDriver>>;
+  PFrame: Branded$1<"pframe", ServiceTypesLike<PFrameModelDriver<PColumn<string | PColumnValues | DataInfo<string>>>, PFrameDriver, "node", PFrameModelDriver<PColumn<string | PColumnValues | DataInfo<string>>>, PFrameDriver>>;
+  Dialog: Branded$1<"dialog", ServiceTypesLike<Record<string, never>, DialogService, "main", Record<string, never>, DialogService>>;
+  ColumnsCollection: Branded$1<"columnsCollection", ServiceTypesLike<ColumnsCollectionDriverModel, ColumnsCollectionDriverModel, "wasm", ColumnsCollectionDriver, ColumnsCollectionDriver>>;
+}; //#endregion
+//#endregion
+//#region ../../../../lib/model/common/dist/flags/block_flags.d.ts
+/**
+ * Known block flags. Flags are set during model compilation, see `BlockModel.create` for more details and for initial values.
+ */
+type BlockCodeKnownFeatureFlags = {
+  readonly supportsLazyState?: boolean;
+  readonly supportsPframeQueryRanking?: boolean;
+  readonly requiresModelAPIVersion?: number;
+  readonly requiresUIAPIVersion?: number;
+  readonly requiresCreatePTable?: number;
+  readonly requiresPFramesVersion?: number;
+} & ServiceRequireFlags;
+/**
+ * Required PFrames version. Bump this in lockstep with the `@milaboratories/pframes-rs-*`
+ * version in `pnpm-workspace.yaml` so blocks built against the new SDK refuse to load on
+ * older desktop apps.
+ */
+//#endregion
+//#region ../../../../lib/model/common/dist/driver_kit.d.ts
+//#region src/driver_kit.d.ts
+/** Set of all drivers exposed in UI SDK via the platforma object. */
+interface DriverKit {
+  /** Driver allowing to retrieve blob data */
+  readonly blobDriver: BlobDriver;
+  /** Driver allowing to dynamically work with logs */
+  readonly logDriver: LogsDriver;
+  /**
+   * Driver allowing to list local and remote files that current user has
+   * access to.
+   *
+   * Along with file listing this driver provides import handles for listed
+   * files, that can be communicated to the workflow via block arguments,
+   * converted into blobs using standard workflow library functions.
+   * */
+  readonly lsDriver: LsDriver;
+  /** Driver allowing to interact with PFrames and PTables */
+  readonly pFrameDriver: PFrameDriver;
+} //#endregion
+//#endregion
+//#region ../../../../lib/model/common/dist/errors.d.ts
+type ResultOrError<S, F = Error> = {
+  value: S;
+  error?: undefined;
+} | {
+  error: F;
+};
+//#endregion
+//#region ../../../../lib/model/common/dist/utag.d.ts
+//#region src/utag.d.ts
+/** Value returned for changing states supporting reactive listening for changes */
+interface ValueWithUTag<V> {
+  /** Value snapshot. */
+  readonly value: V;
+  /**
+   * Unique tag for the value snapshot.
+   *
+   * It can be used to synchronously detect if changes happened after current
+   * snapshot was retrieved, or asynchronously await next value snapshot,
+   * generated on underlying data changes.
+   * */
+  readonly uTag: string;
+}
+interface ValueWithUTagAndAuthor<V> extends ValueWithUTag<V> {
+  readonly author?: AuthorMarker;
+} //#endregion
+//#endregion
+//#region ../../../../sdk/model/dist/block_state_patch.d.ts
+//#region src/block_state_patch.d.ts
+/** Patch for the structural object */
+type Patch<K, V> = {
+  /** Field name to patch */readonly key: K; /** New value for the field */
+  readonly value: V;
+};
+/** Creates union type of all possible shallow patches for the given structure */
+type Unionize<T extends Record<string, unknown>> = { [K in keyof T]: Patch<K, T[K]> }[keyof T];
+/** Patch for the BlockState, pushed by onStateUpdates method in SDK. */
+type BlockStatePatch<Args = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, UiState = unknown, Href extends `/${string}` = `/${string}`> = Unionize<BlockState<Args, Outputs, UiState, Href>>; //#endregion
+//#endregion
+//#region ../../../../sdk/model/dist/plugin_handle.d.ts
+//#region src/plugin_handle.d.ts
+/**
+ * Phantom-only base type for constraining PluginHandle's type parameter.
+ *
+ * PluginFactory has create() → PluginInstance with function properties, making it invariant
+ * under strictFunctionTypes. PluginFactoryLike exposes only the covariant `__types` phantom,
+ * avoiding the contravariance chain. Handles only need `__types` for type extraction.
+ *
+ * PluginFactory extends PluginFactoryLike, so every concrete factory satisfies this constraint.
+ */
+interface PluginFactoryLike<Data extends Record<string, unknown> = Record<string, unknown>, Params extends undefined | Record<string, unknown> = undefined | Record<string, unknown>, Outputs extends Record<string, unknown> = Record<string, unknown>, ModelServices = unknown, UiServices = unknown> {
+  readonly __types?: {
+    data: Data;
+    params: Params;
+    outputs: Outputs;
+    modelServices: ModelServices;
+    uiServices: UiServices;
+  };
+}
+/** Extract the Data type from a PluginFactoryLike phantom. */
+/**
+ * Opaque handle for a plugin instance. Runtime value is the plugin instance ID string.
+ * Branded with factory phantom `F` for type-safe data/outputs extraction.
+ * Constrained with PluginFactoryLike (not PluginFactory) to avoid variance issues.
+ */
+type PluginHandle<F extends PluginFactoryLike = PluginFactoryLike> = Branded<string, F>;
+/** Construct the output key for a plugin output in the block outputs map. */
+//#endregion
+//#region ../../../../sdk/model/dist/block_storage.d.ts
+/** Payload for storage mutation operations. SDK defines specific operations. */
+type MutateStoragePayload<T = unknown> = {
+  operation: "update-block-data";
+  value: T;
+} | {
+  operation: "update-plugin-data";
+  pluginId: PluginHandle;
+  value: unknown;
+};
+/**
+ * Updates the data in BlockStorage (immutable)
+ *
+ * @param storage - The current BlockStorage
+ * @param payload - The update payload with operation and value
+ * @returns A new BlockStorage with updated data
+ */
+//#endregion
+//#region ../../../../sdk/model/dist/bconfig/lambdas.d.ts
+/** Additional information that may alter lambda rendering procedure. */
+type ConfigRenderLambdaFlags = {
+  /**
+   * Tells the system that corresponding computable should be created with StableOnlyRetentive rendering mode.
+   * This flag can be overridden by the system.
+   * */
+  retentive?: boolean;
+  /**
+   * Tells the system that resulting computable has important side-effects, thus it's rendering is required even
+   * nobody is actively monitoring rendered values. Like file upload progress, that triggers upload itself.
+   * */
+  isActive?: boolean;
+  /**
+   * If true, result will be wrapped with additional status information,
+   * such as stability status and explicit error
+   */
+  withStatus?: boolean;
+};
+/** Creates branded Cfg type */
+interface ConfigRenderLambda<Return = unknown> extends ConfigRenderLambdaFlags {
+  /** Type marker */
+  __renderLambda: true;
+  /** Phantom property for type inference. Never set at runtime. */
+  __phantomReturn?: Return;
+  /** Reference to a callback registered inside the model code. */
+  handle: string;
+}
+type ExtractFunctionHandleReturn<Func extends ConfigRenderLambda> = Func extends ConfigRenderLambda<infer Return> ? Return : never;
+/** Infers the output type from a TypedConfig or ConfigRenderLambda */
+/** Maps lambda-only outputs configuration to inferred output types (for V3 blocks) */
+type InferOutputsFromLambdas<OutputsCfg extends Record<string, ConfigRenderLambda>> = { [Key in keyof OutputsCfg]: OutputWithStatus<ExtractFunctionHandleReturn<OutputsCfg[Key]>> & {
+  __unwrap: OutputsCfg[Key] extends {
+    withStatus: true;
+  } ? false : true;
+} }; //#endregion
+//#endregion
+//#region ../../../../sdk/model/dist/block_api_v1.d.ts
+//#region src/block_api_v1.d.ts
+/** Returned by state subscription methods to be able to cancel the subscription. */
+type CancelSubscription = () => void;
+/** Defines methods to read and write current block data. */
+interface BlockApiV1<Args = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, UiState = unknown, Href extends `/${string}` = `/${string}`> {
+  /**
+   * Use this method to retrieve block state during UI initialization. Then use
+   * {@link onStateUpdates} method to subscribe for updates.
+   * */
+  loadBlockState(): Promise<BlockState<Args, Outputs, UiState, Href>>;
+  /**
+   * Subscribe to updates of block state.
+   *
+   * This method internally have several ways to limit the rate at which new
+   * states are pushed to the corresponding callback. Among other rate limiting
+   * approaches it guarantees that new state will never be pushed to the
+   * supplied async callback until the previous call returns.
+   *
+   * It is a good idea to develop the callback in such a way that it will wait
+   * until the given state propagates all the way to the DOM. See for example
+   * nextTick() method from Vue framework to achieve this.
+   *
+   * This method will only push args and uiState patches if changes were made
+   * externally, i.e. by another user editing the same block.
+   *
+   * @return function that cancels created subscription
+   * */
+  onStateUpdates(cb: (updates: BlockStatePatch<Args, Outputs, UiState, Href>[]) => Promise<void>): CancelSubscription;
+  /**
+   * Sets block args.
+   *
+   * This method returns when corresponding arguments are safely saved so in
+   * case the window is closed there will be no information losses. This
+   * function under the hood may delay actual persistence of the supplied
+   * arguments.
+   * */
+  setBlockArgs(args: Args): Promise<void>;
+  /**
+   * Sets block ui state.
+   *
+   * This method returns when corresponding arguments are safely saved so in
+   * case the window is closed there will be no information losses. This
+   * function under the hood may delay actual persistence of the supplied
+   * values.
+   * */
+  setBlockUiState(state: UiState): Promise<void>;
+  /**
+   * Sets block args and ui state.
+   *
+   * This method returns when corresponding arguments are safely saved so in
+   * case the window is closed there will be no information losses. This
+   * function under the hood may delay actual persistence of the supplied
+   * values.
+   * */
+  setBlockArgsAndUiState(args: Args, state: UiState): Promise<void>;
+  /**
+   * Sets block navigation state.
+   * */
+  setNavigationState(state: NavigationState<Href>): Promise<void>;
+} //#endregion
+//#endregion
+//#region ../../../../node_modules/.pnpm/fast-json-patch@3.1.1/node_modules/fast-json-patch/module/core.d.ts
+declare type Operation = AddOperation<any> | RemoveOperation | ReplaceOperation<any> | MoveOperation | CopyOperation | TestOperation<any> | GetOperation<any>;
+interface BaseOperation {
+  path: string;
+}
+interface AddOperation<T> extends BaseOperation {
+  op: 'add';
+  value: T;
+}
+interface RemoveOperation extends BaseOperation {
+  op: 'remove';
+}
+interface ReplaceOperation<T> extends BaseOperation {
+  op: 'replace';
+  value: T;
+}
+interface MoveOperation extends BaseOperation {
+  op: 'move';
+  from: string;
+}
+interface CopyOperation extends BaseOperation {
+  op: 'copy';
+  from: string;
+}
+interface TestOperation<T> extends BaseOperation {
+  op: 'test';
+  value: T;
+}
+interface GetOperation<T> extends BaseOperation {
+  op: '_get';
+  value: T;
+}
+//#endregion
+//#region ../../../../sdk/model/dist/block_api_v2.d.ts
+//#region src/block_api_v2.d.ts
+/** Defines methods to read and write current block data. */
+interface BlockApiV2<Args = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, UiState = unknown, Href extends `/${string}` = `/${string}`> {
+  /**
+   * Use this method to retrieve block state during UI initialization. Then use
+   * {@link onStateUpdates} method to subscribe for updates.
+   * */
+  loadBlockState(): Promise<ResultOrError<ValueWithUTag<BlockState<Args, Outputs, UiState, Href>>>>;
+  /**
+   * Get all json patches (rfc6902) that were applied to the block state.
+   * */
+  getPatches(uTag: string): Promise<ResultOrError<ValueWithUTagAndAuthor<Operation[]>>>;
+  /**
+   * Sets block args.
+   *
+   * This method returns when corresponding arguments are safely saved so in
+   * case the window is closed there will be no information losses. This
+   * function under the hood may delay actual persistence of the supplied
+   * arguments.
+   * */
+  setBlockArgs(args: Args, author?: AuthorMarker): Promise<ResultOrError<void>>;
+  /**
+   * Sets block ui state.
+   *
+   * This method returns when corresponding arguments are safely saved so in
+   * case the window is closed there will be no information losses. This
+   * function under the hood may delay actual persistence of the supplied
+   * values.
+   * */
+  setBlockUiState(state: UiState, author?: AuthorMarker): Promise<ResultOrError<void>>;
+  /**
+   * Sets block args and ui state.
+   *
+   * This method returns when corresponding arguments are safely saved so in
+   * case the window is closed there will be no information losses. This
+   * function under the hood may delay actual persistence of the supplied
+   * values.
+   * */
+  setBlockArgsAndUiState(args: Args, state: UiState, author?: AuthorMarker): Promise<ResultOrError<void>>;
+  /**
+   * Sets block navigation state.
+   * */
+  setNavigationState(state: NavigationState<Href>): Promise<ResultOrError<void>>;
+  /**
+   * Disposes the block API.
+   * */
+  dispose(): Promise<ResultOrError<void>>;
+} //#endregion
+//#endregion
+//#region ../../../../sdk/model/dist/version.d.ts
+type SdkInfo = {
+  readonly sdkVersion: string;
+};
+//#endregion
+//#region ../../../../sdk/model/dist/services/block_services.d.ts
+//#region src/services/block_services.d.ts
+/**
+ * Services required by all V3 blocks by default.
+ * Edit this when a new service should be available to all blocks.
+ *
+ * Standalone module to avoid circular dependencies between block_model.ts
+ * and service type resolution.
+ */
+declare const BLOCK_SERVICE_FLAGS: {
+  readonly requiresPFrameSpec: true;
+  readonly requiresPFrame: true;
+  readonly requiresDialog: true;
+  readonly requiresColumnsCollection: true;
+};
+type BlockServiceFlags = typeof BLOCK_SERVICE_FLAGS;
+//#endregion
+//#region ../../../../sdk/model/dist/services/service_resolve.d.ts
+//#region src/services/service_resolve.d.ts
+type FlagToName<Flag extends string> = Flag extends `requires${infer K}` ? K extends keyof ServiceNameLiterals ? ServiceNameLiterals[K] : never : never;
+type RequiredServiceNames<Flags> = { [K in keyof Flags & `requires${string}`]: Flags[K] extends true ? FlagToName<K & string> : never }[keyof Flags & `requires${string}`];
+type ResolveUiServices<Flags> = Pick<UiServices$1, RequiredServiceNames<Flags> & keyof UiServices$1>;
+type BlockDefaultUiServices = ResolveUiServices<BlockServiceFlags>; //#endregion
+//#endregion
+//#region ../../../../sdk/model/dist/plugin_model.d.ts
+/**
+ * Runtime definition for a single public output field.
+ * Stored in PluginModel and passed through BlockModelInfo to the UI layer.
+ */
+type PublicOutputFieldDef = {
+  readonly getter: (data: unknown) => unknown;
+};
+//#endregion
+//#region ../../../../sdk/model/dist/block_api_v3.d.ts
+//#region src/block_api_v3.d.ts
+/** Defines methods to read and write current block data. */
+interface BlockApiV3<_Data = unknown, _Args = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, Href extends `/${string}` = `/${string}`> {
+  /**
+   * Use this method to retrieve block state during UI initialization. Then use
+   * {@link onStateUpdates} method to subscribe for updates.
+   * */
+  loadBlockState(): Promise<ResultOrError<ValueWithUTag<BlockStateV3<_Data, Outputs, Href>>>>;
+  /**
+   * Get all json patches (rfc6902) that were applied to the block state.
+   * */
+  getPatches(uTag: string): Promise<ResultOrError<ValueWithUTagAndAuthor<Operation[]>>>;
+  /**
+   * Mutates block storage with the given operation.
+   *
+   * This method returns when the data is safely saved so in case the window is
+   * closed there will be no information losses. This function under the hood
+   * may delay actual persistence of the supplied values.
+   * */
+  mutateStorage(payload: MutateStoragePayload, author?: AuthorMarker): Promise<ResultOrError<void>>;
+  /**
+   * Sets block navigation state.
+   * */
+  setNavigationState(state: NavigationState<Href>): Promise<ResultOrError<void>>;
+  /**
+   * Disposes the block API.
+   * */
+  dispose(): Promise<ResultOrError<void>>;
+} //#endregion
+//#endregion
+//#region ../../../../sdk/model/dist/platforma.d.ts
+//#region src/platforma.d.ts
+/** Defines all methods to interact with the platform environment from within a block UI. @deprecated */
+interface PlatformaV1<Args = unknown, Outputs extends Record<string, OutputWithStatus<unknown>> = Record<string, OutputWithStatus<unknown>>, UiState = unknown, Href extends `/${string}` = `/${string}`> extends BlockApiV1<Args, Outputs, UiState, Href>, DriverKit {
+  /** Information about SDK version current platforma environment was compiled with. */
+  readonly sdkInfo: SdkInfo;
+  readonly apiVersion?: 1;
+}
+/** V2 version based on effective json patches pulling API */
+interface PlatformaV2<Args = unknown, Outputs extends Record<string, OutputWithStatus<unknown>> = Record<string, OutputWithStatus<unknown>>, UiState = unknown, Href extends `/${string}` = `/${string}`> extends BlockApiV2<Args, Outputs, UiState, Href>, DriverKit {
+  /** Information about SDK version current platforma environment was compiled with. */
+  readonly sdkInfo: SdkInfo;
+  readonly apiVersion: 2;
+}
+interface PlatformaV3<Data = unknown, Args = unknown, Outputs extends Record<string, OutputWithStatus<unknown>> = Record<string, OutputWithStatus<unknown>>, Href extends `/${string}` = `/${string}`, Plugins extends Record<string, unknown> = Record<string, unknown>, UiServices extends Partial<UiServices$1> = Partial<UiServices$1>> extends BlockApiV3<Data, Args, Outputs, Href>, DriverKit {
+  /** Information about SDK version current platforma environment was compiled with. */
+  readonly sdkInfo: SdkInfo;
+  readonly apiVersion: 3;
+  /** Service dispatch — lists available services, their methods, and invokes them. */
+  readonly serviceDispatch: ServiceDispatch;
+  /** @internal Type brand for plugin type inference. Not used at runtime. */
+  readonly __pluginsBrand?: Plugins;
+  /** @internal Type brand for UI service type inference. Not used at runtime. */
+  readonly __uiServicesBrand?: UiServices;
+}
+type Platforma<Args = unknown, Outputs extends Record<string, OutputWithStatus<unknown>> = Record<string, OutputWithStatus<unknown>>, UiStateOrData = unknown, Href extends `/${string}` = `/${string}`> = PlatformaV1<Args, Outputs, UiStateOrData, Href> | PlatformaV2<Args, Outputs, UiStateOrData, Href> | PlatformaV3<UiStateOrData, Args, Outputs, Href>;
+type PlatformaExtended<Pl extends Platforma = Platforma> = Pl & {
+  blockModelInfo: BlockModelInfo;
+};
+type BlockModelInfo = {
+  outputs: Record<string, {
+    withStatus: boolean;
+  }>;
+  pluginIds: PluginHandle[];
+  featureFlags: BlockCodeKnownFeatureFlags;
+  pluginPublicOutputs: Record<string, Record<string, PublicOutputFieldDef>>;
+};
+type InferOutputsType<Pl extends Platforma> = Pl extends Platforma<unknown, infer Outputs> ? Outputs : never;
+type InferDataType<Pl extends Platforma> = Pl extends Platforma<unknown, Record<string, OutputWithStatus<unknown>>, infer Data> ? Data : never;
+type InferHrefType<Pl extends Platforma> = Pl extends Platforma<unknown, BlockOutputsBase, unknown, infer Href> ? Href : never;
+//#endregion
+//#region ../model/dist/index.d.ts
+//#region src/index.d.ts
+/**
+ * Pool Explorer persists nothing: the page renders whatever the result pool
+ * currently exposes, and its filter controls are local Vue state. The kind's
+ * `BlockParams` is empty for the same reason, so `init` takes no params.
+ */
+type BlockData$1 = Record<string, never>;
+declare const platforma: PlatformaExtended<PlatformaV3<BlockData$1, BlockData$1, InferOutputsFromLambdas<{
+  allSpecs: ConfigRenderLambda<{
+    readonly entries: {
+      readonly ref: {
+        readonly __isRef: true;
+        readonly blockId: string;
+        readonly name: string;
+        readonly requireEnrichments?: true | undefined | undefined;
+      };
+      readonly obj: {
+        readonly kind: string;
+        readonly name: string;
+        readonly domain?: {
+          [x: string]: string;
+        } | undefined;
+        readonly contextDomain?: {
+          [x: string]: string;
+        } | undefined;
+        readonly annotations?: {
+          [x: string]: string;
+        } | undefined;
+      };
+    }[];
+    readonly isComplete: boolean;
+  }>;
+}>, "/", {}, BlockDefaultUiServices>>;
+//#endregion
+//#region src/index.d.ts
+type BlockContract = {
+  outputs: InferOutputsType<typeof platforma>;
+  data: InferDataType<typeof platforma>;
+  href: InferHrefType<typeof platforma>;
+};
+type BlockOutputs = BlockContract["outputs"];
+type BlockData = BlockContract["data"];
+//#endregion
+export type { BlockContract, BlockData, BlockOutputs };
+//# sourceMappingURL=AGENTS.d.ts.map