@cj-tech-master/excelts 3.1.0-canary.20260102041828.82ed571 → 3.1.0

package/dist/types/modules/archive/zip-builder.d.ts

@@ -1,117 +0,0 @@
-/**
- * ZIP file format builder
- *
- * Implements ZIP file structure according to PKWARE's APPNOTE.TXT specification
- * https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
- *
- * ZIP file structure:
- * ┌──────────────────────────┐
- * │   Local File Header 1    │
- * │   File Data 1            │
- * ├──────────────────────────┤
- * │   Local File Header 2    │
- * │   File Data 2            │
- * ├──────────────────────────┤
- * │         ...              │
- * ├──────────────────────────┤
- * │  Central Directory 1     │
- * │  Central Directory 2     │
- * │         ...              │
- * ├──────────────────────────┤
- * │ End of Central Directory │
- * └──────────────────────────┘
- */
-import { type CompressOptions } from "@archive/compress";
-import { type ZipTimestampMode } from "@archive/utils/timestamps";
-/**
- * ZIP file entry
- */
-export interface ZipEntry {
-    /** File name (can include directory path, use forward slashes) */
-    name: string;
-    /** File data (will be compressed unless level=0) */
-    data: Uint8Array;
-    /** File modification time (optional, defaults to current time) */
-    modTime?: Date;
-    /** File comment (optional) */
-    comment?: string;
-}
-/**
- * ZIP builder options
- */
-export interface ZipOptions extends CompressOptions {
-    /** ZIP file comment (optional) */
-    comment?: string;
-    /**
-     * Timestamp writing strategy.
-     * - "dos": only write DOS date/time fields (smallest output)
-     * - "dos+utc": also write UTC mtime in 0x5455 extra field (default, best practice)
-     */
-    timestamps?: ZipTimestampMode;
-}
-/**
- * Create a ZIP file from entries (async)
- *
- * @param entries - Files to include in ZIP
- * @param options - ZIP options
- * @returns ZIP file as Uint8Array
- *
- * @example
- * ```ts
- * const zip = await createZip([
- *   { name: "hello.txt", data: new TextEncoder().encode("Hello!") },
- *   { name: "folder/file.txt", data: new TextEncoder().encode("Nested!") }
- * ], { level: 6 });
- * ```
- */
-export declare function createZip(entries: ZipEntry[], options?: ZipOptions): Promise<Uint8Array>;
-/**
- * Create a ZIP file from entries (sync)
- *
- * This is supported in both Node.js and browser builds.
- */
-export declare function createZipSync(entries: ZipEntry[], options?: ZipOptions): Uint8Array;
-/**
- * Streaming ZIP builder for large files
- * Writes chunks to a callback as they are generated
- */
-export declare class ZipBuilder {
-    private entries;
-    private currentOffset;
-    private level;
-    private zipComment;
-    private timestamps;
-    private compressOptions;
-    private settings;
-    private finalized;
-    /**
-     * Create a new ZIP builder
-     * @param options - ZIP options
-     */
-    constructor(options?: ZipOptions);
-    /**
-     * Add a file to the ZIP (async)
-     * @param entry - File entry
-     * @returns Local file header and compressed data chunks
-     */
-    addFile(entry: ZipEntry): Promise<Uint8Array[]>;
-    /**
-     * Add a file to the ZIP (sync)
-     * @param entry - File entry
-     * @returns Local file header and compressed data chunks
-     */
-    addFileSync(entry: ZipEntry): Uint8Array[];
-    /**
-     * Finalize the ZIP and return central directory + end record
-     * @returns Central directory and end of central directory chunks
-     */
-    finalize(): Uint8Array[];
-    /**
-     * Get current number of entries
-     */
-    get entryCount(): number;
-    /**
-     * Get current ZIP data size (without central directory)
-     */
-    get dataSize(): number;
-}

package/dist/types/modules/archive/zip-constants.d.ts

@@ -1,18 +0,0 @@
-/**
- * ZIP format constants (PKWARE APPNOTE)
- * Shared by ZIP writer and parser implementations.
- */
-export declare const LOCAL_FILE_HEADER_SIG = 67324752;
-export declare const CENTRAL_DIR_HEADER_SIG = 33639248;
-export declare const END_OF_CENTRAL_DIR_SIG = 101010256;
-export declare const DATA_DESCRIPTOR_SIG = 134695760;
-export declare const ZIP64_END_OF_CENTRAL_DIR_SIG = 101075792;
-export declare const ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG = 117853008;
-export declare const VERSION_NEEDED = 20;
-export declare const VERSION_MADE_BY = 20;
-export declare const COMPRESSION_STORE = 0;
-export declare const COMPRESSION_DEFLATE = 8;
-export declare const FLAG_UTF8 = 2048;
-export declare const FLAG_DATA_DESCRIPTOR = 8;
-export declare const UINT16_MAX = 65535;
-export declare const UINT32_MAX = 4294967295;

package/dist/types/modules/archive/zip-entry-info.d.ts

@@ -1,29 +0,0 @@
-/**
- * Shared ZIP entry metadata used by unzip parsers and higher-level extract APIs.
- *
- * This is intentionally platform-agnostic and does not depend on Node.js streams.
- */
-export interface ZipEntryInfo {
-    /** File path within the ZIP */
-    path: string;
-    /** Whether this is a directory */
-    isDirectory: boolean;
-    /** Compressed size */
-    compressedSize: number;
-    /** Uncompressed size */
-    uncompressedSize: number;
-    /** Compression method (0 = stored, 8 = deflate) */
-    compressionMethod: number;
-    /** CRC-32 checksum */
-    crc32: number;
-    /** Last modified date */
-    lastModified: Date;
-    /** Offset to local file header */
-    localHeaderOffset: number;
-    /** File comment */
-    comment: string;
-    /** External file attributes */
-    externalAttributes: number;
-    /** Is encrypted */
-    isEncrypted: boolean;
-}

package/dist/types/modules/archive/zip-entry-metadata.d.ts

@@ -1,23 +0,0 @@
-import { type ZipTimestampMode } from "@archive/utils/timestamps";
-export interface ZipEntryMetadata {
-    nameBytes: Uint8Array;
-    commentBytes: Uint8Array;
-    dosTime: number;
-    dosDate: number;
-    extraField: Uint8Array;
-    compressionMethod: number;
-    flags: number;
-}
-export interface ZipEntryMetadataInput {
-    name: string;
-    comment?: string;
-    modTime: Date;
-    timestamps: ZipTimestampMode;
-    /** If true, set FLAG_DATA_DESCRIPTOR and expect CRC/sizes written later. */
-    useDataDescriptor: boolean;
-    /** If true, use DEFLATE; else STORE. */
-    deflate: boolean;
-}
-export declare function resolveZipCompressionMethod(deflate: boolean): number;
-export declare function resolveZipFlags(useDataDescriptor: boolean): number;
-export declare function buildZipEntryMetadata(input: ZipEntryMetadataInput): ZipEntryMetadata;

package/dist/types/modules/archive/zip-parser.d.ts

@@ -1,62 +0,0 @@
-/**
- * Pure Uint8Array-based ZIP parser
- * Works in both Node.js and browser environments
- * No dependency on Node.js stream module
- */
-import type { ZipEntryInfo } from "@archive/zip-entry-info";
-export type { ZipEntryInfo };
-/**
- * ZIP parsing options
- */
-export interface ZipParseOptions {
-    /** Whether to decode file names as UTF-8 (default: true) */
-    decodeStrings?: boolean;
-}
-/**
- * High-level ZIP parser class
- */
-export declare class ZipParser {
-    private data;
-    private entries;
-    private entryMap;
-    constructor(data: Uint8Array | ArrayBuffer, options?: ZipParseOptions);
-    /**
-     * Get all entries in the ZIP file
-     */
-    getEntries(): ZipEntryInfo[];
-    /**
-     * Get entry by path
-     */
-    getEntry(path: string): ZipEntryInfo | undefined;
-    /**
-     * Check if entry exists
-     */
-    hasEntry(path: string): boolean;
-    /**
-     * List all file paths
-     */
-    listFiles(): string[];
-    /**
-     * Extract a single file (async)
-     */
-    extract(path: string): Promise<Uint8Array | null>;
-    /**
-     * Extract a single file (sync)
-     *
-     * This is supported in both Node.js and browser builds.
-     */
-    extractSync(path: string): Uint8Array | null;
-    /**
-     * Extract all files (async)
-     */
-    extractAll(): Promise<Map<string, Uint8Array>>;
-    /**
-     * Extract all files (sync)
-     * Returns object with file paths as keys and Uint8Array content as values
-     */
-    extractAllSync(): Record<string, Uint8Array>;
-    /**
-     * Iterate over entries with async callback
-     */
-    forEach(callback: (entry: ZipEntryInfo, getData: () => Promise<Uint8Array>) => Promise<boolean | void>): Promise<void>;
-}

package/dist/types/modules/archive/zip-records.d.ts

@@ -1,43 +0,0 @@
-/**
- * ZIP record builders (PKWARE APPNOTE)
- *
- * Shared by streaming zip writer and buffer zip builder.
- */
-export interface ZipLocalFileHeaderInput {
-    fileName: Uint8Array;
-    extraField: Uint8Array;
-    flags: number;
-    compressionMethod: number;
-    dosTime: number;
-    dosDate: number;
-    crc32: number;
-    compressedSize: number;
-    uncompressedSize: number;
-    versionNeeded?: number;
-}
-export declare function buildLocalFileHeader(input: ZipLocalFileHeaderInput): Uint8Array;
-export interface ZipCentralDirectoryHeaderInput {
-    fileName: Uint8Array;
-    extraField: Uint8Array;
-    comment: Uint8Array;
-    flags: number;
-    compressionMethod: number;
-    dosTime: number;
-    dosDate: number;
-    crc32: number;
-    compressedSize: number;
-    uncompressedSize: number;
-    localHeaderOffset: number;
-    versionMadeBy?: number;
-    versionNeeded?: number;
-    externalAttributes?: number;
-}
-export declare function buildCentralDirectoryHeader(input: ZipCentralDirectoryHeaderInput): Uint8Array;
-export interface ZipEndOfCentralDirectoryInput {
-    entryCount: number;
-    centralDirSize: number;
-    centralDirOffset: number;
-    comment: Uint8Array;
-}
-export declare function buildEndOfCentralDirectory(input: ZipEndOfCentralDirectoryInput): Uint8Array;
-export declare function buildDataDescriptor(crc32: number, compressedSize: number, uncompressedSize: number): Uint8Array<ArrayBuffer>;

package/dist/types/modules/csv/csv-core.d.ts

@@ -1,215 +0,0 @@
-/**
- * CSV Parser and Formatter - RFC 4180 compliant
- *
- * A lightweight, cross-platform CSV implementation that works in both
- * Node.js and Browser environments with zero dependencies.
- *
- * High-performance RFC 4180 compliant CSV parser and formatter.
- *
- * @see https://tools.ietf.org/html/rfc4180
- */
-/** Header array type (can include undefined to skip columns) */
-export type HeaderArray = (string | undefined | null)[];
-/** Header transform function */
-export type HeaderTransformFunction = (headers: string[]) => HeaderArray;
-/** Row types */
-export type RowArray = string[];
-export type RowMap = Record<string, string>;
-export type Row = RowArray | RowMap;
-/** Row transform callback */
-export type RowTransformCallback<T> = (error?: Error | null, row?: T | null) => void;
-/** Row transform function - sync or async */
-export type RowTransformFunction<I = Row, O = Row> = ((row: I) => O | null) | ((row: I, callback: RowTransformCallback<O>) => void);
-/** Row validate callback */
-export type RowValidateCallback = (error?: Error | null, isValid?: boolean, reason?: string) => void;
-/** Row validate function - sync or async */
-export type RowValidateFunction<T = Row> = ((row: T) => boolean) | ((row: T, callback: RowValidateCallback) => void);
-/**
- * CSV parsing options
- */
-export interface CsvParseOptions {
-    /** Field delimiter (default: ",") */
-    delimiter?: string;
-    /** Quote character (default: '"'), set to false or null to disable quoting */
-    quote?: string | false | null;
-    /** Escape character for quotes (default: '"'), set to false or null to disable */
-    escape?: string | false | null;
-    /** Skip empty lines (default: false) */
-    skipEmptyLines?: boolean;
-    /** Alias for skipEmptyLines */
-    ignoreEmpty?: boolean;
-    /** Trim whitespace from both sides of fields (default: false) */
-    trim?: boolean;
-    /** Left trim whitespace from fields (default: false) */
-    ltrim?: boolean;
-    /** Right trim whitespace from fields (default: false) */
-    rtrim?: boolean;
-    /**
-     * Header handling:
-     * - true: first row is headers, return objects
-     * - false: no headers, return arrays
-     * - string[]: use these as headers
-     * - function: transform first row headers
-     */
-    headers?: boolean | HeaderArray | HeaderTransformFunction;
-    /**
-     * If true and headers is string[], discard first row and use provided headers
-     */
-    renameHeaders?: boolean;
-    /** Comment character - lines starting with this are ignored */
-    comment?: string;
-    /**
-     * Decimal separator used when parsing numbers from CSV (default: ".").
-     *
-     * Note: core CSV parsing returns strings; number conversion is handled by higher-level
-     * consumers (e.g. the default value mapper in the CSV module).
-     *
-     * @deprecated Use CsvReadOptions.valueMapperOptions.decimalSeparator instead.
-     */
-    decimalSeparator?: "." | ",";
-    /** Maximum number of data rows to parse (excluding header) */
-    maxRows?: number;
-    /** Number of lines to skip at the beginning (before header detection) */
-    skipLines?: number;
-    /** Number of data rows to skip (after header detection) */
-    skipRows?: number;
-    /**
-     * Strict column handling:
-     * - If true, rows with column count mismatch emit 'data-invalid' event
-     * - If false (default), throws error on mismatch (unless discardUnmappedColumns)
-     */
-    strictColumnHandling?: boolean;
-    /**
-     * If true, discard columns that exceed header count
-     * Only valid when headers are specified
-     */
-    discardUnmappedColumns?: boolean;
-    /**
-     * Enable object mode (default: true for Node.js streams)
-     * - true: push row objects/arrays
-     * - false: push JSON strings
-     */
-    objectMode?: boolean;
-    /**
-     * Character encoding for input (default: "utf8")
-     * Only used in Node.js streaming context
-     */
-    encoding?: BufferEncoding;
-    /**
-     * Synchronous transform function to apply to each row after parsing
-     * Return null/undefined to skip the row
-     * Works in both Node.js and Browser environments
-     *
-     * @example
-     * // With headers (row is Record<string, string>)
-     * transform: (row) => ({ ...row, name: row.name.toUpperCase() })
-     *
-     * // Without headers (row is string[])
-     * transform: (row) => [row[0].toUpperCase(), row[1]]
-     */
-    transform?: (row: Row) => Row | null | undefined;
-    /**
-     * Synchronous validate function to check each row
-     * Return false to mark row as invalid (will be in invalidRows)
-     * Can also return { isValid: boolean, reason?: string }
-     * Works in both Node.js and Browser environments
-     *
-     * @example
-     * // With headers
-     * validate: (row) => row.name !== ''
-     *
-     * // With custom reason
-     * validate: (row) => ({ isValid: row.age >= 18, reason: 'Must be adult' })
-     */
-    validate?: (row: Row) => boolean | {
-        isValid: boolean;
-        reason?: string;
-    };
-}
-/**
- * CSV formatting options
- */
-export interface CsvFormatOptions {
-    /** Field delimiter (default: ",") */
-    delimiter?: string;
-    /** Quote character (default: '"'), set to false or null to disable quoting */
-    quote?: string | false | null;
-    /** Escape character (default: same as quote) */
-    escape?: string | false | null;
-    /** Row delimiter (default: "\n") */
-    rowDelimiter?: string;
-    /**
-     * Decimal separator used when formatting numbers to CSV (default: ".").
-     * For European-style CSV, this is commonly "," (often together with delimiter ";").
-     */
-    decimalSeparator?: "." | ",";
-    /** Always quote all fields (default: false, only quote when necessary) */
-    alwaysQuote?: boolean;
-    /** Quote specific columns by name or index */
-    quoteColumns?: boolean | boolean[] | Record<string, boolean>;
-    /** Quote header fields */
-    quoteHeaders?: boolean | boolean[] | Record<string, boolean>;
-    /**
-     * Header handling:
-     * - true: auto-detect headers from first object
-     * - false/null: no headers
-     * - string[]: use these as headers
-     */
-    headers?: string[] | boolean | null;
-    /**
-     * Whether to write headers (default: true when headers is provided)
-     * Set to false to suppress header row output
-     */
-    writeHeaders?: boolean;
-    /** Include BOM for UTF-8 (default: false) */
-    writeBOM?: boolean;
-    /** Include final row delimiter (default: true) */
-    includeEndRowDelimiter?: boolean;
-    /** Write headers even when there's no data (default: false) */
-    alwaysWriteHeaders?: boolean;
-    /**
-     * Transform function to apply to each row before formatting
-     * Can be sync (returns row) or async (calls callback)
-     */
-    transform?: RowTransformFunction<Row, Row>;
-    /**
-     * Enable object mode (default: true for Node.js streams)
-     * - true: accept row objects/arrays directly
-     * - false: accept JSON strings
-     */
-    objectMode?: boolean;
-}
-/**
- * Parsed CSV result with headers
- */
-export interface CsvParseResult<T = string[]> {
-    /** Header row (if headers option was true) */
-    headers?: string[];
-    /** Data rows */
-    rows: T[];
-    /** Invalid rows (when strictColumnHandling is true) */
-    invalidRows?: {
-        row: string[];
-        reason: string;
-    }[];
-}
-/**
- * Check if a transform function is synchronous (1 argument) vs async (2 arguments)
- */
-export declare function isSyncTransform<I, O>(transform: RowTransformFunction<I, O>): transform is (row: I) => O | null;
-/**
- * Check if a validate function is synchronous (1 argument) vs async (2 arguments)
- */
-export declare function isSyncValidate<T>(validate: RowValidateFunction<T>): validate is (row: T) => boolean;
-/**
- * Parse a CSV string into rows of fields
- */
-export declare function parseCsv(input: string, options?: CsvParseOptions): string[][] | CsvParseResult<Record<string, string>>;
-/**
- * Format data as a CSV string
- */
-export declare function formatCsv(data: (string | number | boolean | null | undefined)[][] | Record<string, any>[], options?: CsvFormatOptions): string;
-/**
- * Async CSV parser that yields rows one at a time
- */
-export declare function parseCsvStream(input: string | AsyncIterable<string>, options?: CsvParseOptions): AsyncGenerator<string[] | Record<string, string>, void, unknown>;

package/dist/types/modules/csv/csv-stream.d.ts

@@ -1,121 +0,0 @@
-/**
- * CSV Streaming Support - Cross-Platform
- *
- * Provides true streaming CSV parsing and formatting using our cross-platform stream module.
- * Works identically in both Node.js and Browser environments.
- */
-import { Transform } from "@stream";
-import type { IReadable } from "@stream/types";
-import type { CsvParseOptions, CsvFormatOptions, RowTransformFunction, RowValidateFunction, Row } from "@csv/csv-core";
-/**
- * Transform stream that parses CSV data row by row
- *
- * @example
- * ```ts
- * const parser = new CsvParserStream({ headers: true });
- * readable.pipe(parser).on('data', (row) => console.log(row));
- * ```
- */
-export declare class CsvParserStream extends Transform {
-    private options;
-    private buffer;
-    private currentRow;
-    private currentField;
-    private currentFieldParts;
-    private currentFieldLength;
-    private inQuotes;
-    private lineNumber;
-    private rowCount;
-    private skippedDataRows;
-    private headerRow;
-    private headersEmitted;
-    private delimiter;
-    private quote;
-    private escape;
-    private quoteEnabled;
-    private trimField;
-    private decoder;
-    private _rowTransform;
-    private _rowValidator;
-    constructor(options?: CsvParseOptions);
-    /**
-     * Set a transform function to modify rows before emitting
-     * Supports both sync and async transforms
-     */
-    transform<I extends Row = Row, O extends Row = Row>(transformFunction: RowTransformFunction<I, O>): this;
-    /**
-     * Set a validate function to filter rows
-     * Invalid rows emit 'data-invalid' event
-     */
-    validate<T extends Row = Row>(validateFunction: RowValidateFunction<T>): this;
-    _transform(chunk: Uint8Array | string, _encoding: string, callback: (error?: Error | null, data?: Row) => void): void;
-    _flush(callback: (error?: Error | null) => void): void;
-    private flushCurrentRow;
-    private appendToField;
-    private takeCurrentField;
-    private processBuffer;
-    private buildRow;
-    private processPendingRows;
-    private transformAndValidateRow;
-    private validateRow;
-    private emitRow;
-}
-/**
- * Options for CSV formatter stream
- */
-export interface CsvFormatterStreamOptions extends CsvFormatOptions {
-    /** Whether input is objects (vs arrays) */
-    objectMode?: boolean;
-}
-/**
- * Transform stream that formats rows to CSV
- *
- * @example
- * ```ts
- * const formatter = new CsvFormatterStream({ headers: ['name', 'age'] });
- * formatter.pipe(writable);
- * formatter.write(['Alice', 30]);
- * formatter.write(['Bob', 25]);
- * formatter.end();
- * ```
- */
-export declare class CsvFormatterStream extends Transform {
-    private options;
-    private delimiter;
-    private quote;
-    private escape;
-    private rowDelimiter;
-    private quoteEnabled;
-    private alwaysQuote;
-    private decimalSeparator;
-    private headerWritten;
-    private headers;
-    private shouldWriteHeaders;
-    private rowCount;
-    private _rowTransform;
-    private escapeQuoteRegex;
-    private escapedQuote;
-    constructor(options?: CsvFormatterStreamOptions);
-    /**
-     * Set a transform function to modify rows before formatting
-     */
-    transform<I extends Row = Row, O extends Row = Row>(transformFunction: RowTransformFunction<I, O>): this;
-    _transform(chunk: Row, _encoding: string, callback: (error?: Error | null, data?: string) => void): void;
-    _flush(callback: (error?: Error | null) => void): void;
-    private formatAndPush;
-    private formatRow;
-    private shouldQuoteField;
-    private formatField;
-}
-/**
- * Create a readable stream from an array of rows
- */
-export declare function createCsvReadableStream(rows: unknown[][], options?: CsvFormatOptions): IReadable<any>;
-/**
- * Create parser stream factory
- */
-export declare function createCsvParserStream(options?: CsvParseOptions): CsvParserStream;
-/**
- * Create formatter stream factory
- */
-export declare function createCsvFormatterStream(options?: CsvFormatterStreamOptions): CsvFormatterStream;

package/dist/types/modules/csv/csv.browser.d.ts

@@ -1,60 +0,0 @@
-/**
- * CSV class - Cross-Platform Base Implementation
- *
- * Provides CSV read/write functionality for both Node.js and Browser.
- * Node.js version (csv.ts) extends this with file system support.
- */
-import { type DateFormat } from "@utils/datetime";
-import { type CsvParseOptions, type CsvFormatOptions } from "@csv/csv-core";
-import { type DecimalSeparator } from "@csv/csv-number";
-import type { IReadable, IWritable } from "@stream/types";
-import type { Workbook } from "@excel/workbook";
-import type { Worksheet } from "@excel/worksheet";
-export interface CsvReadOptions {
-    dateFormats?: readonly DateFormat[];
-    map?(value: any, index: number): any;
-    sheetName?: string;
-    parserOptions?: Partial<CsvParseOptions>;
-    /** Options for the default value mapper (string -> number/date/etc). */
-    valueMapperOptions?: DefaultValueMapperOptions;
-}
-export interface CsvWriteOptions {
-    dateFormat?: string;
-    dateUTC?: boolean;
-    sheetName?: string;
-    sheetId?: number;
-    encoding?: string;
-    map?(value: any, index: number): any;
-    includeEmptyRows?: boolean;
-    formatterOptions?: Partial<CsvFormatOptions>;
-}
-export interface CsvStreamReadOptions extends CsvReadOptions {
-    highWaterMark?: number;
-}
-export interface CsvStreamWriteOptions extends CsvWriteOptions {
-    highWaterMark?: number;
-}
-export interface DefaultValueMapperOptions {
-    decimalSeparator?: DecimalSeparator;
-}
-export declare function createDefaultValueMapper(dateFormats: readonly DateFormat[], options?: DefaultValueMapperOptions): (datum: any) => any;
-export declare function createDefaultWriteMapper(dateFormat?: string, dateUTC?: boolean): (value: any) => any;
-declare class CSV {
-    workbook: Workbook;
-    constructor(workbook: Workbook);
-    load(content: string | ArrayBuffer | Uint8Array, options?: CsvReadOptions): Worksheet;
-    writeString(options?: CsvWriteOptions): string;
-    writeBuffer(options?: CsvWriteOptions): Promise<Uint8Array>;
-    read(stream: IReadable<any>, options?: CsvReadOptions): Promise<Worksheet>;
-    write(stream: IWritable<any>, options?: CsvWriteOptions): Promise<void>;
-    createReadStream(options?: CsvWriteOptions): IReadable<any>;
-    createWriteStream(options?: CsvReadOptions): IWritable<any>;
-    readFile(_filename: string, _options?: CsvStreamReadOptions): Promise<Worksheet>;
-    writeFile(_filename: string, _options?: CsvStreamWriteOptions): Promise<void>;
-}
-export declare function parseCsvToWorksheet(content: string, workbook: Workbook, options?: CsvReadOptions): Worksheet;
-export declare function formatWorksheetToCsv(worksheet: Worksheet | undefined, options?: CsvWriteOptions): string;
-export { CSV };
-export { CsvParserStream, CsvFormatterStream } from "@csv/csv-stream";
-export { parseCsv, formatCsv } from "@csv/csv-core";
-export type { CsvParseOptions, CsvFormatOptions } from "@csv/csv-core";