@milaboratories/pl-model-common 1.25.1 → 1.25.3

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

@@ -1,3 +1,4 @@
+//#region src/drivers/pframe/data_info.d.ts
 /**
  * Represents a JavaScript representation of a value in a PColumn. Can be null, a number, or a string.
  * These are the primitive types that can be stored directly in PColumns.
@@ -5,117 +6,89 @@
  * Note: Actual columns can hold more value types, which are converted to these JavaScript types
  * once they enter the JavaScript runtime.
  */
-export type PColumnValue = null | number | string;
+type PColumnValue = null | number | string;
 /**
  * Represents a key for a PColumn value.
  * Can be an array of strings or numbers.
  */
-export type PColumnKey = (number | string)[];
+type PColumnKey = (number | string)[];
 /**
  * Represents a single entry in a PColumn's data structure.
  * Contains a key and a value.
  */
-export type PColumnDataEntry<T> = {
-    /** Key for the value */
-    key: PColumnKey;
-    /** Value / blob at the given key */
-    value: T;
+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.
  */
-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
-     * and values are the column values for those coordinates
-     */
-    data: Record<string, PColumnValue>;
+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
+   * and values are the column values for those coordinates
+   */
+  data: Record<string, PColumnValue>;
 };
 /**
  * Represents column data partitioned across multiple JSON blobs.
  * Used for larger datasets that need to be split into manageable chunks.
  */
-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>;
+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.
  */
-export type BinaryChunk<Blob> = {
-    /** Binary blob containing structured index information */
-    index: Blob;
-    /** Binary blob containing the actual values */
-    values: Blob;
+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.
  */
-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 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>>;
 };
-export type ParquetChunkMappingAxis = {
-    /** Data type (matches PColumn axis types) */
-    type: "Int" | "Long" | "String";
-    /** Field name in the Parquet file */
-    id: string;
+type ParquetChunkMappingAxis = {
+  /** Data type (matches PColumn axis types) */type: "Int" | "Long" | "String"; /** Field name in the Parquet file */
+  id: string;
 };
-export type ParquetChunkMappingColumn = {
-    /** Data type (matches PColumn value type) */
-    type: "Int" | "Long" | "Float" | "Double" | "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 */
+  id: string;
 };
-export type ParquetChunkMapping = {
-    /** Axes mappings - Parquet file is sorted by these fields in this order */
-    axes: ParquetChunkMappingAxis[];
-    /** Column mapping */
-    column: ParquetChunkMappingColumn;
+type ParquetChunkMapping = {
+  /** Axes mappings - Parquet file is sorted by these fields in this order */axes: ParquetChunkMappingAxis[]; /** Column mapping */
+  column: ParquetChunkMappingColumn;
 };
-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 */
-        column: number;
-    };
+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 */
+    column: number;
+  };
 };
-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 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>;
 };
-export type ParquetChunk<Blob> = {
-    /** Parquet file (PTable) containing column data */
-    data: Blob;
+type ParquetChunk<Blob> = {
+  /** Parquet file (PTable) containing column data */data: Blob;
 } & ParquetChunkMapping & Partial<ParquetChunkMetadata>;
-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>;
+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>;
 };
 /**
  * Union type representing all possible data storage formats for PColumn data.
@@ -123,14 +96,14 @@ export type ParquetPartitionedDataInfo<Blob> = {
  *
  * @template Blob - Type parameter representing the storage reference type (could be ResourceInfo, PFrameBlobId, etc.)
  */
-export type DataInfo<Blob> = JsonDataInfo | JsonPartitionedDataInfo<Blob> | BinaryPartitionedDataInfo<Blob> | ParquetPartitionedDataInfo<Blob>;
+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
  */
-export declare function isDataInfo<Blob>(value: unknown): value is DataInfo<Blob>;
+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.
  *
@@ -140,75 +113,75 @@ export 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
  */
-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>;
+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>;
 /**
  * @param dataInfo - The source DataInfo object
  * @param cb - Callback, function that have access to every blob to visit them all
  * @returns Nothing
  */
-export declare function visitDataInfo<B>(dataInfo: DataInfo<B>, cb: (blob: B) => void): void;
+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.
  */
-export type PColumnValuesEntry = {
-    key: PColumnKey;
-    val: PColumnValue;
+type PColumnValuesEntry = {
+  key: PColumnKey;
+  val: PColumnValue;
 };
 /**
  * Array of key-value entries representing explicit column data.
  * Used for lightweight explicit instantiation of PColumns.
  */
-export type PColumnValues = PColumnValuesEntry[];
+type PColumnValues = PColumnValuesEntry[];
 /**
  * Entry-based representation of JsonDataInfo
  */
-export interface JsonDataInfoEntries {
-    type: "Json";
-    keyLength: number;
-    data: PColumnDataEntry<PColumnValue>[];
+interface JsonDataInfoEntries {
+  type: "Json";
+  keyLength: number;
+  data: PColumnDataEntry<PColumnValue>[];
 }
 /**
  * Entry-based representation of JsonPartitionedDataInfo
  */
-export interface JsonPartitionedDataInfoEntries<Blob> {
-    type: "JsonPartitioned";
-    partitionKeyLength: number;
-    parts: PColumnDataEntry<Blob>[];
+interface JsonPartitionedDataInfoEntries<Blob> {
+  type: "JsonPartitioned";
+  partitionKeyLength: number;
+  parts: PColumnDataEntry<Blob>[];
 }
 /**
  * Entry-based representation of BinaryPartitionedDataInfo
  */
-export interface BinaryPartitionedDataInfoEntries<Blob> {
-    type: "BinaryPartitioned";
-    partitionKeyLength: number;
-    parts: PColumnDataEntry<BinaryChunk<Blob>>[];
+interface BinaryPartitionedDataInfoEntries<Blob> {
+  type: "BinaryPartitioned";
+  partitionKeyLength: number;
+  parts: PColumnDataEntry<BinaryChunk<Blob>>[];
 }
 /**
  * Entry-based representation of ParquetPartitionedDataInfo
  */
-export interface ParquetPartitionedDataInfoEntries<Blob> {
-    type: "ParquetPartitioned";
-    partitionKeyLength: number;
-    parts: PColumnDataEntry<Blob>[];
+interface ParquetPartitionedDataInfoEntries<Blob> {
+  type: "ParquetPartitioned";
+  partitionKeyLength: number;
+  parts: PColumnDataEntry<Blob>[];
 }
 /**
  * Union type representing all possible entry-based partitioned data storage formats
  */
-export type PartitionedDataInfoEntries<Blob> = JsonPartitionedDataInfoEntries<Blob> | BinaryPartitionedDataInfoEntries<Blob> | ParquetPartitionedDataInfoEntries<Blob>;
+type PartitionedDataInfoEntries<Blob> = JsonPartitionedDataInfoEntries<Blob> | BinaryPartitionedDataInfoEntries<Blob> | ParquetPartitionedDataInfoEntries<Blob>;
 /**
  * Union type representing all possible entry-based data storage formats
  */
-export type DataInfoEntries<Blob> = JsonDataInfoEntries | PartitionedDataInfoEntries<Blob>;
+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
  */
-export declare function isDataInfoEntries<Blob>(value: unknown): value is DataInfoEntries<Blob>;
+declare function isDataInfoEntries<Blob>(value: unknown): value is DataInfoEntries<Blob>;
 /**
  * Type guard function that checks if the given value is a valid PartitionedDataInfoEntries.
  *
@@ -216,21 +189,21 @@ export declare function isDataInfoEntries<Blob>(value: unknown): value is DataIn
  * @param value - The value to check
  * @returns True if the value is a valid PartitionedDataInfoEntries, false otherwise
  */
-export declare function isPartitionedDataInfoEntries<Blob>(value: unknown): value is PartitionedDataInfoEntries<Blob>;
+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
  */
-export declare function dataInfoToEntries<Blob>(dataInfo: DataInfo<Blob>): DataInfoEntries<Blob>;
+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
  */
-export declare function entriesToDataInfo<Blob>(dataInfoEntries: DataInfoEntries<Blob>): DataInfo<Blob>;
+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.
  *
@@ -240,5 +213,7 @@ export declare function entriesToDataInfo<Blob>(dataInfoEntries: DataInfoEntries
  * @param mapFn - Function to transform blobs from type B1 to type B2
  * @returns A new DataInfoEntries object with transformed blob references
  */
-export declare function mapDataInfoEntries<B1, B2>(dataInfoEntries: DataInfoEntries<B1>, mapFn: (blob: B1) => B2): DataInfoEntries<B2>;
+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