@milaboratories/pl-model-common 1.48.0 → 1.49.0

package/dist/drivers/log.d.ts

@@ -1,5 +1,4 @@
 import { Branded } from "../branding.js";
-
 //#region src/drivers/log.d.ts
 /** Prefix constants — single source of truth for handle format. */
 declare const LIVE_LOG_PREFIX = "log+live://log/";
@@ -7,71 +6,70 @@ declare const READY_LOG_PREFIX = "log+ready://log/";
 /** Handle of the live logs of a program.
  * The resource that represents a log can be deleted,
  * in this case the handle should be refreshed. */
-type LiveLogHandle = Branded<`${typeof LIVE_LOG_PREFIX}${string}`, "LiveLogHandle">;
+export type LiveLogHandle = Branded<`${typeof LIVE_LOG_PREFIX}${string}`, "LiveLogHandle">;
 /** Handle of the ready logs of a program. */
-type ReadyLogHandle = Branded<`${typeof READY_LOG_PREFIX}${string}`, "ReadyLogHandle">;
+export type ReadyLogHandle = Branded<`${typeof READY_LOG_PREFIX}${string}`, "ReadyLogHandle">;
 /** Handle of logs. This handle should be passed
  * to the driver for retrieving logs. */
-type AnyLogHandle = LiveLogHandle | ReadyLogHandle;
+export type AnyLogHandle = LiveLogHandle | ReadyLogHandle;
 /** Type guard to check if a value is any kind of log handle. */
-declare function isAnyLogHandle(value: unknown): value is AnyLogHandle;
+export declare function isAnyLogHandle(value: unknown): value is AnyLogHandle;
 /** Type guard to check if log is live, and corresponding process is not finished. */
-declare function isLiveLog(handle: AnyLogHandle | undefined): handle is LiveLogHandle;
+export declare function isLiveLog(handle: AnyLogHandle | undefined): handle is LiveLogHandle;
 /** Driver to retrieve logs given log handle */
-interface LogsDriver {
-  lastLines(/** A handle that was issued previously. */
-
-  handle: AnyLogHandle, /** Allows client to limit total data sent from server. */
-
+export interface LogsDriver {
+  lastLines(
+  /** A handle that was issued previously. */
+  handle: AnyLogHandle,
+  /** Allows client to limit total data sent from server. */
   lineCount: number,
   /** Makes streamer to perform seek operation to given offset before sending the contents.
    * Client can just use the <new_offset> value of the last response from server to continue streaming after reconnection.
    * If undefined, then starts from the end. */
-
   offsetBytes?: number,
   /** Is substring for line search pattern.
    * This option makes controller to send to the client only lines, that
    * have given substring. */
-
   searchStr?: string): Promise<StreamingApiResponse>;
-  readText(/** A handle that was issued previously. */
-
-  handle: AnyLogHandle, /** Allows client to limit total data sent from server. */
-
+  readText(
+  /** A handle that was issued previously. */
+  handle: AnyLogHandle,
+  /** Allows client to limit total data sent from server. */
   lineCount: number,
   /** Makes streamer to perform seek operation to given offset before sending the contents.
    * Client can just use the <new_offset> value of the last response from server to continue streaming after reconnection.
    * If undefined of 0, then starts from the beginning. */
-
   offsetBytes?: number,
   /** Is substring for line search pattern.
    * This option makes controller to send to the client only lines, that
    * have given substring. */
-
   searchStr?: string): Promise<StreamingApiResponse>;
 }
 /** Response of the driver.
  * The caller should give a handle to retrieve it.
  * It can be OK or outdated, in which case the handle
  * should be issued again. */
-type StreamingApiResponse = StreamingApiResponseOk | StreamingApiResponseHandleOutdated;
-type StreamingApiResponseOk = {
+export type StreamingApiResponse = StreamingApiResponseOk | StreamingApiResponseHandleOutdated;
+export type StreamingApiResponseOk = {
   /** The handle don't have to be updated,
    * the response is OK. */
-  shouldUpdateHandle: false; /** Whether the log can still grow or it's in a final state. */
-  live: boolean; /** Data of the response, in bytes. */
-  data: Uint8Array; /** Current size of the file. It can grow if it's still live. */
-  size: number; /** Offset in bytes from the beginning of a file. */
+  shouldUpdateHandle: false;
+  /** Whether the log can still grow or it's in a final state. */
+  live: boolean;
+  /** Data of the response, in bytes. */
+  data: Uint8Array;
+  /** Current size of the file. It can grow if it's still live. */
+  size: number;
+  /** Offset in bytes from the beginning of a file. */
   newOffset: number;
 };
 /** The handle should be issued again, this one is done. */
-type StreamingApiResponseHandleOutdated = {
+export type StreamingApiResponseHandleOutdated = {
   shouldUpdateHandle: true;
 };
-type ProgressLogWithInfo = {
+export type ProgressLogWithInfo = {
   progressLine?: string;
   live: boolean;
 };
 //#endregion
-export { AnyLogHandle, LiveLogHandle, LogsDriver, ProgressLogWithInfo, ReadyLogHandle, StreamingApiResponse, StreamingApiResponseHandleOutdated, StreamingApiResponseOk, isAnyLogHandle, isLiveLog };
 //# sourceMappingURL=log.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"log.d.ts","names":[],"sources":["../../src/drivers/log.ts"],"mappings":";;;;cAGM,eAAA;AAAA,cACA,gBAAA;;;;KAKM,aAAA,GAAgB,OAAO,WAAW,eAAA;AANzB;AAAA,KAST,cAAA,GAAiB,OAAO,WAAW,gBAAA;;;KAInC,YAAA,GAAe,aAAA,GAAgB,cAAc;AAPzD;AAAA,iBAUgB,cAAA,CAAe,KAAA,YAAiB,KAAA,IAAS,YAAY;;iBAQrD,SAAA,CAAU,MAAA,EAAQ,YAAA,eAA2B,MAAA,IAAU,aAAa;AAlBvB;AAAA,UAuB5C,UAAA;EACf,SAAA;;EAEE,MAAA,EAAQ,YAAA,EAvBmD;;EA0B3D,SAAA;EAtBoB;;;;EA2BpB,WAAA;EAxBY;;;;EA6BZ,SAAA,YACC,OAAA,CAAQ,oBAAA;EAEX,QAAA,CAhC8C;;EAkC5C,MAAA,EAAQ,YAAA,EAlCyD;;EAqCjE,SAAA;EA7BY;;;;EAkCZ,WAAA;EAlC8B;;;;EAuC9B,SAAA,YACC,OAAA,CAAQ,oBAAA;AAAA;AAxCuE;AAKpF;;;AALoF,KA+CxE,oBAAA,GAAuB,sBAAA,GAAyB,kCAAkC;AAAA,KAElF,sBAAA;EA3BP;;EA8BH,kBAAA,SAZG;EAeH,IAAA,WAfU;EAkBV,IAAA,EAAM,UAAU,EAlDN;EAoDV,IAAA,UAjDE;EAmDF,SAAA;AAAA;;KAIU,kCAAA;EACV,kBAAkB;AAAA;AAAA,KAGR,mBAAA;EACV,YAAA;EACA,IAAI;AAAA"}
+{"version":3,"file":"log.d.ts","names":[],"sources":["../../src/drivers/log.ts"],"mappings":";;;cAGM;cACA;;;;YAKM,gBAAgB,kBAAkB;;YAGlC,iBAAiB,kBAAkB;;;YAInC,eAAe,gBAAgB;;wBAG3B,eAAe,iBAAiB,SAAS;;wBAQzC,UAAU,QAAQ,2BAA2B,UAAU;;iBAKtD;EACf,UAEE;;EAAA,QAAQ,cAGR;;EAAA,mBAKA;;;;EAAA,sBAKA;;;;EAAA,qBACC,QAAQ;EAEX,SAEE;;EAAA,QAAQ,cAGR;;EAAA,mBAKA;;;;EAAA,sBAKA;;;;EAAA,qBACC,QAAQ;;;;;;YAOD,uBAAuB,yBAAyB;YAEhD;;;EAGV;;EAGA;;EAGA,MAAM;;EAEN;;EAEA;;;YAIU;EACV;;YAGU;EACV;EACA"}

package/dist/drivers/ls.d.ts

@@ -1,63 +1,74 @@
 import { Branded } from "../branding.js";
 import { TableRange } from "./pframe/data_types.js";
 import { FileLike } from "./interfaces.js";
+import "./pframe/index.js";
 //#region src/drivers/ls.d.ts
-type ImportFileHandleUpload = `upload://upload/${string}`;
-type ImportFileHandleIndex = `index://index/${string}`;
-type ImportFileHandle = ImportFileHandleUpload | ImportFileHandleIndex;
-type LocalImportFileHandle = Branded<ImportFileHandle, "Local">;
-declare function isImportFileHandleUpload(handle: ImportFileHandle): handle is ImportFileHandleUpload;
-declare function isImportFileHandleIndex(handle: ImportFileHandle): handle is ImportFileHandleIndex;
+export type ImportFileHandleUpload = `upload://upload/${string}`;
+export type ImportFileHandleIndex = `index://index/${string}`;
+export type ImportFileHandle = ImportFileHandleUpload | ImportFileHandleIndex;
+export type LocalImportFileHandle = Branded<ImportFileHandle, "Local">;
+export declare function isImportFileHandleUpload(handle: ImportFileHandle): handle is ImportFileHandleUpload;
+export declare function isImportFileHandleIndex(handle: ImportFileHandle): handle is ImportFileHandleIndex;
 /** Results in upload */
-type StorageHandleLocal = `local://${string}`;
+export type StorageHandleLocal = `local://${string}`;
 /** Results in index */
-type StorageHandleRemote = `remote://${string}`;
-type StorageHandle = StorageHandleLocal | StorageHandleRemote;
-type StorageEntry = {
-  /** Stable machine identifier (e.g. "library", "root", "local"). Used for filtering. */id: string; /** Human-readable display name. */
+export type StorageHandleRemote = `remote://${string}`;
+export type StorageHandle = StorageHandleLocal | StorageHandleRemote;
+export type StorageEntry = {
+  /** Stable machine identifier (e.g. "library", "root", "local"). Used for filtering. */
+  id: string;
+  /** Human-readable display name. */
   name: string;
   handle: StorageHandle;
   initialFullPath: string;
 };
-type ListFilesResult = {
+export type ListFilesResult = {
   parent?: string;
   entries: LsEntry[];
 };
-type LsEntry = {
+export type LsEntry = {
   type: "dir";
   name: string;
   fullPath: string;
 } | {
   type: "file";
   name: string;
-  fullPath: string; /** This handle should be set to args... */
+  fullPath: string;
+  /** This handle should be set to args... */
   handle: ImportFileHandle;
 };
-type OpenDialogFilter = {
-  /** Human-readable file type name */readonly name: string; /** File extensions */
+export type OpenDialogFilter = {
+  /** Human-readable file type name */
+  readonly name: string;
+  /** File extensions */
   readonly extensions: string[];
 };
-type OpenDialogOps = {
-  /** Open dialog window title */readonly title?: string; /** Custom label for the confirmation button, when left empty the default label will be used. */
-  readonly buttonLabel?: string; /** Limits of file types user can select */
+export type OpenDialogOps = {
+  /** Open dialog window title */
+  readonly title?: string;
+  /** Custom label for the confirmation button, when left empty the default label will be used. */
+  readonly buttonLabel?: string;
+  /** Limits of file types user can select */
   readonly filters?: OpenDialogFilter[];
 };
-type OpenSingleFileResponse = {
+export type OpenSingleFileResponse = {
   /** Contains local file handle, allowing file importing or content reading. If user canceled
    * the dialog, field will be undefined. */
   readonly file?: LocalImportFileHandle;
 };
-type OpenMultipleFilesResponse = {
+export type OpenMultipleFilesResponse = {
   /** Contains local file handles, allowing file importing or content reading. If user canceled
    * the dialog, field will be undefined. */
   readonly files?: LocalImportFileHandle[];
 };
 /** Can be used to limit request for local file content to a certain bytes range */
-type FileRange = {
-  /** From byte index (inclusive) */readonly from: number; /** To byte index (exclusive) */
+export type FileRange = {
+  /** From byte index (inclusive) */
+  readonly from: number;
+  /** To byte index (exclusive) */
   readonly to: number;
 };
-interface LsDriver {
+export interface LsDriver {
   /** remote and local storages */
   getStorageList(): Promise<StorageEntry[]>;
   listFiles(storage: StorageHandle, fullPath: string): Promise<ListFilesResult>;
@@ -80,9 +91,8 @@ interface LsDriver {
   exportToPdf?(): Promise<void>;
 }
 /** Gets a file path from an import handle. */
-declare function getFilePathFromHandle(handle: ImportFileHandle): string;
+export declare function getFilePathFromHandle(handle: ImportFileHandle): string;
 /** Gets a file name from an import handle. */
-declare function getFileNameFromHandle(handle: ImportFileHandle): string;
+export declare function getFileNameFromHandle(handle: ImportFileHandle): string;
 //#endregion
-export { FileRange, ImportFileHandle, ImportFileHandleIndex, ImportFileHandleUpload, ListFilesResult, LocalImportFileHandle, LsDriver, LsEntry, OpenDialogFilter, OpenDialogOps, OpenMultipleFilesResponse, OpenSingleFileResponse, StorageEntry, StorageHandle, StorageHandleLocal, StorageHandleRemote, getFileNameFromHandle, getFilePathFromHandle, isImportFileHandleIndex, isImportFileHandleUpload };
 //# sourceMappingURL=ls.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ls.d.ts","names":[],"sources":["../../src/drivers/ls.ts"],"mappings":";;;;KAQY,sBAAA;AAAA,KACA,qBAAA;AAAA,KAEA,gBAAA,GAAmB,sBAAA,GAAyB,qBAAqB;AAAA,KAEjE,qBAAA,GAAwB,OAAO,CAAC,gBAAA;AAAA,iBAE5B,wBAAA,CACd,MAAA,EAAQ,gBAAA,GACP,MAAA,IAAU,sBAAsB;AAAA,iBAInB,uBAAA,CAAwB,MAAA,EAAQ,gBAAA,GAAmB,MAAA,IAAU,qBAAqB;;KAKtF,kBAAA;AAjBZ;AAAA,KAoBY,mBAAA;AAAA,KAEA,aAAA,GAAgB,kBAAA,GAAqB,mBAAmB;AAAA,KAExD,YAAA;EAxBqB,uFA0B/B,EAAA,UAxB0B;EA0B1B,IAAA;EACA,MAAA,EAAQ,aAAa;EACrB,eAAA;AAAA;AAAA,KAGU,eAAA;EACV,MAAA;EACA,OAAA,EAAS,OAAO;AAAA;AAAA,KAGN,OAAA;EAEN,IAAA;EACA,IAAA;EACA,QAAA;AAAA;EAGA,IAAA;EACA,IAAA;EACA,QAAA,UAvC6B;EA0C7B,MAAA,EAAQ,gBAAgB;AAAA;AAAA,KAGlB,gBAAA;+CAED,IAAA,UA3CqC;EAAA,SA6CrC,UAAU;AAAA;AAAA,KAGT,aAAA;EAhDsF,wCAkDvF,KAAA,WA7CC;EAAA,SA+CD,WAAA;WAEA,OAAA,GAAU,gBAAgB;AAAA;AAAA,KAGzB,sBAAA;EAjDmB;;EAAA,SAoDpB,IAAA,GAAO,qBAAqB;AAAA;AAAA,KAG3B,yBAAA;EArDa;;EAAA,SAwDd,KAAA,GAAQ,qBAAqB;AAAA;AAtDxC;AAAA,KA0DY,SAAA;6CAED,IAAA,UA1DT;EAAA,SA4DS,EAAE;AAAA;AAAA,UAGI,QAAA;EA3Df;EA6DA,cAAA,IAAkB,OAAA,CAAQ,YAAA;EAE1B,SAAA,CAAU,OAAA,EAAS,aAAA,EAAe,QAAA,WAAmB,OAAA,CAAQ,eAAA;EA5DnD;EA+DV,wBAAA,CAAyB,GAAA,EAAK,aAAA,GAAgB,OAAA,CAAQ,sBAAA;;EAGtD,2BAAA,CAA4B,GAAA,EAAK,aAAA,GAAgB,OAAA,CAAQ,yBAAA;EAjEzD;EAoEA,gBAAA,CAAiB,IAAA,EAAM,qBAAA,GAAwB,OAAA;EAnEtC;EAsET,mBAAA,CAAoB,IAAA,EAAM,qBAAA,EAAuB,KAAA,GAAQ,UAAA,GAAa,OAAA,CAAQ,UAAA;EAtE9D;AAGlB;;;;;EA2EE,kBAAA,CAAmB,IAAA,EAAM,QAAA,GAAW,OAAA,CAAQ,gBAAA;EAvExC;EA0EJ,WAAA,KAAgB,OAAA;AAAA;;iBAIF,qBAAA,CAAsB,MAAwB,EAAhB,gBAAgB;;iBAmB9C,qBAAA,CAAsB,MAAwB,EAAhB,gBAAgB"}
+{"version":3,"file":"ls.d.ts","names":[],"sources":["../../src/drivers/ls.ts"],"mappings":";;;;;YAQY;YACA;YAEA,mBAAmB,yBAAyB;YAE5C,wBAAwB,QAAQ;wBAE5B,yBACd,QAAQ,mBACP,UAAU;wBAIG,wBAAwB,QAAQ,mBAAmB,UAAU;;YAKjE;;YAGA;YAEA,gBAAgB,qBAAqB;YAErC;;EAEV;;EAEA;EACA,QAAQ;EACR;;YAGU;EACV;EACA,SAAS;;YAGC;EAEN;EACA;EACA;;EAGA;EACA;EACA;;EAGA,QAAQ;;YAGF;;WAED;;WAEA;;YAGC;;WAED;;WAEA;;WAEA,UAAU;;YAGT;;;WAGD,OAAO;;YAGN;;;WAGD,QAAQ;;;YAIP;;WAED;;WAEA;;iBAGM;;EAEf,kBAAkB,QAAQ;EAE1B,UAAU,SAAS,eAAe,mBAAmB,QAAQ;;EAG7D,yBAAyB,KAAK,gBAAgB,QAAQ;;EAGtD,4BAA4B,KAAK,gBAAgB,QAAQ;;EAGzD,iBAAiB,MAAM,wBAAwB;;EAG/C,oBAAoB,MAAM,uBAAuB,QAAQ,aAAa,QAAQ;;;;;;;EAQ9E,mBAAmB,MAAM,WAAW,QAAQ;;EAG5C,gBAAgB;;;wBAIF,sBAAsB,QAAQ;;wBAmB9B,sBAAsB,QAAQ"}

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

@@ -1,8 +1,7 @@
 import { ValueType } from "./spec/spec.js";
-
 //#region src/drivers/pframe/column_filter.d.ts
 /** Allows to search multiple columns in different contexts. */
-interface ColumnFilter {
+export interface ColumnFilter {
   /** Match any of the types listed here. If undefined, will be ignored during
    * matching. */
   readonly type?: ValueType[];
@@ -18,5 +17,4 @@ interface ColumnFilter {
   readonly annotationPattern?: Record<string, string>;
 }
 //#endregion
-export { ColumnFilter };
 //# sourceMappingURL=column_filter.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"column_filter.d.ts","names":[],"sources":["../../../src/drivers/pframe/column_filter.ts"],"mappings":";;;;UAGiB,YAAA;EAAA;;EAAA,SAGN,IAAA,GAAO,SAAA;EAAA;;EAAA,SAIP,IAAA;EAUoB;EAAA,SAPpB,WAAA,GAAc,MAAA;EAOY;EAAA,SAJ1B,eAAA,GAAkB,MAAA;EAVX;;EAAA,SAcP,iBAAA,GAAoB,MAAA;AAAA"}
+{"version":3,"file":"column_filter.d.ts","names":[],"sources":["../../../src/drivers/pframe/column_filter.ts"],"mappings":";;;iBAGiB;;;WAGN,OAAO;;;WAIP;;WAGA,cAAc;;WAGd,kBAAkB;;;WAIlB,oBAAoB"}

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"}