@milaboratories/pl-model-common 1.47.3 → 1.49.0

package/dist/drivers/pframe/spec_driver.d.ts

@@ -1,16 +1,18 @@
 import { PoolEntry } from "../../pool_entry.js";
 import { AxesId, AxesSpec, AxisSpec, AxisValueType, ColumnValueType, PColumnIdAndSpec, PColumnSpec } from "./spec/spec.js";
+import "./spec/index.js";
 import { PTableColumnId, PTableColumnSpec } from "./table_common.js";
 import { SpecQuery, SpecQueryJoinEntry } from "./query/query_spec.js";
 import { PTableRecordFilter } from "./table_calculate.js";
 import { DataQuery, DataQueryBooleanExpression } from "./query/query_data.js";
+import "./query/index.js";
 import { AxisQualification, SingleAxisSelector } from "./spec/selectors.js";
 import { PObjectId } from "../../pool/spec.js";
+import "../../index.js";
 import { Branded } from "@milaboratories/helpers";
-
 //#region src/drivers/pframe/spec_driver.d.ts
 /** Matches a string value either exactly or by regex pattern */
-type StringMatcher = {
+export type StringMatcher = {
   type: "exact";
   value: string;
 } | {
@@ -18,9 +20,9 @@ type StringMatcher = {
   value: string;
 };
 /** Map of key to array of string matchers (OR-ed per key, AND-ed across keys) */
-type MatcherMap = Record<string, StringMatcher[]>;
+export type MatcherMap = Record<string, StringMatcher[]>;
 /** Selector for matching axes by various criteria */
-interface MultiAxisSelector {
+export interface MultiAxisSelector {
   /** Match any of the axis types listed here */
   readonly type?: AxisValueType[];
   /** Match any of the axis names listed here */
@@ -34,7 +36,7 @@ interface MultiAxisSelector {
 }
 /** Column selector for discover columns request, matching columns by various criteria.
  * Multiple selectors are OR-ed: a column matches if it satisfies any selector. */
-interface MultiColumnSelector {
+export interface MultiColumnSelector {
   /** Match any of the value types listed here */
   readonly type?: ColumnValueType[];
   /** Match any of the names listed here */
@@ -51,14 +53,14 @@ interface MultiColumnSelector {
   readonly partialAxesMatch?: boolean;
 }
 /** Qualifications needed for both query (already-integrated) columns and the hit column. */
-interface ColumnAxesWithQualifications {
+export interface ColumnAxesWithQualifications {
   /** Already integrated (query) columns with their qualifications. */
   axesSpec: AxisSpec[];
   /** Qualifications for each already integrated (query) column. */
   qualifications: AxisQualification[];
 }
 /** Fine-grained constraints controlling axes matching and qualification behavior */
-interface DiscoverColumnsConstraints {
+export interface DiscoverColumnsConstraints {
   /** Allow source (query) axes that have no match in the hit column */
   allowFloatingSourceAxes: boolean;
   /** Allow hit column axes that have no match in the source (query) */
@@ -69,7 +71,7 @@ interface DiscoverColumnsConstraints {
   allowHitQualifications: boolean;
 }
 /** Request for discovering columns compatible with a given axes integration */
-interface DiscoverColumnsRequest {
+export interface DiscoverColumnsRequest {
   /** Include columns matching these selectors (OR-ed); empty or omitted matches all columns */
   includeColumns?: MultiColumnSelector[];
   /** Exclude columns matching these selectors (OR-ed); applied after include filter */
@@ -82,7 +84,7 @@ interface DiscoverColumnsRequest {
   constraints: DiscoverColumnsConstraints;
 }
 /** Linker step: traversal through a linker column */
-interface DiscoverColumnsLinkerStep {
+export interface DiscoverColumnsLinkerStep {
   type: "linker";
   /** The linker column traversed in this step */
   linker: PColumnIdAndSpec;
@@ -93,13 +95,13 @@ interface DiscoverColumnsLinkerStep {
  * axes, so the inner-join narrows the key space to rows where the filter is
  * present.
  */
-interface DiscoverColumnsFilterStep {
+export interface DiscoverColumnsFilterStep {
   type: "filter";
   /** The filter column applied in this step */
   filter: PColumnIdAndSpec;
 }
 /** A step traversed during path-based column discovery. Discriminated by `type`. */
-type DiscoverColumnsStepInfo = DiscoverColumnsLinkerStep | DiscoverColumnsFilterStep;
+export type DiscoverColumnsStepInfo = DiscoverColumnsLinkerStep | DiscoverColumnsFilterStep;
 /**
  * Input to `buildQuery`: a terminal column plus an ordered
  * path of wrapping steps (linker hops, filter joins). Produces a
@@ -117,28 +119,32 @@ type DiscoverColumnsStepInfo = DiscoverColumnsLinkerStep | DiscoverColumnsFilter
  * Qualifications annotate the resulting outermost entry; they do not
  * propagate into the inner query.
  */
-type BuildQueryInput = {
-  /** Shape version marker — bumped only on breaking structural changes. */readonly version: "v1"; /** Terminal column id — the column actually returning data. */
-  readonly column: PObjectId; /** Ordered path from source integration to `column`. Outermost first. */
-  readonly path?: DiscoverColumnsStepInfo[]; /** Axis qualifications attached to the resulting join entry. */
+export type BuildQueryInput = {
+  /** Shape version marker — bumped only on breaking structural changes. */
+  readonly version: "v1";
+  /** Terminal column id — the column actually returning data. */
+  readonly column: PObjectId;
+  /** Ordered path from source integration to `column`. Outermost first. */
+  readonly path?: DiscoverColumnsStepInfo[];
+  /** Axis qualifications attached to the resulting join entry. */
   readonly qualifications?: AxisQualification[];
 };
 /** Qualifications info for a discover columns response mapping variant */
-interface DiscoverColumnsResponseQualifications {
+export interface DiscoverColumnsResponseQualifications {
   /** Qualifications for each query (already-integrated) column set */
   forQueries: AxisQualification[][];
   /** Qualifications for the hit column */
   forHit: AxisQualification[];
 }
 /** A single mapping variant describing how a hit column can be integrated */
-interface DiscoverColumnsMappingVariant {
+export interface DiscoverColumnsMappingVariant {
   /** Full qualifications needed for integration */
   qualifications: DiscoverColumnsResponseQualifications;
   /** Distinctive (minimal) qualifications needed for integration */
   distinctiveQualifications: DiscoverColumnsResponseQualifications;
 }
 /** A single hit in the discover columns response */
-interface DiscoverColumnsResponseHit {
+export interface DiscoverColumnsResponseHit {
   /** The column that was found compatible */
   hit: PColumnIdAndSpec;
   /** Linker steps traversed to reach this hit; empty for direct matches */
@@ -147,23 +153,23 @@ interface DiscoverColumnsResponseHit {
   mappingVariants: DiscoverColumnsMappingVariant[];
 }
 /** Response from discover columns */
-interface DiscoverColumnsResponse {
+export interface DiscoverColumnsResponse {
   /** Columns that could be integrated and possible ways to integrate them */
   hits: DiscoverColumnsResponseHit[];
 }
 /** Request for deleting an entry from a given axes integration */
-interface DeleteColumnRequest {
+export interface DeleteColumnRequest {
   /** Already integrated axes with qualifications */
   axes: ColumnAxesWithQualifications[];
   /** Zero based index of the entry to be deleted */
   delete: number;
 }
 /** Response from delete column */
-interface DeleteColumnResponse {
+export interface DeleteColumnResponse {
   axes: ColumnAxesWithQualifications[];
 }
 /** Response from evaluating a query against a PFrame. */
-type EvaluateQueryResponse = {
+export type EvaluateQueryResponse = {
   /**
    * The table specification describing the structure of the query result,
    * including all axes and columns that will be present in the output.
@@ -176,7 +182,7 @@ type EvaluateQueryResponse = {
   dataQuery: DataQuery;
 };
 /** Handle to a spec-only PFrame (no data, synchronous operations). */
-type SpecFrameHandle = Branded<string, "SpecFrameHandle">;
+export type SpecFrameHandle = Branded<string, "SpecFrameHandle">;
 /**
  * Synchronous driver for spec-level PFrame operations.
  *
@@ -184,7 +190,7 @@ type SpecFrameHandle = Branded<string, "SpecFrameHandle">;
  * operates on column specifications only. All methods are synchronous
  * because the underlying WASM PFrame computes results immediately.
  */
-interface PFrameSpecDriver {
+export interface PFrameSpecDriver {
   /** Create a spec-only PFrame from column specs. Returns a pool entry with handle and unref. */
   createSpecFrame(specs: Record<string, PColumnSpec>): PoolEntry<SpecFrameHandle>;
   /** List all columns currently registered in the frame. */
@@ -222,5 +228,4 @@ interface PFrameSpecDriver {
   }): DataQueryBooleanExpression[];
 }
 //#endregion
-export { BuildQueryInput, ColumnAxesWithQualifications, DeleteColumnRequest, DeleteColumnResponse, DiscoverColumnsConstraints, DiscoverColumnsFilterStep, DiscoverColumnsLinkerStep, DiscoverColumnsMappingVariant, DiscoverColumnsRequest, DiscoverColumnsResponse, DiscoverColumnsResponseHit, DiscoverColumnsResponseQualifications, DiscoverColumnsStepInfo, EvaluateQueryResponse, MatcherMap, MultiAxisSelector, MultiColumnSelector, PFrameSpecDriver, SpecFrameHandle, StringMatcher };
 //# sourceMappingURL=spec_driver.d.ts.map

package/dist/drivers/pframe/spec_driver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spec_driver.d.ts","names":[],"sources":["../../../src/drivers/pframe/spec_driver.ts"],"mappings":"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"}
+{"version":3,"file":"spec_driver.d.ts","names":[],"sources":["../../../src/drivers/pframe/spec_driver.ts"],"mappings":";;;;;;;;;;;;;;YAmBY;EAEN;EACA;;EAGA;EACA;;;YAIM,aAAa,eAAe;;iBAGvB;;WAEN,OAAO;;WAEP,OAAO;;WAEP,SAAS;;WAET,gBAAgB;;WAEhB,cAAc;;;;iBAKR;;WAEN,OAAO;;WAEP,OAAO;;WAEP,SAAS;;WAET,gBAAgB;;WAEhB,cAAc;;WAEd,OAAO;;WAEP;;;iBAIM;;EAEf,UAAU;;EAEV,gBAAgB;;;iBAID;;EAEf;;EAEA;;EAEA;;EAEA;;;iBAIe;;EAEf,iBAAiB;;EAEjB,iBAAiB;;EAEjB,MAAM;;EAEN;;EAEA,aAAa;;;iBAIE;EACf;;EAEA,QAAQ;;;;;;;;iBASO;EACf;;EAEA,QAAQ;;;YAIE,0BAA0B,4BAA4B;;;;;;;;;;;;;;;;;;YAmBtD;;WAED;;WAEA,QAAQ;;WAER,OAAO;;WAEP,iBAAiB;;;iBAIX;;EAEf,YAAY;;EAEZ,QAAQ;;;iBAIO;;EAEf,gBAAgB;;EAEhB,2BAA2B;;;iBAIZ;;EAEf,KAAK;;EAEL,MAAM;;EAEN,iBAAiB;;;iBAIF;;EAEf,MAAM;;;iBAIS;;EAEf,MAAM;;EAEN;;;iBAIe;EACf,MAAM;;;YAII;;;;;EAKV,WAAW;;;;;EAKX,WAAW;;;YAID,kBAAkB;;;;;;;;iBASb;;EAEf,gBAAgB,OAAO,eAAe,eAAe,UAAU;;EAG/D,YAAY,QAAQ,kBAAkB;;EAGtC,gBACE,QAAQ,iBACR,SAAS,yBACR;;EAGH,aAAa,QAAQ,iBAAiB,SAAS,sBAAsB;;EAGrE,cAAc,QAAQ,iBAAiB,SAAS,YAAY;;;;;;;;EAS5D,WAAW,OAAO,kBAAkB;;EAGpC,WAAW,MAAM,WAAW;;EAG5B,aAAa,KAAK,SAAS;;EAG3B,SAAS,MAAM,UAAU,UAAU;;EAGnC,gBAAgB,WAAW,oBAAoB,UAAU;;;;;;EAOzD,qBAAqB;IACnB,WAAW;IACX,SAAS;MACP"}

package/dist/drivers/pframe/table.d.ts

@@ -1,11 +1,10 @@
 import { PTableColumnSpec } from "./table_common.js";
 import { PTableShape, PTableVector, TableRange } from "./data_types.js";
-
 //#region src/drivers/pframe/table.d.ts
 /**
  * Table view.
  * */
-interface PTable {
+export interface PTable {
   /** Unified table shape */
   getShape(): Promise<PTableShape>;
   /**
@@ -29,5 +28,4 @@ interface PTable {
   getData(columnIndices: number[], range?: TableRange): Promise<PTableVector[]>;
 }
 //#endregion
-export { PTable };
 //# sourceMappingURL=table.d.ts.map

package/dist/drivers/pframe/table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"table.d.ts","names":[],"sources":["../../../src/drivers/pframe/table.ts"],"mappings":";;;;;;AAMA;UAAiB,MAAA;;EAEf,QAAA,IAAY,OAAA,CAAQ,WAAA;EAAR;;;;;;;;;EAWZ,OAAA,IAAW,OAAA,CAAQ,gBAAA;EAXC;;;;;;;;EAqBpB,OAAA,CAAQ,aAAA,YAAyB,KAAA,GAAQ,UAAA,GAAa,OAAA,CAAQ,YAAA;AAAA"}
+{"version":3,"file":"table.d.ts","names":[],"sources":["../../../src/drivers/pframe/table.ts"],"mappings":";;;;;;iBAMiB;;EAEf,YAAY,QAAQ;;;;;;;;;;EAWpB,WAAW,QAAQ;;;;;;;;;EAUnB,QAAQ,yBAAyB,QAAQ,aAAa,QAAQ"}

package/dist/drivers/pframe/table_calculate.d.ts

@@ -4,9 +4,10 @@ import { PTableVector } from "./data_types.js";
 import { PColumnValues } from "./data_info.js";
 import { SpecQuery, SpecQueryJoinEntry } from "./query/query_spec.js";
 import { PObjectId } from "../../pool/spec.js";
+import "../../pool/index.js";
 //#region src/drivers/pframe/table_calculate.d.ts
 /** Defines a terminal column node in the join request tree */
-interface ColumnJoinEntry<Col> {
+export interface ColumnJoinEntry<Col> {
   /** Node type discriminator */
   readonly type: "column";
   /** Local column */
@@ -16,7 +17,7 @@ interface ColumnJoinEntry<Col> {
  * Axis filter slicing target axis from column axes.
  * If the axis has parents or is a parent, slicing cannot be applied (an error will be thrown).
  * */
-interface ConstantAxisFilter {
+export interface ConstantAxisFilter {
   /** Filter type discriminator */
   readonly type: "constant";
   /** Index of axis to slice (zero-based) */
@@ -25,7 +26,7 @@ interface ConstantAxisFilter {
   readonly constant: string | number;
 }
 /** Defines a terminal column node in the join request tree */
-interface SlicedColumnJoinEntry<Col> {
+export interface SlicedColumnJoinEntry<Col> {
   /** Node type discriminator */
   readonly type: "slicedColumn";
   /** Local column */
@@ -35,7 +36,7 @@ interface SlicedColumnJoinEntry<Col> {
   /** Non-empty list of axis filters */
   readonly axisFilters: ConstantAxisFilter[];
 }
-interface ArtificialColumnJoinEntry<Col> {
+export interface ArtificialColumnJoinEntry<Col> {
   /** Node type discriminator */
   readonly type: "artificialColumn";
   /** Column definition */
@@ -46,7 +47,7 @@ interface ArtificialColumnJoinEntry<Col> {
   readonly axesIndices: number[];
 }
 /** Defines a terminal column node in the join request tree */
-interface InlineColumnJoinEntry {
+export interface InlineColumnJoinEntry {
   /** Node type discriminator */
   readonly type: "inlineColumn";
   /** Column definition */
@@ -56,7 +57,7 @@ interface InlineColumnJoinEntry {
  * Defines a join request tree node that will output only records present in
  * all child nodes ({@link entries}).
  * */
-interface InnerJoin<Col> {
+export interface InnerJoin<Col> {
   /** Node type discriminator */
   readonly type: "inner";
   /** Child nodes to be inner joined */
@@ -67,7 +68,7 @@ interface InnerJoin<Col> {
  * least in one of the child nodes ({@link entries}), values for those PColumns
  * that lack corresponding combinations of axis values will be null.
  * */
-interface FullJoin<Col> {
+export interface FullJoin<Col> {
   /** Node type discriminator */
   readonly type: "full";
   /** Child nodes to be fully outer joined */
@@ -83,7 +84,7 @@ interface FullJoin<Col> {
  * This node can be thought as a chain of SQL LEFT JOIN operations starting from
  * the {@link primary} node and adding {@link secondary} nodes one by one.
  * */
-interface OuterJoin<Col> {
+export interface OuterJoin<Col> {
   /** Node type discriminator */
   readonly type: "outer";
   /** Primes the join operation. Left part of LEFT JOIN. */
@@ -99,79 +100,79 @@ interface OuterJoin<Col> {
  * the PColumns. Common axis are those axis which have equal {@link AxisId} derived
  * from the columns axes spec.
  * */
-type JoinEntry<Col> = ColumnJoinEntry<Col> | SlicedColumnJoinEntry<Col> | ArtificialColumnJoinEntry<Col> | InlineColumnJoinEntry | InnerJoin<Col> | FullJoin<Col> | OuterJoin<Col>;
+export type JoinEntry<Col> = ColumnJoinEntry<Col> | SlicedColumnJoinEntry<Col> | ArtificialColumnJoinEntry<Col> | InlineColumnJoinEntry | InnerJoin<Col> | FullJoin<Col> | OuterJoin<Col>;
 /** Container representing whole data stored in specific PTable column. */
-interface FullPTableColumnData {
+export interface FullPTableColumnData {
   /** Unified spec */
   readonly spec: PTableColumnSpec;
   /** Data */
   readonly data: PTableVector;
 }
-interface SingleValueIsNAPredicate {
+export interface SingleValueIsNAPredicate {
   /** Comparison operator */
   readonly operator: "IsNA";
 }
-interface SingleValueEqualPredicate {
+export interface SingleValueEqualPredicate {
   /** Comparison operator */
   readonly operator: "Equal";
   /** Reference value, NA values will not match */
   readonly reference: string | number;
 }
-interface SingleValueInSetPredicate {
+export interface SingleValueInSetPredicate {
   /** Comparison operator */
   readonly operator: "InSet";
   /** Reference values, NA values will not match */
   readonly references: (string | number)[];
 }
-interface SingleValueIEqualPredicate {
+export interface SingleValueIEqualPredicate {
   /** Comparison operator (case insensitive) */
   readonly operator: "IEqual";
   /** Reference value, NA values will not match */
   readonly reference: string;
 }
-interface SingleValueLessPredicate {
+export interface SingleValueLessPredicate {
   /** Comparison operator */
   readonly operator: "Less";
   /** Reference value, NA values will not match */
   readonly reference: string | number;
 }
-interface SingleValueLessOrEqualPredicate {
+export interface SingleValueLessOrEqualPredicate {
   /** Comparison operator */
   readonly operator: "LessOrEqual";
   /** Reference value, NA values will not match */
   readonly reference: string | number;
 }
-interface SingleValueGreaterPredicate {
+export interface SingleValueGreaterPredicate {
   /** Comparison operator */
   readonly operator: "Greater";
   /** Reference value, NA values will not match */
   readonly reference: string | number;
 }
-interface SingleValueGreaterOrEqualPredicate {
+export interface SingleValueGreaterOrEqualPredicate {
   /** Comparison operator */
   readonly operator: "GreaterOrEqual";
   /** Reference value, NA values will not match */
   readonly reference: string | number;
 }
-interface SingleValueStringContainsPredicate {
+export interface SingleValueStringContainsPredicate {
   /** Comparison operator */
   readonly operator: "StringContains";
   /** Reference substring, NA values are skipped */
   readonly substring: string;
 }
-interface SingleValueStringIContainsPredicate {
+export interface SingleValueStringIContainsPredicate {
   /** Comparison operator (case insensitive) */
   readonly operator: "StringIContains";
   /** Reference substring, NA values are skipped */
   readonly substring: string;
 }
-interface SingleValueMatchesPredicate {
+export interface SingleValueMatchesPredicate {
   /** Comparison operator */
   readonly operator: "Matches";
   /** Regular expression, NA values are skipped */
   readonly regex: string;
 }
-interface SingleValueStringContainsFuzzyPredicate {
+export interface SingleValueStringContainsFuzzyPredicate {
   /** Comparison operator */
   readonly operator: "StringContainsFuzzy";
   /** Reference value, NA values are skipped */
@@ -195,7 +196,7 @@ interface SingleValueStringContainsFuzzyPredicate {
    */
   readonly wildcard?: string;
 }
-interface SingleValueStringIContainsFuzzyPredicate {
+export interface SingleValueStringIContainsFuzzyPredicate {
   /** Comparison operator (case insensitive) */
   readonly operator: "StringIContainsFuzzy";
   /** Reference value, NA values are skipped */
@@ -219,33 +220,33 @@ interface SingleValueStringIContainsFuzzyPredicate {
    */
   readonly wildcard?: string;
 }
-interface SingleValueNotPredicateV2 {
+export interface SingleValueNotPredicateV2 {
   /** Comparison operator */
   readonly operator: "Not";
   /** Operand to negate */
   readonly operand: SingleValuePredicateV2;
 }
-interface SingleValueAndPredicateV2 {
+export interface SingleValueAndPredicateV2 {
   /** Comparison operator */
   readonly operator: "And";
   /** Operands to combine */
   readonly operands: SingleValuePredicateV2[];
 }
-interface SingleValueOrPredicateV2 {
+export interface SingleValueOrPredicateV2 {
   /** Comparison operator */
   readonly operator: "Or";
   /** Operands to combine */
   readonly operands: SingleValuePredicateV2[];
 }
 /** Filtering predicate for a single axis or column value */
-type SingleValuePredicateV2 = SingleValueIsNAPredicate | SingleValueEqualPredicate | SingleValueInSetPredicate | SingleValueLessPredicate | SingleValueLessOrEqualPredicate | SingleValueGreaterPredicate | SingleValueGreaterOrEqualPredicate | SingleValueStringContainsPredicate | SingleValueMatchesPredicate | SingleValueStringContainsFuzzyPredicate | SingleValueNotPredicateV2 | SingleValueAndPredicateV2 | SingleValueOrPredicateV2 | SingleValueIEqualPredicate | SingleValueStringIContainsPredicate | SingleValueStringIContainsFuzzyPredicate;
+export type SingleValuePredicateV2 = SingleValueIsNAPredicate | SingleValueEqualPredicate | SingleValueInSetPredicate | SingleValueLessPredicate | SingleValueLessOrEqualPredicate | SingleValueGreaterPredicate | SingleValueGreaterOrEqualPredicate | SingleValueStringContainsPredicate | SingleValueMatchesPredicate | SingleValueStringContainsFuzzyPredicate | SingleValueNotPredicateV2 | SingleValueAndPredicateV2 | SingleValueOrPredicateV2 | SingleValueIEqualPredicate | SingleValueStringIContainsPredicate | SingleValueStringIContainsFuzzyPredicate;
 /**
  * Filter PTable records based on specific axis or column value. If this is an
  * axis value filter and the axis is part of a partitioning key in some of the
  * source PColumns, the filter will be pushed down to those columns, so only
  * specific partitions will be retrieved from the remote storage.
  * */
-interface PTableRecordSingleValueFilterV2 {
+export interface PTableRecordSingleValueFilterV2 {
   /** Filter type discriminator */
   readonly type: "bySingleColumnV2";
   /** Target axis selector to examine values from */
@@ -254,15 +255,18 @@ interface PTableRecordSingleValueFilterV2 {
   readonly predicate: SingleValuePredicateV2;
 }
 /** Generic PTable records filter */
-type PTableRecordFilter = PTableRecordSingleValueFilterV2;
+export type PTableRecordFilter = PTableRecordSingleValueFilterV2;
 /** Sorting parameters for a PTable.  */
-type PTableSorting = {
-  /** Unified column identifier */readonly column: PTableColumnId; /** Sorting order */
-  readonly ascending: boolean; /** Sorting in respect to NA and absent values */
+export type PTableSorting = {
+  /** Unified column identifier */
+  readonly column: PTableColumnId;
+  /** Sorting order */
+  readonly ascending: boolean;
+  /** Sorting in respect to NA and absent values */
   readonly naAndAbsentAreLeastValues: boolean;
 };
 /** Information required to instantiate a PTable. */
-interface PTableDef<Col> {
+export interface PTableDef<Col> {
   /** Join tree to populate the PTable */
   readonly src: JoinEntry<Col>;
   /** Partition filters */
@@ -273,27 +277,32 @@ interface PTableDef<Col> {
   readonly sorting: PTableSorting[];
 }
 /** Information required to instantiate a PTable (V2, query-based). */
-interface PTableDefV2<Col> {
+export interface PTableDefV2<Col> {
   /** Pre-built query spec describing joins, filters and sorting */
   readonly query: SpecQuery<Col>;
 }
 /** Request to create and retrieve entirety of data of PTable. */
-type CalculateTableDataRequest<Col> = {
-  /** Join tree to populate the PTable */readonly src: JoinEntry<Col>; /** Record filters */
-  readonly filters: PTableRecordFilter[]; /** Table sorting */
+export type CalculateTableDataRequest<Col> = {
+  /** Join tree to populate the PTable */
+  readonly src: JoinEntry<Col>;
+  /** Record filters */
+  readonly filters: PTableRecordFilter[];
+  /** Table sorting */
   readonly sorting: PTableSorting[];
 };
 /** Response for {@link CalculateTableDataRequest} */
-type CalculateTableDataResponse = FullPTableColumnData[];
-declare function mapPTableDef<C1, C2>(def: PTableDef<C1>, cb: (c: C1) => C2): PTableDef<C2>;
-declare function sortPTableDef(def: PTableDef<PObjectId>): PTableDef<PObjectId>;
-declare function mapPTableDefV2<C1, C2>(def: PTableDefV2<C1>, visitor: {
-  /** Transform column references in leaf nodes (column, sparseToDenseColumn). */column: (c: C1) => C2; /** Visit a node after its children have been traversed. */
-  node?: (node: SpecQuery<C2>) => SpecQuery<C2>; /** Visit a join entry after its inner query has been traversed. */
+export type CalculateTableDataResponse = FullPTableColumnData[];
+export declare function mapPTableDef<C1, C2>(def: PTableDef<C1>, cb: (c: C1) => C2): PTableDef<C2>;
+export declare function sortPTableDef(def: PTableDef<PObjectId>): PTableDef<PObjectId>;
+export declare function mapPTableDefV2<C1, C2>(def: PTableDefV2<C1>, visitor: {
+  /** Transform column references in leaf nodes (column, sparseToDenseColumn). */
+  column: (c: C1) => C2;
+  /** Visit a node after its children have been traversed. */
+  node?: (node: SpecQuery<C2>) => SpecQuery<C2>;
+  /** Visit a join entry after its inner query has been traversed. */
   joinEntry?: (entry: SpecQueryJoinEntry<C2>) => SpecQueryJoinEntry<C2>;
 }): PTableDefV2<C2>;
-declare function mapJoinEntry<C1, C2>(entry: JoinEntry<C1>, cb: (c: C1) => C2): JoinEntry<C2>;
-declare function sortJoinEntry(entry: JoinEntry<PObjectId>): JoinEntry<PObjectId>;
+export declare function mapJoinEntry<C1, C2>(entry: JoinEntry<C1>, cb: (c: C1) => C2): JoinEntry<C2>;
+export declare function sortJoinEntry(entry: JoinEntry<PObjectId>): JoinEntry<PObjectId>;
 //#endregion
-export { ArtificialColumnJoinEntry, CalculateTableDataRequest, CalculateTableDataResponse, ColumnJoinEntry, ConstantAxisFilter, FullJoin, FullPTableColumnData, InlineColumnJoinEntry, InnerJoin, JoinEntry, OuterJoin, PTableDef, PTableDefV2, PTableRecordFilter, PTableRecordSingleValueFilterV2, PTableSorting, SingleValueAndPredicateV2, SingleValueEqualPredicate, SingleValueGreaterOrEqualPredicate, SingleValueGreaterPredicate, SingleValueIEqualPredicate, SingleValueInSetPredicate, SingleValueIsNAPredicate, SingleValueLessOrEqualPredicate, SingleValueLessPredicate, SingleValueMatchesPredicate, SingleValueNotPredicateV2, SingleValueOrPredicateV2, SingleValuePredicateV2, SingleValueStringContainsFuzzyPredicate, SingleValueStringContainsPredicate, SingleValueStringIContainsFuzzyPredicate, SingleValueStringIContainsPredicate, SlicedColumnJoinEntry, mapJoinEntry, mapPTableDef, mapPTableDefV2, sortJoinEntry, sortPTableDef };
 //# sourceMappingURL=table_calculate.d.ts.map

package/dist/drivers/pframe/table_calculate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"table_calculate.d.ts","names":[],"sources":["../../../src/drivers/pframe/table_calculate.ts"],"mappings":"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"}
+{"version":3,"file":"table_calculate.d.ts","names":[],"sources":["../../../src/drivers/pframe/table_calculate.ts"],"mappings":";;;;;;;;;iBAWiB,gBAAgB;;WAEtB;;WAGA,QAAQ;;;;;;iBAOF;;WAEN;;WAGA;;WAGA;;;iBAIM,sBAAsB;;WAE5B;;WAGA,QAAQ;;WAGR,OAAO;;WAGP,aAAa;;iBAGP,0BAA0B;;WAEhC;;WAGA,QAAQ;;WAGR,OAAO;;WAGP;;;iBAIM;;WAEN;;WAGA,QAAQ,QAAQ;;;;;;iBAOV,UAAU;;WAEhB;;WAGA,SAAS,UAAU;;;;;;;iBAQb,SAAS;;WAEf;;WAGA,SAAS,UAAU;;;;;;;;;;;;iBAab,UAAU;;WAEhB;;WAGA,SAAS,UAAU;;;WAInB,WAAW,UAAU;;;;;;;;;YAUpB,UAAU,OAClB,gBAAgB,OAChB,sBAAsB,OACtB,0BAA0B,OAC1B,wBACA,UAAU,OACV,SAAS,OACT,UAAU;;iBAGG;;WAEN,MAAM;;WAGN,MAAM;;iBAGA;;WAEN;;iBAGM;;WAEN;;WAGA;;iBAGM;;WAEN;;WAGA;;iBAGM;;WAEN;;WAGA;;iBAGM;;WAEN;;WAGA;;iBAGM;;WAEN;;WAGA;;iBAGM;;WAEN;;WAGA;;iBAGM;;WAEN;;WAGA;;iBAGM;;WAEN;;WAGA;;iBAGM;;WAEN;;WAGA;;iBAGM;;WAEN;;WAGA;;iBAGM;;WAEN;;WAGA;;;;;;;;;;;WAYA;;WAGA;;;;;WAMA;;iBAGM;;WAEN;;WAGA;;;;;;;;;;;WAYA;;WAGA;;;;;WAMA;;iBAGM;;WAEN;;WAGA,SAAS;;iBAGH;;WAEN;;WAGA,UAAU;;iBAGJ;;WAEN;;WAGA,UAAU;;;YAIT,yBACR,2BACA,4BACA,4BACA,2BACA,kCACA,8BACA,qCACA,qCACA,8BACA,0CACA,4BACA,4BACA,2BACA,6BACA,sCACA;;;;;;;iBAQa;;WAEN;;WAGA,QAAQ;;WAGR,WAAW;;;YAIV,qBAAqB;;YAGrB;;WAED,QAAQ;;WAGR;;WAGA;;;iBAIM,UAAU;;WAEhB,KAAK,UAAU;;WAGf,kBAAkB;;WAGlB,SAAS;;WAGT,SAAS;;;iBAIH,YAAY;;WAElB,OAAO,UAAU;;;YAIhB,0BAA0B;;WAE3B,KAAK,UAAU;;WAGf,SAAS;;WAGT,SAAS;;;YAIR,6BAA6B;wBAEzB,aAAa,IAAI,IAAI,KAAK,UAAU,KAAK,KAAK,GAAG,OAAO,KAAK,UAAU;wBAIvE,cAAc,KAAK,UAAU,aAAa,UAAU;wBAsBpD,eAAe,IAAI,IACjC,KAAK,YAAY,KACjB;;EAEE,SAAS,GAAG,OAAO;;EAEnB,QAAQ,MAAM,UAAU,QAAQ,UAAU;;EAE1C,aAAa,OAAO,mBAAmB,QAAQ,mBAAmB;IAEnE,YAAY;wBAIC,aAAa,IAAI,IAAI,OAAO,UAAU,KAAK,KAAK,GAAG,OAAO,KAAK,UAAU;wBA0FzE,cAAc,OAAO,UAAU,aAAa,UAAU"}

package/dist/drivers/pframe/table_common.d.ts

@@ -1,13 +1,12 @@
 import { AxisId, AxisSpec, PColumnSpec } from "./spec/spec.js";
 import { ColumnUniversalId } from "./spec/ids.js";
-
 //#region src/drivers/pframe/table_common.d.ts
-type PTableColumnSpecAxis = {
+export type PTableColumnSpecAxis = {
   type: "axis";
   id: AxisId;
   spec: AxisSpec;
 };
-type PTableColumnSpecColumn = {
+export type PTableColumnSpecColumn = {
   type: "column";
   /**
    * Leaf column id as it appears in the SpecQuery — may be a rich
@@ -19,18 +18,18 @@ type PTableColumnSpecColumn = {
   spec: PColumnSpec;
 };
 /** Unified spec object for axes and columns */
-type PTableColumnSpec = PTableColumnSpecAxis | PTableColumnSpecColumn;
-type PTableColumnIdAxis = {
+export type PTableColumnSpec = PTableColumnSpecAxis | PTableColumnSpecColumn;
+export type PTableColumnIdAxis = {
   type: "axis";
   id: AxisId;
 };
-type PTableColumnIdColumn = {
-  type: "column"; /** @see PTableColumnSpecColumn.id */
+export type PTableColumnIdColumn = {
+  type: "column";
+  /** @see PTableColumnSpecColumn.id */
   id: ColumnUniversalId;
 };
 /** Unified PTable column identifier */
-type PTableColumnId = PTableColumnIdAxis | PTableColumnIdColumn;
-declare function getPTableColumnId(spec: PTableColumnSpec): PTableColumnId;
+export type PTableColumnId = PTableColumnIdAxis | PTableColumnIdColumn;
+export declare function getPTableColumnId(spec: PTableColumnSpec): PTableColumnId;
 //#endregion
-export { PTableColumnId, PTableColumnIdAxis, PTableColumnIdColumn, PTableColumnSpec, PTableColumnSpecAxis, PTableColumnSpecColumn, getPTableColumnId };
 //# sourceMappingURL=table_common.d.ts.map

package/dist/drivers/pframe/table_common.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"table_common.d.ts","names":[],"sources":["../../../src/drivers/pframe/table_common.ts"],"mappings":";;;;KAGY,oBAAA;EACV,IAAA;EACA,EAAA,EAAI,MAAA;EACJ,IAAA,EAAM,QAAQ;AAAA;AAAA,KAGJ,sBAAA;EACV,IAAA;EALA;;;;;AACc;EAWd,EAAA,EAAI,iBAAA;EACJ,IAAA,EAAM,WAAW;AAAA;;KAIP,gBAAA,GAAmB,oBAAA,GAAuB,sBAAsB;AAAA,KAEhE,kBAAA;EACV,IAAA;EACA,EAAA,EAAI,MAAM;AAAA;AAAA,KAGA,oBAAA;EACV,IAAA,YARU;EAUV,EAAA,EAAI,iBAAiB;AAAA;;KAIX,cAAA,GAAiB,kBAAA,GAAqB,oBAAoB;AAAA,iBAEtD,iBAAA,CAAkB,IAAA,EAAM,gBAAA,GAAmB,cAAc"}
+{"version":3,"file":"table_common.d.ts","names":[],"sources":["../../../src/drivers/pframe/table_common.ts"],"mappings":";;;YAGY;EACV;EACA,IAAI;EACJ,MAAM;;YAGI;EACV;;;;;;;EAOA,IAAI;EACJ,MAAM;;;YAII,mBAAmB,uBAAuB;YAE1C;EACV;EACA,IAAI;;YAGM;EACV;;EAEA,IAAI;;;YAIM,iBAAiB,qBAAqB;wBAElC,kBAAkB,MAAM,mBAAmB"}

package/dist/drivers/pframe/unique_values.d.ts

@@ -2,9 +2,10 @@ import { AxisId } from "./spec/spec.js";
 import { PTableVector } from "./data_types.js";
 import { PTableRecordFilter } from "./table_calculate.js";
 import { PObjectId } from "../../pool/spec.js";
+import "../../pool/index.js";
 //#region src/drivers/pframe/unique_values.d.ts
 /** Calculate set of unique values for a specific axis for the filtered set of records */
-interface UniqueValuesRequest {
+export interface UniqueValuesRequest {
   /** Target axis id */
   readonly columnId: PObjectId;
   /** Target axis id, if not specified calculates unique column values */
@@ -14,12 +15,11 @@ interface UniqueValuesRequest {
   /** Max number of values to return, if reached response will contain overflow flag */
   readonly limit: number;
 }
-interface UniqueValuesResponse {
+export interface UniqueValuesResponse {
   /** Unique values */
   readonly values: PTableVector;
   /** True if limit was reached and response contain non-exhaustive list of values. */
   readonly overflow: boolean;
 }
 //#endregion
-export { UniqueValuesRequest, UniqueValuesResponse };
 //# sourceMappingURL=unique_values.d.ts.map

package/dist/drivers/pframe/unique_values.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unique_values.d.ts","names":[],"sources":["../../../src/drivers/pframe/unique_values.ts"],"mappings":";;;;;;UAMiB,mBAAA;;WAEN,QAAA,EAAU,SAAA;EAFe;EAAA,SAKzB,IAAA,GAAO,MAAA;EAHG;EAAA,SAMV,OAAA,EAAS,kBAAA;EAAA;EAAA,SAGT,KAAA;AAAA;AAAA,UAGM,oBAAA;EAZI;EAAA,SAcV,MAAA,EAAQ,YAAY;EAXb;EAAA,SAcP,QAAA;AAAA"}
+{"version":3,"file":"unique_values.d.ts","names":[],"sources":["../../../src/drivers/pframe/unique_values.ts"],"mappings":";;;;;;;iBAMiB;;WAEN,UAAU;;WAGV,OAAO;;WAGP,SAAS;;WAGT;;iBAGM;;WAEN,QAAQ;;WAGR"}

package/dist/drivers/upload.d.ts

@@ -1,5 +1,5 @@
 //#region src/drivers/upload.d.ts
-interface ImportProgress {
+export interface ImportProgress {
   done: boolean;
   /** Status of indexing/uploading got from platforma gRPC. */
   status?: ImportStatus;
@@ -14,12 +14,11 @@ interface ImportProgress {
   lastError?: string;
 }
 /** Almost direct mapping from proto struct got from gRPC. */
-interface ImportStatus {
+export interface ImportStatus {
   /** A float from 0 to 1 and is equal to bytesProcessed / bytesTotal. */
   readonly progress: number;
   readonly bytesProcessed?: number;
   readonly bytesTotal?: number;
 }
 //#endregion
-export { ImportProgress, ImportStatus };
 //# sourceMappingURL=upload.d.ts.map

package/dist/drivers/upload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upload.d.ts","names":[],"sources":["../../src/drivers/upload.ts"],"mappings":";UAAiB,cAAA;EACf,IAAA;EAD6B;EAG7B,MAAA,GAAS,YAAY;EAAA;EAAA,SAEZ,QAAA;EAFT;EAIA,iBAAA;EAFS;;;;EAOT,SAAA;AAAA;;UAIe,YAAA;EAAY;EAAA,SAElB,QAAA;EAAA,SACA,cAAA;EAAA,SACA,UAAA;AAAA"}
+{"version":3,"file":"upload.d.ts","names":[],"sources":["../../src/drivers/upload.ts"],"mappings":";iBAAiB;EACf;;EAEA,SAAS;;WAEA;;EAET;;;;;EAKA;;;iBAIe;;WAEN;WACA;WACA"}