@elaraai/east-node-io 0.0.1-beta.0 → 0.0.1-beta.2

package/dist/format/index.d.ts

@@ -0,0 +1,641 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * File format platform functions for East Node IO.
+ *
+ * Provides functions for reading and writing structured file formats like
+ * Excel (XLSX), CSV, and more.
+ *
+ * @example
+ * ```ts
+ * import { East, BlobType, IntegerType } from "@elaraai/east";
+ * import { Format } from "@elaraai/east-node-io";
+ *
+ * const countRows = East.function([BlobType], IntegerType, ($, xlsxBlob) => {
+ *     const options = $.let({
+ *         sheetName: { tag: "none", value: {} },
+ *     });
+ *
+ *     const sheet = $.let(Format.XLSX.read(xlsxBlob, options));
+ *     return $.return(sheet.size());
+ * });
+ *
+ * const compiled = East.compile(countRows.toIR(), Format.XLSX.Implementation);
+ * const xlsxBlob = new Uint8Array([]);  // XLSX file bytes
+ * compiled(xlsxBlob);  // 100n
+ * ```
+ *
+ * @packageDocumentation
+ */
+export * from "./types.js";
+export { xlsx_read, xlsx_write, xlsx_info, XlsxImpl } from "./xlsx.js";
+export { csv_parse, csv_serialize, CsvImpl, CsvParseConfig, CsvSerializeConfig, CsvRowType, CsvDataType } from "./csv.js";
+export { xml_parse, xml_serialize, XmlImpl, XmlParseConfig, XmlSerializeConfig, XmlNode } from "./xml.js";
+/**
+ * File format platform functions grouped by format type.
+ *
+ * Provides organized access to format-specific operations for reading and
+ * writing structured data files in East programs.
+ *
+ * @example
+ * ```ts
+ * import { East, BlobType } from "@elaraai/east";
+ * import { Format } from "@elaraai/east-node-io";
+ *
+ * const createExcel = East.function([], BlobType, $ => {
+ *     const data = $.let([
+ *         [East.variant('String', "Name"), East.variant('String', "Age")],
+ *         [East.variant('String', "Alice"), East.variant('Float', 30)],
+ *         [East.variant('String', "Bob"), East.variant('Float', 25)],
+ *     ]);
+ *
+ *     const options = $.let({
+ *         sheetName: { tag: "some", value: "People" },
+ *     });
+ *
+ *     const blob = $.let(Format.XLSX.write(data, options));
+ *     return $.return(blob);
+ * });
+ *
+ * const compiled = East.compile(createExcel.toIR(), Format.XLSX.Implementation);
+ * const xlsxBlob = compiled();  // Uint8Array with XLSX file bytes
+ * ```
+ */
+export declare const Format: {
+    /**
+     * XLSX (Excel) file format operations.
+     *
+     * Provides functions for reading and writing Excel files as 2D arrays
+     * of literal values (strings, numbers, booleans, null).
+     */
+    readonly XLSX: {
+        /**
+         * Reads an XLSX file and returns a 2D array of cell values.
+         *
+         * Parses an Excel file from a blob and extracts data as ArrayType<ArrayType<LiteralValueType>>.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, IntegerType, variant } from "@elaraai/east";
+         * import { Format } from "@elaraai/east-node-io";
+         *
+         * const countRows = East.function([BlobType], IntegerType, ($, xlsxBlob) => {
+         *     const options = $.let({
+         *         sheetName: variant('none', null),
+         *     });
+         *
+         *     const sheet = $.let(Format.XLSX.read(xlsxBlob, options));
+         *     $.return(sheet.size());
+         * });
+         *
+         * const compiled = East.compile(countRows.toIR(), Format.XLSX.Implementation);
+         * const blob = new Uint8Array([]);
+         * compiled(blob);  // 100n
+         * ```
+         */
+        readonly read: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").BlobType, import("@elaraai/east").StructType<{
+            sheetName: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+        }>], import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+            Null: import("@elaraai/east").NullType;
+            Boolean: import("@elaraai/east").BooleanType;
+            Integer: import("@elaraai/east").IntegerType;
+            Float: import("@elaraai/east").FloatType;
+            String: import("@elaraai/east").StringType;
+            DateTime: import("@elaraai/east").DateTimeType;
+            Blob: import("@elaraai/east").BlobType;
+        }>>>>;
+        /**
+         * Writes a 2D array of cell values to an XLSX file.
+         *
+         * Creates an Excel file from a 2D array of literal values.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, variant } from "@elaraai/east";
+         * import { Format } from "@elaraai/east-node-io";
+         *
+         * const createExcel = East.function([], BlobType, $ => {
+         *     const data = $.let([
+         *         [variant('String', "Name"), variant('String', "Age")],
+         *         [variant('String', "Alice"), variant('Float', 30)],
+         *     ], Format.XLSX.Types.Sheet);
+         *
+         *     const options = $.let({
+         *         sheetName: variant('some', "People"),
+         *     });
+         *
+         *     const blob = $.let(Format.XLSX.write(data, options));
+         *     $.return(blob);
+         * });
+         *
+         * const compiled = East.compile(createExcel.toIR(), Format.XLSX.Implementation);
+         * const xlsxBlob = compiled();
+         * ```
+         */
+        readonly write: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+            Null: import("@elaraai/east").NullType;
+            Boolean: import("@elaraai/east").BooleanType;
+            Integer: import("@elaraai/east").IntegerType;
+            Float: import("@elaraai/east").FloatType;
+            String: import("@elaraai/east").StringType;
+            DateTime: import("@elaraai/east").DateTimeType;
+            Blob: import("@elaraai/east").BlobType;
+        }>>>, import("@elaraai/east").StructType<{
+            sheetName: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+        }>], import("@elaraai/east").BlobType>;
+        /**
+         * Gets metadata about an XLSX file.
+         *
+         * Returns sheet names and approximate sizes without reading all data.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, IntegerType, variant } from "@elaraai/east";
+         * import { Format } from "@elaraai/east-node-io";
+         *
+         * const countSheets = East.function([BlobType], IntegerType, ($, xlsxBlob) => {
+         *     const info = $.let(Format.XLSX.info(xlsxBlob));
+         *     $.return(info.sheets.size());
+         * });
+         *
+         * const compiled = East.compile(countSheets.toIR(), Format.XLSX.Implementation);
+         * const blob = new Uint8Array([]);
+         * compiled(blob);  // 3n
+         * ```
+         */
+        readonly info: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").BlobType], import("@elaraai/east").StructType<{
+            sheets: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+                name: import("@elaraai/east").StringType;
+                rowCount: import("@elaraai/east").IntegerType;
+                columnCount: import("@elaraai/east").IntegerType;
+            }>>;
+        }>>;
+        /**
+         * Node.js implementation of XLSX platform functions.
+         *
+         * Pass this to {@link East.compile} to enable XLSX operations.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, NullType, variant } from "@elaraai/east";
+         * import { Format } from "@elaraai/east-node-io";
+         *
+         * const myFunction = East.function([BlobType], NullType, ($, xlsxBlob) => {
+         *     const options = $.let({
+         *         sheetName: variant('none', null),
+         *     });
+         *     const sheet = $.let(Format.XLSX.read(xlsxBlob, options));
+         *     $.return(null);
+         * });
+         *
+         * const compiled = East.compile(myFunction.toIR(), Format.XLSX.Implementation);
+         * const blob = new Uint8Array([]);
+         * compiled(blob);
+         * ```
+         */
+        readonly Implementation: import("@elaraai/east/internal").PlatformFunction[];
+        /**
+         * Type definitions for XLSX operations.
+         */
+        readonly Types: {
+            /**
+             * A single cell value in a spreadsheet (LiteralValueType).
+             */
+            readonly Cell: import("@elaraai/east").VariantType<{
+                Null: import("@elaraai/east").NullType;
+                Boolean: import("@elaraai/east").BooleanType;
+                Integer: import("@elaraai/east").IntegerType;
+                Float: import("@elaraai/east").FloatType;
+                String: import("@elaraai/east").StringType;
+                DateTime: import("@elaraai/east").DateTimeType;
+                Blob: import("@elaraai/east").BlobType;
+            }>;
+            /**
+             * A row of cells in a spreadsheet.
+             */
+            readonly Row: import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+                Null: import("@elaraai/east").NullType;
+                Boolean: import("@elaraai/east").BooleanType;
+                Integer: import("@elaraai/east").IntegerType;
+                Float: import("@elaraai/east").FloatType;
+                String: import("@elaraai/east").StringType;
+                DateTime: import("@elaraai/east").DateTimeType;
+                Blob: import("@elaraai/east").BlobType;
+            }>>;
+            /**
+             * A 2D array representing a complete worksheet.
+             */
+            readonly Sheet: import("@elaraai/east").ArrayType<import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+                Null: import("@elaraai/east").NullType;
+                Boolean: import("@elaraai/east").BooleanType;
+                Integer: import("@elaraai/east").IntegerType;
+                Float: import("@elaraai/east").FloatType;
+                String: import("@elaraai/east").StringType;
+                DateTime: import("@elaraai/east").DateTimeType;
+                Blob: import("@elaraai/east").BlobType;
+            }>>>;
+            /**
+             * XLSX read options configuration.
+             */
+            readonly ReadOptions: import("@elaraai/east").StructType<{
+                sheetName: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+            }>;
+            /**
+             * XLSX write options configuration.
+             */
+            readonly WriteOptions: import("@elaraai/east").StructType<{
+                sheetName: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+            }>;
+            /**
+             * Information about a single sheet in an XLSX file.
+             */
+            readonly SheetInfo: import("@elaraai/east").StructType<{
+                name: import("@elaraai/east").StringType;
+                rowCount: import("@elaraai/east").IntegerType;
+                columnCount: import("@elaraai/east").IntegerType;
+            }>;
+            /**
+             * XLSX file metadata with sheet listing.
+             */
+            readonly Info: import("@elaraai/east").StructType<{
+                sheets: import("@elaraai/east").ArrayType<import("@elaraai/east").StructType<{
+                    name: import("@elaraai/east").StringType;
+                    rowCount: import("@elaraai/east").IntegerType;
+                    columnCount: import("@elaraai/east").IntegerType;
+                }>>;
+            }>;
+        };
+    };
+    /**
+     * CSV (Comma-Separated Values) file format operations.
+     *
+     * Provides functions for parsing and serializing CSV files as arrays of dictionaries,
+     * where each row is a dictionary mapping column names to optional string values.
+     */
+    readonly CSV: {
+        /**
+         * Parses CSV data from a binary blob into structured row data.
+         *
+         * Converts CSV-formatted binary data into an array of row dictionaries,
+         * where each dictionary maps column names to optional string values.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, variant } from "@elaraai/east";
+         * import { Format } from "@elaraai/east-node-io";
+         *
+         * const parseCSV = East.function([BlobType], Format.CSV.Types.Data, ($, csvBlob) => {
+         *     const config = $.let({
+         *         delimiter: variant('none', null),
+         *         quoteChar: variant('none', null),
+         *         escapeChar: variant('none', null),
+         *         newline: variant('none', null),
+         *         hasHeader: true,
+         *         nullString: variant('some', ""),
+         *         skipEmptyLines: true,
+         *         trimFields: false,
+         *     });
+         *
+         *     return $.return(Format.CSV.parse(csvBlob, config));
+         * });
+         *
+         * const compiled = East.compile(parseCSV.toIR(), Format.CSV.Implementation);
+         * const csvBlob = new TextEncoder().encode("name,age\nAlice,30\nBob,25");
+         * compiled(csvBlob);  // Returns parsed CSV data
+         * ```
+         */
+        readonly parse: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").BlobType, import("@elaraai/east").StructType<{
+            columns: import("@elaraai/east").OptionType<import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").VariantType<{
+                Null: import("@elaraai/east").NullType;
+                Boolean: import("@elaraai/east").NullType;
+                Integer: import("@elaraai/east").NullType;
+                Float: import("@elaraai/east").NullType;
+                String: import("@elaraai/east").NullType;
+                DateTime: import("@elaraai/east").NullType;
+                Blob: import("@elaraai/east").NullType;
+            }>>>;
+            delimiter: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+            quoteChar: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+            escapeChar: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+            newline: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+            hasHeader: import("@elaraai/east").BooleanType;
+            nullString: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+            skipEmptyLines: import("@elaraai/east").BooleanType;
+            trimFields: import("@elaraai/east").BooleanType;
+        }>], import("@elaraai/east").ArrayType<import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").VariantType<{
+            Null: import("@elaraai/east").NullType;
+            Boolean: import("@elaraai/east").BooleanType;
+            Integer: import("@elaraai/east").IntegerType;
+            Float: import("@elaraai/east").FloatType;
+            String: import("@elaraai/east").StringType;
+            DateTime: import("@elaraai/east").DateTimeType;
+            Blob: import("@elaraai/east").BlobType;
+        }>>>>;
+        /**
+         * Serializes structured row data into CSV-formatted binary data.
+         *
+         * Converts an array of row dictionaries into CSV-formatted binary data
+         * with configurable formatting options.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, variant } from "@elaraai/east";
+         * import { Format } from "@elaraai/east-node-io";
+         *
+         * const serializeCSV = East.function([Format.CSV.Types.Data], BlobType, ($, data) => {
+         *     const config = $.let({
+         *         delimiter: ",",
+         *         quoteChar: '"',
+         *         escapeChar: '"',
+         *         newline: "\n",
+         *         includeHeader: true,
+         *         nullString: "",
+         *         alwaysQuote: false,
+         *     });
+         *
+         *     return $.return(Format.CSV.serialize(data, config));
+         * });
+         *
+         * const compiled = East.compile(serializeCSV.toIR(), Format.CSV.Implementation);
+         * const data = [new Map([["name", variant("some", "Alice")], ["age", variant("some", "30")]])];
+         * compiled(data);  // Returns CSV blob
+         * ```
+         */
+        readonly serialize: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").ArrayType<import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").VariantType<{
+            Null: import("@elaraai/east").NullType;
+            Boolean: import("@elaraai/east").BooleanType;
+            Integer: import("@elaraai/east").IntegerType;
+            Float: import("@elaraai/east").FloatType;
+            String: import("@elaraai/east").StringType;
+            DateTime: import("@elaraai/east").DateTimeType;
+            Blob: import("@elaraai/east").BlobType;
+        }>>>, import("@elaraai/east").StructType<{
+            delimiter: import("@elaraai/east").StringType;
+            quoteChar: import("@elaraai/east").StringType;
+            escapeChar: import("@elaraai/east").StringType;
+            newline: import("@elaraai/east").StringType;
+            includeHeader: import("@elaraai/east").BooleanType;
+            nullString: import("@elaraai/east").StringType;
+            alwaysQuote: import("@elaraai/east").BooleanType;
+        }>], import("@elaraai/east").BlobType>;
+        /**
+         * Node.js implementation of CSV platform functions.
+         *
+         * Pass this to {@link East.compile} to enable CSV operations.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType } from "@elaraai/east";
+         * import { Format } from "@elaraai/east-node-io";
+         *
+         * const myFunction = East.function([BlobType], BlobType, ($, csvBlob) => {
+         *     const parseConfig = $.let({
+         *         delimiter: variant('none', null),
+         *         quoteChar: variant('none', null),
+         *         escapeChar: variant('none', null),
+         *         newline: variant('none', null),
+         *         hasHeader: true,
+         *         nullString: variant('none', null),
+         *         skipEmptyLines: true,
+         *         trimFields: false,
+         *     });
+         *
+         *     const data = $.let(Format.CSV.parse(csvBlob, parseConfig));
+         *
+         *     const serializeConfig = $.let({
+         *         delimiter: ",",
+         *         quoteChar: '"',
+         *         escapeChar: '"',
+         *         newline: "\n",
+         *         includeHeader: true,
+         *         nullString: "",
+         *         alwaysQuote: false,
+         *     });
+         *
+         *     return $.return(Format.CSV.serialize(data, serializeConfig));
+         * });
+         *
+         * const compiled = East.compile(myFunction.toIR(), Format.CSV.Implementation);
+         * const csvBlob = new TextEncoder().encode("name,age\nAlice,30");
+         * compiled(csvBlob);
+         * ```
+         */
+        readonly Implementation: import("@elaraai/east/internal").PlatformFunction[];
+        /**
+         * Type definitions for CSV operations.
+         */
+        readonly Types: {
+            /**
+             * CSV parse configuration options.
+             */
+            readonly ParseConfig: import("@elaraai/east").StructType<{
+                columns: import("@elaraai/east").OptionType<import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").VariantType<{
+                    Null: import("@elaraai/east").NullType;
+                    Boolean: import("@elaraai/east").NullType;
+                    Integer: import("@elaraai/east").NullType;
+                    Float: import("@elaraai/east").NullType;
+                    String: import("@elaraai/east").NullType;
+                    DateTime: import("@elaraai/east").NullType;
+                    Blob: import("@elaraai/east").NullType;
+                }>>>;
+                delimiter: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+                quoteChar: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+                escapeChar: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+                newline: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+                hasHeader: import("@elaraai/east").BooleanType;
+                nullString: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+                skipEmptyLines: import("@elaraai/east").BooleanType;
+                trimFields: import("@elaraai/east").BooleanType;
+            }>;
+            /**
+             * CSV serialize configuration options.
+             */
+            readonly SerializeConfig: import("@elaraai/east").StructType<{
+                delimiter: import("@elaraai/east").StringType;
+                quoteChar: import("@elaraai/east").StringType;
+                escapeChar: import("@elaraai/east").StringType;
+                newline: import("@elaraai/east").StringType;
+                includeHeader: import("@elaraai/east").BooleanType;
+                nullString: import("@elaraai/east").StringType;
+                alwaysQuote: import("@elaraai/east").BooleanType;
+            }>;
+            /**
+             * A row in a CSV file (dictionary mapping column names to optional string values).
+             */
+            readonly Row: import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").VariantType<{
+                Null: import("@elaraai/east").NullType;
+                Boolean: import("@elaraai/east").BooleanType;
+                Integer: import("@elaraai/east").IntegerType;
+                Float: import("@elaraai/east").FloatType;
+                String: import("@elaraai/east").StringType;
+                DateTime: import("@elaraai/east").DateTimeType;
+                Blob: import("@elaraai/east").BlobType;
+            }>>;
+            /**
+             * CSV data as an array of rows.
+             */
+            readonly Data: import("@elaraai/east").ArrayType<import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").VariantType<{
+                Null: import("@elaraai/east").NullType;
+                Boolean: import("@elaraai/east").BooleanType;
+                Integer: import("@elaraai/east").IntegerType;
+                Float: import("@elaraai/east").FloatType;
+                String: import("@elaraai/east").StringType;
+                DateTime: import("@elaraai/east").DateTimeType;
+                Blob: import("@elaraai/east").BlobType;
+            }>>>;
+        };
+    };
+    /**
+     * XML (Extensible Markup Language) file format operations.
+     *
+     * Provides functions for parsing and serializing XML files as recursive tree structures,
+     * where each node contains a tag name, attributes dictionary, and children array.
+     */
+    readonly XML: {
+        /**
+         * Parses XML data from a binary blob into a recursive tree structure.
+         *
+         * Converts XML-formatted binary data into an XmlNode recursive structure.
+         * Supports XML declarations, namespaces, CDATA, entity decoding, and comments.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType } from "@elaraai/east";
+         * import { Format } from "@elaraai/east-node-io";
+         *
+         * const parseXML = East.function([BlobType], Format.XML.Types.Node, ($, xmlBlob) => {
+         *     const config = $.let({
+         *         preserveWhitespace: false,
+         *         decodeEntities: true,
+         *     });
+         *
+         *     return $.return(Format.XML.parse(xmlBlob, config));
+         * });
+         *
+         * const compiled = East.compile(parseXML.toIR(), Format.XML.Implementation);
+         * const xmlBlob = new TextEncoder().encode("<book id='123'><title>East Guide</title></book>");
+         * compiled(xmlBlob);  // Returns parsed XML tree
+         * ```
+         */
+        readonly parse: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").BlobType, import("@elaraai/east").StructType<{
+            preserveWhitespace: import("@elaraai/east").BooleanType;
+            decodeEntities: import("@elaraai/east").BooleanType;
+        }>], import("@elaraai/east").RecursiveType<import("@elaraai/east").StructType<{
+            tag: import("@elaraai/east").StringType;
+            attributes: import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").StringType>;
+            children: import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+                TEXT: import("@elaraai/east").StringType;
+                ELEMENT: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+        }>>>;
+        /**
+         * Serializes a recursive XML tree structure into XML-formatted binary data.
+         *
+         * Converts an XmlNode recursive structure into XML-formatted binary data.
+         * Supports indentation, XML declarations, entity encoding, and self-closing tags.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, variant } from "@elaraai/east";
+         * import { Format } from "@elaraai/east-node-io";
+         *
+         * const serializeXML = East.function([Format.XML.Types.Node], BlobType, ($, doc) => {
+         *     const config = $.let({
+         *         indent: variant('some', "  "),
+         *         includeXmlDeclaration: true,
+         *         encodeEntities: true,
+         *         selfClosingTags: true,
+         *     });
+         *
+         *     return $.return(Format.XML.serialize(doc, config));
+         * });
+         *
+         * const compiled = East.compile(serializeXML.toIR(), Format.XML.Implementation);
+         * const xmlNode = { tag: "book", attributes: new Map([["id", "123"]]), children: [] };
+         * compiled(xmlNode);  // Returns XML blob
+         * ```
+         */
+        readonly serialize: import("@elaraai/east").PlatformDefinition<[import("@elaraai/east").RecursiveType<import("@elaraai/east").StructType<{
+            tag: import("@elaraai/east").StringType;
+            attributes: import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").StringType>;
+            children: import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+                TEXT: import("@elaraai/east").StringType;
+                ELEMENT: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+        }>>, import("@elaraai/east").StructType<{
+            indent: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+            includeXmlDeclaration: import("@elaraai/east").BooleanType;
+            encodeEntities: import("@elaraai/east").BooleanType;
+            selfClosingTags: import("@elaraai/east").BooleanType;
+        }>], import("@elaraai/east").BlobType>;
+        /**
+         * Node.js implementation of XML platform functions.
+         *
+         * Pass this to {@link East.compile} to enable XML operations.
+         *
+         * @example
+         * ```ts
+         * import { East, BlobType, variant } from "@elaraai/east";
+         * import { Format } from "@elaraai/east-node-io";
+         *
+         * const myFunction = East.function([BlobType], BlobType, ($, xmlBlob) => {
+         *     const parseConfig = $.let({
+         *         preserveWhitespace: false,
+         *         decodeEntities: true,
+         *     });
+         *
+         *     const doc = $.let(Format.XML.parse(xmlBlob, parseConfig));
+         *
+         *     const serializeConfig = $.let({
+         *         indent: variant('some', "  "),
+         *         includeXmlDeclaration: true,
+         *         encodeEntities: true,
+         *         selfClosingTags: true,
+         *     });
+         *
+         *     return $.return(Format.XML.serialize(doc, serializeConfig));
+         * });
+         *
+         * const compiled = East.compile(myFunction.toIR(), Format.XML.Implementation);
+         * const xmlBlob = new TextEncoder().encode("<book><title>East</title></book>");
+         * compiled(xmlBlob);
+         * ```
+         */
+        readonly Implementation: import("@elaraai/east/internal").PlatformFunction[];
+        /**
+         * Type definitions for XML operations.
+         */
+        readonly Types: {
+            /**
+             * XML parsing configuration type.
+             */
+            readonly ParseConfig: import("@elaraai/east").StructType<{
+                preserveWhitespace: import("@elaraai/east").BooleanType;
+                decodeEntities: import("@elaraai/east").BooleanType;
+            }>;
+            /**
+             * XML serialization configuration type.
+             */
+            readonly SerializeConfig: import("@elaraai/east").StructType<{
+                indent: import("@elaraai/east").OptionType<import("@elaraai/east").StringType>;
+                includeXmlDeclaration: import("@elaraai/east").BooleanType;
+                encodeEntities: import("@elaraai/east").BooleanType;
+                selfClosingTags: import("@elaraai/east").BooleanType;
+            }>;
+            /**
+             * XML node recursive type (element with tag, attributes, and children).
+             */
+            readonly Node: import("@elaraai/east").RecursiveType<import("@elaraai/east").StructType<{
+                tag: import("@elaraai/east").StringType;
+                attributes: import("@elaraai/east").DictType<import("@elaraai/east").StringType, import("@elaraai/east").StringType>;
+                children: import("@elaraai/east").ArrayType<import("@elaraai/east").VariantType<{
+                    TEXT: import("@elaraai/east").StringType;
+                    ELEMENT: import("@elaraai/east").RecursiveTypeMarker;
+                }>>;
+            }>>;
+        };
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/format/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/format/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,cAAc,YAAY,CAAC;AAG3B,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACvE,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC1H,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAgB1G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,MAAM;IACf;;;;;OAKG;;QAEC;;;;;;;;;;;;;;;;;;;;;;;WAuBG;;;;;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;WA2BG;;;;;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;WAmBG;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;WAsBG;;QAGH;;WAEG;;YAEC;;eAEG;;;;;;;;;;YAGH;;eAEG;;;;;;;;;;YAGH;;eAEG;;;;;;;;;;YAGH;;eAEG;;;;YAGH;;eAEG;;;;YAGH;;eAEG;;;;;;YAGH;;eAEG;;;;;;;;;;IAKX;;;;;OAKG;;QAEC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA8BG;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA6BG;;;;;;;;;;;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAyCG;;QAGH;;WAEG;;YAEC;;eAEG;;;;;;;;;;;;;;;;;;;;YAGH;;eAEG;;;;;;;;;;YAGH;;eAEG;;;;;;;;;;YAGH;;eAEG;;;;;;;;;;;;IAKX;;;;;OAKG;;QAEC;;;;;;;;;;;;;;;;;;;;;;;;WAwBG;;;;;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;;WA0BG;;;;;;;;;;;;;;QAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgCG;;QAGH;;WAEG;;YAEC;;eAEG;;;;;YAGH;;eAEG;;;;;;;YAGH;;eAEG;;;;;;;;;;;CAIL,CAAC"}