@platforma-sdk/model 1.83.0 → 1.83.17

package/dist/columns/column_recipes/types.d.ts

@@ -1,5 +1,4 @@
 import { ColumnUniversalId, PColumnSpec, PObjectId, SpecOverrides, SpecQuery as SpecQuery$1 } from "@milaboratories/pl-model-common";
-
 //#region src/columns/column_recipes/types.d.ts
 /**
  * Stable identifier of a recipe: either the canonical {@link PObjectId} of a
@@ -9,7 +8,7 @@ import { ColumnUniversalId, PColumnSpec, PObjectId, SpecOverrides, SpecQuery as
  * Recipes are equivalent as value-objects iff their `id`s match (structurally,
  * after canonicalization).
  */
-type ColumnRecipeId = ColumnUniversalId;
+export type ColumnRecipeId = ColumnUniversalId;
 /**
  * Aggregate data status of a recipe: the "worst" status across every
  * PObjectId the recipe references (the leaf itself plus any refs inside
@@ -18,7 +17,7 @@ type ColumnRecipeId = ColumnUniversalId;
  * "All or nothing" semantics: spec/query built from a recipe are meaningful
  * only when every referenced column is `present`.
  */
-type ColumnFieldStatus = "resolving" | "absent" | "present";
+export type ColumnFieldStatus = "resolving" | "absent" | "present";
 /**
  * Resolution status of a recipe — whether the recipe is meaningful in the
  * active render ctx. Aggregates spec readiness (the recipe can be
@@ -34,7 +33,7 @@ type ColumnFieldStatus = "resolving" | "absent" | "present";
  * status only. {@link ColumnResolutionStatus} also folds in spec/registry
  * readiness, so the recipe interface exposes both.
  */
-type ColumnResolutionStatus = "present" | "resolving" | "absent";
+export type ColumnResolutionStatus = "present" | "resolving" | "absent";
 /**
  * Base contract of a column recipe — an immutable description of HOW to
  * obtain a column, not the column itself.
@@ -55,7 +54,7 @@ type ColumnResolutionStatus = "present" | "resolving" | "absent";
  * Consumers that need to decompose call utilities from `pl-model-common`
  * over `recipe.id`.
  */
-interface ColumnRecipe<ID extends ColumnRecipeId = ColumnRecipeId> {
+export interface ColumnRecipe<ID extends ColumnRecipeId = ColumnRecipeId> {
   /** Canonical recipe identifier. */
   readonly id: ID;
   /** PObjectIds referenced by this recipe (leaf + any nested refs). */
@@ -97,5 +96,5 @@ interface ColumnRecipe<ID extends ColumnRecipeId = ColumnRecipeId> {
   withSpecs(overrides: SpecOverrides): ColumnRecipe;
 }
 //#endregion
-export { ColumnFieldStatus, ColumnRecipe, ColumnRecipeId, ColumnResolutionStatus, type SpecQuery$1 as SpecQuery };
+export type { SpecQuery$1 as SpecQuery };
 //# sourceMappingURL=types.d.ts.map

package/dist/columns/column_recipes/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/columns/column_recipes/types.ts"],"mappings":";;;;AAkBA;;;;AAA8C;AAU9C;;KAVY,cAAA,GAAiB,iBAAiB;;AAUjB;AAiB7B;;;;AAAkC;AAsBlC;KAvCY,iBAAA;;;;;;;;;;;;;;;;KAiBA,sBAAA;;;;;;;;;;;;;;;AAkEuC;;;;;;UA5ClC,YAAA,YAAwB,cAAA,GAAiB,cAAA;;WAE/C,EAAA,EAAI,EAAA;;EAGb,gBAAA,IAAoB,SAAA;;;;;;;;;;EAWpB,OAAA,IAAW,WAAA;;;;;;;;;;EAWX,QAAA,IAAY,WAAA;;;;;;;EAQZ,aAAA,IAAiB,iBAAA;;;;;;;;EASjB,SAAA,CAAU,SAAA,EAAW,aAAA,GAAgB,YAAA;AAAA"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/columns/column_recipes/types.ts"],"mappings":";;;;;;;;;;YAkBY,iBAAiB;;;;;;;;;YAUjB;;;;;;;;;;;;;;;;YAiBA;;;;;;;;;;;;;;;;;;;;;iBAsBK,aAAa,WAAW,iBAAiB;;WAE/C,IAAI;;EAGb,oBAAoB;;;;;;;;;;EAWpB,WAAW;;;;;;;;;;EAWX,YAAY;;;;;;;EAQZ,iBAAiB;;;;;;;;EASjB,UAAU,WAAW,gBAAgB"}

package/dist/columns/columns_collection.d.ts

@@ -1,10 +1,10 @@
 import { GlobalCfgRenderCtx } from "../render/internal.js";
 import { ColumnRecipe } from "./column_recipes/index.js";
 import { ColumnsSource } from "./column_providers/types.js";
+import "./column_providers/index.js";
 import { CollectionHandle, ColumnUniversalId, ColumnsCollectionDriverModel, ColumnsDiscoverOptions, ColumnsFilterOptions } from "@milaboratories/pl-model-common";
-
 //#region src/columns/columns_collection.d.ts
-interface ColumnsCollectionDeps {
+export interface ColumnsCollectionDeps {
   /** Render ctx used both for service resolution and for default ctx sources. */
   readonly ctx?: GlobalCfgRenderCtx;
   /** Override the resolved `columnsCollection` service — primarily for tests. */
@@ -18,7 +18,7 @@ interface ColumnsCollectionDeps {
  * - `"current_block"` – main outputs + prerun (staging) accessors of the
  *   current block, when present.
  */
-type ColumnsSourceShorthand = "result_pool" | "current_block";
+export type ColumnsSourceShorthand = "result_pool" | "current_block";
 /**
  * Build a {@link ColumnsCollection} from sandbox-side source descriptors.
  * Resolves the `columnsCollection` driver (either from `deps.driver` or via
@@ -29,8 +29,8 @@ type ColumnsSourceShorthand = "result_pool" | "current_block";
  * `sources` accepts {@link ColumnsSourceShorthand} string literals
  * (`"result_pool"`, `"current_block"`) for the common ctx-derived sources.
  */
-declare function ColumnsCollection(sources?: (ColumnsCollection | ColumnsSource | ColumnsSourceShorthand)[], deps?: ColumnsCollectionDeps): ColumnsCollection;
-declare function isColumnsCollection(value: unknown): value is ColumnsCollection;
+export declare function ColumnsCollection(sources?: (ColumnsCollection | ColumnsSource | ColumnsSourceShorthand)[], deps?: ColumnsCollectionDeps): ColumnsCollection;
+export declare function isColumnsCollection(value: unknown): value is ColumnsCollection;
 /**
  * Sandbox proxy over the host-side `ColumnsCollection` driver. The driver
  * owns all column-set state; this object only carries an opaque
@@ -45,7 +45,7 @@ declare function isColumnsCollection(value: unknown): value is ColumnsCollection
  * host — the host VM bridge pins it to the active render ctx, so the sandbox
  * never has to manage refcounts.
  */
-declare class ColumnsCollectionImpl {
+export declare class ColumnsCollectionImpl {
   readonly handle: CollectionHandle;
   private readonly driver;
   constructor(handle: CollectionHandle, driver: ColumnsCollectionDriverModel);
@@ -58,7 +58,6 @@ declare class ColumnsCollectionImpl {
   filter(options: ColumnsFilterOptions): ColumnsCollection;
 }
 /** Public type alias — value of the same name is the factory function above. */
-type ColumnsCollection = ColumnsCollectionImpl;
+export type ColumnsCollection = ColumnsCollectionImpl;
 //#endregion
-export { ColumnsCollection, ColumnsCollectionDeps, ColumnsCollectionImpl, ColumnsSourceShorthand, isColumnsCollection };
 //# sourceMappingURL=columns_collection.d.ts.map

package/dist/columns/columns_collection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"columns_collection.d.ts","names":[],"sources":["../../src/columns/columns_collection.ts"],"mappings":";;;;;;UAkBiB,qBAAA;;WAEN,GAAA,GAAM,kBAAA;EAFA;EAAA,SAIN,MAAA,GAAS,4BAA4B;AAAA;;;;;;;AAAA;AAWhD;KAAY,sBAAA;;;AAAsB;AAYlC;;;;;;;iBAAgB,iBAAA,CACd,OAAA,IAAW,iBAAA,GAAoB,aAAA,GAAgB,sBAAA,KAC/C,IAAA,GAAO,qBAAA,GACN,iBAAA;AAAA,iBAQa,mBAAA,CAAoB,KAAA,YAAiB,KAAA,IAAS,iBAAiB;;;;;;;;;;AAR3D;AAQpB;;;;cAkBa,qBAAA;EAAA,SAEO,MAAA,EAAQ,gBAAA;EAAA,iBACP,MAAA;cADD,MAAA,EAAQ,gBAAA,EACP,MAAA,EAAQ,4BAAA;EAG3B,OAAA;EAIA,OAAA;EAIA,YAAA,IAAgB,iBAAA;EAIhB,UAAA,IAAc,YAAA;EAMd,SAAA,CAAU,MAAA,EAAQ,aAAA,GAAgB,iBAAA,GAAoB,iBAAA;EAOtD,QAAA,CAAS,OAAA,EAAS,sBAAA,GAAyB,iBAAA;EAI3C,MAAA,CAAO,OAAA,EAAS,oBAAA,GAAuB,iBAAA;AAAA;;KAM7B,iBAAA,GAAoB,qBAAqB"}
+{"version":3,"file":"columns_collection.d.ts","names":[],"sources":["../../src/columns/columns_collection.ts"],"mappings":";;;;;;iBAkBiB;;WAEN,MAAM;;WAEN,SAAS;;;;;;;;;;YAWR;;;;;;;;;;;wBAYI,kBACd,WAAW,oBAAoB,gBAAgB,2BAC/C,OAAO,wBACN;wBAQa,oBAAoB,iBAAiB,SAAS;;;;;;;;;;;;;;;qBAkBjD;WAEO,QAAQ;mBACP;EAFnB,YACkB,QAAQ,kBACP,QAAQ;EAG3B;EAIA;EAIA,gBAAgB;EAIhB,cAAc;EAMd,UAAU,QAAQ,gBAAgB,oBAAoB;EAOtD,SAAS,SAAS,yBAAyB;EAI3C,OAAO,SAAS,uBAAuB;;;YAM7B,oBAAoB"}

package/dist/columns/data_column.d.ts

@@ -1,11 +1,11 @@
 import { GlobalCfgRenderCtx, PColumnDataUniversal } from "../render/internal.js";
 import { TreeNodeAccessor } from "../render/accessor.js";
+import "../render/index.js";
 import { ColumnFieldStatus, ColumnRecipe, ColumnRecipeId, ColumnResolutionStatus } from "./column_recipes/types.js";
 import { ColumnUniversalId, LeafEntry, PColumn, PColumnSpec, PObjectId, PlRef, SpecOverrides, SpecQuery } from "@milaboratories/pl-model-common";
-
 //#region src/columns/data_column.d.ts
-type DataColumnId = PObjectId;
-type ColumnData = undefined | PColumnDataUniversal;
+export type DataColumnId = PObjectId;
+export type ColumnData = undefined | PColumnDataUniversal;
 /**
  * A {@link ColumnRecipe} that can be read directly in the sandbox: its
  * {@link getData} is guaranteed to be consistent with {@link getSpec}.
@@ -21,7 +21,7 @@ type ColumnData = undefined | PColumnDataUniversal;
  * class — which recipe classes exist is an implementation detail behind
  * `recipe.id`.
  */
-interface DataColumnRecipe<ID extends ColumnRecipeId = ColumnRecipeId> extends ColumnRecipe<ID> {
+export interface DataColumnRecipe<ID extends ColumnRecipeId = ColumnRecipeId> extends ColumnRecipe<ID> {
   /** Column data, consistent with {@link ColumnRecipe.getSpec}. */
   getData(): ColumnData;
 }
@@ -36,7 +36,7 @@ interface DataColumnRecipe<ID extends ColumnRecipeId = ColumnRecipeId> extends C
  * when partial absence should be surfaced to the user rather than silently
  * producing an empty result.
  */
-declare class ColumnAbsentError extends Error {
+export declare class ColumnAbsentError extends Error {
   readonly id: ColumnUniversalId;
   constructor(id: ColumnUniversalId);
 }
@@ -49,7 +49,7 @@ declare class ColumnAbsentError extends Error {
  * Internal — consumers hold the {@link DataColumnRecipe} interface and construct
  * through the {@link DataColumnRecipe} dispatcher.
  */
-declare class DataColumnImpl implements DataColumnRecipe<PObjectId> {
+export declare class DataColumnImpl implements DataColumnRecipe<PObjectId> {
   readonly id: PObjectId;
   private readonly options;
   private specCache?;
@@ -76,9 +76,7 @@ declare class DataColumnImpl implements DataColumnRecipe<PObjectId> {
    * and the column did not appear — the column will not exist in this ctx.
    * Data and dataStatus stay lazy.
    */
-  static fromId(id: PObjectId, {
-    ctx
-  }?: {
+  static fromId(id: PObjectId, { ctx }?: {
     ctx?: GlobalCfgRenderCtx;
   }): undefined | DataColumnRecipe<PObjectId>;
   /** {@link PlRef} wrapper over {@link fromId}. */
@@ -100,9 +98,7 @@ declare class DataColumnImpl implements DataColumnRecipe<PObjectId> {
    * when the id has no entry — only then we can say `absent` instead of
    * `resolving`.
    */
-  static getStatusById(id: PObjectId, {
-    ctx
-  }?: {
+  static getStatusById(id: PObjectId, { ctx }?: {
     ctx?: GlobalCfgRenderCtx;
   }): ColumnResolutionStatus;
   /** {@link PlRef} wrapper over {@link getStatusById}. */
@@ -113,7 +109,7 @@ declare class DataColumnImpl implements DataColumnRecipe<PObjectId> {
   static getStatusByAccessor(entry: LeafEntry<TreeNodeAccessor>): ColumnResolutionStatus;
 }
 /** Anything the {@link DataColumnRecipe} dispatcher can build a leaf from. */
-type DataColumnSource = PObjectId | PlRef | LeafEntry<TreeNodeAccessor> | PColumn<ColumnData> | DataColumnRecipe<PObjectId>;
+export type DataColumnSource = PObjectId | PlRef | LeafEntry<TreeNodeAccessor> | PColumn<ColumnData> | DataColumnRecipe<PObjectId>;
 /**
  * Unified dispatcher — picks the right `DataColumnImpl.fromX` by source
  * shape. For ambiguous inputs callers can still use the explicit factories
@@ -132,7 +128,7 @@ declare function DataColumnDispatch(source: DataColumnSource, opts?: {
 declare function DataColumnGetStatus(source: DataColumnSource, opts?: {
   ctx?: GlobalCfgRenderCtx;
 }): ColumnResolutionStatus;
-declare const DataColumn: typeof DataColumnDispatch & {
+export declare const DataColumn: typeof DataColumnDispatch & {
   fromId: typeof DataColumnImpl.fromId;
   fromPlRef: typeof DataColumnImpl.fromPlRef;
   fromAccessor: typeof DataColumnImpl.fromAccessor;
@@ -146,7 +142,7 @@ declare const DataColumn: typeof DataColumnDispatch & {
  * Type-guard narrowing to a bare leaf — a {@link DataColumnRecipe} whose `id` is a
  * plain {@link PObjectId}.
  */
-declare function isDataColumn(value: unknown): value is DataColumnRecipe<PObjectId>;
+export declare function isDataColumn(value: unknown): value is DataColumnRecipe<PObjectId>;
 //#endregion
-export { ColumnAbsentError, ColumnData, type ColumnFieldStatus, type ColumnResolutionStatus, DataColumn, DataColumnId, DataColumnImpl, DataColumnRecipe, DataColumnSource, isDataColumn };
+export type { ColumnFieldStatus, ColumnResolutionStatus };
 //# sourceMappingURL=data_column.d.ts.map

package/dist/columns/data_column.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data_column.d.ts","names":[],"sources":["../../src/columns/data_column.ts"],"mappings":";;;;;;KA2BY,YAAA,GAAe,SAAS;AAAA,KACxB,UAAA,eAAyB,oBAAoB;AADzD;;;;AAAoC;AACpC;;;;AAAyD;AAkBzD;;;;;AAnBA,UAmBiB,gBAAA,YACJ,cAAA,GAAiB,cAAA,UACpB,YAAA,CAAa,EAAA;EAEV;EAAX,OAAA,IAAW,UAAA;AAAA;;;;;;;;;;AAAU;AAcvB;cAAa,iBAAA,SAA0B,KAAA;EAAA,SACT,EAAA,EAAI,iBAAA;cAAJ,EAAA,EAAI,iBAAA;AAAA;;;;;;;;;;cAerB,cAAA,YAA0B,gBAAA,CAAiB,SAAA;EAAA,SAMpC,EAAA,EAAI,SAAA;EAAA,iBACH,OAAA;EAAA,QANX,SAAA;EAAA,QACA,SAAA;EAAA,QACA,eAAA;EAAA,QAED,WAAA;EAUa;EAApB,gBAAA,IAAoB,SAAA;EAIpB,OAAA,IAAW,WAAA;EAYA;EAJX,QAAA,IAAY,SAAA;EAIZ,OAAA,IAAW,UAAA;EAKX,aAAA,IAAiB,iBAAA;EAwBX;;;;;EAZN,SAAA,CAAU,SAAA,EAAW,aAAA,GAAgB,YAAA;EAmCsB;;;;;;;EAAA,OAxBpD,MAAA,CACL,EAAA,EAAI,SAAA;IACF;EAAA;IAAS,GAAA,GAAM,kBAAA;EAAA,gBACJ,gBAAA,CAAiB,SAAA;EAkDZ;EAAA,OA7Bb,SAAA,CAAU,GAAA,EAAK,KAAA,eAAoB,gBAAA,CAAiB,SAAA;EAkDrD;;;;;EAAA,OAzCC,YAAA,CAAa,KAAA,EAAO,SAAA,CAAU,gBAAA,gBAAgC,gBAAA,CAAiB,SAAA;EAsDnF;;;;EAAA,OApCI,UAAA,CACL,MAAA,EAAQ,OAAA,CAAQ,UAAA,IAAc,gBAAA,CAAiB,SAAA,IAC9C,gBAAA,CAAiB,SAAA;EAhHiC;;;;;;EAAA,OAoI9C,aAAA,CACL,EAAA,EAAI,SAAA;IACF;EAAA;IAAS,GAAA,GAAM,kBAAA;EAAA,IAChB,sBAAA;EApIK;EAAA,OA4ID,gBAAA,CACL,GAAA,EAAK,KAAA,EACL,IAAA;IAAQ,GAAA,GAAM,kBAAA;EAAA,IACb,sBAAA;EA/HH;EAAA,OAoIO,mBAAA,CAAoB,KAAA,EAAO,SAAA,CAAU,gBAAA,IAAoB,sBAAA;AAAA;;KAMtD,gBAAA,GACR,SAAA,GACA,KAAA,GACA,SAAA,CAAU,gBAAA,IACV,OAAA,CAAQ,UAAA,IACR,gBAAA,CAAiB,SAAA;;;;;;;iBAQZ,kBAAA,CACP,MAAA,EAAQ,gBAAA,EACR,IAAA;EAAQ,GAAA,GAAM,kBAAA;AAAA,gBACD,gBAAA,CAAiB,SAAA;;;;;;;iBAkBvB,mBAAA,CACP,MAAA,EAAQ,gBAAA,EACR,IAAA;EAAQ,GAAA,GAAM,kBAAA;AAAA,IACb,sBAAA;AAAA,cAUU,UAAA,SAAU,kBAAA;;;;;;;;;;;;;;iBAeP,YAAA,CAAa,KAAA,YAAiB,KAAA,IAAS,gBAAgB,CAAC,SAAA"}
+{"version":3,"file":"data_column.d.ts","names":[],"sources":["../../src/columns/data_column.ts"],"mappings":";;;;;;YA2BY,eAAe;YACf,yBAAyB;;;;;;;;;;;;;;;;iBAkBpB,iBACf,WAAW,iBAAiB,wBACpB,aAAa;;EAErB,WAAW;;;;;;;;;;;;;qBAcA,0BAA0B;WACT,IAAI;EAAhC,YAA4B,IAAI;;;;;;;;;;;qBAerB,0BAA0B,iBAAiB;WAMpC,IAAI;mBACH;UANX;UACA;UACA;UAED;;EAUP,oBAAoB;EAIpB,WAAW;;EAQX,YAAY;EAIZ,WAAW;EAKX,iBAAiB;;;;;;EAYjB,UAAU,WAAW,gBAAgB;;;;;;;;SAW9B,OACL,IAAI,aACF;IAAS,MAAM;kBACJ,iBAAiB;;SAqBzB,UAAU,KAAK,oBAAoB,iBAAiB;;;;;;SASpD,aAAa,OAAO,UAAU,gCAAgC,iBAAiB;;;;;SAkB/E,WACL,QAAQ,QAAQ,cAAc,iBAAiB,aAC9C,iBAAiB;;;;;;;SAoBb,cACL,IAAI,aACF;IAAS,MAAM;MAChB;;SAQI,iBACL,KAAK,OACL;IAAQ,MAAM;MACb;;SAKI,oBAAoB,OAAO,UAAU,oBAAoB;;;YAMtD,mBACR,YACA,QACA,UAAU,oBACV,QAAQ,cACR,iBAAiB;;;;;;;iBAQZ,mBACP,QAAQ,kBACR;EAAQ,MAAM;gBACD,iBAAiB;;;;;;;iBAkBvB,oBACP,QAAQ,kBACR;EAAQ,MAAM;IACb;qBAUU,mBAAU;;;;;;;;;;;;;;wBAeP,aAAa,iBAAiB,SAAS,iBAAiB"}

package/dist/columns/derive_axis_values_labels.d.ts

@@ -1,8 +1,8 @@
 import { GlobalCfgRenderCtx } from "../render/internal.js";
 import { ColumnsSource } from "./column_providers/types.js";
+import "./column_providers/index.js";
 import { ColumnsCollection } from "./columns_collection.js";
 import { AxisId } from "@milaboratories/pl-model-common";
-
 //#region src/columns/derive_axis_values_labels.d.ts
 /**
  * Build an `axisValuesLabels` callback by discovering `pl7.app/label` columns
@@ -22,9 +22,8 @@ import { AxisId } from "@milaboratories/pl-model-common";
  *  - label columns whose data resource type isn't `PColumnData/Json` /
  *    `PColumnData/JsonPartitioned`.
  */
-declare function deriveAxisValuesLabels(source?: ColumnsCollection | (ColumnsCollection | ColumnsSource)[], opts?: {
+export declare function deriveAxisValuesLabels(source?: ColumnsCollection | (ColumnsCollection | ColumnsSource)[], opts?: {
   ctx?: GlobalCfgRenderCtx;
 }): (axisId: AxisId) => Record<string | number, string> | undefined;
 //#endregion
-export { deriveAxisValuesLabels };
 //# sourceMappingURL=derive_axis_values_labels.d.ts.map

package/dist/columns/derive_axis_values_labels.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"derive_axis_values_labels.d.ts","names":[],"sources":["../../src/columns/derive_axis_values_labels.ts"],"mappings":";;;;;;;;;AA6BA;;;;;;;;;;;;;;;iBAAgB,sBAAA,CACd,MAAA,GAAS,iBAAA,IAAqB,iBAAA,GAAoB,aAAA,KAClD,IAAA;EAAS,GAAA,GAAM,kBAAA;AAAA,KACb,MAAA,EAAQ,MAAA,KAAW,MAAA"}
+{"version":3,"file":"derive_axis_values_labels.d.ts","names":[],"sources":["../../src/columns/derive_axis_values_labels.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;wBA6BgB,uBACd,SAAS,qBAAqB,oBAAoB,kBAClD;EAAS,MAAM;KACb,QAAQ,WAAW"}

package/dist/columns/split_by_axes.d.ts

@@ -1,13 +1,12 @@
 import { Column } from "./column.js";
 import { ColumnRecipe } from "./column_recipes/index.js";
 import { AxisId } from "@milaboratories/pl-model-common";
-
 //#region src/columns/split_by_axes.d.ts
-interface SplitAxis {
+export interface SplitAxis {
   /** Index of the axis in the column's axesSpec to split by. */
   readonly idx: number;
 }
-interface SplitByAxesOpts {
+export interface SplitByAxesOpts {
   /**
    * Resolve axis values to human-readable labels.
    *
@@ -41,7 +40,6 @@ interface SplitByAxesOpts {
  * Returns `undefined` when any input's `getData()` is not a
  * {@link TreeNodeAccessor} — partition inspection is not yet possible.
  */
-declare function splitByAxes(inputs: Column[], splitAxes: SplitAxis[], opts?: SplitByAxesOpts): ColumnRecipe[] | undefined;
+export declare function splitByAxes(inputs: Column[], splitAxes: SplitAxis[], opts?: SplitByAxesOpts): ColumnRecipe[] | undefined;
 //#endregion
-export { SplitAxis, SplitByAxesOpts, splitByAxes };
 //# sourceMappingURL=split_by_axes.d.ts.map

package/dist/columns/split_by_axes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"split_by_axes.d.ts","names":[],"sources":["../../src/columns/split_by_axes.ts"],"mappings":";;;;;UAwBiB,SAAA;;WAEN,GAAG;AAAA;AAAA,UAGG,eAAA;EAHH;AAAA;AAGd;;;;;;EASE,gBAAA,IAAoB,MAAA,EAAQ,MAAA,iBAAuB,MAAM;AAAA;;AAAA;AA8B3D;;;;;;;;;;;;;;;;;AAIe;;;;iBAJC,WAAA,CACd,MAAA,EAAQ,MAAA,IACR,SAAA,EAAW,SAAA,IACX,IAAA,GAAO,eAAA,GACN,YAAA"}
+{"version":3,"file":"split_by_axes.d.ts","names":[],"sources":["../../src/columns/split_by_axes.ts"],"mappings":";;;;iBAwBiB;;WAEN;;iBAGM;;;;;;;;;EASf,oBAAoB,QAAQ,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;wBA8BrC,YACd,QAAQ,UACR,WAAW,aACX,OAAO,kBACN"}

package/dist/columns/utils.d.ts

@@ -5,7 +5,6 @@ import { DataColumnRecipe } from "./data_column.js";
 import { ColumnsSource } from "./column_providers/types.js";
 import { ColumnsCollection } from "./columns_collection.js";
 import { AxisQualification, ColumnUniversalId, PObjectId } from "@milaboratories/pl-model-common";
-
 //#region src/columns/utils.d.ts
 /**
  * PObjectIds of every non-hit column referenced by `recipe.getQuery()`,
@@ -16,13 +15,13 @@ import { AxisQualification, ColumnUniversalId, PObjectId } from "@milaboratories
  * Pure query walk — no registry access. Use {@link collectLinkerColumns} for
  * the resolved {@link DataColumnRecipe} variant.
  */
-declare function collectLinkerIds(recipe: ColumnRecipe): PObjectId[];
+export declare function collectLinkerIds(recipe: ColumnRecipe): PObjectId[];
 /**
  * {@link collectLinkerIds} resolved against the ambient context as
  * {@link DataColumnRecipe} leaves. Throws if any id fails to resolve —
  * matches the contract of the legacy `resolveLinkers` it replaces.
  */
-declare function collectLinkerColumns(recipe: ColumnRecipe, opts?: {
+export declare function collectLinkerColumns(recipe: ColumnRecipe, opts?: {
   ctx?: GlobalCfgRenderCtx;
 }): DataColumnRecipe<PObjectId>[];
 /**
@@ -33,7 +32,7 @@ declare function collectLinkerColumns(recipe: ColumnRecipe, opts?: {
  * `getInner()` until it finds a {@link ColumnDiscoveredRecipe}; otherwise
  * returns `[]`. Pure recipe walk — no query-tree introspection.
  */
-declare function hitQualifications(recipe: ColumnRecipe): readonly AxisQualification[];
+export declare function hitQualifications(recipe: ColumnRecipe): readonly AxisQualification[];
 /**
  * Per-primary-column axis qualifications for the recipe — applied to the
  * outer primary anchors on this recipe's group side. Keyed by the external
@@ -41,7 +40,7 @@ declare function hitQualifications(recipe: ColumnRecipe): readonly AxisQualifica
  *
  * Same walk strategy as {@link hitQualifications}.
  */
-declare function queriesQualifications(recipe: ColumnRecipe): Readonly<Record<PObjectId, AxisQualification[]>>;
+export declare function queriesQualifications(recipe: ColumnRecipe): Readonly<Record<PObjectId, AxisQualification[]>>;
 /**
  * Whether the recipe's underlying data resources actually carry bytes —
  * strictly stronger than `getDataStatus() === "present"`, which only tells
@@ -56,7 +55,7 @@ declare function queriesQualifications(recipe: ColumnRecipe): Readonly<Record<PO
  * "not yet ready") rather than throwing — this is a UI-facing predicate, not
  * a contract assertion.
  */
-declare function hasColumnData(recipe: ColumnRecipe, opts?: {
+export declare function hasColumnData(recipe: ColumnRecipe, opts?: {
   ctx?: GlobalCfgRenderCtx;
 }): boolean;
 /**
@@ -78,13 +77,13 @@ declare function hasColumnData(recipe: ColumnRecipe, opts?: {
  * through the whole wrapper chain, so no class walk is involved and foreign
  * `ColumnRecipe` implementations are handled too.
  */
-declare function hasSingleDataColumn(recipe: ColumnRecipe): boolean;
+export declare function hasSingleDataColumn(recipe: ColumnRecipe): boolean;
 /**
  * @deprecated Renamed to {@link hasSingleDataColumn} — "leaf" read as "you can
  * get data out of it", which is a different question (see
  * {@link hasReachableData}). Same semantics.
  */
-declare const isLeafColumn: typeof hasSingleDataColumn;
+export declare const isLeafColumn: typeof hasSingleDataColumn;
 /**
  * Whether the column's data can be read here and now, consistent with its
  * spec — narrows to {@link DataColumnRecipe}, which exposes `getData()`.
@@ -101,9 +100,9 @@ declare const isLeafColumn: typeof hasSingleDataColumn;
  * result narrows to a value that really has the method, and there is no
  * throwing path behind the guard.
  */
-declare function hasReachableData(recipe: ColumnRecipe): recipe is DataColumnRecipe;
+export declare function hasReachableData(recipe: ColumnRecipe): recipe is DataColumnRecipe;
 /** Drop-down option built over a {@link ColumnsCollection} — universal-id valued. */
-type ColumnOption = {
+export type ColumnOption = {
   readonly id: ColumnUniversalId;
   readonly label: string;
 };
@@ -115,7 +114,6 @@ type ColumnOption = {
  * accessor, column array, or `"result_pool"` / `"current_block"` shorthand)
  * to be wrapped on the fly.
  */
-declare function deriveColumnOptions(source: ColumnsCollection | ColumnsSource[], labelOptions?: DeriveLabelsOptions): ColumnOption[];
+export declare function deriveColumnOptions(source: ColumnsCollection | ColumnsSource[], labelOptions?: DeriveLabelsOptions): ColumnOption[];
 //#endregion
-export { ColumnOption, collectLinkerColumns, collectLinkerIds, deriveColumnOptions, hasColumnData, hasReachableData, hasSingleDataColumn, hitQualifications, isLeafColumn, queriesQualifications };
 //# sourceMappingURL=utils.d.ts.map

package/dist/columns/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/columns/utils.ts"],"mappings":";;;;;;;;;;;AAiCA;;;;;;;iBAAgB,gBAAA,CAAiB,MAAA,EAAQ,YAAA,GAAe,SAAS;AAAA;AAsBjE;;;;AAtBiE,iBAsBjD,oBAAA,CACd,MAAA,EAAQ,YAAA,EACR,IAAA;EAAQ,GAAA,GAAM,kBAAA;AAAA,IACb,gBAAA,CAAiB,SAAA;;;;;;;;;iBAgBJ,iBAAA,CAAkB,MAAA,EAAQ,YAAA,YAAwB,iBAAiB;;AAhBtD;AAgB7B;;;;;iBAYgB,qBAAA,CACd,MAAA,EAAQ,YAAA,GACP,QAAA,CAAS,MAAA,CAAO,SAAA,EAAW,iBAAA;;;AAdqD;AAYnF;;;;;;;;;;;iBAqBgB,aAAA,CACd,MAAA,EAAQ,YAAA,EACR,IAAA;EAAQ,GAAA,GAAM,kBAAkB;AAAA;;;;AArBa;AAmB/C;;;;;;;;;;AAEyC;AAiEzC;;;;iBAAgB,mBAAA,CAAoB,MAAoB,EAAZ,YAAY;AASxD;;;;AAA+C;AAA/C,cAAa,YAAA,SAAY,mBAAsB;;;;;;;;;AAkBmC;AAKlF;;;;;;;iBALgB,gBAAA,CAAiB,MAAA,EAAQ,YAAA,GAAe,MAAA,IAAU,gBAAgB;AAOlE;AAAA,KAFJ,YAAA;EAAA,SACD,EAAA,EAAI,iBAAiB;EAAA,SACrB,KAAA;AAAA;;;;;;;;;iBAWK,mBAAA,CACd,MAAA,EAAQ,iBAAA,GAAoB,aAAA,IAC5B,YAAA,GAAc,mBAAA,GACb,YAAA"}
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../src/columns/utils.ts"],"mappings":";;;;;;;;;;;;;;;;;wBAiCgB,iBAAiB,QAAQ,eAAe;;;;;;wBAsBxC,qBACd,QAAQ,cACR;EAAQ,MAAM;IACb,iBAAiB;;;;;;;;;wBAgBJ,kBAAkB,QAAQ,wBAAwB;;;;;;;;wBAYlD,sBACd,QAAQ,eACP,SAAS,OAAO,WAAW;;;;;;;;;;;;;;;wBAmBd,cACd,QAAQ,cACR;EAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;wBAiEA,oBAAoB,QAAQ;;;;;;qBAS/B,qBAAY;;;;;;;;;;;;;;;;;wBAkBT,iBAAiB,QAAQ,eAAe,UAAU;;YAKtD;WACD,IAAI;WACJ;;;;;;;;;;wBAWK,oBACd,QAAQ,oBAAoB,iBAC5B,eAAc,sBACb"}

package/dist/components/PFrameForGraphs.d.ts

@@ -1,11 +1,11 @@
 import { PColumnDataUniversal } from "../render/internal.js";
 import { RenderCtxBase } from "../render/api.js";
+import "../render/index.js";
 import { AxesVault, enrichCompatible, getAvailableWithLinkersAxes } from "../pframe_utils/axes.js";
 import { PColumn, PColumnSpec, PFrameHandle } from "@milaboratories/pl-model-common";
-
 //#region src/components/PFrameForGraphs.d.ts
-declare function isHiddenFromGraphColumn(column: PColumnSpec): boolean;
-declare function isHiddenFromUIColumn(column: PColumnSpec): boolean;
+export declare function isHiddenFromGraphColumn(column: PColumnSpec): boolean;
+export declare function isHiddenFromUIColumn(column: PColumnSpec): boolean;
 /**
  The aim of createPFrameForGraphs: to create pframe with block’s columns and all compatible columns from result pool
  (including linker columns and all label columns).
@@ -18,7 +18,7 @@ declare function isHiddenFromUIColumn(column: PColumnSpec): boolean;
  of partially matched axis we add to pframe a copy of this column with modified axis (with filled missed domains)
  and modified label (with added domain values in case if more than one copy with different domains exist).
  */
-declare function createPFrameForGraphs<A, U>(ctx: RenderCtxBase<A, U>, blockColumns?: PColumn<undefined | PColumnDataUniversal>[]): PFrameHandle | undefined;
+export declare function createPFrameForGraphs<A, U>(ctx: RenderCtxBase<A, U>, blockColumns?: PColumn<undefined | PColumnDataUniversal>[]): PFrameHandle | undefined;
 //#endregion
-export { type AxesVault, createPFrameForGraphs, enrichCompatible, getAvailableWithLinkersAxes, isHiddenFromGraphColumn, isHiddenFromUIColumn };
+export { type AxesVault, enrichCompatible, getAvailableWithLinkersAxes };
 //# sourceMappingURL=PFrameForGraphs.d.ts.map

package/dist/components/PFrameForGraphs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PFrameForGraphs.d.ts","names":[],"sources":["../../src/components/PFrameForGraphs.ts"],"mappings":";;;;;;iBAOgB,uBAAA,CAAwB,MAAmB,EAAX,WAAW;AAAA,iBAI3C,oBAAA,CAAqB,MAAmB,EAAX,WAAW;;AAJxD;;;;AAA2D;AAI3D;;;;AAAwD;AAgBxD;iBAAgB,qBAAA,OACd,GAAA,EAAK,aAAA,CAAc,CAAA,EAAG,CAAA,GACtB,YAAA,GAAe,OAAA,aAAoB,oBAAA,MAClC,YAAA"}
+{"version":3,"file":"PFrameForGraphs.d.ts","names":[],"sources":["../../src/components/PFrameForGraphs.ts"],"mappings":";;;;;;wBAOgB,wBAAwB,QAAQ;wBAIhC,qBAAqB,QAAQ;;;;;;;;;;;;;wBAgB7B,sBAAsB,GAAG,GACvC,KAAK,cAAc,GAAG,IACtB,eAAe,oBAAoB,0BAClC"}

package/dist/components/PlAnnotations/filter.d.ts

@@ -1,13 +1,13 @@
 import { SUniversalPColumnId } from "@milaboratories/pl-model-common";
-
 //#region src/components/PlAnnotations/filter.d.ts
 /**
  * Represents an equals predicate for pattern filtering.
  * Checks if the pattern exactly matches the provided value.
  * Can handle both string literals and biological sequences with wildcards.
  */
-type PatternPredicateEquals = {
-  type: "equals"; /** The exact pattern value to match */
+export type PatternPredicateEquals = {
+  type: "equals";
+  /** The exact pattern value to match */
   value: string;
 };
 /**
@@ -15,21 +15,24 @@ type PatternPredicateEquals = {
  * Checks if the pattern contains the provided subsequence.
  * Can handle both string literals and biological sequences with wildcards.
  */
-type PatternPredicateContainSubsequence = {
-  type: "containSubsequence"; /** The subpattern to search for within the target pattern */
+export type PatternPredicateContainSubsequence = {
+  type: "containSubsequence";
+  /** The subpattern to search for within the target pattern */
   value: string;
 };
 /**
  * Union type for pattern predicates that can be applied to both sequence and string data.
  */
-type PatternPredicate = PatternPredicateEquals | PatternPredicateContainSubsequence;
+export type PatternPredicate = PatternPredicateEquals | PatternPredicateContainSubsequence;
 /**
  * Filter for pattern data, specifying the column to filter and the predicate to apply.
  * Works with both biological sequences (with wildcards) and regular strings.
  */
-type PatternFilter = {
-  type: "pattern"; /** The column identifier to apply the filter to */
-  column: SUniversalPColumnId; /** The predicate defining the filtering logic */
+export type PatternFilter = {
+  type: "pattern";
+  /** The column identifier to apply the filter to */
+  column: SUniversalPColumnId;
+  /** The predicate defining the filtering logic */
   predicate: PatternPredicate;
 };
 /**
@@ -43,9 +46,11 @@ type PatternFilter = {
  *
  * The ranked values can be used in numerical comparison filters.
  */
-type ValueRank = {
-  transformer: "rank"; /** The column identifier to apply the ranking to */
-  column: SUniversalPColumnId; /** If true, sorts highest values first (highest value gets rank 1) */
+export type ValueRank = {
+  transformer: "rank";
+  /** The column identifier to apply the ranking to */
+  column: SUniversalPColumnId;
+  /** If true, sorts highest values first (highest value gets rank 1) */
   descending?: true;
 };
 /**
@@ -58,9 +63,11 @@ type ValueRank = {
  *
  * The cumulative values can be used in numerical comparison filters.
  */
-type SortedCumulativeSum = {
-  transformer: "sortedCumulativeSum"; /** The column identifier to apply the cumulative sum to */
-  column: SUniversalPColumnId; /** If true, sorts values in descending order before calculating the cumulative sum */
+export type SortedCumulativeSum = {
+  transformer: "sortedCumulativeSum";
+  /** The column identifier to apply the cumulative sum to */
+  column: SUniversalPColumnId;
+  /** If true, sorts values in descending order before calculating the cumulative sum */
   descending?: true;
 };
 /**
@@ -72,8 +79,9 @@ type SortedCumulativeSum = {
  * The log10-transformed values can be used in numerical comparison filters.
  * Note: The behavior for non-positive input values (<= 0) results in -Infinity.
  */
-type Log10 = {
-  transformer: "log10"; /** The column identifier to apply the log10 transformation to */
+export type Log10 = {
+  transformer: "log10";
+  /** The column identifier to apply the log10 transformation to */
   column: SUniversalPColumnId;
 };
 /**
@@ -82,7 +90,7 @@ type Log10 = {
  * operations such as "top N" or "first X%" queries.
  * Any NA values are propagated to the transformed column, and ignored in ranks and cumulative sums.
  */
-type TransformedColumn = ValueRank | SortedCumulativeSum | Log10;
+export type TransformedColumn = ValueRank | SortedCumulativeSum | Log10;
 /**
  * Defines a numerical comparison between two values that can be column references or constants.
  *
@@ -100,26 +108,31 @@ type TransformedColumn = ValueRank | SortedCumulativeSum | Log10;
  * - The minDiff parameter can only be used when both sides are columns or transformed columns
  * - Use allowEqual=true to include equality in the comparison (<=)
  */
-type NumericalComparisonFilter = {
-  type: "numericalComparison"; /** The first column to compare (left side of comparison) */
-  lhs: SUniversalPColumnId | TransformedColumn | number; /** The second column to compare (right side of comparison) */
-  rhs: SUniversalPColumnId | TransformedColumn | number; /** The minimum difference between lhs and rhs values */
-  minDiff?: number; /** Whether equality is permitted in the comparison */
+export type NumericalComparisonFilter = {
+  type: "numericalComparison";
+  /** The first column to compare (left side of comparison) */
+  lhs: SUniversalPColumnId | TransformedColumn | number;
+  /** The second column to compare (right side of comparison) */
+  rhs: SUniversalPColumnId | TransformedColumn | number;
+  /** The minimum difference between lhs and rhs values */
+  minDiff?: number;
+  /** Whether equality is permitted in the comparison */
   allowEqual?: true;
 };
 /**
  * Represents a filter that checks if a column's values are NA (not available).
  * This filter is useful for filtering out records where a specific column has no value / clonotype is not present.
  */
-type IsNA = {
-  type: "isNA"; /** The column identifier to check for NA values */
+export type IsNA = {
+  type: "isNA";
+  /** The column identifier to check for NA values */
   column: SUniversalPColumnId;
 };
 /**
  * Represents a logical OR operation between multiple filters.
  * A record matches if at least one of the contained filters matches.
  */
-interface OrFilter {
+export interface OrFilter {
   type: "or";
   /** Array of filters to combine with OR logic */
   filters: AnnotationFilter[];
@@ -128,7 +141,7 @@ interface OrFilter {
  * Represents a logical AND operation between multiple filters.
  * A record matches only if all of the contained filters match.
  */
-interface AndFilter {
+export interface AndFilter {
   type: "and";
   /** Array of filters to combine with AND logic */
   filters: AnnotationFilter[];
@@ -137,7 +150,7 @@ interface AndFilter {
  * Represents a logical NOT operation on a filter.
  * A record matches if it does not match the contained filter.
  */
-interface NotFilter {
+export interface NotFilter {
   type: "not";
   /** The filter to negate */
   filter: AnnotationFilter;
@@ -145,27 +158,29 @@ interface NotFilter {
 /**
  * Union type for all supported annotation filters.
  */
-type AnnotationFilter = IsNA | PatternFilter | NumericalComparisonFilter | OrFilter | AndFilter | NotFilter;
+export type AnnotationFilter = IsNA | PatternFilter | NumericalComparisonFilter | OrFilter | AndFilter | NotFilter;
 /**
  * Represents a single step in the annotation process.
  * Each step consists of a filter to select records and a label to assign to those records.
  */
-type AnnotationStep = {
-  /** The filter to apply for selecting records */filter: AnnotationFilter; /** The label to assign to records that match the filter */
+export type AnnotationStep = {
+  /** The filter to apply for selecting records */
+  filter: AnnotationFilter;
+  /** The label to assign to records that match the filter */
   label: string;
 };
 /**
  * Specifies which entity to annotate: either entire clonotypes or clonotypes within specific samples.
  * This choice affects how filtering and labeling will be applied across your dataset.
  */
-type AnnotationMode =
+export type AnnotationMode =
 /**
  * Annotates entire clonotypes globally, regardless of which samples they appear in.
  * A clonotype will either be fully included or excluded across all samples.
  * The resulting column will have the following shape:
  *   [clonotype_key] -> label
  */
-"byClonotype"
+"byClonotype" |
 /**
  * Annotates clonotypes independently within each sample.
  * This allows sample-specific filtering, where a clonotype might be included in one sample
@@ -175,22 +190,26 @@ type AnnotationMode =
  * The resulting column will have the following shape:
  *   [sample_id, clonotype_key] -> label
  */
-| "bySampleAndClonotype";
+"bySampleAndClonotype";
 /**
  * Represents a complete annotation configuration.
  * Contains a series of annotation steps that are applied in sequence.
  * Annotations are applied from lower indices to higher indices (earlier steps are processed first),
  * with later steps taking precedence when multiple steps match the same record.
  */
-type AnnotationScript = {
-  /** The title of the annotation */title: string; /** The mode of annotation to apply */
-  mode: AnnotationMode; /** Ordered list of annotation steps to apply */
+export type AnnotationScript = {
+  /** The title of the annotation */
+  title: string;
+  /** The mode of annotation to apply */
+  mode: AnnotationMode;
+  /** Ordered list of annotation steps to apply */
   steps: AnnotationStep[];
 };
-type AnnotationScript2<S extends AnnotationStep> = {
-  /** The mode of annotation to apply */mode: AnnotationMode; /** Ordered list of annotation steps to apply */
+export type AnnotationScript2<S extends AnnotationStep> = {
+  /** The mode of annotation to apply */
+  mode: AnnotationMode;
+  /** Ordered list of annotation steps to apply */
   steps: S[];
 };
 //#endregion
-export { AndFilter, AnnotationFilter, AnnotationMode, AnnotationScript, AnnotationScript2, AnnotationStep, IsNA, Log10, NotFilter, NumericalComparisonFilter, OrFilter, PatternFilter, PatternPredicate, PatternPredicateContainSubsequence, PatternPredicateEquals, SortedCumulativeSum, TransformedColumn, ValueRank };
 //# sourceMappingURL=filter.d.ts.map

package/dist/components/PlAnnotations/filter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filter.d.ts","names":[],"sources":["../../../src/components/PlAnnotations/filter.ts"],"mappings":";;;;;AAWA;;;KAAY,sBAAA;EACV,IAAA,YAUU;EARV,KAAK;AAAA;;AAWA;AAMP;;;KATY,kCAAA;EACV,IAAA,wBAcU;EAZV,KAAK;AAAA;;;;KAMK,gBAAA,GAAmB,sBAAA,GAAyB,kCAAkC;;;;AAW7D;KALjB,aAAA;EACV,IAAA;EAEA,MAAA,EAAQ,mBAAA,EAqBR;EAnBA,SAAA,EAAW,gBAAgB;AAAA;;;AAuBjB;AAaZ;;;;;;;;KAlBY,SAAA;EACV,WAAA,UAkCU;EAhCV,MAAA,EAAQ,mBAAmB;EAE3B,UAAA;AAAA;;;;AAiC2B;AAS7B;;;;;;KA7BY,mBAAA;EACV,WAAA,yBA4B8B;EA1B9B,MAAA,EAAQ,mBAAmB,EA0BqC;EAxBhE,UAAA;AAAA;AA2CF;;;;;;;;;AAAA,KA/BY,KAAA;EACV,WAAA,WAiCK;EA/BL,MAAA,EAAQ,mBAAmB;AAAA;;;;;;AAqCjB;KA5BA,iBAAA,GAAoB,SAAA,GAAY,mBAAA,GAAsB,KAAA;;;;;;;;AAsCrC;AAW7B;;;;;;;;AAG2B;KAjCf,yBAAA;EACV,IAAA;EAEA,GAAA,EAAK,mBAAA,GAAsB,iBAAA,WAsC3B;EApCA,GAAA,EAAK,mBAAA,GAAsB,iBAAA,WAsClB;EApCT,OAAA,WAoCyB;EAlCzB,UAAA;AAAA;;;;;KAOU,IAAA;EACV,IAAA,UAoCwB;EAlCxB,MAAA,EAAQ,mBAAmB;AAAA;;;;;UAWZ,QAAA;EACf,IAAA;EAkCE;EAhCF,OAAA,EAAS,gBAAgB;AAAA;;;;;UAOV,SAAA;EACf,IAAA;EAwBW;EAtBX,OAAA,EAAS,gBAAgB;AAAA;;;;;UAOV,SAAA;EACf,IAAA;EA4BK;EA1BL,MAAA,EAAQ,gBAAgB;AAAA;;;;KAMd,gBAAA,GACR,IAAA,GACA,aAAA,GACA,yBAAA,GACA,QAAA,GACA,SAAA,GACA,SAAA;AA8CJ;;;;AAAA,KApCY,cAAA;EAwCV,gDAtCA,MAAA,EAAQ,gBAAgB,EAwCxB;EAtCA,KAAA;AAAA;AAsCqB;AAGvB;;;AAHuB,KA/BX,cAAA;;;;;;;;;;;;AAsCF;;;;;;;;;;;;KAbE,gBAAA;oCAEV,KAAA;EAEA,IAAA,EAAM,cAAA;EAEN,KAAA,EAAO,cAAc;AAAA;AAAA,KAGX,iBAAA,WAA4B,cAAA;wCAEtC,IAAA,EAAM,cAAA;EAEN,KAAA,EAAO,CAAA;AAAA"}
+{"version":3,"file":"filter.d.ts","names":[],"sources":["../../../src/components/PlAnnotations/filter.ts"],"mappings":";;;;;;;YAWY;EACV;;EAEA;;;;;;;YAQU;EACV;;EAEA;;;;;YAMU,mBAAmB,yBAAyB;;;;;YAM5C;EACV;;EAEA,QAAQ;;EAER,WAAW;;;;;;;;;;;;;YAkBD;EACV;;EAEA,QAAQ;;EAER;;;;;;;;;;;;YAaU;EACV;;EAEA,QAAQ;;EAER;;;;;;;;;;;YAYU;EACV;;EAEA,QAAQ;;;;;;;;YASE,oBAAoB,YAAY,sBAAsB;;;;;;;;;;;;;;;;;;YAmBtD;EACV;;EAEA,KAAK,sBAAsB;;EAE3B,KAAK,sBAAsB;;EAE3B;;EAEA;;;;;;YAOU;EACV;;EAEA,QAAQ;;;;;;iBAWO;EACf;;EAEA,SAAS;;;;;;iBAOM;EACf;;EAEA,SAAS;;;;;;iBAOM;EACf;;EAEA,QAAQ;;;;;YAME,mBACR,OACA,gBACA,4BACA,WACA,YACA;;;;;YAUQ;;EAEV,QAAQ;;EAER;;;;;;YAOU;;;;;;;;;;;;;;;;;;;;;;;;YAyBA;;EAEV;;EAEA,MAAM;;EAEN,OAAO;;YAGG,kBAAkB,UAAU;;EAEtC,MAAM;;EAEN,OAAO"}