langsmith 0.5.16 → 0.5.18

package/dist/utils/console-table-printer/src/internalTable/internal-table.cjs

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const colored_console_line_js_1 = require("../utils/colored-console-line.cjs");
+const table_constants_js_1 = require("../utils/table-constants.cjs");
+const table_helpers_js_1 = require("../utils/table-helpers.cjs");
+const input_converter_js_1 = require("./input-converter.cjs");
+const internal_table_printer_js_1 = require("./internal-table-printer.cjs");
+const DEFAULT_ROW_SORT_FUNC = () => 0;
+const DEFAULT_ROW_FILTER_FUNC = () => true;
+class TableInternal {
+    initSimple(columns) {
+        this.columns = columns.map((column) => ({
+            name: column,
+            title: column,
+            alignment: table_constants_js_1.DEFAULT_ROW_ALIGNMENT,
+        }));
+    }
+    initDetailed(options) {
+        this.title = options?.title || this.title;
+        this.tableStyle = {
+            ...this.tableStyle,
+            ...options?.style,
+        };
+        this.sortFunction = options?.sort || this.sortFunction;
+        this.filterFunction = options?.filter || this.filterFunction;
+        this.enabledColumns = options?.enabledColumns || this.enabledColumns;
+        this.disabledColumns = options?.disabledColumns || this.disabledColumns;
+        this.computedColumns = options?.computedColumns || this.computedColumns;
+        this.columns =
+            options?.columns?.map((column) => (0, input_converter_js_1.rawColumnToInternalColumn)(column, options?.defaultColumnOptions)) || this.columns;
+        this.rowSeparator = options?.rowSeparator || this.rowSeparator;
+        this.charLength = options?.charLength || this.charLength;
+        this.defaultColumnOptions =
+            options?.defaultColumnOptions || this.defaultColumnOptions;
+        if (options?.shouldDisableColors) {
+            this.colorMap = {};
+        }
+        else if (options?.colorMap) {
+            this.colorMap = { ...this.colorMap, ...options.colorMap };
+        }
+        if (options.rows !== undefined) {
+            this.addRows(options.rows);
+        }
+    }
+    constructor(options) {
+        Object.defineProperty(this, "title", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tableStyle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "columns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "rows", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "filterFunction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sortFunction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "enabledColumns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "disabledColumns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "computedColumns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "rowSeparator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "colorMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "charLength", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "defaultColumnOptions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "transforms", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // default construction
+        this.rows = [];
+        this.columns = [];
+        this.title = undefined;
+        this.tableStyle = table_constants_js_1.DEFAULT_TABLE_STYLE;
+        this.filterFunction = DEFAULT_ROW_FILTER_FUNC;
+        this.sortFunction = DEFAULT_ROW_SORT_FUNC;
+        this.enabledColumns = [];
+        this.disabledColumns = [];
+        this.computedColumns = [];
+        this.rowSeparator = table_constants_js_1.DEFAULT_ROW_SEPARATOR;
+        this.colorMap = colored_console_line_js_1.DEFAULT_COLOR_MAP;
+        this.charLength = {};
+        this.defaultColumnOptions = undefined;
+        this.transforms = {};
+        if (options instanceof Array) {
+            this.initSimple(options);
+        }
+        else if (typeof options === 'object') {
+            this.initDetailed(options);
+        }
+    }
+    createColumnFromRow(text) {
+        const colNames = this.columns.map((col) => col.name);
+        Object.keys(text).forEach((key) => {
+            if (!colNames.includes(key)) {
+                this.columns.push((0, input_converter_js_1.rawColumnToInternalColumn)((0, table_helpers_js_1.createColumFromOnlyName)(key), this.defaultColumnOptions));
+            }
+        });
+    }
+    addColumn(textOrObj) {
+        const columnOptionsFromInput = typeof textOrObj === 'string'
+            ? (0, table_helpers_js_1.createColumFromOnlyName)(textOrObj)
+            : textOrObj;
+        this.columns.push((0, input_converter_js_1.rawColumnToInternalColumn)(columnOptionsFromInput, this.defaultColumnOptions));
+    }
+    addColumns(toBeInsertedColumns) {
+        toBeInsertedColumns.forEach((toBeInsertedColumn) => {
+            this.addColumn(toBeInsertedColumn);
+        });
+    }
+    addRow(text, options) {
+        this.createColumnFromRow(text);
+        this.rows.push((0, table_helpers_js_1.createRow)(options?.color || table_constants_js_1.DEFAULT_ROW_FONT_COLOR, text, options?.separator !== undefined
+            ? options?.separator
+            : this.rowSeparator));
+    }
+    addRows(toBeInsertedRows, options) {
+        toBeInsertedRows.forEach((toBeInsertedRow) => {
+            this.addRow(toBeInsertedRow, options);
+        });
+    }
+    renderTable() {
+        return (0, internal_table_printer_js_1.renderTable)(this);
+    }
+}
+exports.default = TableInternal;

package/dist/utils/console-table-printer/src/internalTable/internal-table.d.ts

@@ -0,0 +1,31 @@
+import { CharLengthDict, Dictionary, Row } from '../models/common.js';
+import { ColumnOptionsRaw, ComplexOptions, ComputedColumn, DefaultColumnOptions, RowFilterFunction, RowSortFunction, Valuetransform } from '../models/external-table.js';
+import { Column, TableStyleDetails } from '../models/internal-table.js';
+import { ColorMap } from '../utils/colored-console-line.js';
+import { RowOptions } from '../utils/table-helpers.js';
+declare class TableInternal {
+    title?: string;
+    tableStyle: TableStyleDetails;
+    columns: Column[];
+    rows: Row[];
+    filterFunction: RowFilterFunction;
+    sortFunction: RowSortFunction;
+    enabledColumns: string[];
+    disabledColumns: string[];
+    computedColumns: ComputedColumn[];
+    rowSeparator: boolean;
+    colorMap: ColorMap;
+    charLength: CharLengthDict;
+    defaultColumnOptions?: DefaultColumnOptions;
+    transforms?: Record<string, Valuetransform>;
+    initSimple(columns: string[]): void;
+    initDetailed(options: ComplexOptions): void;
+    constructor(options?: ComplexOptions | string[]);
+    createColumnFromRow(text: Dictionary): void;
+    addColumn(textOrObj: string | ComputedColumn | ColumnOptionsRaw): void;
+    addColumns(toBeInsertedColumns: string[] | ColumnOptionsRaw[]): void;
+    addRow(text: Dictionary, options?: RowOptions): void;
+    addRows(toBeInsertedRows: Dictionary[], options?: RowOptions): void;
+    renderTable(): string;
+}
+export default TableInternal;

package/dist/utils/console-table-printer/src/internalTable/internal-table.js

@@ -0,0 +1,184 @@
+import { DEFAULT_COLOR_MAP } from '../utils/colored-console-line.js';
+import { DEFAULT_TABLE_STYLE, DEFAULT_ROW_ALIGNMENT, DEFAULT_ROW_FONT_COLOR, DEFAULT_ROW_SEPARATOR, } from '../utils/table-constants.js';
+import { createColumFromOnlyName, createRow, } from '../utils/table-helpers.js';
+import { rawColumnToInternalColumn } from './input-converter.js';
+import { renderTable } from './internal-table-printer.js';
+const DEFAULT_ROW_SORT_FUNC = () => 0;
+const DEFAULT_ROW_FILTER_FUNC = () => true;
+class TableInternal {
+    initSimple(columns) {
+        this.columns = columns.map((column) => ({
+            name: column,
+            title: column,
+            alignment: DEFAULT_ROW_ALIGNMENT,
+        }));
+    }
+    initDetailed(options) {
+        this.title = options?.title || this.title;
+        this.tableStyle = {
+            ...this.tableStyle,
+            ...options?.style,
+        };
+        this.sortFunction = options?.sort || this.sortFunction;
+        this.filterFunction = options?.filter || this.filterFunction;
+        this.enabledColumns = options?.enabledColumns || this.enabledColumns;
+        this.disabledColumns = options?.disabledColumns || this.disabledColumns;
+        this.computedColumns = options?.computedColumns || this.computedColumns;
+        this.columns =
+            options?.columns?.map((column) => rawColumnToInternalColumn(column, options?.defaultColumnOptions)) || this.columns;
+        this.rowSeparator = options?.rowSeparator || this.rowSeparator;
+        this.charLength = options?.charLength || this.charLength;
+        this.defaultColumnOptions =
+            options?.defaultColumnOptions || this.defaultColumnOptions;
+        if (options?.shouldDisableColors) {
+            this.colorMap = {};
+        }
+        else if (options?.colorMap) {
+            this.colorMap = { ...this.colorMap, ...options.colorMap };
+        }
+        if (options.rows !== undefined) {
+            this.addRows(options.rows);
+        }
+    }
+    constructor(options) {
+        Object.defineProperty(this, "title", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "tableStyle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "columns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "rows", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "filterFunction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sortFunction", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "enabledColumns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "disabledColumns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "computedColumns", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "rowSeparator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "colorMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "charLength", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "defaultColumnOptions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "transforms", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // default construction
+        this.rows = [];
+        this.columns = [];
+        this.title = undefined;
+        this.tableStyle = DEFAULT_TABLE_STYLE;
+        this.filterFunction = DEFAULT_ROW_FILTER_FUNC;
+        this.sortFunction = DEFAULT_ROW_SORT_FUNC;
+        this.enabledColumns = [];
+        this.disabledColumns = [];
+        this.computedColumns = [];
+        this.rowSeparator = DEFAULT_ROW_SEPARATOR;
+        this.colorMap = DEFAULT_COLOR_MAP;
+        this.charLength = {};
+        this.defaultColumnOptions = undefined;
+        this.transforms = {};
+        if (options instanceof Array) {
+            this.initSimple(options);
+        }
+        else if (typeof options === 'object') {
+            this.initDetailed(options);
+        }
+    }
+    createColumnFromRow(text) {
+        const colNames = this.columns.map((col) => col.name);
+        Object.keys(text).forEach((key) => {
+            if (!colNames.includes(key)) {
+                this.columns.push(rawColumnToInternalColumn(createColumFromOnlyName(key), this.defaultColumnOptions));
+            }
+        });
+    }
+    addColumn(textOrObj) {
+        const columnOptionsFromInput = typeof textOrObj === 'string'
+            ? createColumFromOnlyName(textOrObj)
+            : textOrObj;
+        this.columns.push(rawColumnToInternalColumn(columnOptionsFromInput, this.defaultColumnOptions));
+    }
+    addColumns(toBeInsertedColumns) {
+        toBeInsertedColumns.forEach((toBeInsertedColumn) => {
+            this.addColumn(toBeInsertedColumn);
+        });
+    }
+    addRow(text, options) {
+        this.createColumnFromRow(text);
+        this.rows.push(createRow(options?.color || DEFAULT_ROW_FONT_COLOR, text, options?.separator !== undefined
+            ? options?.separator
+            : this.rowSeparator));
+    }
+    addRows(toBeInsertedRows, options) {
+        toBeInsertedRows.forEach((toBeInsertedRow) => {
+            this.addRow(toBeInsertedRow, options);
+        });
+    }
+    renderTable() {
+        return renderTable(this);
+    }
+}
+export default TableInternal;

package/dist/utils/console-table-printer/src/internalTable/table-pre-processors.cjs

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preProcessRows = exports.preProcessColumns = void 0;
+const table_helpers_js_1 = require("../utils/table-helpers.cjs");
+// All these functions are ran when renderTable/printTable is called
+const createComputedColumnsIfNecessary = (table) => {
+    if (table.computedColumns.length) {
+        table.computedColumns.forEach((computedColumn) => {
+            // This can happen if renderTable/printTable is called multiple times
+            const isColumnAlreadyExists = table.columns.some((col) => col.name === computedColumn.name);
+            if (isColumnAlreadyExists) {
+                return;
+            }
+            table.addColumn({
+                ...computedColumn,
+                ...table.defaultColumnOptions,
+            });
+            table.rows.forEach((row, index, rowsArray) => {
+                const arrayRowText = rowsArray.map((elemInRowsArray) => elemInRowsArray.text);
+                row.text[computedColumn.name] = computedColumn.function(row.text, index, arrayRowText);
+            });
+        });
+    }
+};
+const disableColumnsIfNecessary = (table) => {
+    if (table.enabledColumns.length) {
+        table.columns = table.columns.filter((col) => table.enabledColumns.includes(col.name));
+    }
+};
+const enableColumnsIfNecessary = (table) => {
+    if (table.disabledColumns.length) {
+        table.columns = table.columns.filter((col) => !table.disabledColumns.includes(col.name));
+    }
+};
+const findColumnWidth = (table) => {
+    table.columns.forEach((column) => {
+        column.length = (0, table_helpers_js_1.findLenOfColumn)(column, table.rows, table.charLength);
+    });
+};
+const preProcessColumns = (table) => {
+    createComputedColumnsIfNecessary(table);
+    enableColumnsIfNecessary(table);
+    disableColumnsIfNecessary(table);
+    findColumnWidth(table);
+};
+exports.preProcessColumns = preProcessColumns;
+const preProcessRows = (table) => {
+    const newRows = table.rows
+        .filter((r) => table.filterFunction(r.text))
+        .sort((r1, r2) => table.sortFunction(r1.text, r2.text));
+    table.rows = newRows;
+};
+exports.preProcessRows = preProcessRows;

package/dist/utils/console-table-printer/src/internalTable/table-pre-processors.d.ts

@@ -0,0 +1,3 @@
+import TableInternal from './internal-table.js';
+export declare const preProcessColumns: (table: TableInternal) => void;
+export declare const preProcessRows: (table: TableInternal) => void;

package/dist/utils/console-table-printer/src/internalTable/table-pre-processors.js

@@ -0,0 +1,48 @@
+import { findLenOfColumn } from '../utils/table-helpers.js';
+// All these functions are ran when renderTable/printTable is called
+const createComputedColumnsIfNecessary = (table) => {
+    if (table.computedColumns.length) {
+        table.computedColumns.forEach((computedColumn) => {
+            // This can happen if renderTable/printTable is called multiple times
+            const isColumnAlreadyExists = table.columns.some((col) => col.name === computedColumn.name);
+            if (isColumnAlreadyExists) {
+                return;
+            }
+            table.addColumn({
+                ...computedColumn,
+                ...table.defaultColumnOptions,
+            });
+            table.rows.forEach((row, index, rowsArray) => {
+                const arrayRowText = rowsArray.map((elemInRowsArray) => elemInRowsArray.text);
+                row.text[computedColumn.name] = computedColumn.function(row.text, index, arrayRowText);
+            });
+        });
+    }
+};
+const disableColumnsIfNecessary = (table) => {
+    if (table.enabledColumns.length) {
+        table.columns = table.columns.filter((col) => table.enabledColumns.includes(col.name));
+    }
+};
+const enableColumnsIfNecessary = (table) => {
+    if (table.disabledColumns.length) {
+        table.columns = table.columns.filter((col) => !table.disabledColumns.includes(col.name));
+    }
+};
+const findColumnWidth = (table) => {
+    table.columns.forEach((column) => {
+        column.length = findLenOfColumn(column, table.rows, table.charLength);
+    });
+};
+export const preProcessColumns = (table) => {
+    createComputedColumnsIfNecessary(table);
+    enableColumnsIfNecessary(table);
+    disableColumnsIfNecessary(table);
+    findColumnWidth(table);
+};
+export const preProcessRows = (table) => {
+    const newRows = table.rows
+        .filter((r) => table.filterFunction(r.text))
+        .sort((r1, r2) => table.sortFunction(r1.text, r2.text));
+    table.rows = newRows;
+};

package/dist/utils/console-table-printer/src/models/common.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/console-table-printer/src/models/common.d.ts

@@ -0,0 +1,14 @@
+import { ALIGNMENTS, COLORS } from '../utils/table-constants.js';
+export type ALIGNMENT = (typeof ALIGNMENTS)[number];
+export type COLOR = (typeof COLORS)[number];
+export interface Dictionary {
+    [key: string]: any;
+}
+export interface CharLengthDict {
+    [key: string]: number;
+}
+export interface Row {
+    color: COLOR;
+    separator: boolean;
+    text: Dictionary;
+}

package/dist/utils/console-table-printer/src/models/common.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/console-table-printer/src/models/external-table.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/console-table-printer/src/models/external-table.d.ts

@@ -0,0 +1,99 @@
+import { ColorMap } from '../utils/colored-console-line.js';
+import { ALIGNMENT, CharLengthDict, COLOR, Dictionary } from './common.js';
+import { TableStyleDetails as InternalTableStyleDetails } from './internal-table.js';
+export { ALIGNMENT, COLOR };
+export type TableStyleDetails = Partial<InternalTableStyleDetails>;
+export type CellValue = string | number | boolean | undefined | null;
+export type Valuetransform = (cellValue: CellValue) => CellValue;
+/**
+ * Configuration options for a table column
+ */
+export interface ColumnOptionsRaw {
+    /** Unique identifier for the column */
+    name: string;
+    /** Display name for the column header. If not provided, uses the name property */
+    title?: string;
+    /** Text alignment within the column: 'left', 'center', or 'right' */
+    alignment?: ALIGNMENT;
+    /** Text color for the column content */
+    color?: COLOR;
+    /** Maximum length of text in the column. Longer text will be wrapped to multiple lines */
+    maxLen?: number;
+    /** Minimum length of text in the column. Shorter text will be padded with spaces */
+    minLen?: number;
+    /** Value transform, For example 2.00000 => 2.0 */
+    transform?: Valuetransform;
+}
+/**
+ * Configuration for a computed column that generates values dynamically
+ */
+export interface ComputedColumn extends ColumnOptionsRaw {
+    /** Function that computes the column value for each row
+     * @param arg0 - The current row data object
+     * @param index - The index of the current row in the data array
+     * @param array - The complete array of row data
+     * @returns The computed value for this column
+     */
+    function: (arg0: Dictionary, index: number, array: Dictionary[]) => CellValue;
+}
+/**
+ * Function type for sorting table rows
+ * @param row1 - First row to compare
+ * @param row2 - Second row to compare
+ * @returns Negative number if row1 should come before row2, positive if row2 should come before row1, 0 if equal
+ */
+export type RowSortFunction = (row1: Dictionary, row2: Dictionary) => number;
+/**
+ * Function type for filtering table rows
+ * @param row - The row data to evaluate
+ * @returns True if the row should be included, false if it should be filtered out
+ */
+export type RowFilterFunction = (row: Dictionary) => boolean;
+/**
+ * Default styling options applied to all columns unless overridden
+ */
+export interface DefaultColumnOptions {
+    /** Default text alignment for all columns */
+    alignment?: ALIGNMENT;
+    /** Default text color for all columns */
+    color?: COLOR;
+    /** Default title prefix for all columns */
+    title?: string;
+    /** Default maximum length for all columns */
+    maxLen?: number;
+    /** Default minimum length for all columns */
+    minLen?: number;
+}
+/**
+ * Complete configuration options for table creation and styling
+ */
+export interface ComplexOptions {
+    /** Table styling configuration including borders and colors */
+    style?: TableStyleDetails;
+    /** Title displayed at the top of the table */
+    title?: string;
+    /** Array of column configurations */
+    columns?: ColumnOptionsRaw[];
+    /** Initial data rows for the table */
+    rows?: Dictionary[];
+    /** Function to sort rows before display */
+    sort?: RowSortFunction;
+    /** Function to filter rows before display */
+    filter?: RowFilterFunction;
+    /** Array of column names to include (all others will be hidden) */
+    enabledColumns?: string[];
+    /** Array of column names to exclude (these will always be hidden) */
+    disabledColumns?: string[];
+    /** Array of computed columns that generate values dynamically */
+    computedColumns?: ComputedColumn[];
+    /** Whether to add separator lines between rows */
+    rowSeparator?: boolean;
+    /** Whether to disable color output (useful for non-color terminals) */
+    shouldDisableColors?: boolean;
+    /** Custom color mapping for special characters or values */
+    colorMap?: ColorMap;
+    /** Custom character length mapping for special characters (e.g., emojis) */
+    charLength?: CharLengthDict;
+    /** Default options applied to all columns unless overridden */
+    defaultColumnOptions?: DefaultColumnOptions;
+}

package/dist/utils/console-table-printer/src/models/external-table.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/console-table-printer/src/models/internal-table.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/console-table-printer/src/models/internal-table.d.ts

@@ -0,0 +1,24 @@
+import { ALIGNMENT, COLOR } from './common.js';
+import { Valuetransform } from './external-table.js';
+export interface Column {
+    name: string;
+    title: string;
+    alignment?: ALIGNMENT;
+    color?: COLOR;
+    length?: number;
+    minLen?: number;
+    maxLen?: number;
+    transform?: Valuetransform;
+}
+type TableLineDetailsKeys = 'left' | 'right' | 'mid' | 'other';
+export type TableLineDetails = {
+    [key in TableLineDetailsKeys]: string;
+};
+export type TableStyleDetails = {
+    headerTop: TableLineDetails;
+    headerBottom: TableLineDetails;
+    tableBottom: TableLineDetails;
+    vertical: string;
+    rowSeparator: TableLineDetails;
+};
+export {};

package/dist/utils/console-table-printer/src/models/internal-table.js

@@ -0,0 +1 @@
+export {};