@platforma-open/milaboratories.repertoire-mutation-heatmap.block 1.1.3 → 1.1.5

package/dist/index.d.ts

@@ -8,10 +8,11 @@ interface AuthorMarker {
   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$1 = string | number | symbol | bigint | boolean | null | undefined;
+type Scalars = Primitive$1 | Primitive$1[];
 //#endregion
 //#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/util.d.cts
 declare namespace util {
@@ -24,8 +25,8 @@ declare namespace util {
   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 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"];
@@ -39,16 +40,16 @@ declare namespace util {
   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 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 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 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: {
@@ -74,12 +75,14 @@ declare const ZodParsedType: {
   set: "set";
 };
 type ZodParsedType = keyof typeof ZodParsedType;
+declare const getParsedType: (data: any) => 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 inferFlattenedErrors<T extends ZodType<any, any, any>, U = string> = typeToFlattenedError<TypeOf<T>, U>;
 type typeToFlattenedError<T, U = string> = {
   formErrors: U[];
-  fieldErrors: { [P in allKeys<T>]?: U[] };
+  fieldErrors: { [P in allKeys<T>]?: U[]; };
 };
 declare const ZodIssueCode: {
   invalid_type: "invalid_type";
@@ -184,17 +187,22 @@ interface ZodCustomIssue extends ZodIssueBase {
     [k: string]: any;
   };
 }
+type DenormalizedError = {
+  [k: string]: DenormalizedError | string[];
+};
 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[] ? {
+declare const quotelessJson: (obj: any) => 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;
+} : T extends object ? { [K in keyof T]?: ZodFormattedError<T[K]>; } : unknown;
 type ZodFormattedError<T, U = string> = {
   _errors: U[];
 } & recursiveZodFormattedError<NonNullable<T>>;
+type inferFormattedError<T extends ZodType<any, any, any>, U = string> = ZodFormattedError<TypeOf<T>, U>;
 declare class ZodError<T = any> extends Error {
   issues: ZodIssue[];
   get errors(): ZodIssue[];
@@ -225,7 +233,20 @@ type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
   message: string;
 };
 //#endregion
+//#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/locales/en.d.cts
+declare const errorMap: ZodErrorMap;
+//#endregion
+//#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/errors.d.cts
+declare function setErrorMap(map: ZodErrorMap): void;
+declare function getErrorMap(): ZodErrorMap;
+//#endregion
 //#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.d.cts
+declare const makeIssue: (params: {
+  data: any;
+  path: (string | number)[];
+  errorMaps: ZodErrorMap[];
+  issueData: IssueData;
+}) => ZodIssue;
 type ParseParams = {
   path: (string | number)[];
   errorMap: ZodErrorMap;
@@ -233,6 +254,7 @@ type ParseParams = {
 };
 type ParsePathComponent = string | number;
 type ParsePath = ParsePathComponent[];
+declare const EMPTY_PATH: ParsePath;
 interface ParseContext {
   readonly common: {
     readonly issues: ZodIssue[];
@@ -250,6 +272,11 @@ type ParseInput = {
   path: (string | number)[];
   parent: ParseContext;
 };
+declare function addIssueToContext(ctx: ParseContext, issueData: IssueData): void;
+type ObjectPair = {
+  key: SyncParseReturnType<any>;
+  value: SyncParseReturnType<any>;
+};
 declare class ParseStatus {
   value: "aborted" | "dirty" | "valid";
   dirty(): void;
@@ -265,6 +292,10 @@ declare class ParseStatus {
     alwaysSet?: boolean;
   }[]): SyncParseReturnType;
 }
+interface ParseResult {
+  status: "aborted" | "dirty" | "valid";
+  data: any;
+}
 type INVALID = {
   status: "aborted";
 };
@@ -282,6 +313,10 @@ 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>;
+declare const isAborted: (x: ParseReturnType<any>) => x is INVALID;
+declare const isDirty: <T>(x: ParseReturnType<T>) => x is OK<T> | DIRTY<T>;
+declare const isValid: <T>(x: ParseReturnType<T>) => x is OK<T>;
+declare const isAsync: <T>(x: ParseReturnType<T>) => x is AsyncParseReturnType<T>;
 //#endregion
 //#region ../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/enumUtil.d.cts
 declare namespace enumUtil {
@@ -306,7 +341,7 @@ declare namespace errorUtil {
 //#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;
+  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
@@ -437,6 +472,10 @@ type RawCreateParams = {
   message?: string | undefined;
   description?: string | undefined;
 } | undefined;
+type ProcessedCreateParams = {
+  errorMap?: ZodErrorMap | undefined;
+  description?: string | undefined;
+};
 type SafeParseSuccess<Output> = {
   success: true;
   data: Output;
@@ -605,6 +644,11 @@ interface ZodStringDef extends ZodTypeDef {
   typeName: ZodFirstPartyTypeKind.ZodString;
   coerce: boolean;
 }
+declare function datetimeRegex(args: {
+  precision?: number | null;
+  offset?: boolean;
+  local?: boolean;
+}): RegExp;
 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>;
@@ -735,6 +779,135 @@ declare class ZodNumber extends ZodType<number, ZodNumberDef, number> {
   get isInt(): boolean;
   get isFinite(): boolean;
 }
+type ZodBigIntCheck = {
+  kind: "min";
+  value: bigint;
+  inclusive: boolean;
+  message?: string | undefined;
+} | {
+  kind: "max";
+  value: bigint;
+  inclusive: boolean;
+  message?: string | undefined;
+} | {
+  kind: "multipleOf";
+  value: bigint;
+  message?: string | undefined;
+};
+interface ZodBigIntDef extends ZodTypeDef {
+  checks: ZodBigIntCheck[];
+  typeName: ZodFirstPartyTypeKind.ZodBigInt;
+  coerce: boolean;
+}
+declare class ZodBigInt extends ZodType<bigint, ZodBigIntDef, bigint> {
+  _parse(input: ParseInput): ParseReturnType<bigint>;
+  _getInvalidInput(input: ParseInput): INVALID;
+  static create: (params?: RawCreateParams & {
+    coerce?: boolean;
+  }) => ZodBigInt;
+  gte(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+  min: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;
+  gt(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+  lte(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+  max: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;
+  lt(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+  protected setLimit(kind: "min" | "max", value: bigint, inclusive: boolean, message?: string): ZodBigInt;
+  _addCheck(check: ZodBigIntCheck): ZodBigInt;
+  positive(message?: errorUtil.ErrMessage): ZodBigInt;
+  negative(message?: errorUtil.ErrMessage): ZodBigInt;
+  nonpositive(message?: errorUtil.ErrMessage): ZodBigInt;
+  nonnegative(message?: errorUtil.ErrMessage): ZodBigInt;
+  multipleOf(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+  get minValue(): bigint | null;
+  get maxValue(): bigint | null;
+}
+interface ZodBooleanDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodBoolean;
+  coerce: boolean;
+}
+declare class ZodBoolean extends ZodType<boolean, ZodBooleanDef, boolean> {
+  _parse(input: ParseInput): ParseReturnType<boolean>;
+  static create: (params?: RawCreateParams & {
+    coerce?: boolean;
+  }) => ZodBoolean;
+}
+type ZodDateCheck = {
+  kind: "min";
+  value: number;
+  message?: string | undefined;
+} | {
+  kind: "max";
+  value: number;
+  message?: string | undefined;
+};
+interface ZodDateDef extends ZodTypeDef {
+  checks: ZodDateCheck[];
+  coerce: boolean;
+  typeName: ZodFirstPartyTypeKind.ZodDate;
+}
+declare class ZodDate extends ZodType<Date, ZodDateDef, Date> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  _addCheck(check: ZodDateCheck): ZodDate;
+  min(minDate: Date, message?: errorUtil.ErrMessage): ZodDate;
+  max(maxDate: Date, message?: errorUtil.ErrMessage): ZodDate;
+  get minDate(): Date | null;
+  get maxDate(): Date | null;
+  static create: (params?: RawCreateParams & {
+    coerce?: boolean;
+  }) => ZodDate;
+}
+interface ZodSymbolDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodSymbol;
+}
+declare class ZodSymbol extends ZodType<symbol, ZodSymbolDef, symbol> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: (params?: RawCreateParams) => ZodSymbol;
+}
+interface ZodUndefinedDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodUndefined;
+}
+declare class ZodUndefined extends ZodType<undefined, ZodUndefinedDef, undefined> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  params?: RawCreateParams;
+  static create: (params?: RawCreateParams) => ZodUndefined;
+}
+interface ZodNullDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodNull;
+}
+declare class ZodNull extends ZodType<null, ZodNullDef, null> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: (params?: RawCreateParams) => ZodNull;
+}
+interface ZodAnyDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodAny;
+}
+declare class ZodAny extends ZodType<any, ZodAnyDef, any> {
+  _any: true;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: (params?: RawCreateParams) => ZodAny;
+}
+interface ZodUnknownDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodUnknown;
+}
+declare class ZodUnknown extends ZodType<unknown, ZodUnknownDef, unknown> {
+  _unknown: true;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: (params?: RawCreateParams) => ZodUnknown;
+}
+interface ZodNeverDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodNever;
+}
+declare class ZodNever extends ZodType<never, ZodNeverDef, never> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: (params?: RawCreateParams) => ZodNever;
+}
+interface ZodVoidDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodVoid;
+}
+declare class ZodVoid extends ZodType<void, ZodVoidDef, void> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: (params?: RawCreateParams) => ZodVoid;
+}
 interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
   type: T;
   typeName: ZodFirstPartyTypeKind.ZodArray;
@@ -762,6 +935,7 @@ declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinalit
   nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
   static create: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
 }
+type ZodNonEmptyArray<T extends ZodTypeAny> = ZodArray<T, "atleastone">;
 type UnknownKeysParam = "passthrough" | "strict" | "strip";
 interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
   typeName: ZodFirstPartyTypeKind.ZodObject;
@@ -769,10 +943,11 @@ interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends
   catchall: Catchall;
   unknownKeys: UnknownKeys;
 }
+type mergeTypes<A, B> = { [k in keyof A | keyof B]: k extends keyof B ? B[k] : k extends keyof A ? A[k] : never; };
 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 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 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"];
 };
@@ -783,6 +958,8 @@ 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;
+type SomeZodObject = ZodObject<ZodRawShape, UnknownKeysParam, ZodTypeAny>;
+type noUnrecognized<Obj extends object, Shape extends object> = { [k in keyof Obj]: k extends keyof Shape ? Obj[k] : never; };
 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(): {
@@ -810,18 +987,18 @@ declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysPa
    * 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>;
+  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>;
+  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>;
+  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">;
@@ -838,6 +1015,28 @@ declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_ou
   get options(): T;
   static create: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
 }
+type ZodDiscriminatedUnionOption<Discriminator extends string> = ZodObject<{ [key in Discriminator]: ZodTypeAny; } & ZodRawShape, UnknownKeysParam, ZodTypeAny>;
+interface ZodDiscriminatedUnionDef<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<string>[] = ZodDiscriminatedUnionOption<string>[]> extends ZodTypeDef {
+  discriminator: Discriminator;
+  options: Options;
+  optionsMap: Map<Primitive$1, ZodDiscriminatedUnionOption<any>>;
+  typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion;
+}
+declare class ZodDiscriminatedUnion<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<Discriminator>[]> extends ZodType<output<Options[number]>, ZodDiscriminatedUnionDef<Discriminator, Options>, input<Options[number]>> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get discriminator(): Discriminator;
+  get options(): Options;
+  get optionsMap(): Map<Primitive$1, ZodDiscriminatedUnionOption<any>>;
+  /**
+   * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
+   * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
+   * have a different value for each object in the union.
+   * @param discriminator the name of the discriminator property
+   * @param types an array of object schemas
+   * @param params
+   */
+  static create<Discriminator extends string, Types extends readonly [ZodDiscriminatedUnionOption<Discriminator>, ...ZodDiscriminatedUnionOption<Discriminator>[]]>(discriminator: Discriminator, options: Types, params?: RawCreateParams): ZodDiscriminatedUnion<Discriminator, Types>;
+}
 interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
   left: T;
   right: U;
@@ -849,21 +1048,98 @@ declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extend
 }
 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 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 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;
 }
+type AnyZodTuple = ZodTuple<[ZodTypeAny, ...ZodTypeAny[]] | [], ZodTypeAny | null>;
 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 ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  valueType: Value;
+  keyType: Key;
+  typeName: ZodFirstPartyTypeKind.ZodRecord;
+}
+type KeySchema = ZodType<string | number | symbol, any, any>;
+type RecordType<K extends string | number | symbol, V> = [string] extends [K] ? Record<K, V> : [number] extends [K] ? Record<K, V> : [symbol] extends [K] ? Record<K, V> : [BRAND<string | number | symbol>] extends [K] ? Record<K, V> : Partial<Record<K, V>>;
+declare class ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<RecordType<Key["_output"], Value["_output"]>, ZodRecordDef<Key, Value>, RecordType<Key["_input"], Value["_input"]>> {
+  get keySchema(): Key;
+  get valueSchema(): Value;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  get element(): Value;
+  static create<Value extends ZodTypeAny>(valueType: Value, params?: RawCreateParams): ZodRecord<ZodString, Value>;
+  static create<Keys extends KeySchema, Value extends ZodTypeAny>(keySchema: Keys, valueType: Value, params?: RawCreateParams): ZodRecord<Keys, Value>;
+}
+interface ZodMapDef<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  valueType: Value;
+  keyType: Key;
+  typeName: ZodFirstPartyTypeKind.ZodMap;
+}
+declare class ZodMap<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Map<Key["_output"], Value["_output"]>, ZodMapDef<Key, Value>, Map<Key["_input"], Value["_input"]>> {
+  get keySchema(): Key;
+  get valueSchema(): Value;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <KeySchema extends ZodTypeAny = ZodTypeAny, ValueSchema extends ZodTypeAny = ZodTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: RawCreateParams) => ZodMap<KeySchema, ValueSchema>;
+}
+interface ZodSetDef<Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  valueType: Value;
+  typeName: ZodFirstPartyTypeKind.ZodSet;
+  minSize: {
+    value: number;
+    message?: string | undefined;
+  } | null;
+  maxSize: {
+    value: number;
+    message?: string | undefined;
+  } | null;
+}
+declare class ZodSet<Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Set<Value["_output"]>, ZodSetDef<Value>, Set<Value["_input"]>> {
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  min(minSize: number, message?: errorUtil.ErrMessage): this;
+  max(maxSize: number, message?: errorUtil.ErrMessage): this;
+  size(size: number, message?: errorUtil.ErrMessage): this;
+  nonempty(message?: errorUtil.ErrMessage): ZodSet<Value>;
+  static create: <ValueSchema extends ZodTypeAny = ZodTypeAny>(valueType: ValueSchema, params?: RawCreateParams) => ZodSet<ValueSchema>;
+}
+interface ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any, any>, Returns extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  args: Args;
+  returns: Returns;
+  typeName: ZodFirstPartyTypeKind.ZodFunction;
+}
+type OuterTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_input"] extends Array<any> ? (...args: Args["_input"]) => Returns["_output"] : never;
+type InnerTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_output"] extends Array<any> ? (...args: Args["_output"]) => Returns["_input"] : never;
+declare class ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> extends ZodType<OuterTypeOfFunction<Args, Returns>, ZodFunctionDef<Args, Returns>, InnerTypeOfFunction<Args, Returns>> {
+  _parse(input: ParseInput): ParseReturnType<any>;
+  parameters(): Args;
+  returnType(): Returns;
+  args<Items extends Parameters<(typeof ZodTuple)["create"]>[0]>(...items: Items): ZodFunction<ZodTuple<Items, ZodUnknown>, Returns>;
+  returns<NewReturnType extends ZodType<any, any, any>>(returnType: NewReturnType): ZodFunction<Args, NewReturnType>;
+  implement<F extends InnerTypeOfFunction<Args, Returns>>(func: F): ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
+  strictImplement(func: InnerTypeOfFunction<Args, Returns>): InnerTypeOfFunction<Args, Returns>;
+  validate: <F extends InnerTypeOfFunction<Args, Returns>>(func: F) => ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
+  static create(): ZodFunction<ZodTuple<[], ZodUnknown>, ZodUnknown>;
+  static create<T extends AnyZodTuple = ZodTuple<[], ZodUnknown>>(args: T): ZodFunction<T, ZodUnknown>;
+  static create<T extends AnyZodTuple, U extends ZodTypeAny>(args: T, returns: U): ZodFunction<T, U>;
+  static create<T extends AnyZodTuple = ZodTuple<[], ZodUnknown>, U extends ZodTypeAny = ZodUnknown>(args: T, returns: U, params?: RawCreateParams): ZodFunction<T, U>;
+}
+interface ZodLazyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+  getter: () => T;
+  typeName: ZodFirstPartyTypeKind.ZodLazy;
+}
+declare class ZodLazy<T extends ZodTypeAny> extends ZodType<output<T>, ZodLazyDef<T>, input<T>> {
+  get schema(): T;
+  _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+  static create: <Inner extends ZodTypeAny>(getter: () => Inner, params?: RawCreateParams) => ZodLazy<Inner>;
+}
 interface ZodLiteralDef<T = any> extends ZodTypeDef {
   value: T;
   typeName: ZodFirstPartyTypeKind.ZodLiteral;
@@ -873,13 +1149,15 @@ declare class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>, T> {
   get value(): T;
   static create: <Value extends Primitive$1>(value: Value, params?: RawCreateParams) => ZodLiteral<Value>;
 }
+type ArrayKeys = keyof any[];
+type Indices<T> = Exclude<keyof T, ArrayKeys>;
 type EnumValues<T extends string = string> = readonly [T, ...T[]];
-type Values<T extends EnumValues> = { [k in T[number]]: k };
+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 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>>;
@@ -895,6 +1173,20 @@ declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[number]
   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 ZodNativeEnumDef<T extends EnumLike = EnumLike> extends ZodTypeDef {
+  values: T;
+  typeName: ZodFirstPartyTypeKind.ZodNativeEnum;
+}
+type EnumLike = {
+  [k: string]: string | number;
+  [nu: number]: string;
+};
+declare class ZodNativeEnum<T extends EnumLike> extends ZodType<T[keyof T], ZodNativeEnumDef<T>, T[keyof T]> {
+  _cache: Set<T[keyof T]> | undefined;
+  _parse(input: ParseInput): ParseReturnType<T[keyof T]>;
+  get enum(): T;
+  static create: <Elements extends EnumLike>(values: Elements, params?: RawCreateParams) => ZodNativeEnum<Elements>;
+}
 interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
   type: T;
   typeName: ZodFirstPartyTypeKind.ZodPromise;
@@ -904,6 +1196,8 @@ declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_outpu
   _parse(input: ParseInput): ParseReturnType<this["_output"]>;
   static create: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
 }
+type Refinement<T> = (arg: T, ctx: RefinementCtx) => any;
+type SuperRefinement<T> = (arg: T, ctx: RefinementCtx) => void | Promise<void>;
 type RefinementEffect<T> = {
   type: "refinement";
   refinement: (arg: T, ctx: RefinementCtx) => any;
@@ -933,6 +1227,7 @@ interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
   innerType: T;
   typeName: ZodFirstPartyTypeKind.ZodOptional;
 }
+type ZodOptionalType<T extends ZodTypeAny> = ZodOptional<T>;
 declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
   _parse(input: ParseInput): ParseReturnType<this["_output"]>;
   unwrap(): T;
@@ -942,6 +1237,7 @@ interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
   innerType: T;
   typeName: ZodFirstPartyTypeKind.ZodNullable;
 }
+type ZodNullableType<T extends ZodTypeAny> = ZodNullable<T>;
 declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
   _parse(input: ParseInput): ParseReturnType<this["_output"]>;
   unwrap(): T;
@@ -974,13 +1270,20 @@ declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCa
     catch: Inner["_output"] | (() => Inner["_output"]);
   }) => ZodCatch<Inner>;
 }
+interface ZodNaNDef extends ZodTypeDef {
+  typeName: ZodFirstPartyTypeKind.ZodNaN;
+}
+declare class ZodNaN extends ZodType<number, ZodNaNDef, number> {
+  _parse(input: ParseInput): ParseReturnType<any>;
+  static create: (params?: RawCreateParams) => ZodNaN;
+}
 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 };
+  [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>;
@@ -1008,6 +1311,24 @@ declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReadonly<T["
   static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodReadonly<Inner>;
   unwrap(): T;
 }
+type CustomParams = CustomErrorParams & {
+  fatal?: boolean;
+};
+declare function custom<T>(check?: (data: any) => any, _params?: string | CustomParams | ((input: any) => CustomParams),
+/**
+ * @deprecated
+ *
+ * Pass `fatal` into the params object instead:
+ *
+ * ```ts
+ * z.string().custom((val) => val.length > 5, { fatal: false })
+ * ```
+ *
+ */
+fatal?: boolean): ZodType<T, ZodTypeDef, T>;
+declare const late: {
+  object: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;
+};
 declare enum ZodFirstPartyTypeKind {
   ZodString = "ZodString",
   ZodNumber = "ZodNumber",
@@ -1046,6 +1367,69 @@ declare enum ZodFirstPartyTypeKind {
   ZodPipeline = "ZodPipeline",
   ZodReadonly = "ZodReadonly"
 }
+type ZodFirstPartySchemaTypes = ZodString | ZodNumber | ZodNaN | ZodBigInt | ZodBoolean | ZodDate | ZodUndefined | ZodNull | ZodAny | ZodUnknown | ZodNever | ZodVoid | ZodArray<any, any> | ZodObject<any, any, any> | ZodUnion<any> | ZodDiscriminatedUnion<any, any> | ZodIntersection<any, any> | ZodTuple<any, any> | ZodRecord<any, any> | ZodMap<any> | ZodSet<any> | ZodFunction<any, any> | ZodLazy<any> | ZodLiteral<any> | ZodEnum<any> | ZodEffects<any, any, any> | ZodNativeEnum<any> | ZodOptional<any> | ZodNullable<any> | ZodDefault<any> | ZodCatch<any> | ZodPromise<any> | ZodBranded<any, any> | ZodPipeline<any, any> | ZodReadonly<any> | ZodSymbol;
+declare abstract class Class {
+  constructor(..._: any[]);
+}
+declare const instanceOfType: <T extends typeof Class>(cls: T, params?: CustomParams) => ZodType<InstanceType<T>, ZodTypeDef, InstanceType<T>>;
+declare const stringType: (params?: RawCreateParams & {
+  coerce?: true;
+}) => ZodString;
+declare const numberType: (params?: RawCreateParams & {
+  coerce?: boolean;
+}) => ZodNumber;
+declare const nanType: (params?: RawCreateParams) => ZodNaN;
+declare const bigIntType: (params?: RawCreateParams & {
+  coerce?: boolean;
+}) => ZodBigInt;
+declare const booleanType: (params?: RawCreateParams & {
+  coerce?: boolean;
+}) => ZodBoolean;
+declare const dateType: (params?: RawCreateParams & {
+  coerce?: boolean;
+}) => ZodDate;
+declare const symbolType: (params?: RawCreateParams) => ZodSymbol;
+declare const undefinedType: (params?: RawCreateParams) => ZodUndefined;
+declare const nullType: (params?: RawCreateParams) => ZodNull;
+declare const anyType: (params?: RawCreateParams) => ZodAny;
+declare const unknownType: (params?: RawCreateParams) => ZodUnknown;
+declare const neverType: (params?: RawCreateParams) => ZodNever;
+declare const voidType: (params?: RawCreateParams) => ZodVoid;
+declare const arrayType: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
+declare const objectType: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;
+declare const strictObjectType: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;
+declare const unionType: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
+declare const discriminatedUnionType: typeof ZodDiscriminatedUnion.create;
+declare const intersectionType: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;
+declare const tupleType: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;
+declare const recordType: typeof ZodRecord.create;
+declare const mapType: <KeySchema extends ZodTypeAny = ZodTypeAny, ValueSchema extends ZodTypeAny = ZodTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: RawCreateParams) => ZodMap<KeySchema, ValueSchema>;
+declare const setType: <ValueSchema extends ZodTypeAny = ZodTypeAny>(valueType: ValueSchema, params?: RawCreateParams) => ZodSet<ValueSchema>;
+declare const functionType: typeof ZodFunction.create;
+declare const lazyType: <Inner extends ZodTypeAny>(getter: () => Inner, params?: RawCreateParams) => ZodLazy<Inner>;
+declare const literalType: <Value extends Primitive$1>(value: Value, params?: RawCreateParams) => ZodLiteral<Value>;
+declare const enumType: typeof createZodEnum;
+declare const nativeEnumType: <Elements extends EnumLike>(values: Elements, params?: RawCreateParams) => ZodNativeEnum<Elements>;
+declare const promiseType: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
+declare const effectsType: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;
+declare const optionalType: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;
+declare const nullableType: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;
+declare const preprocessType: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
+declare const pipelineType: typeof ZodPipeline.create;
+declare const ostring: () => ZodOptional<ZodString>;
+declare const onumber: () => ZodOptional<ZodNumber>;
+declare const oboolean: () => ZodOptional<ZodBoolean>;
+declare const coerce: {
+  string: (typeof ZodString)["create"];
+  number: (typeof ZodNumber)["create"];
+  boolean: (typeof ZodBoolean)["create"];
+  bigint: (typeof ZodBigInt)["create"];
+  date: (typeof ZodDate)["create"];
+};
+declare const NEVER: never;
+declare namespace external_d_exports {
+  export { AnyZodObject, AnyZodTuple, ArrayCardinality, ArrayKeys, AssertArray, AsyncParseReturnType, BRAND, CatchallInput, CatchallOutput, CustomErrorParams, DIRTY, DenormalizedError, EMPTY_PATH, Effect, EnumLike, EnumValues, ErrorMapCtx, FilterEnum, INVALID, Indices, InnerTypeOfFunction, InputTypeOfTuple, InputTypeOfTupleWithRest, IpVersion, IssueData, KeySchema, NEVER, OK, ObjectPair, OuterTypeOfFunction, OutputTypeOfTuple, OutputTypeOfTupleWithRest, ParseContext, ParseInput, ParseParams, ParsePath, ParsePathComponent, ParseResult, ParseReturnType, ParseStatus, PassthroughType, PreprocessEffect, Primitive$1 as Primitive, ProcessedCreateParams, RawCreateParams, RecordType, Refinement, RefinementCtx, RefinementEffect, SafeParseError, SafeParseReturnType, SafeParseSuccess, Scalars, ZodType as Schema, SomeZodObject, StringValidation, SuperRefinement, SyncParseReturnType, TransformEffect, TypeOf, UnknownKeysParam, Values, Writeable, ZodAny, ZodAnyDef, ZodArray, ZodArrayDef, ZodBigInt, ZodBigIntCheck, ZodBigIntDef, ZodBoolean, ZodBooleanDef, ZodBranded, ZodBrandedDef, ZodCatch, ZodCatchDef, ZodCustomIssue, ZodDate, ZodDateCheck, ZodDateDef, ZodDefault, ZodDefaultDef, ZodDiscriminatedUnion, ZodDiscriminatedUnionDef, ZodDiscriminatedUnionOption, ZodEffects, ZodEffectsDef, ZodEnum, ZodEnumDef, ZodError, ZodErrorMap, ZodFirstPartySchemaTypes, ZodFirstPartyTypeKind, ZodFormattedError, ZodFunction, ZodFunctionDef, ZodIntersection, ZodIntersectionDef, ZodInvalidArgumentsIssue, ZodInvalidDateIssue, ZodInvalidEnumValueIssue, ZodInvalidIntersectionTypesIssue, ZodInvalidLiteralIssue, ZodInvalidReturnTypeIssue, ZodInvalidStringIssue, ZodInvalidTypeIssue, ZodInvalidUnionDiscriminatorIssue, ZodInvalidUnionIssue, ZodIssue, ZodIssueBase, ZodIssueCode, ZodIssueOptionalMessage, ZodLazy, ZodLazyDef, ZodLiteral, ZodLiteralDef, ZodMap, ZodMapDef, ZodNaN, ZodNaNDef, ZodNativeEnum, ZodNativeEnumDef, ZodNever, ZodNeverDef, ZodNonEmptyArray, ZodNotFiniteIssue, ZodNotMultipleOfIssue, ZodNull, ZodNullDef, ZodNullable, ZodNullableDef, ZodNullableType, ZodNumber, ZodNumberCheck, ZodNumberDef, ZodObject, ZodObjectDef, ZodOptional, ZodOptionalDef, ZodOptionalType, ZodParsedType, ZodPipeline, ZodPipelineDef, ZodPromise, ZodPromiseDef, ZodRawShape, ZodReadonly, ZodReadonlyDef, ZodRecord, ZodRecordDef, ZodType as ZodSchema, ZodSet, ZodSetDef, ZodString, ZodStringCheck, ZodStringDef, ZodSymbol, ZodSymbolDef, ZodTooBigIssue, ZodTooSmallIssue, ZodEffects as ZodTransformer, ZodTuple, ZodTupleDef, ZodTupleItems, ZodType, ZodTypeAny, ZodTypeDef, ZodUndefined, ZodUndefinedDef, ZodUnion, ZodUnionDef, ZodUnionOptions, ZodUnknown, ZodUnknownDef, ZodUnrecognizedKeysIssue, ZodVoid, ZodVoidDef, addIssueToContext, anyType as any, arrayType as array, arrayOutputType, baseObjectInputType, baseObjectOutputType, bigIntType as bigint, booleanType as boolean, coerce, custom, dateType as date, datetimeRegex, errorMap as defaultErrorMap, deoptional, discriminatedUnionType as discriminatedUnion, effectsType as effect, enumType as enum, functionType as function, getErrorMap, getParsedType, TypeOf as infer, inferFlattenedErrors, inferFormattedError, input, instanceOfType as instanceof, intersectionType as intersection, isAborted, isAsync, isDirty, isValid, late, lazyType as lazy, literalType as literal, makeIssue, mapType as map, mergeTypes, nanType as nan, nativeEnumType as nativeEnum, neverType as never, noUnrecognized, nullType as null, nullableType as nullable, numberType as number, objectType as object, objectInputType, objectOutputType, objectUtil, oboolean, onumber, optionalType as optional, ostring, output, pipelineType as pipeline, preprocessType as preprocess, promiseType as promise, quotelessJson, recordType as record, setType as set, setErrorMap, strictObjectType as strictObject, stringType as string, symbolType as symbol, effectsType as transformer, tupleType as tuple, typeToFlattenedError, typecast, undefinedType as undefined, unionType as union, unknownType as unknown, util, voidType as void };
+}
 //#endregion
 //#region ../node_modules/.pnpm/@milaboratories+pl-error-like@1.12.10/node_modules/@milaboratories/pl-error-like/dist/error_like_shape.d.ts
 //#region src/error_like_shape.d.ts
@@ -1098,7 +1482,6 @@ type StandardErrorLike = TypeOf<typeof BaseStandardErrorLike> & {
 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 ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/common_types.d.ts
 type OutputWithStatus<T> = {
@@ -1129,7 +1512,7 @@ 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 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;
 };
@@ -1148,7 +1531,7 @@ type CanonicalizedJson<T = unknown> = JsonCompatible<T> extends never ? never :
  * @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;
+  /** 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 */
@@ -1157,16 +1540,16 @@ type BlockState<Args = unknown, Outputs extends BlockOutputsBase = BlockOutputsB
   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 */
+  /** 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 ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-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
+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
 //#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/dialog/index.d.ts
 //#region src/dialog/index.d.ts
@@ -1199,7 +1582,7 @@ interface ShowSaveDialogResult {
  */
 interface DialogService {
   showSaveDialog(options: ShowSaveDialogOptions): Promise<ShowSaveDialogResult>;
-} //#endregion
+}
 //#endregion
 //#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/pool_entry.d.ts
 //#region src/pool_entry.d.ts
@@ -1215,10 +1598,6 @@ interface PoolEntry<K extends string = string, R extends {} = {}> extends Dispos
    */
   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 ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/table_common.d.ts
 //#region src/drivers/pframe/table_common.d.ts
@@ -1261,7 +1640,7 @@ 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 */
+  /** 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,
@@ -1275,17 +1654,16 @@ type PTableVectorTyped<DataType extends ValueType> = {
 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 */
+  /** 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 */
+  /** 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;
@@ -1319,11 +1697,6 @@ interface WritePTableToFsResult {
   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
@@ -1344,7 +1717,7 @@ interface ExportPTableOptions {
    * read. Older runtimes ignore this field and use {@link columnIndices} alone.
    */
   headerNames?: string[];
-} //#endregion
+}
 //#endregion
 //#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/data_info.d.ts
 //#region src/drivers/pframe/data_info.d.ts
@@ -1361,16 +1734,12 @@ type PColumnValue = null | number | string;
  * 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) */
+  /** 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
@@ -1383,7 +1752,7 @@ type JsonDataInfo = {
  * 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 */
+  /** 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>;
 };
@@ -1392,7 +1761,7 @@ type JsonPartitionedDataInfo<Blob> = {
  * 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 */
+  /** Binary blob containing structured index information */ index: Blob; /** Binary blob containing the actual values */
   values: Blob;
 };
 /**
@@ -1400,12 +1769,12 @@ type BinaryChunk<Blob> = {
  * 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 */
+  /** 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 */
+  /** 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>;
 };
@@ -1416,12 +1785,6 @@ type ParquetPartitionedDataInfo<Blob> = {
  * @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.
@@ -1435,9 +1798,6 @@ type PColumnValuesEntry = {
  * Used for lightweight explicit instantiation of PColumns.
  */
 type PColumnValues = PColumnValuesEntry[];
-/**
- * Entry-based representation of JsonDataInfo
- */
 //#endregion
 //#region ../node_modules/.pnpm/@milaboratories+helpers@1.14.5/node_modules/@milaboratories/helpers/dist/types/brand.d.ts
 //#region src/types/brand.d.ts
@@ -1486,7 +1846,7 @@ type ColumnOverriddenId = Branded<CanonicalizedJson<ColumnOverriddenKey>, "Colum
  * `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 */
+  /** List of axis value types defining the dimensions of the data */ axes: AxisValueType[]; /** The single column value type */
   column: ColumnValueType;
 };
 /**
@@ -2173,7 +2533,7 @@ interface QuerySliceAxes<Q, A> {
   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 */
+    /** 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;
   }[];
 }
@@ -2523,7 +2883,7 @@ interface QuerySpecOverride<Q, SO> {
   input: Q;
   /** Spec override patch to overlay on the inner spec. */
   override: SO;
-} //#endregion
+}
 //#endregion
 //#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/query/query_data.d.ts
 //#region src/drivers/pframe/query/query_data.d.ts
@@ -2534,7 +2894,7 @@ interface QuerySpecOverride<Q, SO> {
  * 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 */
+  /** Unique identifier of the column */ id: PObjectId; /** Type specification defining the axes and the single column value type */
   spec: ColumnTypeSpec;
 };
 /**
@@ -2572,7 +2932,7 @@ type DataQueryOuterJoin = QueryOuterJoin<DataQueryJoinEntry>;
  * - `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. */
+  /** 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[];
 };
@@ -2603,7 +2963,7 @@ 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
+type DataQueryBooleanExpression = InferBooleanExpressionUnion<DataQueryExpression>;
 //#endregion
 //#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec_driver.d.ts
 //#region src/drivers/pframe/spec_driver.d.ts
@@ -2716,7 +3076,7 @@ type DiscoverColumnsStepInfo = DiscoverColumnsLinkerStep | DiscoverColumnsFilter
  * 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. */
+  /** 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[];
@@ -2818,7 +3178,7 @@ interface PFrameSpecDriver {
     tableSpec: PTableColumnSpec[];
     filters: PTableRecordFilter[];
   }): DataQueryBooleanExpression[];
-} //#endregion
+}
 //#endregion
 //#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/selectors.d.ts
 /** Single axis selector */
@@ -2841,10 +3201,6 @@ interface AxisQualification {
   /** 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 ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/query/query_spec.d.ts
 //#region src/drivers/pframe/query/query_spec.d.ts
@@ -2860,7 +3216,7 @@ interface AxisQualification {
  */
 type SpecQueryJoinEntry<C = ColumnUniversalId> = QueryJoinEntry<SpecQuery<C>> & {
   qualifications?: readonly {
-    /** Axis to qualify. */axis: SingleAxisSelector; /** Additional domain constraints for this axis. */
+    /** Axis to qualify. */ axis: SingleAxisSelector; /** Additional domain constraints for this axis. */
     contextDomain: Domain;
   }[];
 };
@@ -2913,7 +3269,7 @@ 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
+type SpecQueryBooleanExpression = InferBooleanExpressionUnion<SpecQueryExpression>;
 //#endregion
 //#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/table_calculate.d.ts
 //#region src/drivers/pframe/table_calculate.d.ts
@@ -3169,7 +3525,7 @@ interface PTableRecordSingleValueFilterV2 {
 type PTableRecordFilter = PTableRecordSingleValueFilterV2;
 /** Sorting parameters for a PTable.  */
 type PTableSorting = {
-  /** Unified column identifier */readonly column: PTableColumnId; /** Sorting order */
+  /** Unified column identifier */ readonly column: PTableColumnId; /** Sorting order */
   readonly ascending: boolean; /** Sorting in respect to NA and absent values */
   readonly naAndAbsentAreLeastValues: boolean;
 };
@@ -3191,7 +3547,7 @@ interface PTableDefV2<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 */
+  /** Join tree to populate the PTable */ readonly src: JoinEntry<Col>; /** Record filters */
   readonly filters: PTableRecordFilter[]; /** Table sorting */
   readonly sorting: PTableSorting[];
 };
@@ -3217,13 +3573,12 @@ declare const PlRef: ZodReadonly<ZodObject<{
   requireEnrichments?: true | undefined;
 }>>;
 type PlRef = TypeOf<typeof PlRef>;
-/** @deprecated use {@link PlRef} */
 //#endregion
 //#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-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 */
+  /** 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
@@ -3295,7 +3650,7 @@ type Domain = Metadata & Partial<{
  * 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 */
+  /** 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 */
@@ -3326,7 +3681,6 @@ type AxisSpec = {
    */
   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[];
 /**
@@ -3367,10 +3721,9 @@ type PUniversalColumnSpec = PObjectSpec & {
  * basic tabular data.
  */
 type PDataColumnSpec = PUniversalColumnSpec & {
-  /** Type of column values */readonly valueType: ValueType;
+  /** 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;
@@ -3383,7 +3736,6 @@ interface PColumnIdAndSpec {
   /** 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. */
@@ -3399,7 +3751,6 @@ interface AxisId {
 }
 /** Array of axis ids */
 type AxesId = AxisId[];
-/** Extracts axis ids from axis spec */
 //#endregion
 //#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/filtered_column.d.ts
 //#region src/drivers/pframe/spec/filtered_column.d.ts
@@ -3407,7 +3758,6 @@ type AxesId = AxisId[];
 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
@@ -3432,21 +3782,12 @@ type ColumnFilteredId = Branded<CanonicalizedJson<ColumnFilteredKey>, "ColumnFil
  * 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}
- */
 /**
  * Canonically serialized {@link UniversalPColumnId}.
  * @deprecated use {@link ColumnUniversalId}
  */
 type SUniversalPColumnId = ColumnUniversalId;
 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 ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/spec/discovered_column.d.ts
 //#region src/drivers/pframe/spec/discovered_column.d.ts
@@ -3486,7 +3827,7 @@ interface FileLike extends BlobLike {
   readonly lastModified: number;
   /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/name) */
   readonly name: string;
-} //#endregion
+}
 //#endregion
 //#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/blob.d.ts
 //#region src/drivers/blob.d.ts
@@ -3496,11 +3837,9 @@ 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. */
+  /** Included left border. */ from: ZodNumber; /** Excluded right border. */
   to: ZodNumber;
 }, "strip", ZodTypeAny, {
   from: number;
@@ -3519,9 +3858,6 @@ interface BlobDriver {
    */
   getContent(handle: LocalBlobHandle | RemoteBlobHandle, range?: RangeBytes): Promise<Uint8Array>;
 }
-/**
- * Operational metrics of the blob download driver.
- */
 //#endregion
 //#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/log.d.ts
 //#region src/drivers/log.d.ts
@@ -3537,38 +3873,29 @@ type ReadyLogHandle = Branded$1<`${typeof READY_LOG_PREFIX}${string}`, "ReadyLog
 /** 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,
+  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,
+  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.
@@ -3607,7 +3934,7 @@ interface ColumnFilter {
   /** Match requires all the annotations listed here to match corresponding regex
    * pattern. */
   readonly annotationPattern?: Record<string, string>;
-} //#endregion
+}
 //#endregion
 //#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/find_columns.d.ts
 //#region src/drivers/pframe/find_columns.d.ts
@@ -3634,7 +3961,7 @@ interface FindColumnsRequest {
 interface FindColumnsResponse {
   /** Array of column ids found using request criteria. */
   readonly hits: PColumnIdAndSpec[];
-} //#endregion
+}
 //#endregion
 //#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/unique_values.d.ts
 //#region src/drivers/pframe/unique_values.d.ts
@@ -3654,11 +3981,11 @@ interface UniqueValuesResponse {
   readonly values: PTableVector;
   /** True if limit was reached and response contain non-exhaustive list of values. */
   readonly overflow: boolean;
-} //#endregion
+}
 //#endregion
 //#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/pframe.d.ts
 /** Information required to instantiate a PFrame. */
-type PFrameDef<Col> = Col[]; //#endregion
+type PFrameDef<Col> = Col[];
 //#endregion
 //#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/pframe/driver.d.ts
 //#region src/drivers/pframe/driver.d.ts
@@ -3726,7 +4053,7 @@ interface PFrameDriver {
    * 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 ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/ls.d.ts
 //#region src/drivers/ls.d.ts
@@ -3740,7 +4067,7 @@ type StorageHandleLocal = `local://${string}`;
 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. */
+  /** Stable machine identifier (e.g. "library", "root", "local"). Used for filtering. */ id: string; /** Human-readable display name. */
   name: string;
   handle: StorageHandle;
   initialFullPath: string;
@@ -3760,11 +4087,11 @@ type LsEntry = {
   handle: ImportFileHandle;
 };
 type OpenDialogFilter = {
-  /** Human-readable file type name */readonly name: string; /** File extensions */
+  /** 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. */
+  /** 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[];
 };
@@ -3778,7 +4105,6 @@ type OpenMultipleFilesResponse = {
    * 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[]>;
@@ -3801,7 +4127,6 @@ interface LsDriver {
   /** Saves currently opened block webview as a PDF. */
   exportToPdf?(): Promise<void>;
 }
-/** Gets a file path from an import handle. */
 //#endregion
 //#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/columns/column_selector.d.ts
 //#region src/columns/column_selector.d.ts
@@ -3847,7 +4172,6 @@ type MatchingMode = "enrichment" | "related" | "exact";
  * 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 —
@@ -3878,7 +4202,6 @@ type ColumnsDiscoverOptions = DiscoverColumnsOptions;
  * 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 ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/columns/types.d.ts
 //#region src/columns/types.d.ts
@@ -3960,13 +4283,6 @@ interface AccessorLike<Self extends AccessorLike<Self>> {
   /** 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 ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/drivers/columns/columns_collection_driver.d.ts
 //#region src/drivers/columns/columns_collection_driver.d.ts
@@ -4080,7 +4396,7 @@ interface ColumnsCollectionDriver {
   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 ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/services/service_types.d.ts
 //#region src/services/service_types.d.ts
@@ -4105,13 +4421,12 @@ interface ServiceDispatch {
 }
 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]>> };
+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]> };
+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 };
+type ServiceRequireFlags = { [K in keyof TServices as `requires${K & string}`]?: boolean; };
 //#endregion
 //#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/services/service_declarations.d.ts
 //#region src/services/service_declarations.d.ts
@@ -4120,7 +4435,7 @@ declare const Services: {
   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 ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/flags/block_flags.d.ts
 /**
@@ -4134,11 +4449,6 @@ type BlockCodeKnownFeatureFlags = {
   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 ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/driver_kit.d.ts
 //#region src/driver_kit.d.ts
@@ -4159,7 +4469,7 @@ interface DriverKit {
   readonly lsDriver: LsDriver;
   /** Driver allowing to interact with PFrames and PTables */
   readonly pFrameDriver: PFrameDriver;
-} //#endregion
+}
 //#endregion
 //#region ../node_modules/.pnpm/@milaboratories+pl-model-common@1.48.0/node_modules/@milaboratories/pl-model-common/dist/errors.d.ts
 type ResultOrError<S, F = Error> = {
@@ -4186,21 +4496,24 @@ interface ValueWithUTag<V> {
 }
 interface ValueWithUTagAndAuthor<V> extends ValueWithUTag<V> {
   readonly author?: AuthorMarker;
-} //#endregion
+}
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/block_state_patch.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.9/node_modules/@platforma-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 */
+  /** 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];
+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
+type BlockStatePatch<Args = unknown, Outputs extends BlockOutputsBase = BlockOutputsBase, UiState = unknown, Href extends `/${string}` = `/${string}`> = Unionize<BlockState<Args, Outputs, UiState, Href>>;
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/plugin_handle.d.ts
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.9/node_modules/@platforma-sdk/model/dist/plugin_handle.d.ts
 //#region src/plugin_handle.d.ts
 /**
  * Phantom-only base type for constraining PluginHandle's type parameter.
@@ -4220,16 +4533,14 @@ interface PluginFactoryLike<Data extends Record<string, unknown> = Record<string
     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 ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/block_storage.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.9/node_modules/@platforma-sdk/model/dist/block_storage.d.ts
 /** Payload for storage mutation operations. SDK defines specific operations. */
 type MutateStoragePayload<T = unknown> = {
   operation: "update-block-data";
@@ -4239,15 +4550,8 @@ type MutateStoragePayload<T = unknown> = {
   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 ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/bconfig/lambdas.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.9/node_modules/@platforma-sdk/model/dist/bconfig/lambdas.d.ts
 /** Additional information that may alter lambda rendering procedure. */
 type ConfigRenderLambdaFlags = {
   /**
@@ -4276,15 +4580,15 @@ interface ConfigRenderLambda<Return = unknown> extends ConfigRenderLambdaFlags {
   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 ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/block_api_v1.d.ts
+//#endregion
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.9/node_modules/@platforma-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;
@@ -4344,7 +4648,8 @@ interface BlockApiV1<Args = unknown, Outputs extends BlockOutputsBase = BlockOut
    * Sets block navigation state.
    * */
   setNavigationState(state: NavigationState<Href>): Promise<void>;
-} //#endregion
+}
+//#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>;
@@ -4379,7 +4684,7 @@ interface GetOperation<T> extends BaseOperation {
   value: T;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/block_api_v2.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.9/node_modules/@platforma-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}`> {
@@ -4427,14 +4732,15 @@ interface BlockApiV2<Args = unknown, Outputs extends BlockOutputsBase = BlockOut
    * Disposes the block API.
    * */
   dispose(): Promise<ResultOrError<void>>;
-} //#endregion
+}
+//#endregion
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/version.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.9/node_modules/@platforma-sdk/model/dist/version.d.ts
 type SdkInfo = {
   readonly sdkVersion: string;
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/services/block_services.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.9/node_modules/@platforma-sdk/model/dist/services/block_services.d.ts
 //#region src/services/block_services.d.ts
 /**
  * Services required by all V3 blocks by default.
@@ -4451,14 +4757,14 @@ declare const BLOCK_SERVICE_FLAGS: {
 };
 type BlockServiceFlags = typeof BLOCK_SERVICE_FLAGS;
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/services/service_resolve.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.9/node_modules/@platforma-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 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
+type BlockDefaultUiServices = ResolveUiServices<BlockServiceFlags>;
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/plugin_model.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.9/node_modules/@platforma-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.
@@ -4467,7 +4773,7 @@ type PublicOutputFieldDef = {
   readonly getter: (data: unknown) => unknown;
 };
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/block_api_v3.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.9/node_modules/@platforma-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}`> {
@@ -4496,9 +4802,10 @@ interface BlockApiV3<_Data = unknown, _Args = unknown, Outputs extends BlockOutp
    * Disposes the block API.
    * */
   dispose(): Promise<ResultOrError<void>>;
-} //#endregion
+}
+//#endregion
 //#endregion
-//#region ../node_modules/.pnpm/@platforma-sdk+model@1.82.0/node_modules/@platforma-sdk/model/dist/platforma.d.ts
+//#region ../node_modules/.pnpm/@platforma-sdk+model@1.83.9/node_modules/@platforma-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 {
@@ -4539,10 +4846,10 @@ type InferOutputsType<Pl extends Platforma> = Pl extends Platforma<unknown, infe
 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 ../node_modules/.pnpm/@milaboratories+pf-plots@1.4.6_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.82.0/node_modules/@milaboratories/pf-plots/dist/spec.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pf-plots@1.5.0_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.83.9/node_modules/@milaboratories/pf-plots/dist/spec.d.ts
 type ColumnOrAxisIdString = string;
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pf-plots@1.4.6_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.82.0/node_modules/@milaboratories/pf-plots/dist/common.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pf-plots@1.5.0_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.83.9/node_modules/@milaboratories/pf-plots/dist/common.d.ts
 type InputStateMap = Record<string, ComponentStateSimple | ComponentStateFilter>;
 type ChartType = 'discrete' | 'scatterplot' | 'scatterplot-umap' | 'heatmap' | 'dendro' | 'histogram' | 'bubble' | 'selection';
 interface InputStateParent<Type extends ChartType> {
@@ -4572,7 +4879,7 @@ interface ComponentStateFilter {
   selectorStates: SelectorStateFilter[];
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pf-plots@1.4.6_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.82.0/node_modules/@milaboratories/pf-plots/dist/controllers/controllersByChartType/bubble.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pf-plots@1.5.0_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.83.9/node_modules/@milaboratories/pf-plots/dist/controllers/controllersByChartType/bubble.d.ts
 interface BubbleUIState extends InputStateParent<'bubble'> {
   type: 'bubble';
   components: {
@@ -4591,7 +4898,7 @@ interface BubbleUIState extends InputStateParent<'bubble'> {
   };
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pf-plots@1.4.6_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.82.0/node_modules/@milaboratories/pf-plots/dist/controllers/controllersByChartType/dendro.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pf-plots@1.5.0_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.83.9/node_modules/@milaboratories/pf-plots/dist/controllers/controllersByChartType/dendro.d.ts
 interface DendroUIState extends InputStateParent<'dendro'> {
   components: {
     value: ComponentStateSimple;
@@ -4612,7 +4919,7 @@ interface DendroUIState extends InputStateParent<'dendro'> {
   };
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pf-plots@1.4.6_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.82.0/node_modules/@milaboratories/pf-plots/dist/controllers/controllersByChartType/discrete.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pf-plots@1.5.0_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.83.9/node_modules/@milaboratories/pf-plots/dist/controllers/controllersByChartType/discrete.d.ts
 interface DiscreteUIState extends InputStateParent<'discrete'> {
   type: 'discrete';
   components: {
@@ -4625,7 +4932,7 @@ interface DiscreteUIState extends InputStateParent<'discrete'> {
   };
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pf-plots@1.4.6_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.82.0/node_modules/@milaboratories/pf-plots/dist/controllers/controllersByChartType/heatmap.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pf-plots@1.5.0_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.83.9/node_modules/@milaboratories/pf-plots/dist/controllers/controllersByChartType/heatmap.d.ts
 interface HeatmapUIState extends InputStateParent<'heatmap'> {
   type: 'heatmap';
   components: {
@@ -4645,7 +4952,7 @@ interface HeatmapUIState extends InputStateParent<'heatmap'> {
   };
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pf-plots@1.4.6_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.82.0/node_modules/@milaboratories/pf-plots/dist/controllers/controllersByChartType/histogram.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pf-plots@1.5.0_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.83.9/node_modules/@milaboratories/pf-plots/dist/controllers/controllersByChartType/histogram.d.ts
 interface HistogramUIState extends InputStateParent<'histogram'> {
   type: 'histogram';
   components: {
@@ -4657,7 +4964,7 @@ interface HistogramUIState extends InputStateParent<'histogram'> {
   };
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pf-plots@1.4.6_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.82.0/node_modules/@milaboratories/pf-plots/dist/controllers/controllersByChartType/scatterplot.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pf-plots@1.5.0_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.83.9/node_modules/@milaboratories/pf-plots/dist/controllers/controllersByChartType/scatterplot.d.ts
 interface ScatterplotUIState extends InputStateParent<'scatterplot'> {
   type: 'scatterplot';
   components: {
@@ -4676,7 +4983,7 @@ interface ScatterplotUIState extends InputStateParent<'scatterplot'> {
   };
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pf-plots@1.4.6_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.82.0/node_modules/@milaboratories/pf-plots/dist/controllers/controllersByChartType/scatterplot-umap.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pf-plots@1.5.0_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.83.9/node_modules/@milaboratories/pf-plots/dist/controllers/controllersByChartType/scatterplot-umap.d.ts
 interface ScatterplotUmapUIState extends InputStateParent<'scatterplot-umap'> {
   type: 'scatterplot-umap';
   components: {
@@ -4694,7 +5001,7 @@ interface ScatterplotUmapUIState extends InputStateParent<'scatterplot-umap'> {
   };
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pf-plots@1.4.6_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.82.0/node_modules/@milaboratories/pf-plots/dist/controllers/controllersByChartType/selection.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+pf-plots@1.5.0_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.83.9/node_modules/@milaboratories/pf-plots/dist/controllers/controllersByChartType/selection.d.ts
 interface SelectionUIState extends InputStateParent<'selection'> {
   type: 'selection';
   components: {
@@ -4707,13 +5014,13 @@ interface SelectionUIState extends InputStateParent<'selection'> {
   };
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+pf-plots@1.4.6_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.82.0/node_modules/@milaboratories/pf-plots/dist/index.d.ts
-type InputNamesByChartType = { [K in ChartType]: K extends 'discrete' ? keyof DiscreteUIState['components'] : K extends 'heatmap' ? keyof HeatmapUIState['components'] : K extends 'dendro' ? keyof DendroUIState['components'] : K extends 'scatterplot' ? keyof ScatterplotUIState['components'] : K extends 'scatterplot-umap' ? keyof ScatterplotUmapUIState['components'] : K extends 'histogram' ? keyof HistogramUIState['components'] : K extends 'bubble' ? keyof BubbleUIState['components'] : K extends 'selection' ? keyof SelectionUIState['components'] : never };
+//#region ../node_modules/.pnpm/@milaboratories+pf-plots@1.5.0_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model@1.83.9/node_modules/@milaboratories/pf-plots/dist/index.d.ts
+type InputNamesByChartType = { [K in ChartType]: K extends 'discrete' ? keyof DiscreteUIState['components'] : K extends 'heatmap' ? keyof HeatmapUIState['components'] : K extends 'dendro' ? keyof DendroUIState['components'] : K extends 'scatterplot' ? keyof ScatterplotUIState['components'] : K extends 'scatterplot-umap' ? keyof ScatterplotUmapUIState['components'] : K extends 'histogram' ? keyof HistogramUIState['components'] : K extends 'bubble' ? keyof BubbleUIState['components'] : K extends 'selection' ? keyof SelectionUIState['components'] : never; };
 //#endregion
 //#region ../node_modules/.pnpm/@vue+shared@3.5.24/node_modules/@vue/shared/dist/shared.d.ts
-type Prettify<T> = { [K in keyof T]: T[K] } & {};
+type Prettify<T> = { [K in keyof T]: T[K]; } & {};
 type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
-type LooseRequired<T> = { [P in keyof (T & Required<T>)]: T[P] };
+type LooseRequired<T> = { [P in keyof (T & Required<T>)]: T[P]; };
 type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
 //#endregion
 //#region ../node_modules/.pnpm/@vue+reactivity@3.5.24/node_modules/@vue/reactivity/dist/reactivity.d.ts
@@ -4807,14 +5114,14 @@ type ShallowRef<T = any, S = T> = Ref<T, S> & {
  * ```
  */
 interface RefUnwrapBailTypes {}
-type ShallowUnwrapRef<T> = { [K in keyof T]: DistributeRef<T[K]> };
+type ShallowUnwrapRef<T> = { [K in keyof T]: DistributeRef<T[K]>; };
 type DistributeRef<T> = T extends Ref<infer V, unknown> ? V : T;
 type UnwrapRef<T> = T extends ShallowRef<infer V, unknown> ? V : T extends Ref<infer V, unknown> ? UnwrapRefSimple<V> : UnwrapRefSimple<T>;
 type UnwrapRefSimple<T> = T extends Builtin | Ref | RefUnwrapBailTypes[keyof RefUnwrapBailTypes] | {
   [RawSymbol]?: true;
-} ? T : T extends Map<infer K, infer V> ? Map<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Map<any, any>>> : T extends WeakMap<infer K, infer V> ? WeakMap<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakMap<any, any>>> : T extends Set<infer V> ? Set<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Set<any>>> : T extends WeakSet<infer V> ? WeakSet<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakSet<any>>> : T extends ReadonlyArray<any> ? { [K in keyof T]: UnwrapRefSimple<T[K]> } : T extends object & {
+} ? T : T extends Map<infer K, infer V> ? Map<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Map<any, any>>> : T extends WeakMap<infer K, infer V> ? WeakMap<K, UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakMap<any, any>>> : T extends Set<infer V> ? Set<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof Set<any>>> : T extends WeakSet<infer V> ? WeakSet<UnwrapRefSimple<V>> & UnwrapRef<Omit<T, keyof WeakSet<any>>> : T extends ReadonlyArray<any> ? { [K in keyof T]: UnwrapRefSimple<T[K]>; } : T extends object & {
   [ShallowReactiveMarker]?: never;
-} ? { [P in keyof T]: P extends symbol ? T[P] : UnwrapRef<T[P]> } : T;
+} ? { [P in keyof T]: P extends symbol ? T[P] : UnwrapRef<T[P]>; } : T;
 type WatchCallback<V = any, OV = any> = (value: V, oldValue: OV, onCleanup: OnCleanup) => any;
 type OnCleanup = (cleanupFn: () => void) => void;
 type WatchStopHandle = () => void;
@@ -4830,7 +5137,7 @@ type SlotsType<T extends Record<string, any> = Record<string, any>> = {
   [SlotSymbol]?: T;
 };
 type StrictUnwrapSlotsType<S extends SlotsType, T = NonNullable<S[typeof SlotSymbol]>> = [keyof S] extends [never] ? Slots : Readonly<T> & T;
-type UnwrapSlotsType<S extends SlotsType, T = NonNullable<S[typeof SlotSymbol]>> = [keyof S] extends [never] ? Slots : Readonly<Prettify<{ [K in keyof T]: NonNullable<T[K]> extends ((...args: any[]) => any) ? T[K] : Slot<T[K]> }>>;
+type UnwrapSlotsType<S extends SlotsType, T = NonNullable<S[typeof SlotSymbol]>> = [keyof S] extends [never] ? Slots : Readonly<Prettify<{ [K in keyof T]: NonNullable<T[K]> extends ((...args: any[]) => any) ? T[K] : Slot<T[K]>; }>>;
 type RawSlots = {
   [name: string]: unknown;
   $stable?: boolean;
@@ -4872,7 +5179,7 @@ interface SchedulerJob extends Function {
 declare function nextTick(): Promise<void>;
 declare function nextTick<T, R>(this: T, fn: (this: T) => R | Promise<R>): Promise<R>;
 type ComponentPropsOptions<P = Data$1> = ComponentObjectPropsOptions<P> | string[];
-type ComponentObjectPropsOptions<P = Data$1> = { [K in keyof P]: Prop<P[K]> | null };
+type ComponentObjectPropsOptions<P = Data$1> = { [K in keyof P]: Prop<P[K]> | null; };
 type Prop<T, D = T> = PropOptions<T, D> | PropType<T>;
 type DefaultFactory<T> = (props: Data$1) => T | null | undefined;
 interface PropOptions<T = any, D = T> {
@@ -4900,7 +5207,7 @@ type RequiredKeys<T> = { [K in keyof T]: T[K] extends {
   type: BooleanConstructor;
 } ? T[K] extends {
   default: undefined | (() => undefined);
-} ? never : K : never }[keyof T];
+} ? never : K : never; }[keyof T];
 type OptionalKeys<T> = Exclude<keyof T, RequiredKeys<T>>;
 type DefaultKeys<T> = { [K in keyof T]: T[K] extends {
   default: any;
@@ -4909,7 +5216,7 @@ type DefaultKeys<T> = { [K in keyof T]: T[K] extends {
 } ? T[K] extends {
   type: BooleanConstructor;
   required: true;
-} ? never : K : never }[keyof T];
+} ? never : K : never; }[keyof T];
 type InferPropType<T, NullAsAny = true> = [T] extends [null] ? NullAsAny extends true ? any : null : [T] extends [{
   type: null | true;
 }] ? any : [T] extends [ObjectConstructor | {
@@ -4932,8 +5239,8 @@ type InferPropType<T, NullAsAny = true> = [T] extends [null] ? NullAsAny extends
  */
 type ExtractPropTypes<O> = { [K in keyof Pick<O, RequiredKeys<O>>]: O[K] extends {
   default: any;
-} ? Exclude<InferPropType<O[K]>, undefined> : InferPropType<O[K]> } & { [K in keyof Pick<O, OptionalKeys<O>>]?: InferPropType<O[K]> };
-type ExtractDefaultPropTypes<O> = O extends object ? { [K in keyof Pick<O, DefaultKeys<O>>]: InferPropType<O[K]> } : {};
+} ? Exclude<InferPropType<O[K]>, undefined> : InferPropType<O[K]>; } & { [K in keyof Pick<O, OptionalKeys<O>>]?: InferPropType<O[K]>; };
+type ExtractDefaultPropTypes<O> = O extends object ? { [K in keyof Pick<O, DefaultKeys<O>>]: InferPropType<O[K]>; } : {};
 /**
  * Vue `<script setup>` compiler macro for declaring component props. The
  * expected argument is the same as the component `props` option.
@@ -4966,10 +5273,10 @@ type ExtractDefaultPropTypes<O> = O extends object ? { [K in keyof Pick<O, Defau
  * This is only usable inside `<script setup>`, is compiled away in the
  * output and should **not** be actually called at runtime.
  */
-declare function defineProps<PropNames extends string = string>(props: PropNames[]): Prettify<Readonly<{ [key in PropNames]?: any }>>;
+declare function defineProps<PropNames extends string = string>(props: PropNames[]): Prettify<Readonly<{ [key in PropNames]?: any; }>>;
 declare function defineProps<PP extends ComponentObjectPropsOptions = ComponentObjectPropsOptions>(props: PP): Prettify<Readonly<ExtractPropTypes<PP>>>;
 declare function defineProps<TypeProps>(): DefineProps<LooseRequired<TypeProps>, BooleanKey<TypeProps>>;
-type DefineProps<T, BKeys extends keyof T> = Readonly<T> & { readonly [K in BKeys]-?: boolean };
+type DefineProps<T, BKeys extends keyof T> = Readonly<T> & { readonly [K in BKeys]-?: boolean; };
 type BooleanKey<T, K extends keyof T = keyof T> = K extends any ? [T[K]] extends [boolean | undefined] ? K : never : never;
 /**
  * Vue `<script setup>` compiler macro for declaring a component's emitted
@@ -5002,7 +5309,7 @@ declare function defineEmits<E extends EmitsOptions = EmitsOptions>(emitOptions:
 declare function defineEmits<T extends ComponentTypeEmits>(): T extends ((...args: any[]) => any) ? T : ShortEmits<T>;
 type ComponentTypeEmits = ((...args: any[]) => any) | Record<string, any>;
 type RecordToUnion<T extends Record<string, any>> = T[keyof T];
-type ShortEmits<T extends Record<string, any>> = UnionToIntersection<RecordToUnion<{ [K in keyof T]: (evt: K, ...args: T[K]) => void }>>;
+type ShortEmits<T extends Record<string, any>> = UnionToIntersection<RecordToUnion<{ [K in keyof T]: (evt: K, ...args: T[K]) => void; }>>;
 /**
  * Vue `<script setup>` compiler macro for declaring a component's exposed
  * instance properties when it is accessed by a parent component via template
@@ -5095,11 +5402,11 @@ declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(na
 }) & PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T, M, G, S>;
 declare function defineModel<T, M extends PropertyKey = string, G = T, S = T>(name: string, options?: PropOptions<T> & DefineModelOptions<T, G, S>): ModelRef<T | undefined, M, G | undefined, S | undefined>;
 type NotUndefined<T> = T extends undefined ? never : T;
-type MappedOmit<T, K extends keyof any> = { [P in keyof T as P extends K ? never : P]: T[P] };
-type InferDefaults<T> = { [K in keyof T]?: InferDefault<T, T[K]> };
+type MappedOmit<T, K extends keyof any> = { [P in keyof T as P extends K ? never : P]: T[P]; };
+type InferDefaults<T> = { [K in keyof T]?: InferDefault<T, T[K]>; };
 type NativeType = null | undefined | number | string | boolean | symbol | Function;
 type InferDefault<P, T> = ((props: P) => T & {}) | (T extends NativeType ? T : never);
-type PropsWithDefaults<T, Defaults extends InferDefaults<T>, BKeys extends keyof T> = T extends unknown ? Readonly<MappedOmit<T, keyof Defaults>> & { readonly [K in keyof Defaults as K extends keyof T ? K : never]-?: K extends keyof T ? Defaults[K] extends undefined ? IfAny<Defaults[K], NotUndefined<T[K]>, T[K]> : NotUndefined<T[K]> : never } & { readonly [K in BKeys]-?: K extends keyof Defaults ? Defaults[K] extends undefined ? boolean | undefined : boolean : boolean } : never;
+type PropsWithDefaults<T, Defaults extends InferDefaults<T>, BKeys extends keyof T> = T extends unknown ? Readonly<MappedOmit<T, keyof Defaults>> & { readonly [K in keyof Defaults as K extends keyof T ? K : never]-?: K extends keyof T ? Defaults[K] extends undefined ? IfAny<Defaults[K], NotUndefined<T[K]>, T[K]> : NotUndefined<T[K]> : never; } & { readonly [K in BKeys]-?: K extends keyof Defaults ? Defaults[K] extends undefined ? boolean | undefined : boolean : boolean; } : never;
 /**
  * Vue `<script setup>` compiler macro for providing props default values when
  * using type-based `defineProps` declaration.
@@ -5123,9 +5430,9 @@ type PropsWithDefaults<T, Defaults extends InferDefaults<T>, BKeys extends keyof
 declare function withDefaults<T, BKeys extends keyof T, Defaults extends InferDefaults<T>>(props: DefineProps<T, BKeys>, defaults: Defaults): PropsWithDefaults<T, Defaults, BKeys>;
 type ObjectEmitsOptions = Record<string, ((...args: any[]) => any) | null>;
 type EmitsOptions = ObjectEmitsOptions | string[];
-type EmitsToProps<T extends EmitsOptions | ComponentTypeEmits> = T extends string[] ? { [K in `on${Capitalize<T[number]>}`]?: (...args: any[]) => any } : T extends ObjectEmitsOptions ? { [K in string & keyof T as `on${Capitalize<K>}`]?: (...args: T[K] extends ((...args: infer P) => any) ? P : T[K] extends null ? any[] : never) => any } : {};
-type ShortEmitsToObject<E> = E extends Record<string, any[]> ? { [K in keyof E]: (...args: E[K]) => any } : E;
-type EmitFn<Options = ObjectEmitsOptions, Event extends keyof Options = keyof Options> = Options extends Array<infer V> ? (event: V, ...args: any[]) => void : {} extends Options ? (event: string, ...args: any[]) => void : UnionToIntersection<{ [key in Event]: Options[key] extends ((...args: infer Args) => any) ? (event: key, ...args: Args) => void : Options[key] extends any[] ? (event: key, ...args: Options[key]) => void : (event: key, ...args: any[]) => void }[Event]>;
+type EmitsToProps<T extends EmitsOptions | ComponentTypeEmits> = T extends string[] ? { [K in `on${Capitalize<T[number]>}`]?: (...args: any[]) => any; } : T extends ObjectEmitsOptions ? { [K in string & keyof T as `on${Capitalize<K>}`]?: (...args: T[K] extends ((...args: infer P) => any) ? P : T[K] extends null ? any[] : never) => any; } : {};
+type ShortEmitsToObject<E> = E extends Record<string, any[]> ? { [K in keyof E]: (...args: E[K]) => any; } : E;
+type EmitFn<Options = ObjectEmitsOptions, Event extends keyof Options = keyof Options> = Options extends Array<infer V> ? (event: V, ...args: any[]) => void : {} extends Options ? (event: string, ...args: any[]) => void : UnionToIntersection<{ [key in Event]: Options[key] extends ((...args: infer Args) => any) ? (event: key, ...args: Args) => void : Options[key] extends any[] ? (event: key, ...args: Options[key]) => void : (event: key, ...args: any[]) => void; }[Event]>;
 /**
 Runtime helper for applying directives to a vnode. Example usage:
 
@@ -5202,10 +5509,6 @@ type ComponentPublicInstanceConstructor<T extends ComponentPublicInstance<Props,
   __isSuspense?: never;
   new (...args: any[]): T;
 };
-/**
- * @deprecated This is no longer used internally, but exported and relied on by
- * existing library types generated by vue-tsc.
- */
 /**
  * This is the same as `CreateComponentPublicInstance` but adds local components,
  * global directives, exposed, and provide inference.
@@ -5215,10 +5518,10 @@ type ComponentPublicInstanceConstructor<T extends ComponentPublicInstance<Props,
  */
 type CreateComponentPublicInstanceWithMixins<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, PublicProps = P, Defaults = {}, MakeDefaultsOptional extends boolean = false, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, LC extends Record<string, Component> = {}, Directives extends Record<string, Directive> = {}, Exposed extends string = string, TypeRefs extends Data$1 = {}, TypeEl extends Element = any, Provide extends ComponentProvideOptions = ComponentProvideOptions, PublicMixin = IntersectionMixin<Mixin> & IntersectionMixin<Extends>, PublicP = UnwrapMixinsType<PublicMixin, 'P'> & EnsureNonVoid<P>, PublicB = UnwrapMixinsType<PublicMixin, 'B'> & EnsureNonVoid<B>, PublicD = UnwrapMixinsType<PublicMixin, 'D'> & EnsureNonVoid<D>, PublicC extends ComputedOptions = UnwrapMixinsType<PublicMixin, 'C'> & EnsureNonVoid<C>, PublicM extends MethodOptions = UnwrapMixinsType<PublicMixin, 'M'> & EnsureNonVoid<M>, PublicDefaults = UnwrapMixinsType<PublicMixin, 'Defaults'> & EnsureNonVoid<Defaults>> = ComponentPublicInstance<PublicP, PublicB, PublicD, PublicC, PublicM, E, PublicProps, PublicDefaults, MakeDefaultsOptional, ComponentOptionsBase<P, B, D, C, M, Mixin, Extends, E, string, Defaults, {}, string, S, LC, Directives, Exposed, Provide>, I, S, Exposed, TypeRefs, TypeEl>;
 type ExposedKeys<T, Exposed extends string & keyof T> = '' extends Exposed ? T : Pick<T, Exposed>;
-type ComponentPublicInstance<P = {}, // props type extracted from props option
-B = {}, // raw bindings returned from setup()
-D = {}, // return from data()
-C extends ComputedOptions = {}, M extends MethodOptions = {}, E extends EmitsOptions = {}, PublicProps = {}, Defaults = {}, MakeDefaultsOptional extends boolean = false, Options = ComponentOptionsBase<any, any, any, any, any, any, any, any, any>, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, Exposed extends string = '', TypeRefs extends Data$1 = {}, TypeEl extends Element = any> = {
+type ComponentPublicInstance<P = {} // props type extracted from props option
+, B = {} // raw bindings returned from setup()
+, D = {} // return from data()
+, C extends ComputedOptions = {}, M extends MethodOptions = {}, E extends EmitsOptions = {}, PublicProps = {}, Defaults = {}, MakeDefaultsOptional extends boolean = false, Options = ComponentOptionsBase<any, any, any, any, any, any, any, any, any>, I extends ComponentInjectOptions = {}, S extends SlotsType = {}, Exposed extends string = '', TypeRefs extends Data$1 = {}, TypeEl extends Element = any> = {
   $: ComponentInternalInstance;
   $data: D;
   $props: MakeDefaultsOptional extends true ? Partial<Defaults> & Omit<Prettify<P> & PublicProps, keyof Defaults> : Prettify<P> & PublicProps;
@@ -5353,8 +5656,8 @@ interface RendererInternals<HostNode = RendererNode, HostElement = RendererEleme
   n: NextFn;
   o: RendererOptions<HostNode, HostElement>;
 }
-type PatchFn = (n1: VNode | null, // null means this is a mount
-n2: VNode, container: RendererElement, anchor?: RendererNode | null, parentComponent?: ComponentInternalInstance | null, parentSuspense?: SuspenseBoundary | null, namespace?: ElementNamespace, slotScopeIds?: string[] | null, optimized?: boolean) => void;
+type PatchFn = (n1: VNode | null // null means this is a mount
+, n2: VNode, container: RendererElement, anchor?: RendererNode | null, parentComponent?: ComponentInternalInstance | null, parentSuspense?: SuspenseBoundary | null, namespace?: ElementNamespace, slotScopeIds?: string[] | null, optimized?: boolean) => void;
 type MountChildrenFn = (children: VNodeArrayChildren, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, start?: number) => void;
 type PatchChildrenFn = (n1: VNode | null, n2: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean) => void;
 type PatchBlockChildrenFn = (oldChildren: VNode[], newChildren: VNode[], fallbackContainer: RendererElement, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null) => void;
@@ -5369,21 +5672,6 @@ declare enum MoveType {
   LEAVE = 1,
   REORDER = 2
 }
-/**
- * The createRenderer function accepts two generic arguments:
- * HostNode and HostElement, corresponding to Node and Element types in the
- * host environment. For example, for runtime-dom, HostNode would be the DOM
- * `Node` interface and HostElement would be the DOM `Element` interface.
- *
- * Custom renderers can pass in the platform specific types like this:
- *
- * ``` js
- * const { render, createApp } = createRenderer<Node, Element>({
- *   patchProp,
- *   ...nodeOps
- * })
- * ```
- */
 type MatchPattern = string | RegExp | (string | RegExp)[];
 interface KeepAliveProps {
   include?: MatchPattern;
@@ -5493,7 +5781,7 @@ interface MethodOptions {
 }
 type ExtractComputedReturns<T extends any> = { [key in keyof T]: T[key] extends {
   get: (...args: any[]) => infer TReturn;
-} ? TReturn : T[key] extends ((...args: any[]) => infer TReturn) ? TReturn : never };
+} ? TReturn : T[key] extends ((...args: any[]) => infer TReturn) ? TReturn : never; };
 type ObjectWatchOptionItem = {
   handler: WatchCallback | string;
 } & WatchOptions;
@@ -5507,7 +5795,7 @@ type ObjectInjectOptions = Record<string | symbol, string | symbol | {
   from?: string | symbol;
   default?: unknown;
 }>;
-type InjectToObject<T extends ComponentInjectOptions> = T extends string[] ? { [K in T[number]]?: unknown } : T extends ObjectInjectOptions ? { [K in keyof T]?: unknown } : never;
+type InjectToObject<T extends ComponentInjectOptions> = T extends string[] ? { [K in T[number]]?: unknown; } : T extends ObjectInjectOptions ? { [K in keyof T]?: unknown; } : never;
 interface LegacyOptions<Props, D, C extends ComputedOptions, M extends MethodOptions, Mixin extends ComponentOptionsMixin, Extends extends ComponentOptionsMixin, I extends ComponentInjectOptions, II extends string, Provide extends ComponentProvideOptions = ComponentProvideOptions> {
   compatConfig?: CompatConfig;
   [key: string]: any;
@@ -5561,9 +5849,11 @@ type MergedComponentOptionsOverride = {
   beforeUpdate?: MergedHook;
   updated?: MergedHook;
   activated?: MergedHook;
-  deactivated?: MergedHook; /** @deprecated use `beforeUnmount` instead */
+  deactivated?: MergedHook;
+  /** @deprecated use `beforeUnmount` instead */
   beforeDestroy?: MergedHook;
-  beforeUnmount?: MergedHook; /** @deprecated use `unmounted` instead */
+  beforeUnmount?: MergedHook;
+  /** @deprecated use `unmounted` instead */
   destroyed?: MergedHook;
   unmounted?: MergedHook;
   renderTracked?: MergedHook<DebuggerHook>;
@@ -5579,9 +5869,6 @@ type OptionTypesType<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M e
   M: M;
   Defaults: Defaults;
 };
-/**
- * @deprecated
- */
 interface InjectionConstraint<T> {}
 type InjectionKey<T> = symbol & InjectionConstraint<T>;
 type PublicProps = VNodeProps & AllowedComponentProps & ComponentCustomProps;
@@ -5601,17 +5888,14 @@ interface App<HostElement = any> {
   /**
    * @internal
    */
-
   isHydrate?: boolean,
   /**
    * @internal
    */
-
   namespace?: boolean | ElementNamespace,
   /**
    * @internal
    */
-
   vnode?: VNode): ComponentPublicInstance;
   unmount(): void;
   onUnmount(cb: () => void): void;
@@ -5681,7 +5965,7 @@ type ObjectPlugin<Options = any[]> = {
   install: PluginInstallFunction<Options>;
 };
 type FunctionPlugin<Options = any[]> = PluginInstallFunction<Options> & Partial<ObjectPlugin<Options>>;
-type Plugin<Options = any[], P extends unknown[] = (Options extends unknown[] ? Options : [Options])> = FunctionPlugin<P> | ObjectPlugin<P>;
+type Plugin<Options = any[], P extends unknown[] = Options extends unknown[] ? Options : [Options]> = FunctionPlugin<P> | ObjectPlugin<P>;
 type TeleportVNode = VNode<RendererNode, RendererElement, TeleportProps>;
 interface TeleportProps {
   to: string | RendererElement | null | undefined;
@@ -5692,36 +5976,18 @@ declare const TeleportImpl: {
   name: string;
   __isTeleport: boolean;
   process(n1: TeleportVNode | null, n2: TeleportVNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, internals: RendererInternals): void;
-  remove(vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, {
-    um: unmount,
-    o: {
-      remove: hostRemove
-    }
-  }: RendererInternals, doRemove: boolean): void;
+  remove(vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, { um: unmount, o: { remove: hostRemove } }: RendererInternals, doRemove: boolean): void;
   move: typeof moveTeleport;
   hydrate: typeof hydrateTeleport;
 };
 declare enum TeleportMoveTypes {
   TARGET_CHANGE = 0,
-  TOGGLE = 1,
-  // enable / disable
+  TOGGLE = 1 // enable / disable
+  ,
   REORDER = 2
 }
-declare function moveTeleport(vnode: VNode, container: RendererElement, parentAnchor: RendererNode | null, {
-  o: {
-    insert
-  },
-  m: move
-}: RendererInternals, moveType?: TeleportMoveTypes): void;
-declare function hydrateTeleport(node: Node, vnode: TeleportVNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean, {
-  o: {
-    nextSibling,
-    parentNode,
-    querySelector,
-    insert,
-    createText
-  }
-}: RendererInternals<Node, Element>, hydrateChildren: (node: Node | null, vnode: VNode, container: Element, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean) => Node | null): Node | null;
+declare function moveTeleport(vnode: VNode, container: RendererElement, parentAnchor: RendererNode | null, { o: { insert }, m: move }: RendererInternals, moveType?: TeleportMoveTypes): void;
+declare function hydrateTeleport(node: Node, vnode: TeleportVNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean, { o: { nextSibling, parentNode, querySelector, insert, createText } }: RendererInternals<Node, Element>, hydrateChildren: (node: Node | null, vnode: VNode, container: Element, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean) => Node | null): Node | null;
 declare const Teleport: {
   __isTeleport: true;
   new (): {
@@ -5807,18 +6073,6 @@ interface VNode<HostNode = RendererNode, HostElement = RendererElement, ExtraPro
   appContext: AppContext | null;
 }
 type Data$1 = Record<string, unknown>;
-/**
- * Public utility type for extracting the instance type of a component.
- * Works with all valid component definition types. This is intended to replace
- * the usage of `InstanceType<typeof Comp>` which only works for
- * constructor-based component definition types.
- *
- * @example
- * ```ts
- * const MyComp = { ... }
- * declare const instance: ComponentInstance<typeof MyComp>
- * ```
- */
 /**
  * For extending allowed non-declared props on components in TSX
  */
@@ -5975,7 +6229,8 @@ declare module '@vue/runtime-core' {
     KeepAlive: DefineComponent<KeepAliveProps>;
     BaseTransition: DefineComponent<BaseTransitionProps>;
   }
-} // Note: this file is auto concatenated to the end of the bundled d.ts during
+}
+// Note: this file is auto concatenated to the end of the bundled d.ts during
 // build.
 type _defineProps = typeof defineProps;
 type _defineEmits = typeof defineEmits;
@@ -6034,13 +6289,7 @@ type SystemModifiers = (typeof systemModifiers)[number];
 type CompatModifiers = keyof typeof keyNames;
 type VOnModifiers = SystemModifiers | ModifierGuards | CompatModifiers;
 type ModifierGuards = 'shift' | 'ctrl' | 'alt' | 'meta' | 'left' | 'right' | 'stop' | 'prevent' | 'self' | 'middle' | 'exact';
-/**
- * @private
- */
 declare const keyNames: Record<'esc' | 'space' | 'up' | 'left' | 'right' | 'down' | 'delete', string>;
-/**
- * @private
- */
 type VOnDirective = Directive<any, any, VOnModifiers>;
 type AssignerFn = (value: any) => void;
 declare const assignKey: unique symbol;
@@ -6082,7 +6331,7 @@ declare module '@vue/runtime-core' {
   }
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+graph-maker@1.4.8_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model_odhcalrtmfkwa6guyyg5unhcdy/node_modules/@milaboratories/graph-maker/dist/dataBindAes.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+graph-maker@1.8.0_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model_rmi4yoexe2owj33sow37pnjvh4/node_modules/@milaboratories/graph-maker/dist/dataBindAes.d.ts
 /** Mapping for categorical axes (string axes) */
 interface AestheticMappingCategorical {
   type: 'categorical';
@@ -6103,7 +6352,7 @@ interface AestheticValues {
   dotShape: DotShape;
 }
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+graph-maker@1.4.8_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model_odhcalrtmfkwa6guyyg5unhcdy/node_modules/@milaboratories/graph-maker/dist/components/AesSettings/types.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+graph-maker@1.8.0_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model_rmi4yoexe2owj33sow37pnjvh4/node_modules/@milaboratories/graph-maker/dist/components/AesSettings/types.d.ts
 type CategoricalPalette = 'light' | 'bright' | 'dark' | 'paired' | 'triadic' | 'magnetic';
 type SequentialPalette = 'viridis' | 'magma' | 'density' | 'salinity' | 'sunset' | 'perceptual_rainbow';
 type DivergingPalette = 'spectrum' | 'teal_red' | 'blue_red' | 'lime_rose' | 'viridis_magma';
@@ -6112,7 +6361,14 @@ type Palette = CategoricalPalette | ContinuousPalette;
 type DotShape = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | '11' | '12' | '13' | '14' | '21' | '22' | '23' | '24' | '25';
 type LineType = 'solid' | 'dashed' | 'dotted' | 'dotdash' | 'longdash' | 'twodash';
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+graph-maker@1.4.8_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model_odhcalrtmfkwa6guyyg5unhcdy/node_modules/@milaboratories/graph-maker/dist/constantsCommon.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+graph-maker@1.8.0_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model_rmi4yoexe2owj33sow37pnjvh4/node_modules/@milaboratories/graph-maker/dist/utils/createChartSettingsForRender/resolveLabelParts.d.ts
+type LabelPartsOverlay = {
+  order: string[];
+  hidden?: Record<string, boolean>;
+};
+type LabelPartsState = LabelPartsOverlay | null;
+//#endregion
+//#region ../node_modules/.pnpm/@milaboratories+graph-maker@1.8.0_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model_rmi4yoexe2owj33sow37pnjvh4/node_modules/@milaboratories/graph-maker/dist/constantsCommon.d.ts
 type DiscreteStatisticsState = {
   overall: {
     data: {
@@ -6152,6 +6408,7 @@ type ScatterplotStatisticsState = {
     on: boolean;
     trim: boolean;
     showLegend: boolean;
+    lineWidth: number;
   };
   additionalCurveTrends: Record<string, {
     on: boolean;
@@ -6239,6 +6496,7 @@ type LayersSettings = {
   curve: {
     smoothing: boolean;
     lineColor: ColorAes;
+    lineWidth: number;
   };
   additionalCurves: {
     smoothing: boolean;
@@ -6315,7 +6573,9 @@ type LayersSettings = {
     emptyGroupValue: number;
     lineColor: ColorAes | null;
     dotShape: DotShapeAes;
+    dotSize: number;
     lineType: LineTypeAes;
+    lineWidth: number;
     dotFill: ColorAes | null;
     opacity: number;
   };
@@ -6324,6 +6584,8 @@ type LayersSettings = {
     interval: 'sd' | 'se' | '';
     lineColor: ColorAes | null;
     dotShape: DotShapeAes;
+    dotSize: number;
+    lineWidth: number;
     dotFill: ColorAes | null;
     opacity: number;
   };
@@ -6376,6 +6638,7 @@ type AxesState = {
     annotationTitlePosition: 'left' | 'right' | 'hidden';
     hideAxisLabels: boolean;
     hideAxisGroupLabels: boolean;
+    labelParts: LabelPartsState;
   };
   axisY: {
     labelsRotation: LabelsRotation | null;
@@ -6399,6 +6662,8 @@ type AxesState = {
     annotationTitlePosition: 'top' | 'bottom' | 'hidden';
     hideAxisLabels: boolean;
     hideAxisGroupLabels: boolean;
+    /** Mirror of axisX.labelParts; see axisX for full semantics. */
+    labelParts: LabelPartsState;
   };
   legend: {
     show?: boolean;
@@ -6413,21 +6678,23 @@ type AxesState = {
     groupingStack: 'vertical' | 'horizontal';
     canvasRenderMode: boolean;
     showLegend: boolean;
-    nullValueLabel: string; /** Max number of unique values saved per source (group/axis); over this limit sets overflow */
-    maxGroupCount: number; /** Max number of facet values saved per facetBy column; over this limit sets overflow */
+    nullValueLabel: string;
+    /** Max number of unique values saved per source (group/axis); over this limit sets overflow */
+    maxGroupCount: number;
+    /** Max number of facet values saved per facetBy column; over this limit sets overflow */
     maxFacetsCount: number;
   };
 };
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+uikit@2.15.25_@vue+compiler-dom@3.5.39_@vue+server-renderer@3.5.24_vue@3.5.24_vmdfu5yztq7e55uj55xznpiuxi/node_modules/@milaboratories/uikit/dist/types.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+uikit@2.15.29_@vue+compiler-dom@3.5.39_@vue+server-renderer@3.5.24_vue@3.5.24_w7wd5ao6o5bg3ihsrmlty7jpwm/node_modules/@milaboratories/uikit/dist/types.d.ts
 declare global {
   var platforma: Platforma | undefined;
   interface Window {
     platforma: Platforma | undefined;
   }
-} //# sourceMappingURL=types.d.ts.map
+}
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+graph-maker@1.4.8_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model_odhcalrtmfkwa6guyyg5unhcdy/node_modules/@milaboratories/graph-maker/dist/forms/index.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+graph-maker@1.8.0_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model_rmi4yoexe2owj33sow37pnjvh4/node_modules/@milaboratories/graph-maker/dist/forms/index.d.ts
 declare const forms: {
   settings: {
     icon: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, SVGSVGElement>;
@@ -6532,32 +6799,43 @@ declare const forms: {
 };
 type FormKey = keyof typeof forms;
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+miplots4@1.2.3_d3-dispatch@3.0.1_d3-path@3.1.0_d3-scale-chromatic@3.1.0/node_modules/@milaboratories/miplots4/dist/scatterplot-umap/types.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+miplots4@1.5.0_d3-dispatch@3.0.1_d3-path@3.1.0_d3-scale-chromatic@3.1.0/node_modules/@milaboratories/miplots4/dist/scatterplot-umap/types.d.ts
 type Point = [number, number];
 type Polygon = {
   points: Point[];
   closed: boolean;
 };
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+graph-maker@1.4.8_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model_odhcalrtmfkwa6guyyg5unhcdy/node_modules/@milaboratories/graph-maker/dist/utils/loadDefaultSources.d.ts
+//#region ../node_modules/.pnpm/@milaboratories+graph-maker@1.8.0_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model_rmi4yoexe2owj33sow37pnjvh4/node_modules/@milaboratories/graph-maker/dist/utils/loadDefaultSources.d.ts
 type LoadedDefaultOptionsMap<T extends ChartType> = Record<InputNamesByChartType[T], (SelectorStateFilter | SelectorStateSimple)[]>;
 //#endregion
-//#region ../node_modules/.pnpm/@milaboratories+graph-maker@1.4.8_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model_odhcalrtmfkwa6guyyg5unhcdy/node_modules/@milaboratories/graph-maker/dist/types.d.ts
-type DeepPartial$1<T> = { [P in keyof T]?: Partial<T[P]> };
+//#region ../node_modules/.pnpm/@milaboratories+graph-maker@1.8.0_@milaboratories+pl-model-common@1.48.0_@platforma-sdk+model_rmi4yoexe2owj33sow37pnjvh4/node_modules/@milaboratories/graph-maker/dist/types.d.ts
+type DeepPartial$1<T> = { [P in keyof T]?: Partial<T[P]>; };
 type GraphMakerState = {
-  /** Editable title on the top */title: string; /** 'box', 'violins', 'dots' etc, depends on chart type */
+  /** Editable title on the top */
+  title: string;
+  /** 'box', 'violins', 'dots' etc, depends on chart type */
   template: LayersTemplate;
   /** Optional part, used for data saving to ui-state; don't need to be set in initial settings,
-    it appears in settings after changes in user interface */
-  currentTab?: FormKey | null; /** Value of current zoom in percents, by default 100 */
-  zoomState?: number; /** Lasso state for scatterplot */
-  selectedPolygons?: Polygon[]; /** Data-mapping state, use inner-generated keys to keep selected columns, use default-options prop to set defaults */
-  optionsState?: InputState; /** Technical field, used to keep track of used default options to avoid erasing of user's changes or not applying changed defaults */
-  usedDefaultOptions?: LoadedDefaultOptionsMap<ChartType>; /** Saved settings of p-value (for discrete charts), trends (for scatterplot) */
-  statisticsSettings?: DeepPartial$1<StatisticsState>; /** Settings of grid, axes titles, facet positions, grouping order */
-  axesSettings?: DeepPartial$1<AxesState>; /** Settings for every type of layer, aesthetics */
-  layersSettings?: DeepPartial$1<LayersSettings>; /** Saved palettes and color-mapping settings linked to columns/axes */
-  dataBindAes?: Record<string, AestheticMappingCategorical>; /** Technical field, used to keep track of tooltip hint was shown to avoid showing it again */
+      it appears in settings after changes in user interface */
+  currentTab?: FormKey | null;
+  /** Value of current zoom in percents, by default 100 */
+  zoomState?: number;
+  /** Lasso state for scatterplot */
+  selectedPolygons?: Polygon[];
+  /** Data-mapping state, use inner-generated keys to keep selected columns, use default-options prop to set defaults */
+  optionsState?: InputState;
+  /** Technical field, used to keep track of used default options to avoid erasing of user's changes or not applying changed defaults */
+  usedDefaultOptions?: LoadedDefaultOptionsMap<ChartType>;
+  /** Saved settings of p-value (for discrete charts), trends (for scatterplot) */
+  statisticsSettings?: DeepPartial$1<StatisticsState>;
+  /** Settings of grid, axes titles, facet positions, grouping order */
+  axesSettings?: DeepPartial$1<AxesState>;
+  /** Settings for every type of layer, aesthetics */
+  layersSettings?: DeepPartial$1<LayersSettings>;
+  /** Saved palettes and color-mapping settings linked to columns/axes */
+  dataBindAes?: Record<string, AestheticMappingCategorical>;
+  /** Technical field, used to keep track of tooltip hint was shown to avoid showing it again */
   tooltipHintWasShown?: boolean;
 };
 type DiscreteLayer = 'box' | 'binnedDots' | 'jitteredDots' | 'violin' | 'bar' | 'stackedBar' | 'stackedArea' | 'line' | 'errorbar' | 'sina' | 'logo';
@@ -6586,7 +6864,8 @@ type HeatmapFrame = 'full' | 'none';
 //#region ../model/dist/index.d.ts
 /** Workflow-facing args, derived from `BlockData`. */
 type BlockArgs = {
-  /** Profiler state matrix `[variantKey, parentId, position] -> state`. */stateMatrixRef: PlRef;
+  /** Profiler state matrix `[variantKey, parentId, position] -> state`. */
+  stateMatrixRef: PlRef;
   /** Parent to scope the whole plot to. Required — the args projection throws until it is set
    *  (the UI auto-selects the first parent), so the workflow only ever runs single-parent. */
   selectedParentId: string;
@@ -6628,30 +6907,27 @@ type BlockUiState = {
    */
   selectedLandscapeScore?: string;
 };
-/** Data version `v1`: one faceted landscape chart, so one chart state. */
 /** Unified persisted data: workflow-relevant selections + UI view state. */
 type BlockData$1 = {
   customBlockLabel?: string;
   defaultBlockLabel?: string;
-  stateMatrixRef?: PlRef; /** Parent the plot is scoped to (UI auto-selects the first available on load). */
-  selectedParentId?: string; /** Ordered per-round frequency columns; `[0]` = baseline R0. Empty = composition view off. */
-  roundFrequencyRefs: SUniversalPColumnId[]; /** Fraction-space epsilon for the composition ratio (default 1e-6). */
-  compositionEpsilon: number; /** Ordered per-variant score columns for the mutation landscape. Empty = no map rendered. */
+  stateMatrixRef?: PlRef;
+  /** Parent the plot is scoped to (UI auto-selects the first available on load). */
+  selectedParentId?: string;
+  /** Ordered per-round frequency columns; `[0]` = baseline R0. Empty = composition view off. */
+  roundFrequencyRefs: SUniversalPColumnId[];
+  /** Fraction-space epsilon for the composition ratio (default 1e-6). */
+  compositionEpsilon: number;
+  /** Ordered per-variant score columns for the mutation landscape. Empty = no map rendered. */
   scoreRefs: SUniversalPColumnId[];
 } & BlockUiState;
-/**
- * Default state for a mutation-landscape chart. Used by `init` for the placeholder and by the UI
- * for each score a run produces, so the two look alike.
- *
- * @param currentTab `"settings"` opens the Settings drawer, `null` leaves it closed
- */
-declare const platforma: PlatformaExtended<PlatformaV3<BlockData$1, BlockArgs, InferOutputsFromLambdas<{
+export declare const platforma: PlatformaExtended<PlatformaV3<BlockData$1, BlockArgs, InferOutputsFromLambdas<{
   stateMatrixOptions: ConfigRenderLambda<{
     readonly ref: {
       readonly __isRef: true;
       readonly blockId: string;
       readonly name: string;
-      readonly requireEnrichments?: true | undefined | undefined;
+      readonly requireEnrichments?: true | undefined;
     };
     readonly label: string;
   }[]>;
@@ -6675,35 +6951,6 @@ declare const platforma: PlatformaExtended<PlatformaV3<BlockData$1, BlockArgs, I
   };
 } & {
   singleMutantHeatmapPCols: ConfigRenderLambda<{
-    readonly spec: {
-      readonly kind: "PColumn";
-      readonly name: string;
-      readonly domain?: {
-        [x: string]: string;
-      } | undefined;
-      readonly contextDomain?: {
-        [x: string]: string;
-      } | undefined;
-      readonly annotations?: {
-        [x: string]: string;
-      } | undefined;
-      readonly valueType: "Int" | "Long" | "Float" | "Double" | "String" | "Bytes";
-      readonly parentAxes?: number[] | undefined;
-      readonly axesSpec: {
-        readonly type: AxisValueType;
-        readonly name: string;
-        readonly domain?: {
-          [x: string]: string;
-        } | undefined;
-        readonly contextDomain?: {
-          [x: string]: string;
-        } | undefined;
-        readonly annotations?: {
-          [x: string]: string;
-        } | undefined;
-        readonly parentAxes?: number[] | undefined;
-      }[];
-    };
     readonly id: PObjectId;
     readonly data: {
       readonly handle: AccessorHandle;
@@ -6753,13 +7000,7 @@ declare const platforma: PlatformaExtended<PlatformaV3<BlockData$1, BlockArgs, I
       allFieldsResolved: {};
       mapFields: {};
     };
-  }[] | undefined>;
-} & {
-  landscapePanels: ConfigRenderLambda<{
-    key: string;
-    label: string;
-    index: number;
-    spec: {
+    readonly spec: {
       readonly kind: "PColumn";
       readonly name: string;
       readonly domain?: {
@@ -6771,8 +7012,8 @@ declare const platforma: PlatformaExtended<PlatformaV3<BlockData$1, BlockArgs, I
       readonly annotations?: {
         [x: string]: string;
       } | undefined;
-      readonly valueType: "Int" | "Long" | "Float" | "Double" | "String" | "Bytes";
-      readonly parentAxes?: number[] | undefined;
+      readonly valueType: "Bytes" | "Double" | "Float" | "Int" | "Long" | "String";
+      readonly parentAxes?: number[];
       readonly axesSpec: {
         readonly type: AxisValueType;
         readonly name: string;
@@ -6785,17 +7026,16 @@ declare const platforma: PlatformaExtended<PlatformaV3<BlockData$1, BlockArgs, I
         readonly annotations?: {
           [x: string]: string;
         } | undefined;
-        readonly parentAxes?: number[] | undefined;
+        readonly parentAxes?: number[];
       }[];
     };
   }[] | undefined>;
 } & {
-  compositionHeatmapPf: ConfigRenderLambda<PFrameHandle | undefined> & {
-    withStatus: true;
-  };
-} & {
-  compositionHeatmapPCols: ConfigRenderLambda<{
-    readonly spec: {
+  landscapePanels: ConfigRenderLambda<{
+    key: string;
+    label: string;
+    index: number;
+    spec: {
       readonly kind: "PColumn";
       readonly name: string;
       readonly domain?: {
@@ -6807,8 +7047,8 @@ declare const platforma: PlatformaExtended<PlatformaV3<BlockData$1, BlockArgs, I
       readonly annotations?: {
         [x: string]: string;
       } | undefined;
-      readonly valueType: "Int" | "Long" | "Float" | "Double" | "String" | "Bytes";
-      readonly parentAxes?: number[] | undefined;
+      readonly valueType: "Bytes" | "Double" | "Float" | "Int" | "Long" | "String";
+      readonly parentAxes?: number[];
       readonly axesSpec: {
         readonly type: AxisValueType;
         readonly name: string;
@@ -6821,9 +7061,16 @@ declare const platforma: PlatformaExtended<PlatformaV3<BlockData$1, BlockArgs, I
         readonly annotations?: {
           [x: string]: string;
         } | undefined;
-        readonly parentAxes?: number[] | undefined;
+        readonly parentAxes?: number[];
       }[];
     };
+  }[] | undefined>;
+} & {
+  compositionHeatmapPf: ConfigRenderLambda<PFrameHandle | undefined> & {
+    withStatus: true;
+  };
+} & {
+  compositionHeatmapPCols: ConfigRenderLambda<{
     readonly id: PObjectId;
     readonly data: {
       readonly handle: AccessorHandle;
@@ -6873,32 +7120,60 @@ declare const platforma: PlatformaExtended<PlatformaV3<BlockData$1, BlockArgs, I
       allFieldsResolved: {};
       mapFields: {};
     };
+    readonly spec: {
+      readonly kind: "PColumn";
+      readonly name: string;
+      readonly domain?: {
+        [x: string]: string;
+      } | undefined;
+      readonly contextDomain?: {
+        [x: string]: string;
+      } | undefined;
+      readonly annotations?: {
+        [x: string]: string;
+      } | undefined;
+      readonly valueType: "Bytes" | "Double" | "Float" | "Int" | "Long" | "String";
+      readonly parentAxes?: number[];
+      readonly axesSpec: {
+        readonly type: AxisValueType;
+        readonly name: string;
+        readonly domain?: {
+          [x: string]: string;
+        } | undefined;
+        readonly contextDomain?: {
+          [x: string]: string;
+        } | undefined;
+        readonly annotations?: {
+          [x: string]: string;
+        } | undefined;
+        readonly parentAxes?: number[];
+      }[];
+    };
   }[] | undefined>;
 } & {
   isRunning: ConfigRenderLambda<boolean>;
 }>, `/${string}`, {}, BlockDefaultUiServices>>;
 //#endregion
 //#region src/index.d.ts
-type BlockContract = {
+export type BlockContract = {
   outputs: InferOutputsType<typeof platforma>;
   data: InferDataType<typeof platforma>;
   href: InferHrefType<typeof platforma>;
 };
-type BlockOutputs = BlockContract["outputs"];
-type BlockData = BlockContract["data"];
-declare const BlockPointer: {
+export type BlockOutputs = BlockContract["outputs"];
+export type BlockData = BlockContract["data"];
+export declare const BlockPointer: {
   readonly type: "from-pack-v2";
   readonly packUrl: string;
   readonly rootUrl: string;
 };
-type RepertoireMutationHeatmapBlockContract = BlockContract;
-type RepertoireMutationHeatmapBlockOutputs = BlockOutputs;
-type RepertoireMutationHeatmapBlockData = BlockData;
-declare const RepertoireMutationHeatmapBlockPointer: {
+export type RepertoireMutationHeatmapBlockContract = BlockContract;
+export type RepertoireMutationHeatmapBlockOutputs = BlockOutputs;
+export type RepertoireMutationHeatmapBlockData = BlockData;
+export declare const RepertoireMutationHeatmapBlockPointer: {
   readonly type: "from-pack-v2";
   readonly packUrl: string;
   readonly rootUrl: string;
 };
 //#endregion
-export { BlockContract, BlockData, BlockOutputs, BlockPointer, RepertoireMutationHeatmapBlockContract, RepertoireMutationHeatmapBlockData, RepertoireMutationHeatmapBlockOutputs, RepertoireMutationHeatmapBlockPointer, platforma };
 //# sourceMappingURL=index.d.ts.map