@milaboratories/pl-model-common 1.47.3 → 1.49.0

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

@@ -6,26 +6,30 @@
  * Note: Actual columns can hold more value types, which are converted to these JavaScript types
  * once they enter the JavaScript runtime.
  */
-type PColumnValue = null | number | string;
+export type PColumnValue = null | number | string;
 /**
  * Represents a key for a PColumn value.
  * Can be an array of strings or numbers.
  */
-type PColumnKey = (number | string)[];
+export type PColumnKey = (number | string)[];
 /**
  * Represents a single entry in a PColumn's data structure.
  * Contains a key and a value.
  */
-type PColumnDataEntry<T> = {
-  /** Key for the value */key: PColumnKey; /** Value / blob at the given key */
+export type PColumnDataEntry<T> = {
+  /** Key for the value */
+  key: PColumnKey;
+  /** Value / blob at the given key */
   value: T;
 };
 /**
  * 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) */
+export type JsonDataInfo = {
+  /** Identifier for this data format ('Json') */
+  type: "Json";
+  /** Number of axes that make up the complete key (tuple length) */
   keyLength: number;
   /**
    * Key-value pairs where keys are stringified tuples of axis values
@@ -37,57 +41,81 @@ type JsonDataInfo = {
  * Represents column data partitioned across multiple JSON blobs.
  * Used for larger datasets that need to be split into manageable chunks.
  */
-type JsonPartitionedDataInfo<Blob> = {
-  /** Identifier for this data format ('JsonPartitioned') */type: "JsonPartitioned"; /** Number of leading axes used for partitioning */
-  partitionKeyLength: number; /** Map of stringified partition keys to blob references */
+export type JsonPartitionedDataInfo<Blob> = {
+  /** Identifier for this data format ('JsonPartitioned') */
+  type: "JsonPartitioned";
+  /** Number of leading axes used for partitioning */
+  partitionKeyLength: number;
+  /** Map of stringified partition keys to blob references */
   parts: Record<string, Blob>;
 };
 /**
  * Represents a binary format chunk containing index and values as separate blobs.
  * Used for efficient storage and retrieval of column data in binary format.
  */
-type BinaryChunk<Blob> = {
-  /** Binary blob containing structured index information */index: Blob; /** Binary blob containing the actual values */
+export type BinaryChunk<Blob> = {
+  /** Binary blob containing structured index information */
+  index: Blob;
+  /** Binary blob containing the actual values */
   values: Blob;
 };
 /**
  * Represents column data partitioned across multiple binary chunks.
  * Optimized for efficient storage and retrieval of large datasets.
  */
-type BinaryPartitionedDataInfo<Blob> = {
-  /** Identifier for this data format ('BinaryPartitioned') */type: "BinaryPartitioned"; /** Number of leading axes used for partitioning */
-  partitionKeyLength: number; /** Map of stringified partition keys to binary chunks */
+export type BinaryPartitionedDataInfo<Blob> = {
+  /** Identifier for this data format ('BinaryPartitioned') */
+  type: "BinaryPartitioned";
+  /** Number of leading axes used for partitioning */
+  partitionKeyLength: number;
+  /** Map of stringified partition keys to binary chunks */
   parts: Record<string, BinaryChunk<Blob>>;
 };
-type ParquetChunkMappingAxis = {
-  /** Data type (matches PColumn axis types) */type: "Int" | "Long" | "String"; /** Field name in the Parquet file */
+export type ParquetChunkMappingAxis = {
+  /** Data type (matches PColumn axis types) */
+  type: "Int" | "Long" | "String";
+  /** Field name in the Parquet file */
   id: string;
 };
-type ParquetChunkMappingColumn = {
-  /** Data type (matches PColumn value type) */type: "Int" | "Long" | "Float" | "Double" | "String"; /** Field name in the Parquet file */
+export type ParquetChunkMappingColumn = {
+  /** Data type (matches PColumn value type) */
+  type: "Int" | "Long" | "Float" | "Double" | "String";
+  /** Field name in the Parquet file */
   id: string;
 };
-type ParquetChunkMapping = {
-  /** Axes mappings - Parquet file is sorted by these fields in this order */axes: ParquetChunkMappingAxis[]; /** Column mapping */
+export type ParquetChunkMapping = {
+  /** Axes mappings - Parquet file is sorted by these fields in this order */
+  axes: ParquetChunkMappingAxis[];
+  /** Column mapping */
   column: ParquetChunkMappingColumn;
 };
-type ParquetChunkStats = {
-  /** Number of rows in the chunk */numberOfRows: number; /** Byte size information for storage optimization and query planning */
+export type ParquetChunkStats = {
+  /** Number of rows in the chunk */
+  numberOfRows: number;
+  /** Byte size information for storage optimization and query planning */
   size: {
-    /** Byte sizes for each axis column in the same order as axes mapping */axes: number[]; /** Byte size for the data column */
+    /** Byte sizes for each axis column in the same order as axes mapping */
+    axes: number[];
+    /** Byte size for the data column */
     column: number;
   };
 };
-type ParquetChunkMetadata = {
-  /** Content hash calculated for the specific axes and data this chunk represents */dataDigest: string; /** Pre-computed statistics for optimization without blob download */
+export type ParquetChunkMetadata = {
+  /** Content hash calculated for the specific axes and data this chunk represents */
+  dataDigest: string;
+  /** Pre-computed statistics for optimization without blob download */
   stats: Partial<ParquetChunkStats>;
 };
-type ParquetChunk<Blob> = {
-  /** Parquet file (PTable) containing column data */data: Blob;
+export type ParquetChunk<Blob> = {
+  /** Parquet file (PTable) containing column data */
+  data: Blob;
 } & ParquetChunkMapping & Partial<ParquetChunkMetadata>;
-type ParquetPartitionedDataInfo<Blob> = {
-  /** Identifier for this data format ('ParquetPartitioned') */type: "ParquetPartitioned"; /** Number of leading axes used for partitioning */
-  partitionKeyLength: number; /** Map of stringified partition keys to parquet files */
+export type ParquetPartitionedDataInfo<Blob> = {
+  /** Identifier for this data format ('ParquetPartitioned') */
+  type: "ParquetPartitioned";
+  /** Number of leading axes used for partitioning */
+  partitionKeyLength: number;
+  /** Map of stringified partition keys to parquet files */
   parts: Record<string, Blob>;
 };
 /**
@@ -96,14 +124,14 @@ 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>;
+export 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
  */
-declare function isDataInfo<Blob>(value: unknown): value is DataInfo<Blob>;
+export declare function isDataInfo<Blob>(value: unknown): value is DataInfo<Blob>;
 /**
  * Maps blob references in a DataInfo object from one type to another using a mapping function.
  *
@@ -113,20 +141,20 @@ declare function isDataInfo<Blob>(value: unknown): value is DataInfo<Blob>;
  * @param mapFn - Function to transform blobs from type B1 to type B2
  * @returns A new DataInfo object with transformed blob references
  */
-declare function mapDataInfo<B1, B2>(dataInfo: ParquetPartitionedDataInfo<B1>, mapFn: (blob: B1) => B2): ParquetPartitionedDataInfo<B2>;
-declare function mapDataInfo<B1, B2>(dataInfo: Exclude<DataInfo<B1>, ParquetPartitionedDataInfo<B1>>, mapFn: (blob: B1) => B2): Exclude<DataInfo<B2>, ParquetPartitionedDataInfo<B2>>;
-declare function mapDataInfo<B1, B2>(dataInfo: DataInfo<B1>, mapFn: (blob: B1) => B2): DataInfo<B2>;
+export declare function mapDataInfo<B1, B2>(dataInfo: ParquetPartitionedDataInfo<B1>, mapFn: (blob: B1) => B2): ParquetPartitionedDataInfo<B2>;
+export declare function mapDataInfo<B1, B2>(dataInfo: Exclude<DataInfo<B1>, ParquetPartitionedDataInfo<B1>>, mapFn: (blob: B1) => B2): Exclude<DataInfo<B2>, ParquetPartitionedDataInfo<B2>>;
+export declare function mapDataInfo<B1, B2>(dataInfo: DataInfo<B1>, mapFn: (blob: B1) => B2): DataInfo<B2>;
 /**
  * @param dataInfo - The source DataInfo object
  * @param cb - Callback, function that have access to every blob to visit them all
  * @returns Nothing
  */
-declare function visitDataInfo<B>(dataInfo: DataInfo<B>, cb: (blob: B) => void): void;
+export declare function visitDataInfo<B>(dataInfo: DataInfo<B>, cb: (blob: B) => void): void;
 /**
  * Represents a single key-value entry in a column's explicit data structure.
  * Used when directly instantiating PColumns with explicit data.
  */
-type PColumnValuesEntry = {
+export type PColumnValuesEntry = {
   key: PColumnKey;
   val: PColumnValue;
 };
@@ -134,11 +162,11 @@ type PColumnValuesEntry = {
  * Array of key-value entries representing explicit column data.
  * Used for lightweight explicit instantiation of PColumns.
  */
-type PColumnValues = PColumnValuesEntry[];
+export type PColumnValues = PColumnValuesEntry[];
 /**
  * Entry-based representation of JsonDataInfo
  */
-interface JsonDataInfoEntries {
+export interface JsonDataInfoEntries {
   type: "Json";
   keyLength: number;
   data: PColumnDataEntry<PColumnValue>[];
@@ -146,7 +174,7 @@ interface JsonDataInfoEntries {
 /**
  * Entry-based representation of JsonPartitionedDataInfo
  */
-interface JsonPartitionedDataInfoEntries<Blob> {
+export interface JsonPartitionedDataInfoEntries<Blob> {
   type: "JsonPartitioned";
   partitionKeyLength: number;
   parts: PColumnDataEntry<Blob>[];
@@ -154,7 +182,7 @@ interface JsonPartitionedDataInfoEntries<Blob> {
 /**
  * Entry-based representation of BinaryPartitionedDataInfo
  */
-interface BinaryPartitionedDataInfoEntries<Blob> {
+export interface BinaryPartitionedDataInfoEntries<Blob> {
   type: "BinaryPartitioned";
   partitionKeyLength: number;
   parts: PColumnDataEntry<BinaryChunk<Blob>>[];
@@ -162,7 +190,7 @@ interface BinaryPartitionedDataInfoEntries<Blob> {
 /**
  * Entry-based representation of ParquetPartitionedDataInfo
  */
-interface ParquetPartitionedDataInfoEntries<Blob> {
+export interface ParquetPartitionedDataInfoEntries<Blob> {
   type: "ParquetPartitioned";
   partitionKeyLength: number;
   parts: PColumnDataEntry<Blob>[];
@@ -170,18 +198,18 @@ interface ParquetPartitionedDataInfoEntries<Blob> {
 /**
  * Union type representing all possible entry-based partitioned data storage formats
  */
-type PartitionedDataInfoEntries<Blob> = JsonPartitionedDataInfoEntries<Blob> | BinaryPartitionedDataInfoEntries<Blob> | ParquetPartitionedDataInfoEntries<Blob>;
+export type PartitionedDataInfoEntries<Blob> = JsonPartitionedDataInfoEntries<Blob> | BinaryPartitionedDataInfoEntries<Blob> | ParquetPartitionedDataInfoEntries<Blob>;
 /**
  * Union type representing all possible entry-based data storage formats
  */
-type DataInfoEntries<Blob> = JsonDataInfoEntries | PartitionedDataInfoEntries<Blob>;
+export type DataInfoEntries<Blob> = JsonDataInfoEntries | PartitionedDataInfoEntries<Blob>;
 /**
  * Type guard function that checks if the given value is a valid DataInfoEntries.
  *
  * @param value - The value to check
  * @returns True if the value is a valid DataInfoEntries, false otherwise
  */
-declare function isDataInfoEntries<Blob>(value: unknown): value is DataInfoEntries<Blob>;
+export declare function isDataInfoEntries<Blob>(value: unknown): value is DataInfoEntries<Blob>;
 /**
  * Type guard function that checks if the given value is a valid PartitionedDataInfoEntries.
  *
@@ -189,21 +217,21 @@ declare function isDataInfoEntries<Blob>(value: unknown): value is DataInfoEntri
  * @param value - The value to check
  * @returns True if the value is a valid PartitionedDataInfoEntries, false otherwise
  */
-declare function isPartitionedDataInfoEntries<Blob>(value: unknown): value is PartitionedDataInfoEntries<Blob>;
+export declare function isPartitionedDataInfoEntries<Blob>(value: unknown): value is PartitionedDataInfoEntries<Blob>;
 /**
  * Converts DataInfo to DataInfoEntries
  *
  * @param dataInfo - The record-based DataInfo object
  * @returns The equivalent entry-based DataInfoEntries object
  */
-declare function dataInfoToEntries<Blob>(dataInfo: DataInfo<Blob>): DataInfoEntries<Blob>;
+export declare function dataInfoToEntries<Blob>(dataInfo: DataInfo<Blob>): DataInfoEntries<Blob>;
 /**
  * Converts DataInfoEntries to DataInfo
  *
  * @param dataInfoEntries - The entry-based DataInfoEntries object
  * @returns The equivalent record-based DataInfo object
  */
-declare function entriesToDataInfo<Blob>(dataInfoEntries: DataInfoEntries<Blob>): DataInfo<Blob>;
+export declare function entriesToDataInfo<Blob>(dataInfoEntries: DataInfoEntries<Blob>): DataInfo<Blob>;
 /**
  * Maps blob references in a DataInfoEntries object from one type to another using a mapping function.
  *
@@ -213,7 +241,6 @@ declare function entriesToDataInfo<Blob>(dataInfoEntries: DataInfoEntries<Blob>)
  * @param mapFn - Function to transform blobs from type B1 to type B2
  * @returns A new DataInfoEntries object with transformed blob references
  */
-declare function mapDataInfoEntries<B1, B2>(dataInfoEntries: DataInfoEntries<B1>, mapFn: (blob: B1) => B2): DataInfoEntries<B2>;
+export declare function mapDataInfoEntries<B1, B2>(dataInfoEntries: DataInfoEntries<B1>, mapFn: (blob: B1) => B2): DataInfoEntries<B2>;
 //#endregion
-export { BinaryChunk, BinaryPartitionedDataInfo, BinaryPartitionedDataInfoEntries, DataInfo, DataInfoEntries, JsonDataInfo, JsonDataInfoEntries, JsonPartitionedDataInfo, JsonPartitionedDataInfoEntries, PColumnDataEntry, PColumnKey, PColumnValue, PColumnValues, PColumnValuesEntry, ParquetChunk, ParquetChunkMapping, ParquetChunkMappingAxis, ParquetChunkMappingColumn, ParquetChunkMetadata, ParquetChunkStats, ParquetPartitionedDataInfo, ParquetPartitionedDataInfoEntries, PartitionedDataInfoEntries, dataInfoToEntries, entriesToDataInfo, isDataInfo, isDataInfoEntries, isPartitionedDataInfoEntries, mapDataInfo, mapDataInfoEntries, visitDataInfo };
 //# sourceMappingURL=data_info.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"data_info.d.ts","names":[],"sources":["../../../src/drivers/pframe/data_info.ts"],"mappings":"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"}
+{"version":3,"file":"data_info.d.ts","names":[],"sources":["../../../src/drivers/pframe/data_info.ts"],"mappings":";;;;;;;;YASY;;;;;YAMA;;;;;YAMA,iBAAiB;;EAE3B,KAAK;;EAGL,OAAO;;;;;;YAOG;;EAEV;;EAGA;;;;;EAMA,MAAM,eAAe;;;;;;YAOX,wBAAwB;;EAElC;;EAGA;;EAGA,OAAO,eAAe;;;;;;YAOZ,YAAY;;EAEtB,OAAO;;EAGP,QAAQ;;;;;;YAOE,0BAA0B;;EAEpC;;EAGA;;EAGA,OAAO,eAAe,YAAY;;YAGxB;;EAEV;;EAGA;;YAGU;;EAEV;;EAGA;;YAGU;;EAEV,MAAM;;EAGN,QAAQ;;YAGE;;EAEV;;EAEA;;IAEE;;IAEA;;;YAIQ;;EAEV;;EAGA,OAAO,QAAQ;;YAGL,aAAa;;EAEvB,MAAM;IACJ,sBACF,QAAQ;YAEE,2BAA2B;;EAErC;;EAGA;;EAGA,OAAO,eAAe;;;;;;;;YASZ,SAAS,QACjB,eACA,wBAAwB,QACxB,0BAA0B,QAC1B,2BAA2B;;;;;;;wBAQf,WAAW,MAAM,iBAAiB,SAAS,SAAS;;;;;;;;;;wBAuCpD,YAAY,IAAI,IAC9B,UAAU,2BAA2B,KACrC,QAAQ,MAAM,OAAO,KACpB,2BAA2B;wBACd,YAAY,IAAI,IAC9B,UAAU,QAAQ,SAAS,KAAK,2BAA2B,MAC3D,QAAQ,MAAM,OAAO,KACpB,QAAQ,SAAS,KAAK,2BAA2B;wBACpC,YAAY,IAAI,IAAI,UAAU,SAAS,KAAK,QAAQ,MAAM,OAAO,KAAK,SAAS;;;;;;wBAyD/E,cAAc,GAAG,UAAU,SAAS,IAAI,KAAK,MAAM;;;;;YAkCvD;EACV,KAAK;EACL,KAAK;;;;;;YAOK,gBAAgB;;;;iBAKX;EACf;EACA;EACA,MAAM,iBAAiB;;;;;iBAMR,+BAA+B;EAC9C;EACA;EACA,OAAO,iBAAiB;;;;;iBAMT,iCAAiC;EAChD;EACA;EACA,OAAO,iBAAiB,YAAY;;;;;iBAMrB,kCAAkC;EACjD;EACA;EACA,OAAO,iBAAiB;;;;;YAKd,2BAA2B,QACnC,+BAA+B,QAC/B,iCAAiC,QACjC,kCAAkC;;;;YAK1B,gBAAgB,QAAQ,sBAAsB,2BAA2B;;;;;;;wBAQrE,kBAAkB,MAAM,iBAAiB,SAAS,gBAAgB;;;;;;;;wBA6BlE,6BAA6B,MAC3C,iBACC,SAAS,2BAA2B;;;;;;;wBAkBvB,kBAAkB,MAAM,UAAU,SAAS,QAAQ,gBAAgB;;;;;;;wBAiDnE,kBAAkB,MAAM,iBAAiB,gBAAgB,QAAQ,SAAS;;;;;;;;;;wBAgD1E,mBAAmB,IAAI,IACrC,iBAAiB,gBAAgB,KACjC,QAAQ,MAAM,OAAO,KACpB,gBAAgB"}

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

@@ -1,77 +1,83 @@
 import { Branded } from "../../branding.js";
 import { ValueType } from "./spec/spec.js";
-
 //#region src/drivers/pframe/data_types.d.ts
-type PVectorDataInt = Int32Array;
-type PVectorDataLong = BigInt64Array;
-type PVectorDataFloat = Float32Array;
-type PVectorDataDouble = Float64Array;
-type PVectorDataString = (null | string)[];
-type PVectorDataBytes = (null | Uint8Array)[];
-type PVectorDataTyped<DataType extends ValueType> = DataType extends typeof ValueType.Int ? PVectorDataInt : DataType extends typeof ValueType.Long ? PVectorDataLong : DataType extends typeof ValueType.Float ? PVectorDataFloat : DataType extends typeof ValueType.Double ? PVectorDataDouble : DataType extends typeof ValueType.String ? PVectorDataString : DataType extends typeof ValueType.Bytes ? PVectorDataBytes : never;
-type PVectorData = PVectorDataTyped<ValueType>;
-type PTableVectorTyped<DataType extends ValueType> = {
-  /** Stored data type */readonly type: DataType; /** Values for present positions */
+export type PVectorDataInt = Int32Array;
+export type PVectorDataLong = BigInt64Array;
+export type PVectorDataFloat = Float32Array;
+export type PVectorDataDouble = Float64Array;
+export type PVectorDataString = (null | string)[];
+export type PVectorDataBytes = (null | Uint8Array)[];
+export 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;
+export type PVectorData = PVectorDataTyped<ValueType>;
+export type PTableVectorTyped<DataType extends ValueType> = {
+  /** Stored data type */
+  readonly type: DataType;
+  /** Values for present positions */
   readonly data: PVectorDataTyped<DataType>;
   /**
    * Encoded bit array marking some elements of this vector as NA,
    * call {@link bitSet} to read the data.
    * In old desktop versions NA values are encoded as magic values in data array.
    * */
-  readonly isNA?: Uint8Array; /** @deprecated Always empty. Kept for backwards compatibility with old blocks. */
+  readonly isNA?: Uint8Array;
+  /** @deprecated Always empty. Kept for backwards compatibility with old blocks. */
   readonly absent?: Uint8Array;
 };
 /** Table column data */
-type PTableVector = PTableVectorTyped<ValueType>;
-declare function isValueNA(vector: PTableVector, row: number): boolean;
-declare const PTableNA: null;
-type PTableNA = typeof PTableNA;
+export type PTableVector = PTableVectorTyped<ValueType>;
+export declare function isValueNA(vector: PTableVector, row: number): boolean;
+export declare const PTableNA: null;
+export type PTableNA = typeof PTableNA;
 /** Type guard for NA value */
-declare function isPTableNA(value: unknown): value is PTableNA;
-type ValueTypeSupported = Exclude<ValueType, typeof ValueType.Bytes>;
-type PTableValueInt = number;
-type PTableValueLong = number;
-type PTableValueFloat = number;
-type PTableValueDouble = number;
-type PTableValueString = string;
-type PTableValueData<DataType extends ValueTypeSupported> = DataType extends typeof ValueType.Int ? PTableValueInt : DataType extends typeof ValueType.Long ? PTableValueLong : DataType extends typeof ValueType.Float ? PTableValueFloat : DataType extends typeof ValueType.Double ? PTableValueDouble : DataType extends typeof ValueType.String ? PTableValueString : never;
-type PTableValueDataBranded<DataType extends ValueTypeSupported> = Branded<PTableValueData<DataType>, DataType>;
-type PTableValue<NA = PTableNA, DataType extends ValueTypeSupported = ValueTypeSupported> = NA | PTableValueData<DataType>;
-type PTableValueBranded<NA = PTableNA, DataType extends ValueTypeSupported = ValueTypeSupported> = NA | PTableValueDataBranded<DataType>;
-type PTableValueAxis<DataType extends ValueTypeSupported = ValueTypeSupported> = PTableValueData<DataType>;
+export declare function isPTableNA(value: unknown): value is PTableNA;
+export type ValueTypeSupported = Exclude<ValueType, typeof ValueType.Bytes>;
+export type PTableValueInt = number;
+export type PTableValueLong = number;
+export type PTableValueFloat = number;
+export type PTableValueDouble = number;
+export type PTableValueString = string;
+export type PTableValueData<DataType extends ValueTypeSupported> = DataType extends typeof ValueType.Int ? PTableValueInt : DataType extends typeof ValueType.Long ? PTableValueLong : DataType extends typeof ValueType.Float ? PTableValueFloat : DataType extends typeof ValueType.Double ? PTableValueDouble : DataType extends typeof ValueType.String ? PTableValueString : never;
+export type PTableValueDataBranded<DataType extends ValueTypeSupported> = Branded<PTableValueData<DataType>, DataType>;
+export type PTableValue<NA = PTableNA, DataType extends ValueTypeSupported = ValueTypeSupported> = NA | PTableValueData<DataType>;
+export type PTableValueBranded<NA = PTableNA, DataType extends ValueTypeSupported = ValueTypeSupported> = NA | PTableValueDataBranded<DataType>;
+export type PTableValueAxis<DataType extends ValueTypeSupported = ValueTypeSupported> = PTableValueData<DataType>;
 /** Read PTableValue from PTable column at specified row */
-declare function pTableValue<DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number): DataType extends ValueTypeSupported ? PTableValue<PTableNA, DataType> : never;
-declare function pTableValue<FillNA, DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number, options: {
+export declare function pTableValue<DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number): DataType extends ValueTypeSupported ? PTableValue<PTableNA, DataType> : never;
+export declare function pTableValue<FillNA, DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number, options: {
   na: FillNA;
 }): DataType extends ValueTypeSupported ? PTableValue<FillNA, DataType> : never;
-declare function pTableValue<FillNA, DataType extends ValueTypeSupported>(column: PTableVectorTyped<ValueType>, row: number, options: {
+export declare function pTableValue<FillNA, DataType extends ValueTypeSupported>(column: PTableVectorTyped<ValueType>, row: number, options: {
   na: FillNA;
   dataType: DataType;
 }): PTableValue<FillNA, DataType>;
-declare function pTableValueBranded<DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number): DataType extends ValueTypeSupported ? PTableValueBranded<PTableNA, DataType> : never;
-declare function pTableValueBranded<FillNA, DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number, options: {
+export declare function pTableValueBranded<DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number): DataType extends ValueTypeSupported ? PTableValueBranded<PTableNA, DataType> : never;
+export declare function pTableValueBranded<FillNA, DataType extends ValueType>(column: PTableVectorTyped<DataType>, row: number, options: {
   na: FillNA;
 }): DataType extends ValueTypeSupported ? PTableValueBranded<FillNA, DataType> : never;
-declare function pTableValueBranded<FillNA, DataType extends ValueTypeSupported>(column: PTableVectorTyped<ValueType>, row: number, options: {
+export declare function pTableValueBranded<FillNA, DataType extends ValueTypeSupported>(column: PTableVectorTyped<ValueType>, row: number, options: {
   na: FillNA;
   dataType: DataType;
 }): PTableValueBranded<FillNA, DataType>;
 /** Used in requests to partially retrieve table's data */
-type TableRange = {
-  /** Index of the first record to retrieve */readonly offset: number; /** Block length */
+export type TableRange = {
+  /** Index of the first record to retrieve */
+  readonly offset: number;
+  /** Block length */
   readonly length: number;
 };
 /** Unified information about table shape */
-type PTableShape = {
-  /** Number of unified table columns, including all axes and PColumn values */columns: number; /** Number of rows */
+export type PTableShape = {
+  /** Number of unified table columns, including all axes and PColumn values */
+  columns: number;
+  /** Number of rows */
   rows: number;
 };
 /** Supported formats for PTable file download. */
-type PTableDownloadFormat = "csv" | "tsv";
+export type PTableDownloadFormat = "csv" | "tsv";
 /** Compression applied to the written file. */
-type PTableDownloadCompression = "none" | "gzip";
+export type PTableDownloadCompression = "none" | "gzip";
 /** Options for downloading PTable data to a file. */
-interface WritePTableToFsOptions {
+export interface WritePTableToFsOptions {
   path: string;
   format: PTableDownloadFormat;
   columnIndices: number[];
@@ -98,7 +104,7 @@ interface WritePTableToFsOptions {
   signal?: AbortSignal;
 }
 /** Result of a PTable file download. */
-interface WritePTableToFsResult {
+export interface WritePTableToFsResult {
   path: string;
   rowsWritten: number;
   bytesWritten: number;
@@ -108,9 +114,9 @@ interface WritePTableToFsResult {
  * 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.
  */
-declare const XLSX_MAX_ROWS_PER_SHEET = 1000000;
+export declare const XLSX_MAX_ROWS_PER_SHEET = 1000000;
 /** Options for {@link PFrameDriver.exportPTable}. */
-interface ExportPTableOptions {
+export interface ExportPTableOptions {
   /** Destination file path; its extension selects the output format
    * (`csv`/`tsv`/`parquet`/`xlsx`). */
   path: string;
@@ -131,5 +137,4 @@ interface ExportPTableOptions {
   headerNames?: string[];
 }
 //#endregion
-export { ExportPTableOptions, PTableDownloadCompression, PTableDownloadFormat, PTableNA, PTableShape, PTableValue, PTableValueAxis, PTableValueBranded, PTableValueData, PTableValueDataBranded, PTableValueDouble, PTableValueFloat, PTableValueInt, PTableValueLong, PTableValueString, PTableVector, PTableVectorTyped, PVectorData, PVectorDataBytes, PVectorDataDouble, PVectorDataFloat, PVectorDataInt, PVectorDataLong, PVectorDataString, PVectorDataTyped, TableRange, ValueTypeSupported, WritePTableToFsOptions, WritePTableToFsResult, XLSX_MAX_ROWS_PER_SHEET, isPTableNA, isValueNA, pTableValue, pTableValueBranded };
 //# sourceMappingURL=data_types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"data_types.d.ts","names":[],"sources":["../../../src/drivers/pframe/data_types.ts"],"mappings":"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"}
+{"version":3,"file":"data_types.d.ts","names":[],"sources":["../../../src/drivers/pframe/data_types.ts"],"mappings":";;;YAGY,iBAAiB;YACjB,kBAAkB;YAClB,mBAAmB;YACnB,oBAAoB;YACpB;YACA,2BAA2B;YAC3B,iBAAiB,iBAAiB,aAAa,wBAAwB,UAAU,MACzF,iBACA,wBAAwB,UAAU,OAChC,kBACA,wBAAwB,UAAU,QAChC,mBACA,wBAAwB,UAAU,SAChC,oBACA,wBAAwB,UAAU,SAChC,oBACA,wBAAwB,UAAU,QAChC;YAEF,cAAc,iBAAiB;YAE/B,kBAAkB,iBAAiB;;WAEpC,MAAM;;WAGN,MAAM,iBAAiB;;;;;;WAOvB,OAAO;;WAGP,SAAS;;;YAGR,eAAe,kBAAkB;wBAQ7B,UAAU,QAAQ,cAAc;qBAwBnC;YACD,kBAAkB;;wBAGd,WAAW,iBAAiB,SAAS;YAIzC,qBAAqB,QAAQ,kBAAkB,UAAU;YAEzD;YACA;YACA;YACA;YACA;YACA,gBAAgB,iBAAiB,sBAC3C,wBAAwB,UAAU,MAC9B,iBACA,wBAAwB,UAAU,OAChC,kBACA,wBAAwB,UAAU,QAChC,mBACA,wBAAwB,UAAU,SAChC,oBACA,wBAAwB,UAAU,SAChC;YAEF,uBAAuB,iBAAiB,sBAAsB,QACxE,gBAAgB,WAChB;YAEU,YAAY,KAAK,UAAU,iBAAiB,qBAAqB,sBACzE,KACA,gBAAgB;YACR,mBACV,KAAK,UACL,iBAAiB,qBAAqB,sBACpC,KAAK,uBAAuB;YAEpB,gBAAgB,iBAAiB,qBAAqB,sBAChE,gBAAgB;;wBA4CF,YAAY,iBAAiB,WAC3C,QAAQ,kBAAkB,WAC1B,cACC,iBAAiB,qBAAqB,YAAY,UAAU;wBAC/C,YAAY,QAAQ,iBAAiB,WACnD,QAAQ,kBAAkB,WAC1B,aACA;EACE,IAAI;IAEL,iBAAiB,qBAAqB,YAAY,QAAQ;wBAC7C,YAAY,QAAQ,iBAAiB,oBACnD,QAAQ,kBAAkB,YAC1B,aACA;EACE,IAAI;EACJ,UAAU;IAEX,YAAY,QAAQ;wBAYP,mBAAmB,iBAAiB,WAClD,QAAQ,kBAAkB,WAC1B,cACC,iBAAiB,qBAAqB,mBAAmB,UAAU;wBACtD,mBAAmB,QAAQ,iBAAiB,WAC1D,QAAQ,kBAAkB,WAC1B,aACA;EACE,IAAI;IAEL,iBAAiB,qBAAqB,mBAAmB,QAAQ;wBACpD,mBAAmB,QAAQ,iBAAiB,oBAC1D,QAAQ,kBAAkB,YAC1B,aACA;EACE,IAAI;EACJ,UAAU;IAEX,mBAAmB,QAAQ;;YAgBlB;;WAED;;WAGA;;;YAIC;;EAEV;;EAGA;;;YAIU;;YAGA;;iBAGK;EACf;EACA,QAAQ;EACR;;;;;;;;;;;;EAYA;EACA,QAAQ;EACR;EACA;EACA;EACA;IACE;IACA;;EAEF,SAAS;;;iBAIM;EACf;EACA;EACA;;;;;;;qBAQW;;iBAGI;;;EAGf;;;EAGA;;;;;;;;;;;;EAYA"}

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

@@ -8,19 +8,20 @@ import { FindColumnsRequest, FindColumnsResponse } from "./find_columns.js";
 import { UniqueValuesRequest, UniqueValuesResponse } from "./unique_values.js";
 import { PFrameDef } from "./pframe.js";
 import { PObjectId } from "../../pool/spec.js";
+import "../../pool/index.js";
 //#region src/drivers/pframe/driver.d.ts
 /** PFrame handle */
-type PFrameHandle = Branded<string, "PFrame">;
+export type PFrameHandle = Branded<string, "PFrame">;
 /** PFrame handle */
-type PTableHandle = Branded<string, "PTable">;
+export type PTableHandle = Branded<string, "PTable">;
 /** Model-side PFrame service — creates frames/tables from column definitions. */
-interface PFrameModelDriver<Col = PColumn<string | PColumnValues | DataInfo<string>>> {
+export interface PFrameModelDriver<Col = PColumn<string | PColumnValues | DataInfo<string>>> {
   createPFrame(def: PFrameDef<Col>): PFrameHandle;
   createPTable(def: PTableDef<Col>): PTableHandle;
   createPTableV2(def: PTableDefV2<Col>): PTableHandle;
 }
 /** Allows to access main data layer features of platforma */
-interface PFrameDriver {
+export interface PFrameDriver {
   /**
    * Finds columns given filtering criteria on column name, annotations etc.
    * and a set of axes ids to find only columns with compatible specs.
@@ -75,5 +76,4 @@ interface PFrameDriver {
   exportPTable(handle: PTableHandle, options: ExportPTableOptions): Promise<void>;
 }
 //#endregion
-export { PFrameDriver, PFrameHandle, PFrameModelDriver, PTableHandle };
 //# sourceMappingURL=driver.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"driver.d.ts","names":[],"sources":["../../../src/drivers/pframe/driver.ts"],"mappings":";;;;;;;;;;;;KAuBY,YAAA,GAAe,OAAO;;KAGtB,YAAA,GAAe,OAAO;;UAGjB,iBAAA,OAAwB,OAAA,UAAiB,aAAA,GAAgB,QAAA;EACxE,YAAA,CAAa,GAAA,EAAK,SAAA,CAAU,GAAA,IAAO,YAAA;EACnC,YAAA,CAAa,GAAA,EAAK,SAAA,CAAU,GAAA,IAAO,YAAA;EACnC,cAAA,CAAe,GAAA,EAAK,WAAA,CAAY,GAAA,IAAO,YAAA;AAAA;AANP;AAAA,UAUjB,YAAA;EAPiB;;;;EAgBhC,WAAA,CAAY,MAAA,EAAQ,YAAA,EAAc,OAAA,EAAS,kBAAA,GAAqB,OAAA,CAAQ,mBAAA;EAf5C;EAkB5B,aAAA,CAAc,MAAA,EAAQ,YAAA,EAAc,QAAA,EAAU,SAAA,GAAY,OAAA,CAAQ,WAAA;EAlB/B;EAqBnC,WAAA,CAAY,MAAA,EAAQ,YAAA,GAAe,OAAA,CAAQ,gBAAA;EApBzB;EAuBlB,kBAAA,CACE,MAAA,EAAQ,YAAA,EACR,OAAA,EAAS,yBAAA,CAA0B,SAAA,GACnC,KAAA,GAAQ,UAAA,GACP,OAAA,CAAQ,0BAAA;EA1BqB;EA6BhC,eAAA,CACE,MAAA,EAAQ,YAAA,EACR,OAAA,EAAS,mBAAA,GACR,OAAA,CAAQ,oBAAA;EAhC4B;EAuCvC,QAAA,CAAS,MAAA,EAAQ,YAAA,GAAe,OAAA,CAAQ,WAAA;EAvCW;;;;;;;;;EAkDnD,OAAA,CAAQ,MAAA,EAAQ,YAAA,GAAe,OAAA,CAAQ,gBAAA;EAnDvC;;;;;;;;EA6DA,OAAA,CACE,MAAA,EAAQ,YAAA,EACR,aAAA,YACA,KAAA,GAAQ,UAAA,GACP,OAAA,CAAQ,YAAA;EAhE4B;;AAAY;AAIrD;EAkEE,eAAA,CACE,MAAA,EAAQ,YAAA,EACR,OAAA,EAAS,sBAAA,GACR,OAAA,CAAQ,qBAAA;;;;;;;;;;;;;EAcX,YAAA,CAAa,MAAA,EAAQ,YAAA,EAAc,OAAA,EAAS,mBAAA,GAAsB,OAAA;AAAA"}
+{"version":3,"file":"driver.d.ts","names":[],"sources":["../../../src/drivers/pframe/driver.ts"],"mappings":";;;;;;;;;;;;;YAuBY,eAAe;;YAGf,eAAe;;iBAGV,kBAAkB,MAAM,iBAAiB,gBAAgB;EACxE,aAAa,KAAK,UAAU,OAAO;EACnC,aAAa,KAAK,UAAU,OAAO;EACnC,eAAe,KAAK,YAAY,OAAO;;;iBAIxB;;;;;EASf,YAAY,QAAQ,cAAc,SAAS,qBAAqB,QAAQ;;EAGxE,cAAc,QAAQ,cAAc,UAAU,YAAY,QAAQ;;EAGlE,YAAY,QAAQ,eAAe,QAAQ;;EAG3C,mBACE,QAAQ,cACR,SAAS,0BAA0B,YACnC,QAAQ,aACP,QAAQ;;EAGX,gBACE,QAAQ,cACR,SAAS,sBACR,QAAQ;;EAOX,SAAS,QAAQ,eAAe,QAAQ;;;;;;;;;;EAWxC,QAAQ,QAAQ,eAAe,QAAQ;;;;;;;;;EAUvC,QACE,QAAQ,cACR,yBACA,QAAQ,aACP,QAAQ;;;;;EAMX,gBACE,QAAQ,cACR,SAAS,yBACR,QAAQ;;;;;;;;;;;;;EAcX,aAAa,QAAQ,cAAc,SAAS,sBAAsB"}

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

@@ -1,7 +1,6 @@
 import { SUniversalPColumnId } from "./spec/ids.js";
-
 //#region src/drivers/pframe/filter_spec.d.ts
-type FilterSpecNode<Leaf, CommonNode = {}, CommonLeaf = {}> = (CommonLeaf & Leaf) | (CommonNode & {
+export type FilterSpecNode<Leaf, CommonNode = {}, CommonLeaf = {}> = (CommonLeaf & Leaf) | (CommonNode & {
   type: "not";
   filter: FilterSpecNode<Leaf, CommonNode, CommonLeaf>;
 }) | (CommonNode & {
@@ -11,7 +10,7 @@ type FilterSpecNode<Leaf, CommonNode = {}, CommonLeaf = {}> = (CommonLeaf & Leaf
   type: "and";
   filters: FilterSpecNode<Leaf, CommonNode, CommonLeaf>[];
 });
-type FilterSpecLeaf<T = SUniversalPColumnId> = {
+export type FilterSpecLeaf<T = SUniversalPColumnId> = {
   type: undefined;
 } | {
   type: "isNA";
@@ -115,22 +114,21 @@ type FilterSpecLeaf<T = SUniversalPColumnId> = {
   rhs: T;
   minDiff?: number;
 };
-type FilterSpec<Leaf extends FilterSpecLeaf<unknown> = FilterSpecLeaf<SUniversalPColumnId>, CommonNode = {}, CommonLeaf = CommonNode> = FilterSpecNode<Leaf, CommonNode, CommonLeaf>;
-type RootFilterSpec<Leaf extends FilterSpecLeaf<unknown> = FilterSpecLeaf<SUniversalPColumnId>, CommonNode = {}, CommonLeaf = CommonNode> = Extract<FilterSpec<Leaf, CommonNode, CommonLeaf>, {
+export type FilterSpec<Leaf extends FilterSpecLeaf<unknown> = FilterSpecLeaf<SUniversalPColumnId>, CommonNode = {}, CommonLeaf = CommonNode> = FilterSpecNode<Leaf, CommonNode, CommonLeaf>;
+export type RootFilterSpec<Leaf extends FilterSpecLeaf<unknown> = FilterSpecLeaf<SUniversalPColumnId>, CommonNode = {}, CommonLeaf = CommonNode> = Extract<FilterSpec<Leaf, CommonNode, CommonLeaf>, {
   type: "or" | "and";
 }>;
-type FilterSpecType = Exclude<FilterSpec, {
+export type FilterSpecType = Exclude<FilterSpec, {
   type: undefined;
 }>["type"];
-type FilterSpecOfType<T extends FilterSpecType> = Extract<FilterSpec, {
+export type FilterSpecOfType<T extends FilterSpecType> = Extract<FilterSpec, {
   type: T;
 }>;
-type InferFilterSpecLeaf<T extends FilterSpec<FilterSpecLeaf<unknown>>> = T extends FilterSpecNode<infer Leaf, unknown, unknown> ? Leaf : never;
-type InferFilterSpecLeafColumn<T extends FilterSpec<FilterSpecLeaf<unknown>>> = T extends FilterSpecNode<infer Leaf, unknown, unknown> ? Leaf extends {
+export type InferFilterSpecLeaf<T extends FilterSpec<FilterSpecLeaf<unknown>>> = T extends FilterSpecNode<infer Leaf, unknown, unknown> ? Leaf : never;
+export type InferFilterSpecLeafColumn<T extends FilterSpec<FilterSpecLeaf<unknown>>> = T extends FilterSpecNode<infer Leaf, unknown, unknown> ? Leaf extends {
   column: infer C;
 } ? C : never : never;
-type InferFilterSpecCommonNode<T extends FilterSpec<FilterSpecLeaf<unknown>, unknown, unknown>> = T extends FilterSpecNode<unknown, infer CommonNode, unknown> ? CommonNode : never;
-type InferFilterSpecCommonLeaf<T extends FilterSpec<FilterSpecLeaf<unknown>, unknown, unknown>> = T extends FilterSpecNode<unknown, unknown, infer CommonLeaf> ? CommonLeaf : never;
+export type InferFilterSpecCommonNode<T extends FilterSpec<FilterSpecLeaf<unknown>, unknown, unknown>> = T extends FilterSpecNode<unknown, infer CommonNode, unknown> ? CommonNode : never;
+export type InferFilterSpecCommonLeaf<T extends FilterSpec<FilterSpecLeaf<unknown>, unknown, unknown>> = T extends FilterSpecNode<unknown, unknown, infer CommonLeaf> ? CommonLeaf : never;
 //#endregion
-export { FilterSpec, FilterSpecLeaf, FilterSpecNode, FilterSpecOfType, FilterSpecType, InferFilterSpecCommonLeaf, InferFilterSpecCommonNode, InferFilterSpecLeaf, InferFilterSpecLeafColumn, RootFilterSpec };
 //# sourceMappingURL=filter_spec.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"filter_spec.d.ts","names":[],"sources":["../../../src/drivers/pframe/filter_spec.ts"],"mappings":";;;KAEY,cAAA,4CACP,UAAA,GAAa,IAAA,KACb,UAAA;EAAe,IAAA;EAAa,MAAA,EAAQ,cAAA,CAAe,IAAA,EAAM,UAAA,EAAY,UAAA;AAAA,MACrE,UAAA;EAAe,IAAA;EAAY,OAAA,EAAS,cAAA,CAAe,IAAA,EAAM,UAAA,EAAY,UAAA;AAAA,MACrE,UAAA;EAAe,IAAA;EAAa,OAAA,EAAS,cAAA,CAAe,IAAA,EAAM,UAAA,EAAY,UAAA;AAAA;AAAA,KAE/D,cAAA,KAAmB,mBAAA;EACzB,IAAA;AAAA;EACA,IAAA;EAAc,MAAA,EAAQ,CAAA;AAAA;EACtB,IAAA;EAAiB,MAAA,EAAQ,CAAA;AAAA;EACzB,IAAA;EAAc,MAAA,EAAQ,CAAA;EAAG,WAAA;AAAA;EACzB,IAAA;EAAuB,MAAA,EAAQ,CAAA;EAAG,KAAA;AAAA;EAClC,IAAA;EAA0B,MAAA,EAAQ,CAAA;EAAG,KAAA;AAAA;EACrC,IAAA;EAAmC,MAAA,EAAQ,CAAA;EAAG,KAAA;AAAA;EAC9C,IAAA;EAAsC,MAAA,EAAQ,CAAA;EAAG,KAAA;AAAA;EACjD,IAAA;EAAyC,MAAA,EAAQ,CAAA;EAAG,KAAA;AAAA;EAEpD,IAAA;EACA,MAAA,EAAQ,CAAA;EACR,KAAA;EACA,QAAA;EACA,iBAAA;EACA,QAAA;AAAA;EAEA,IAAA;EAAe,MAAA,EAAQ,CAAA;EAAG,KAAA;AAAA;EAC1B,IAAA;EAAkB,MAAA,EAAQ,CAAA;EAAG,KAAA;AAAA;EAC7B,IAAA;EAAc,MAAA,EAAQ,CAAA;EAAG,CAAA;AAAA;EACzB,IAAA;EAAiB,MAAA,EAAQ,CAAA;EAAG,CAAA;AAAA;EAC5B,IAAA;EAAe,MAAA,EAAQ,CAAA;EAAG,CAAA;AAAA;EAC1B,IAAA;EAAkB,MAAA,EAAQ,CAAA;EAAG,CAAA;AAAA;EAC7B,IAAA;EAAkB,MAAA,EAAQ,CAAA;EAAG,CAAA;AAAA;EAC7B,IAAA;EAAqB,MAAA,EAAQ,CAAA;EAAG,CAAA;AAAA;EAChC,IAAA;EAAyB,MAAA,EAAQ,CAAA;EAAG,CAAA;AAAA;EACpC,IAAA;EAA4B,MAAA,EAAQ,CAAA;EAAG,CAAA;AAAA;EACvC,IAAA;EAAuB,MAAA,EAAQ,CAAA;EAAG,GAAA,EAAK,CAAA;AAAA;EACvC,IAAA;EAAwB,MAAA,EAAQ,CAAA;EAAG,GAAA,EAAK,CAAA;EAAG,OAAA;AAAA;EAC3C,IAAA;EAA2B,MAAA,EAAQ,CAAA;EAAG,GAAA,EAAK,CAAA;EAAG,OAAA;AAAA;EAC9C,IAAA;EAA+B,MAAA,EAAQ,CAAA;EAAG,GAAA,EAAK,CAAA;EAAG,OAAA;AAAA;EAClD,IAAA;EAAkC,MAAA,EAAQ,CAAA;EAAG,GAAA,EAAK,CAAA;EAAG,OAAA;AAAA;AAAA,KAE/C,UAAA,cACG,cAAA,YAA0B,cAAA,CAAe,mBAAA,iCAEzC,UAAA,IACX,cAAA,CAAe,IAAA,EAAM,UAAA,EAAY,UAAA;AAAA,KAEzB,cAAA,cACG,cAAA,YAA0B,cAAA,CAAe,mBAAA,iCAEzC,UAAA,IACX,OAAA,CAAQ,UAAA,CAAW,IAAA,EAAM,UAAA,EAAY,UAAA;EAAe,IAAA;AAAA;AAAA,KAE5C,cAAA,GAAiB,OAAO,CAAC,UAAA;EAAc,IAAA;AAAA;AAAA,KAEvC,gBAAA,WAA2B,cAAA,IAAkB,OAAA,CAAQ,UAAA;EAAc,IAAA,EAAM,CAAA;AAAA;AAAA,KAEzE,mBAAA,WAA8B,UAAA,CAAW,cAAA,cACnD,CAAA,SAAU,cAAA,iCAA+C,IAAA;AAAA,KAE/C,yBAAA,WAAoC,UAAA,CAAW,cAAA,cACzD,CAAA,SAAU,cAAA,iCACN,IAAA;EAAe,MAAA;AAAA,IACb,CAAA;AAAA,KAII,yBAAA,WACA,UAAA,CAAW,cAAA,gCACnB,CAAA,SAAU,cAAA,uCAAqD,UAAA;AAAA,KAEvD,yBAAA,WACA,UAAA,CAAW,cAAA,gCACnB,CAAA,SAAU,cAAA,uCAAqD,UAAA"}
+{"version":3,"file":"filter_spec.d.ts","names":[],"sources":["../../../src/drivers/pframe/filter_spec.ts"],"mappings":";;YAEY,eAAe,MAAM,iBAAiB,oBAC7C,aAAa,SACb;EAAe;EAAa,QAAQ,eAAe,MAAM,YAAY;MACrE;EAAe;EAAY,SAAS,eAAe,MAAM,YAAY;MACrE;EAAe;EAAa,SAAS,eAAe,MAAM,YAAY;;YAE/D,eAAe,IAAI;EACzB;;EACA;EAAc,QAAQ;;EACtB;EAAiB,QAAQ;;EACzB;EAAc,QAAQ;EAAG;;EACzB;EAAuB,QAAQ;EAAG;;EAClC;EAA0B,QAAQ;EAAG;;EACrC;EAAmC,QAAQ;EAAG;;EAC9C;EAAsC,QAAQ;EAAG;;EACjD;EAAyC,QAAQ;EAAG;;EAEpD;EACA,QAAQ;EACR;EACA;EACA;EACA;;EAEA;EAAe,QAAQ;EAAG;;EAC1B;EAAkB,QAAQ;EAAG;;EAC7B;EAAc,QAAQ;EAAG;;EACzB;EAAiB,QAAQ;EAAG;;EAC5B;EAAe,QAAQ;EAAG;;EAC1B;EAAkB,QAAQ;EAAG;;EAC7B;EAAkB,QAAQ;EAAG;;EAC7B;EAAqB,QAAQ;EAAG;;EAChC;EAAyB,QAAQ;EAAG;;EACpC;EAA4B,QAAQ;EAAG;;EACvC;EAAuB,QAAQ;EAAG,KAAK;;EACvC;EAAwB,QAAQ;EAAG,KAAK;EAAG;;EAC3C;EAA2B,QAAQ;EAAG,KAAK;EAAG;;EAC9C;EAA+B,QAAQ;EAAG,KAAK;EAAG;;EAClD;EAAkC,QAAQ;EAAG,KAAK;EAAG;;YAE/C,WACV,aAAa,0BAA0B,eAAe,sBACtD,iBACA,aAAa,cACX,eAAe,MAAM,YAAY;YAEzB,eACV,aAAa,0BAA0B,eAAe,sBACtD,iBACA,aAAa,cACX,QAAQ,WAAW,MAAM,YAAY;EAAe;;YAE5C,iBAAiB,QAAQ;EAAc;;YAEvC,iBAAiB,UAAU,kBAAkB,QAAQ;EAAc,MAAM;;YAEzE,oBAAoB,UAAU,WAAW,4BACnD,UAAU,qBAAqB,0BAA0B;YAE/C,0BAA0B,UAAU,WAAW,4BACzD,UAAU,qBAAqB,0BAC3B;EAAe,cAAc;IAC3B;YAII,0BACV,UAAU,WAAW,8CACnB,UAAU,8BAA8B,uBAAuB;YAEvD,0BACV,UAAU,WAAW,8CACnB,UAAU,uCAAuC,cAAc"}

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

@@ -1,6 +1,5 @@
 import { AxisId, PColumnIdAndSpec } from "./spec/spec.js";
 import { ColumnFilter } from "./column_filter.js";
-
 //#region src/drivers/pframe/find_columns.d.ts
 /**
  * Request to search among existing columns in the PFrame. Two filtering
@@ -8,7 +7,7 @@ import { ColumnFilter } from "./column_filter.js";
  * specific properties like name, annotations and domains, and (2) being
  * compatible with the given list of axis ids.
  * */
-interface FindColumnsRequest {
+export interface FindColumnsRequest {
   /** Basic column filter */
   readonly columnFilter: ColumnFilter;
   /** Will only search for columns compatible with these list of axis ids */
@@ -22,10 +21,9 @@ interface FindColumnsRequest {
   readonly strictlyCompatible: boolean;
 }
 /** Response for {@link FindColumnsRequest} */
-interface FindColumnsResponse {
+export interface FindColumnsResponse {
   /** Array of column ids found using request criteria. */
   readonly hits: PColumnIdAndSpec[];
 }
 //#endregion
-export { FindColumnsRequest, FindColumnsResponse };
 //# sourceMappingURL=find_columns.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"find_columns.d.ts","names":[],"sources":["../../../src/drivers/pframe/find_columns.ts"],"mappings":";;;;;;AASA;;;;UAAiB,kBAAA;EAEQ;EAAA,SAAd,YAAA,EAAc,YAAA;EAGE;EAAA,SAAhB,cAAA,EAAgB,MAAM;EAQJ;AAAA;AAI7B;;;;EAJ6B,SAAlB,kBAAA;AAAA;;UAIM,mBAAA;;WAEN,IAAA,EAAM,gBAAgB;AAAA"}
+{"version":3,"file":"find_columns.d.ts","names":[],"sources":["../../../src/drivers/pframe/find_columns.ts"],"mappings":";;;;;;;;;iBASiB;;WAEN,cAAc;;WAGd,gBAAgB;;;;;;;WAQhB;;;iBAIM;;WAEN,MAAM"}