@xapi-js/core 1.3.0 → 1.4.1

package/dist/index.cjs

@@ -1,4 +1,4 @@
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/types.ts
 /**
 * Defines the possible types of rows in an X-API dataset (e.g., "insert", "update", "delete").
@@ -51,7 +51,6 @@ var InvalidXmlError = class extends Error {
 		this.name = "InvalidXmlError";
 	}
 };
-
 //#endregion
 //#region src/xapi-data.ts
 /**
@@ -317,23 +316,30 @@ var Dataset = class {
 		return this.rows.length;
 	}
 };
-
 //#endregion
 //#region src/utils.ts
 function arrayBufferToString(buffer) {
 	return new TextDecoder().decode(buffer);
 }
 /**
-* Creates an array of entities for parsing XML, including control characters.
-* @returns An array of objects, each with an `entity` (e.g., "") and its `value` (e.g., "\x01").
+* Pre-defined XML entities for parsing, including control characters.
+* Static array to avoid repeated allocation.
 */
-function makeParseEntities() {
-	const entities$1 = [];
-	for (let i = 1; i <= 32; i++) entities$1.push({
+const PARSE_ENTITIES = (() => {
+	const entities = [];
+	for (let i = 1; i <= 32; i++) entities.push({
 		entity: `&#${i};`,
 		value: String.fromCharCode(i)
 	});
-	return entities$1;
+	return entities;
+})();
+/**
+* Creates an array of entities for parsing XML, including control characters.
+* @deprecated Use PARSE_ENTITIES directly for better performance
+* @returns An array of objects, each with an `entity` (e.g., "&#1;") and its `value` (e.g., "\x01").
+*/
+function makeParseEntities() {
+	return PARSE_ENTITIES.slice();
 }
 /**
 * Converts a Base64 string to a Uint8Array.
@@ -462,10 +468,10 @@ function stringToReadableStream(str) {
 function convertToColumnType(value, type) {
 	switch (type) {
 		case "INT":
-		case "BIGDECIMAL":
 			const intValue = parseInt(value, 10);
 			return isNaN(intValue) ? value : intValue;
 		case "FLOAT":
+		case "BIGDECIMAL":
 			const floatValue = parseFloat(value);
 			return isNaN(floatValue) ? value : floatValue;
 		case "DECIMAL":
@@ -503,14 +509,21 @@ function convertToString(value, type) {
 		default: return String(value);
 	}
 }
-const entities = makeParseEntities();
+/**
+* Pre-compiled regex for control character entities.
+* Created once to avoid repeated compilation.
+*/
+const CONTROL_CHAR_ENTITY_REGEX = new RegExp(PARSE_ENTITIES.map((e) => e.entity.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"), "g");
+/**
+* Map for fast entity lookup during decoding.
+*/
+const ENTITY_MAP = new Map(PARSE_ENTITIES.map((e) => [e.entity, e.value]));
 function _unescapeXml(str) {
 	if (!str) return str;
+	if (str.indexOf("&") === -1) return str;
 	let result = str.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, "\"").replace(/&apos;/g, "'").replace(/&amp;/g, "&");
-	const regex = new RegExp(entities.map((e) => e.entity).join("|"), "g");
-	result = result.replace(regex, (match) => {
-		const entity = entities.find((e) => e.entity === match);
-		return entity ? entity.value : match;
+	result = result.replace(CONTROL_CHAR_ENTITY_REGEX, (match) => {
+		return ENTITY_MAP.get(match) || match;
 	});
 	return result;
 }
@@ -621,6 +634,18 @@ function parseXml(xml) {
 	return new XapiXmlParser(xml).parse();
 }
 /**
+* Character codes for fast comparison
+*/
+const CHAR_SPACE = 32;
+const CHAR_TAB = 9;
+const CHAR_LF = 10;
+const CHAR_CR = 13;
+const CHAR_GT = 62;
+const CHAR_SLASH = 47;
+const CHAR_EQUALS = 61;
+const CHAR_QUOTE = 34;
+const CHAR_APOS = 39;
+/**
 * A lightweight XML parser optimized for X-API structure.
 */
 var XapiXmlParser = class {
@@ -636,12 +661,12 @@ var XapiXmlParser = class {
 		while (this.pos < this.length) {
 			this.skipWhitespace();
 			if (this.pos >= this.length) break;
-			if (this.peek(5) === "<?xml") {
+			if (this.matches("<?xml")) {
 				this.skipUntil("?>");
 				this.pos += 2;
 				continue;
 			}
-			if (this.peek(4) === "<!--") {
+			if (this.matches("<!--")) {
 				this.skipUntil("-->");
 				this.pos += 3;
 				continue;
@@ -659,11 +684,15 @@ var XapiXmlParser = class {
 		if (this.current() === "/") return null;
 		const tagName = this.parseTagName();
 		if (!tagName) return null;
-		const node = { tagName };
+		const node = {
+			tagName,
+			attributes: void 0,
+			children: void 0
+		};
 		const attributes = this.parseAttributes();
 		if (attributes && Object.keys(attributes).length > 0) node.attributes = attributes;
 		this.skipWhitespace();
-		if (this.peek(2) === "/>") {
+		if (this.matches("/>")) {
 			this.pos += 2;
 			return node;
 		}
@@ -671,12 +700,12 @@ var XapiXmlParser = class {
 		const children = [];
 		let textContent = "";
 		while (this.pos < this.length) {
-			if (this.peek(9) === "<![CDATA[") {
+			if (this.matches("<![CDATA[")) {
 				const cdataText = this.parseCDATA();
 				if (cdataText !== null) textContent += cdataText;
 				continue;
 			}
-			if (this.peek(2) === "</") {
+			if (this.matches("</")) {
 				if (textContent) children.push(textContent);
 				this.pos += 2;
 				this.skipUntil(">");
@@ -699,21 +728,20 @@ var XapiXmlParser = class {
 		return node;
 	}
 	parseTagName() {
-		let name = "";
+		const start = this.pos;
 		while (this.pos < this.length) {
-			const ch = this.current();
-			if (ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === ">" || ch === "/") break;
-			name += ch;
+			const code = this.currentCharCode();
+			if (this.isWhitespace(code) || code === CHAR_GT || code === CHAR_SLASH) break;
 			this.pos++;
 		}
-		return name;
+		return this.xml.substring(start, this.pos);
 	}
 	parseAttributes() {
 		const attrs = {};
 		while (this.pos < this.length) {
 			this.skipWhitespace();
 			const ch = this.current();
-			if (ch === ">" || ch === "/" || this.peek(2) === "/>") break;
+			if (ch === ">" || ch === "/" || this.matches("/>")) break;
 			const attrName = this.parseAttributeName();
 			if (!attrName) break;
 			this.skipWhitespace();
@@ -724,74 +752,95 @@ var XapiXmlParser = class {
 		return Object.keys(attrs).length > 0 ? attrs : void 0;
 	}
 	parseAttributeName() {
-		let name = "";
+		const start = this.pos;
 		while (this.pos < this.length) {
-			const ch = this.current();
-			if (ch === "=" || ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === ">" || ch === "/") break;
-			name += ch;
+			const code = this.currentCharCode();
+			if (code === CHAR_EQUALS || this.isWhitespace(code) || code === CHAR_GT || code === CHAR_SLASH) break;
 			this.pos++;
 		}
-		return name;
+		return this.xml.substring(start, this.pos);
 	}
 	parseAttributeValue() {
-		let value = "";
-		const quote = this.current();
-		if (quote !== "\"" && quote !== "'") {
+		const quoteCode = this.currentCharCode();
+		if (quoteCode !== CHAR_QUOTE && quoteCode !== CHAR_APOS) {
+			const start = this.pos;
 			while (this.pos < this.length) {
-				const ch = this.current();
-				if (ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === ">" || ch === "/") break;
-				value += ch;
+				const code = this.currentCharCode();
+				if (this.isWhitespace(code) || code === CHAR_GT || code === CHAR_SLASH) break;
 				this.pos++;
 			}
-			return value;
+			return this.xml.substring(start, this.pos);
 		}
 		this.pos++;
+		const start = this.pos;
 		while (this.pos < this.length) {
-			const ch = this.current();
-			if (ch === quote) {
+			if (this.currentCharCode() === quoteCode) {
+				const value = this.xml.substring(start, this.pos);
 				this.pos++;
-				break;
+				return value;
 			}
-			value += ch;
 			this.pos++;
 		}
-		return value;
+		return this.xml.substring(start, this.pos);
 	}
 	parseCDATA() {
-		if (this.peek(9) !== "<![CDATA[") return null;
+		if (!this.matches("<![CDATA[")) return null;
 		this.pos += 9;
-		let content = "";
-		while (this.pos < this.length) {
-			if (this.peek(3) === "]]>") {
-				this.pos += 3;
-				break;
-			}
-			content += this.current();
-			this.pos++;
+		const endPos = this.findString("]]>");
+		if (endPos === -1) {
+			const content = this.xml.substring(this.pos);
+			this.pos = this.length;
+			return content;
 		}
+		const content = this.xml.substring(this.pos, endPos);
+		this.pos = endPos + 3;
 		return content;
 	}
 	skipWhitespace() {
 		while (this.pos < this.length) {
-			const ch = this.current();
-			if (ch !== " " && ch !== "	" && ch !== "\n" && ch !== "\r") break;
+			const code = this.currentCharCode();
+			if (code !== CHAR_SPACE && code !== CHAR_TAB && code !== CHAR_LF && code !== CHAR_CR) break;
 			this.pos++;
 		}
 	}
+	isWhitespace(code) {
+		return code === CHAR_SPACE || code === CHAR_TAB || code === CHAR_LF || code === CHAR_CR;
+	}
 	skipUntil(target) {
-		while (this.pos < this.length) {
-			if (this.peek(target.length) === target) break;
-			this.pos++;
-		}
+		const pos = this.findString(target);
+		if (pos !== -1) this.pos = pos;
+		else this.pos = this.length;
 	}
 	current() {
 		return this.xml[this.pos];
 	}
-	peek(length) {
-		return this.xml.substring(this.pos, this.pos + length);
+	currentCharCode() {
+		return this.xml.charCodeAt(this.pos);
+	}
+	/**
+	* Checks if the string at the given position matches the target string.
+	* This avoids creating substring instances for comparison.
+	* @param str - The target string to match
+	* @param pos - The position to check from (default: current position)
+	*/
+	matches(str, pos = this.pos) {
+		const len = str.length;
+		if (pos + len > this.length) return false;
+		for (let i = 0; i < len; i++) if (this.xml.charCodeAt(pos + i) !== str.charCodeAt(i)) return false;
+		return true;
+	}
+	/**
+	* Finds the position of a target string starting from the given position.
+	* @param str - The string to find
+	* @param startPos - Starting position (default: current position)
+	* @returns The position where the string is found, or -1 if not found
+	*/
+	findString(str, startPos = this.pos) {
+		const maxPos = this.length - str.length;
+		for (let pos = startPos; pos <= maxPos; pos++) if (this.matches(str, pos)) return pos;
+		return -1;
 	}
 };
-
 //#endregion
 //#region src/handler.ts
 let _options = {
@@ -826,28 +875,31 @@ function parse(xml) {
 		if (typeof child === "string") continue;
 		const tagName = child.tagName;
 		if (tagName === "Parameters") parseParameters(child, xapiRoot);
-		else if (tagName === "Dataset") {
-			if (!child.attributes || !child.attributes.id) throw new InvalidXmlError("Dataset element must have an 'id' attribute");
-			const datasetId = child.attributes.id;
-			const dataset = new Dataset(datasetId);
-			xapiRoot.addDataset(dataset);
-			const datasetChildren = child.children;
-			let columnInfoElement;
-			let rowsElement;
-			if (datasetChildren) for (let j = 0; j < datasetChildren.length; j++) {
-				const datasetChild = datasetChildren[j];
-				if (typeof datasetChild === "string") continue;
-				const childTagName = datasetChild.tagName;
-				if (childTagName === "ColumnInfo") columnInfoElement = datasetChild;
-				else if (childTagName === "Rows") rowsElement = datasetChild;
-				if (columnInfoElement && rowsElement) break;
-			}
-			parseColumnInfo(columnInfoElement, dataset);
-			parseRows(rowsElement, dataset);
-		}
+		else if (tagName === "Datasets") {
+			for (const datasetElement of child.children ?? []) if (typeof datasetElement !== "string" && datasetElement.tagName === "Dataset") parseDataset(datasetElement, xapiRoot);
+		} else if (tagName === "Dataset") parseDataset(child, xapiRoot);
 	}
 	return xapiRoot;
 }
+function parseDataset(child, xapiRoot) {
+	if (!child.attributes || !child.attributes.id) throw new InvalidXmlError("Dataset element must have an 'id' attribute");
+	const datasetId = child.attributes.id;
+	const dataset = new Dataset(datasetId);
+	xapiRoot.addDataset(dataset);
+	const datasetChildren = child.children;
+	let columnInfoElement;
+	let rowsElement;
+	if (datasetChildren) for (let j = 0; j < datasetChildren.length; j++) {
+		const datasetChild = datasetChildren[j];
+		if (typeof datasetChild === "string") continue;
+		const childTagName = datasetChild.tagName;
+		if (childTagName === "ColumnInfo") columnInfoElement = datasetChild;
+		else if (childTagName === "Rows") rowsElement = datasetChild;
+		if (columnInfoElement && rowsElement) break;
+	}
+	parseColumnInfo(columnInfoElement, dataset);
+	parseRows(rowsElement, dataset);
+}
 function parseValue(value, type = "STRING") {
 	value = _unescapeXml(value);
 	return _options.parseToTypes ? convertToColumnType(value, type) : value;
@@ -943,7 +995,7 @@ function parseParameters(parametersElement, xapiRoot) {
 			const attrs = p.attributes;
 			const id = attrs?.id;
 			const type = attrs?.type || "STRING";
-			const value = p.children?.[0];
+			const value = p.children?.[0] ?? attrs?.value;
 			xapiRoot.addParameter({
 				id,
 				type,
@@ -1021,7 +1073,111 @@ function writeColumn(builder, dataset, col) {
 		builder.writeElementWithText("Col", { id: col.id }, convertToString(col.value, colInfo.type));
 	} else builder.writeStartElement("Col", { id: col.id }, true);
 }
-
+//#endregion
+//#region src/schema.ts
+const defaultSizes = {
+	STRING: 256,
+	INT: 10,
+	FLOAT: 20,
+	DECIMAL: 20,
+	BIGDECIMAL: 30,
+	DATE: 8,
+	DATETIME: 17,
+	TIME: 6,
+	BLOB: 1e3
+};
+function column(type, options = {}) {
+	return {
+		kind: "xapi-column",
+		type,
+		size: options.size ?? defaultSizes[type],
+		optional: options.optional ?? false
+	};
+}
+function defineDataset(columns) {
+	return {
+		kind: "xapi-dataset",
+		columns
+	};
+}
+function defineRoot(definition) {
+	return {
+		kind: "xapi-root",
+		datasets: definition.datasets,
+		parameters: definition.parameters ?? {}
+	};
+}
+function defineOperation(definition) {
+	return {
+		kind: "xapi-operation",
+		...definition
+	};
+}
+const xapi = {
+	string: (options) => column("STRING", options),
+	int: (options) => column("INT", options),
+	float: (options) => column("FLOAT", options),
+	decimal: (options) => column("DECIMAL", options),
+	bigdecimal: (options) => column("BIGDECIMAL", options),
+	date: (options) => column("DATE", options),
+	datetime: (options) => column("DATETIME", options),
+	time: (options) => column("TIME", options),
+	blob: (options) => column("BLOB", options),
+	dataset: defineDataset,
+	root: defineRoot,
+	operation: defineOperation
+};
+function encodeRoot(schema, value) {
+	const root = new XapiRoot();
+	for (const [id, parameterSchema] of Object.entries(schema.parameters)) {
+		const parameterValue = value.parameters[id];
+		if (parameterValue !== void 0 || !parameterSchema.optional) root.addParameter({
+			id,
+			type: parameterSchema.type,
+			value: parameterValue
+		});
+	}
+	for (const [datasetId, datasetSchema] of Object.entries(schema.datasets)) {
+		const dataset = new Dataset(datasetId);
+		for (const [id, columnSchema] of Object.entries(datasetSchema.columns)) dataset.addColumn({
+			id,
+			type: columnSchema.type,
+			size: columnSchema.size
+		});
+		const rows = value.datasets[datasetId];
+		for (const row of rows) {
+			const rowIndex = dataset.newRow();
+			for (const id of Object.keys(datasetSchema.columns)) dataset.setColumn(rowIndex, id, row[id]);
+		}
+		root.addDataset(dataset);
+	}
+	return root;
+}
+function decodeRoot(schema, root) {
+	const parameters = {};
+	for (const id of Object.keys(schema.parameters)) {
+		const value = root.getParameter(id)?.value;
+		if (value !== void 0) parameters[id] = value;
+	}
+	const datasets = {};
+	for (const [datasetId, datasetSchema] of Object.entries(schema.datasets)) {
+		const dataset = root.getDataset(datasetId);
+		if (!dataset) {
+			datasets[datasetId] = [];
+			continue;
+		}
+		const constants = Object.fromEntries(dataset.getConstColumns().map(({ id, value }) => [id, value]));
+		datasets[datasetId] = dataset.getRows().map((row) => {
+			const value = { ...constants };
+			for (const column of row.cols) if (column.id in datasetSchema.columns) value[column.id] = column.value;
+			return value;
+		});
+	}
+	return {
+		parameters,
+		datasets
+	};
+}
 //#endregion
 exports.ColumnTypeError = ColumnTypeError;
 exports.Dataset = Dataset;
@@ -1038,7 +1194,12 @@ exports.columnType = columnType;
 exports.convertToColumnType = convertToColumnType;
 exports.convertToString = convertToString;
 exports.dateToString = dateToString;
+exports.decodeRoot = decodeRoot;
+exports.defineDataset = defineDataset;
+exports.defineOperation = defineOperation;
+exports.defineRoot = defineRoot;
 exports.encodeControlChars = encodeControlChars;
+exports.encodeRoot = encodeRoot;
 exports.escapeXml = escapeXml;
 exports.initXapi = initXapi;
 exports.isXapiRoot = isXapiRoot;
@@ -1049,4 +1210,5 @@ exports.rowType = rowType;
 exports.stringToDate = stringToDate;
 exports.stringToReadableStream = stringToReadableStream;
 exports.uint8ArrayToBase64 = uint8ArrayToBase64;
-exports.write = write;
+exports.write = write;
+exports.xapi = xapi;

package/dist/index.d.cts

@@ -341,6 +341,7 @@ type XmlNode = {
 declare function arrayBufferToString(buffer: ArrayBuffer): string;
 /**
  * Creates an array of entities for parsing XML, including control characters.
+ * @deprecated Use PARSE_ENTITIES directly for better performance
  * @returns An array of objects, each with an `entity` (e.g., "") and its `value` (e.g., "\x01").
  */
 declare function makeParseEntities(): {
@@ -468,4 +469,78 @@ declare class XmlStringBuilder {
  */
 declare function parseXml(xml: string): XmlNode[];
 //#endregion
-export { Col, Column, ColumnInfo, ColumnType, ColumnTypeError, ConstColumn, Dataset, InvalidXmlError, NexaVersion, Parameter, Row, RowType, Rows, StringWritableStream, XapiOptions, XapiParameters, XapiRoot, XapiValueType, XapiVersion, XmlNode, XmlStringBuilder, XplatformVersion, _unescapeXml, arrayBufferToString, base64ToUint8Array, columnType, convertToColumnType, convertToString, dateToString, encodeControlChars, escapeXml, initXapi, isXapiRoot, makeParseEntities, parse, parseXml, rowType, stringToDate, stringToReadableStream, uint8ArrayToBase64, write };
+//#region src/schema.d.ts
+type XapiTypeMap = {
+  STRING: string;
+  INT: number;
+  FLOAT: number;
+  DECIMAL: number;
+  BIGDECIMAL: number;
+  DATE: Date;
+  DATETIME: Date;
+  TIME: Date;
+  BLOB: Uint8Array;
+};
+interface XapiColumnSchema<T extends ColumnType = ColumnType, Optional extends boolean = boolean> {
+  readonly kind: "xapi-column";
+  readonly type: T;
+  readonly size: number;
+  readonly optional: Optional;
+}
+type XapiColumns = Record<string, XapiColumnSchema>;
+interface XapiDatasetSchema<Columns extends XapiColumns = XapiColumns> {
+  readonly kind: "xapi-dataset";
+  readonly columns: Columns;
+}
+type XapiDatasets = Record<string, XapiDatasetSchema>;
+interface XapiRootSchema<Datasets extends XapiDatasets = XapiDatasets, Parameters extends XapiColumns = XapiColumns> {
+  readonly kind: "xapi-root";
+  readonly datasets: Datasets;
+  readonly parameters: Parameters;
+}
+interface XapiOperation<Request extends XapiRootSchema = XapiRootSchema, Response extends XapiRootSchema = XapiRootSchema> {
+  readonly kind: "xapi-operation";
+  readonly request: Request;
+  readonly response: Response;
+}
+type RequiredColumnKeys<Columns extends XapiColumns> = { [Key in keyof Columns]-?: Columns[Key]["optional"] extends true ? never : Key; }[keyof Columns];
+type OptionalColumnKeys<Columns extends XapiColumns> = { [Key in keyof Columns]-?: Columns[Key]["optional"] extends true ? Key : never; }[keyof Columns];
+type InferColumns<Columns extends XapiColumns> = { [Key in RequiredColumnKeys<Columns>]: XapiTypeMap[Columns[Key]["type"]]; } & { [Key in OptionalColumnKeys<Columns>]?: XapiTypeMap[Columns[Key]["type"]]; };
+type InferDataset<Schema extends XapiDatasetSchema> = InferColumns<Schema["columns"]>[];
+type InferRoot<Schema extends XapiRootSchema> = {
+  parameters: InferColumns<Schema["parameters"]>;
+  datasets: { [Key in keyof Schema["datasets"]]: InferDataset<Schema["datasets"][Key]>; };
+};
+type RequestOf<Operation extends XapiOperation> = InferRoot<Operation["request"]>;
+type ResponseOf<Operation extends XapiOperation> = InferRoot<Operation["response"]>;
+type ColumnOptions<Optional extends boolean> = {
+  size?: number;
+  optional?: Optional;
+};
+declare function defineDataset<const Columns extends XapiColumns>(columns: Columns): XapiDatasetSchema<Columns>;
+declare function defineRoot<const Datasets extends XapiDatasets, const Parameters extends XapiColumns = Record<never, never>>(definition: {
+  datasets: Datasets;
+  parameters?: Parameters;
+}): XapiRootSchema<Datasets, Parameters>;
+declare function defineOperation<const Request extends XapiRootSchema, const Response extends XapiRootSchema>(definition: {
+  request: Request;
+  response: Response;
+}): XapiOperation<Request, Response>;
+declare const xapi: {
+  readonly string: <const Optional extends boolean = false>(options?: ColumnOptions<Optional>) => XapiColumnSchema<"STRING", Optional>;
+  readonly int: <const Optional extends boolean = false>(options?: ColumnOptions<Optional>) => XapiColumnSchema<"INT", Optional>;
+  readonly float: <const Optional extends boolean = false>(options?: ColumnOptions<Optional>) => XapiColumnSchema<"FLOAT", Optional>;
+  readonly decimal: <const Optional extends boolean = false>(options?: ColumnOptions<Optional>) => XapiColumnSchema<"DECIMAL", Optional>;
+  readonly bigdecimal: <const Optional extends boolean = false>(options?: ColumnOptions<Optional>) => XapiColumnSchema<"BIGDECIMAL", Optional>;
+  readonly date: <const Optional extends boolean = false>(options?: ColumnOptions<Optional>) => XapiColumnSchema<"DATE", Optional>;
+  readonly datetime: <const Optional extends boolean = false>(options?: ColumnOptions<Optional>) => XapiColumnSchema<"DATETIME", Optional>;
+  readonly time: <const Optional extends boolean = false>(options?: ColumnOptions<Optional>) => XapiColumnSchema<"TIME", Optional>;
+  readonly blob: <const Optional extends boolean = false>(options?: ColumnOptions<Optional>) => XapiColumnSchema<"BLOB", Optional>;
+  readonly dataset: typeof defineDataset;
+  readonly root: typeof defineRoot;
+  readonly operation: typeof defineOperation;
+};
+declare function encodeRoot<Schema extends XapiRootSchema>(schema: Schema, value: InferRoot<Schema>): XapiRoot;
+declare function decodeRoot<Schema extends XapiRootSchema>(schema: Schema, root: XapiRoot): InferRoot<Schema>;
+//#endregion
+export { Col, Column, ColumnInfo, ColumnType, ColumnTypeError, ConstColumn, Dataset, InferColumns, InferDataset, InferRoot, InvalidXmlError, NexaVersion, Parameter, RequestOf, ResponseOf, Row, RowType, Rows, StringWritableStream, XapiColumnSchema, XapiColumns, XapiDatasetSchema, XapiDatasets, XapiOperation, XapiOptions, XapiParameters, XapiRoot, XapiRootSchema, XapiTypeMap, XapiValueType, XapiVersion, XmlNode, XmlStringBuilder, XplatformVersion, _unescapeXml, arrayBufferToString, base64ToUint8Array, columnType, convertToColumnType, convertToString, dateToString, decodeRoot, defineDataset, defineOperation, defineRoot, encodeControlChars, encodeRoot, escapeXml, initXapi, isXapiRoot, makeParseEntities, parse, parseXml, rowType, stringToDate, stringToReadableStream, uint8ArrayToBase64, write, xapi };