@chilkat/react-native 11.6.1

package/src/specs/Xml.nitro.ts

@@ -0,0 +1,1988 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+import type { HybridObject } from 'react-native-nitro-modules'
+import type { BinData } from './BinData.nitro'
+import type { StringBuilder } from './StringBuilder.nitro'
+
+/**
+ * Load, navigate, search, edit, transform, and save in-memory XML trees.
+ *
+ * `Xml` is the primary Chilkat class for in-memory XML tree
+ * manipulation. It supports loading and saving XML, navigating between elements,
+ * reading and writing text content, managing attributes, working with
+ * namespaces, adding and removing subtrees, searching by tag, content, or
+ * attribute, sorting child records, scrubbing XML, handling CDATA and XML
+ * declarations, storing binary data as Base64, and optionally compressing or
+ * encrypting element content.
+ *
+ * **Load and save XML**
+ *
+ * Load XML from strings, files, byte data, or other Chilkat objects, then
+ * save or emit formatted XML when processing is complete.
+ *
+ * **Navigate XML trees**
+ *
+ * Move through parent, child, sibling, and selected elements while working
+ * directly with the XML document structure.
+ *
+ * **Edit elements and attributes**
+ *
+ * Add, update, remove, or rename elements; set text content; and read,
+ * add, modify, or delete attributes.
+ *
+ * **Search and select**
+ *
+ * Locate elements by tag name, content, path, attribute value, or custom
+ * search patterns.
+ *
+ * **Namespaces and structure**
+ *
+ * Work with namespace-aware XML, declarations, CDATA, child ordering,
+ * sorting, and subtree insertion or removal.
+ *
+ * **Binary and protected content**
+ *
+ * Store binary data as Base64 and optionally compress or encrypt element
+ * content when XML carries encoded payloads.
+ *
+ * **Important usage distinction:**
+ * Some methods return a new `Xml` object reference for the selected
+ * element, while methods ending in `2` update the caller's internal
+ * reference to point to a different element. This distinction is central when
+ * navigating and editing XML trees because it determines whether the current
+ * object stays where it is or moves to another element.
+ *
+ * **Common pattern:**
+ * Load or create the XML document, navigate to the element of interest, read or
+ * modify content and attributes, add or remove child elements as needed, then
+ * save the updated XML. Use `Xml` for tree-oriented XML
+ * manipulation, and use `XmlDSig`,
+ * `XmlDSigGen`, or related classes when the task is XML
+ * digital signing or signature verification.
+ *
+ * For an extended overview, see
+ * [Xml Class Overview](https://www.chilkatsoft.com/xml_class_overview.asp).
+ *
+ * Each `Xml` instance owns a native Chilkat object. It is released when the JavaScript object is
+ * garbage collected, or immediately by `dispose()`; any use after `dispose()` throws.
+ * Create one with `new Xml()`.
+ */
+export interface Xml extends HybridObject<{ ios: 'c++', android: 'c++' }> {
+  // ---- Properties ----
+
+  /**
+   * Provides HTML-formatted information about the last called method or property. If a method call
+   * fails or behaves unexpectedly, check this property for details. Note that information is
+   * available regardless of the method call's success.
+   *
+   * This property is read-only.
+   */
+  readonly lastErrorHtml: string
+
+  /**
+   * Provides plain text information about the last called method or property. If a method call
+   * fails or behaves unexpectedly, check this property for details. Note that information is
+   * available regardless of the method call's success.
+   *
+   * This property is read-only.
+   */
+  readonly lastErrorText: string
+
+  /**
+   * Provides XML-formatted information about the last called method or property. If a method call
+   * fails or behaves unexpectedly, check this property for details. Note that information is
+   * available regardless of the method call's success.
+   *
+   * This property is read-only.
+   */
+  readonly lastErrorXml: string
+
+  /**
+   * Version of the component/library, such as "10.1.0"
+   *
+   * This property is read-only.
+   */
+  readonly version: string
+
+  /**
+   * If set to a file path, this property logs the LastErrorText of each Chilkat method or property
+   * call to the specified file. This logging helps identify the context and history of Chilkat
+   * calls leading up to any crash or hang, aiding in debugging.
+   *
+   * Enabling the VerboseLogging property provides more detailed information.
+   *
+   * This property is mainly used for debugging rare instances where a Chilkat method call causes a
+   * hang or crash, which should generally not happen.
+   *
+   * Possible causes of hangs include:
+   *
+   * - A timeout property set to 0, indicating an infinite timeout.
+   *
+   * - A hang occurring within an event callback in the application code.
+   *
+   * - An internal bug in the Chilkat code causing the hang.
+   */
+  debugLogFilePath: string
+
+  /**
+   * If set to `true`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may
+   * contain more verbose information. The default value is `false`. Verbose logging should only be
+   * used for debugging. The potentially large quantity of logged information may adversely affect
+   * peformance.
+   */
+  verboseLogging: boolean
+
+  /**
+   * Indicates the success or failure of the most recent method call: `true` means success, `false`
+   * means failure. This property remains unchanged by property setters or getters. This method is
+   * present to address challenges in checking for null or Nothing returns in certain programming
+   * languages. Note: This property does not apply to methods that return integer values or to
+   * boolean-returning methods where the boolean does not indicate success or failure.
+   */
+  lastMethodSuccess: boolean
+
+  /**
+   * Controls how this element's text content is emitted. When set to `true`, the element content is
+   * written inside a CDATA section instead of being emitted as ordinary character data with XML
+   * escaping.
+   *
+   * **CDATA and escaping:** CDATA is useful when text contains many characters such as `<` or `&`.
+   * It does not change the logical text value of the element; it only changes how that text is
+   * represented in the serialized XML.
+   */
+  cdata: boolean
+
+  /**
+   * Gets or sets the text content stored directly on this XML element. Child elements are not
+   * included in this value.
+   *
+   * For example, both of the following elements have `This is the content` as their `Content`:
+   *
+   * ```
+   * _LT_tag1_GT_This is the content_LT_/tag1_GT_
+   *
+   * _LT_tag2_GT__LT_child1_GT_abc_LT_/child1_GT__LT_child2_GT_abc_LT_/child2_GT_This is the content_LT_/tag2_GT_
+   * ```
+   *
+   * **Content vs. children:** Chilkat stores an element's direct text content separately from its
+   * child elements. Use the child-navigation methods when you need the nested elements themselves.
+   */
+  content: string
+
+  /**
+   * Gets or sets this element's content as a 32-bit integer. Setting the property converts the
+   * integer to its decimal text representation; getting the property interprets the element's text
+   * content as an integer.
+   *
+   * **Numeric content:** Use `Content` when the value may exceed the range of a 32-bit integer or
+   * when the exact lexical representation must be preserved.
+   */
+  contentInt: number
+
+  /**
+   * Gets or sets the document type declaration associated with the XML document.
+   *
+   * The value represents the document-level `DOCTYPE` declaration, for example `_LT_!DOCTYPE note
+   * SYSTEM "note.dtd"_GT_`.
+   *
+   * **Document-level setting:** Although this property may be accessed from any element reference
+   * in the tree, the DOCTYPE belongs to the XML document as a whole rather than to an individual
+   * element.
+   */
+  docType: string
+
+  /**
+   * Controls whether a byte order mark (BOM, also called a preamble) is written when XML is saved
+   * to a file. The default is `false`.
+   *
+   * This setting is relevant to encodings for which a BOM can be emitted, such as UTF-8 and UTF-16.
+   * It does not affect XML returned as a language string by methods such as `GetXml`.
+   */
+  emitBom: boolean
+
+  /**
+   * Controls whether the XML declaration is included when XML is emitted. The default is `true`.
+   * When set to `false`, output methods such as `GetXml` and `SaveXml` omit the declaration.
+   *
+   * An XML declaration is the leading construct such as `_LT_?xml version="1.0"
+   * encoding="utf-8"?_GT_`.
+   */
+  emitXmlDecl: boolean
+
+  /**
+   * Gets or sets the `encoding` value used in the XML declaration. The default is `utf-8`. This is
+   * a document-level setting and may be accessed from any element in the tree.
+   *
+   * When XML is loaded, Chilkat sets this property from the encoding declared by the input XML when
+   * one is present. If no encoding is declared, the property is reset to `utf-8`.
+   *
+   * **Important:** Changing `Encoding` changes the declared/output encoding used when XML is
+   * serialized; it does not reinterpret or transcode the already-stored Unicode text inside the
+   * in-memory tree.
+   */
+  encoding: string
+
+  /**
+   * Returns the number of attributes on this element.
+   *
+   * For example, `_LT_tag attr1="value1" attr2="value2"_GT_..._LT_/tag_GT_` has two attributes.
+   * Attribute indexes used by methods such as `GetAttributeName` and `GetAttributeValue` are
+   * zero-based.
+   *
+   * This property is read-only.
+   */
+  readonly numAttributes: number
+
+  /**
+   * Returns the number of direct child elements of this element. Descendants below those children
+   * are not included in the count.
+   *
+   * **Direct children only:** Use traversal or search methods when you need to inspect the entire
+   * subtree rather than only the immediate children.
+   *
+   * This property is read-only.
+   */
+  readonly numChildren: number
+
+  /**
+   * Controls case sensitivity for the XML sorting methods. Set to `true` for case-insensitive
+   * string comparisons or `false` for case-sensitive comparisons.
+   */
+  sortCaseInsensitive: boolean
+
+  /**
+   * Controls the `standalone` pseudo-attribute in the XML declaration. This is a document-level
+   * setting and may be accessed from any element in the tree.
+   *
+   * Setting this property to `true` causes the declaration to include `standalone="yes"`.
+   *
+   * **XML declaration:** The standalone declaration concerns whether the document relies on
+   * external markup declarations. It is metadata in the XML declaration; it does not by itself
+   * validate or alter the document.
+   */
+  standalone: boolean
+
+  /**
+   * When `Strict` is **true**, the XML loading methods first check that the input is well-formed
+   * XML. If it is not, the load fails and the contents of this Xml object are left **unchanged**.
+   * The default is `false`.
+   *
+   * This applies to {@link Xml.loadXml}, {@link Xml.loadXml2}, {@link Xml.loadSb}, {@link
+   * Xml.loadBd}, {@link Xml.loadXmlFile} and {@link Xml.loadXmlFile2}.
+   *
+   * Chilkat's XML parser is deliberately tolerant. By default it can accept input that is not
+   * well-formed, succeed, and leave a partially populated tree. That is convenient when the goal is
+   * a best-effort parse of imperfect input, but it is the wrong behavior when a silently dropped
+   * element or attribute changes what the application does.
+   *
+   * Set `Strict` to `true` for XML carrying configuration, credentials, signed content, or security
+   * parameters, where an element that quietly failed to load would be acted on as though it had
+   * never been present.
+   *
+   * The check is for XML 1.0 **well-formedness** only. It is not a validating parse: no DTD or
+   * schema is read, and the document is not checked against one. Markup declarations inside an
+   * internal DTD subset are skipped rather than parsed.
+   *
+   * **Note:** The default is `false` so that existing applications are unaffected. When a strict
+   * load is rejected, this Xml object keeps whatever it held before the call, so a failed reload
+   * never leaves the object empty.
+   */
+  strict: boolean
+
+  /**
+   * Gets or sets the element name for this element, including any namespace prefix. For example,
+   * the tag for `_LT_soapenv:Body_GT_` is `soapenv:Body`.
+   *
+   * Use `TagNsPrefix` and `TagUnprefixed` when the prefix and local portion are needed separately.
+   */
+  tag: string
+
+  /**
+   * Returns the identifier of the XML tree to which this element belongs. Elements in the same XML
+   * document have the same `TreeId`.
+   *
+   * **Useful for element references:** Multiple `Xml` objects can reference different elements in
+   * the same underlying tree. Comparing `TreeId` values is a convenient way to determine whether
+   * two element references belong to that same tree.
+   *
+   * This property is read-only.
+   */
+  readonly treeId: number
+
+  /**
+   * Provides a substitution value for `[i]` in Chilkat tag paths and `ChilkatPath` expressions.
+   * When a path contains `[i]`, the current value of this property is substituted for I.
+   *
+   * **Loop-friendly paths:** The `I`, `J`, and `K` properties make it convenient to reuse a path
+   * expression inside nested loops without constructing a new path string for every index.
+   */
+  i: number
+
+  /**
+   * Provides a substitution value for `[j]` in Chilkat tag paths and `ChilkatPath` expressions.
+   * When a path contains `[j]`, the current value of this property is substituted for J.
+   *
+   * **Loop-friendly paths:** The `I`, `J`, and `K` properties make it convenient to reuse a path
+   * expression inside nested loops without constructing a new path string for every index.
+   */
+  j: number
+
+  /**
+   * Provides a substitution value for `[k]` in Chilkat tag paths and `ChilkatPath` expressions.
+   * When a path contains `[k]`, the current value of this property is substituted for K.
+   *
+   * **Loop-friendly paths:** The `I`, `J`, and `K` properties make it convenient to reuse a path
+   * expression inside nested loops without constructing a new path string for every index.
+   */
+  k: number
+
+  /**
+   * Controls whether XML emitted by `GetXml` and `GetXmlSb` is compact. When `true`, unnecessary
+   * formatting whitespace and line breaks are omitted. The default is `false` for backward
+   * compatibility.
+   *
+   * **Formatting only:** Compact output changes presentation, not the XML tree or its element
+   * content.
+   */
+  emitCompact: boolean
+
+  /**
+   * Returns `true` if this element's content consists only of characters allowed in standard Base64
+   * text, with whitespace ignored. Standard Base64 uses `A-Z`, `a-z`, `0-9`, `+`, `/`, and optional
+   * trailing `=` padding.
+   *
+   * **Syntax check, not semantic validation:** A value can contain only Base64 characters and still
+   * not represent the data your application expects. This property is useful as a quick
+   * content-format test.
+   *
+   * This property is read-only.
+   */
+  readonly isBase64: boolean
+
+  /**
+   * Gets or sets the namespace prefix portion of this element's tag. For `soapenv:Envelope`, the
+   * namespace prefix is `soapenv`.
+   *
+   * **Prefix vs. namespace URI:** This property deals with the lexical prefix in the tag name. A
+   * prefix is not itself the namespace URI; namespace bindings are expressed through `xmlns`
+   * attributes in the XML.
+   */
+  tagNsPrefix: string
+
+  /**
+   * Gets or sets the unprefixed portion of this element's tag. For `soapenv:Envelope`, the
+   * unprefixed tag is `Envelope`.
+   *
+   * Use `TagNsPrefix` to access the prefix separately.
+   */
+  tagUnprefixed: string
+
+  /**
+   * Returns the Chilkat tag path needed to reach this element from the document root. If this
+   * object currently references the root element, the returned path is the empty string.
+   *
+   * **Not XPath:** A Chilkat tag path is Chilkat's own navigation syntax, typically using `|`
+   * between element names. It is not an XPath expression.
+   *
+   * This property is read-only.
+   */
+  readonly tagPath: string
+
+  /**
+   * Provides a catch-all string for uncommon XML behaviors. The default is the empty string, which
+   * is appropriate for normal use.
+   *
+   * Leave this property empty unless Chilkat documentation or support identifies a specific option
+   * needed for a specialized interoperability case.
+   */
+  uncommonOptions: string
+
+  // ---- Methods ----
+
+  /**
+   * Traverses the subtree rooted at the calling element and concatenates the text content of all
+   * elements whose tag equals `tag`.
+   *
+   * `skipTags` is a vertical-bar-delimited list of tag names whose entire subtrees are excluded
+   * from the accumulation. For example, `script|style` skips elements rooted at either of those
+   * tags.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  accumulateTagContent(tag: string, skipTags: string): string
+
+  /**
+   * Adds an attribute named `name` with the specified string `value` to the calling element.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * **When an attribute may already exist:** Use `AddOrUpdateAttribute` or `UpdateAttribute` when
+   * the desired behavior is to update an existing attribute value instead of requiring a new
+   * attribute.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  addAttribute(name: string, value: string): void
+
+  /**
+   * Adds an attribute named `name` whose value is the decimal representation of `value`.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  addAttributeInt(name: string, value: number): void
+
+  /**
+   * Adds the entire XML subtree referenced by `tree` as a new direct child of the calling element.
+   *
+   * If `tree` already belongs to another XML document, the subtree is transferred to the
+   * destination tree rather than copied as an unrelated duplicate.
+   *
+   * **Tree ownership:** After moving a subtree between documents, its elements belong to the
+   * destination tree. `TreeId` can be used to determine which tree an element reference belongs to.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  addChildTree(tree: Xml): void
+
+  /**
+   * Sets the string value of an attribute on the calling element. If an attribute named `name`
+   * already exists, its value is replaced; otherwise the attribute is added.
+   */
+  addOrUpdateAttribute(name: string, value: string): void
+
+  /**
+   * Sets an integer-valued attribute on the calling element. If an attribute named `name` already
+   * exists, its value is replaced with the decimal representation of `value`; otherwise the
+   * attribute is added.
+   */
+  addOrUpdateAttributeI(name: string, value: number): void
+
+  /**
+   * Adds an XML stylesheet processing instruction to the document. Pass the complete
+   * processing-instruction text, for example:
+   *
+   * ```
+   * _LT_?xml-stylesheet href="mystyle.css" title="Compact" type="text/css"?_GT_
+   * ```
+   *
+   * **Processing instruction:** An XML stylesheet declaration associates stylesheet metadata with
+   * the XML document; it does not apply or execute the stylesheet.
+   */
+  addStyleSheet(styleSheet: string): void
+
+  /**
+   * Treats the named attribute value as an integer, adds `amount`, and stores the resulting integer
+   * back in the attribute.
+   *
+   * If the attribute does not yet exist, this method behaves like `AddOrUpdateAttributeI` and
+   * creates it with `amount` as the value.
+   */
+  addToAttribute(name: string, amount: number): void
+
+  /**
+   * Finds the child identified by `tag`, interprets its content as an integer, adds `amount`, and
+   * stores the resulting integer as the child's new content.
+   */
+  addToChildContent(tag: string, amount: number): void
+
+  /**
+   * Interprets this element's content as an integer, adds `amount`, and stores the resulting
+   * integer as the new content.
+   */
+  addToContent(amount: number): void
+
+  /**
+   * Appends `str` to the existing text content of the calling element without replacing its child
+   * elements.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  appendToContent(str: string): void
+
+  /**
+   * Returns `true` if the child identified by `tagPath` has content matching `pattern`; otherwise
+   * returns `false`. `caseSensitive` controls whether letter case is significant.
+   *
+   * The pattern may contain `*` wildcards, where each asterisk matches zero or more characters.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   */
+  childContentMatches(tagPath: string, pattern: string, caseSensitive: boolean): boolean
+
+  /**
+   * Evaluates a Chilkat-specific path command that can navigate from the current element, return
+   * element content or an attribute value, or move the caller's internal element reference.
+   *
+   * **This syntax is not XPath.** Commands are separated by vertical bars and the expression ends
+   * with a return command:
+   *
+   * ```
+   * command|command|command|...|returnCommand
+   * ```
+   *
+   * Navigation commands include:
+   *
+   * - `TagName` - first direct child having that tag.
+   *
+   * - `TagName[n]` - the indexed direct child having that tag.
+   *
+   * - `..` - parent.
+   *
+   * - `++` / `--` - next / previous sibling.
+   *
+   * - `TagName{Content}` - first direct child with that tag and exact content.
+   *
+   * - `/T/TagName` - traverse the subtree and find the first element with that tag.
+   *
+   * - `/C/TagName,ContentPattern` - traverse for a tag whose content matches a wildcard pattern.
+   *
+   * - `/C/ContentPattern` - traverse for any tag whose content matches a wildcard pattern.
+   *
+   * - `/A/TagName,AttrName,AttrValuePattern` - traverse for a tag having a matching attribute
+   *   value.
+   *
+   * The final return command is:
+   *
+   * - `*` - return the current element's content.
+   *
+   * - `(AttrName)` - return an attribute value.
+   *
+   * - `$` - move this `Xml` object to the selected element and return an empty string.
+   *
+   * **Index substitution:** The `I`, `J`, and `K` properties can be used with `[i]`, `[j]`, and
+   * `[k]` in path expressions.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  chilkatPath(pathCmd: string): string
+
+  /**
+   * Clears the calling element by removing all child elements, attributes, and text content, and
+   * resets its tag name to `unnamed`.
+   *
+   * The element itself remains in the tree; this method clears its contents rather than removing
+   * the element from its parent.
+   */
+  clear(): void
+
+  /**
+   * Returns `true` if this element's content matches `pattern`; otherwise returns `false`.
+   * `caseSensitive` controls whether letter case is significant.
+   *
+   * The pattern may contain `*` wildcards, where each asterisk matches zero or more characters.
+   */
+  contentMatches(pattern: string, caseSensitive: boolean): boolean
+
+  /**
+   * Copies the `Tag`, `Content`, and attributes from `node` to the calling element.
+   *
+   * **Not a subtree copy:** This method does not copy the source element's children. Use a
+   * tree-oriented method such as `AddChildTree` or `SwapTree` when child structure is part of the
+   * operation.
+   */
+  copy(node: Xml): void
+
+  /**
+   * Changes this `Xml` object so that it references the same underlying XML element as
+   * `copyFromNode`. The caller's previous element reference is discarded.
+   *
+   * **Reference operation:** `CopyRef` does not copy XML data. After the call, both `Xml` objects
+   * refer to the same element, so edits through either reference affect the same tree element.
+   */
+  copyRef(copyFromNode: Xml): void
+
+  /**
+   * Decodes HTML character entities found in `str` and returns the decoded text. This is a utility
+   * operation; it does not modify the XML tree unless the returned string is assigned to an
+   * element.
+   *
+   * For example, an HTML entity such as `&amp;` is decoded to `&`.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  decodeEntities(str: string): string
+
+  /**
+   * Decrypts element content previously produced by `EncryptContent`, using the same password, and
+   * restores the original plaintext content.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * **Compatibility-oriented encryption:** This method is paired specifically with
+   * `EncryptContent`. It is not a general XML Encryption (XML-Enc) implementation.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  decryptContent(password: string): void
+
+  /**
+   * Encrypts the calling element's text content using Chilkat's password-based 128-bit AES-CBC
+   * format and replaces the plaintext content with Base64-encoded encrypted data.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * **Scope:** Only this element's content is encrypted. The tag, attributes, and child elements
+   * are not encrypted by this method. Use `DecryptContent` with the same password to restore the
+   * content.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  encryptContent(password: string): void
+
+  /**
+   * Removes the direct child at zero-based `index` from the calling element and returns an `Xml`
+   * object for the detached child subtree.
+   *
+   * **Extract vs. remove:** Unlike `RemoveChildByIndex`, extraction gives the caller a reference to
+   * the removed subtree so it can be retained, inspected, or attached elsewhere.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  extractChildByIndex(index: number): Xml
+
+  /**
+   * Finds, removes, and returns the first child selected by `tagPath` and the optional attribute
+   * criteria.
+   *
+   * If `attrName` and `attrValue` are empty, the first child matching the tag/path is extracted. If
+   * `attrName` is provided, the child must have that attribute. If `attrValue` is also provided,
+   * the attribute value must match exactly.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  extractChildByName(tagPath: string, attrName: string, attrValue: string): Xml
+
+  /**
+   * Returns an `Xml` object referencing the child selected by `tagPath`. The calling object remains
+   * positioned on its current element.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  findChild(tagPath: string): Xml
+
+  /**
+   * Moves the calling `Xml` object's internal reference to the child selected by `tagPath`. Returns
+   * `true` when the child is found and the move succeeds; otherwise returns `false`.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  findChild2(tagPath: string): void
+
+  /**
+   * Finds the next direct child record for which the descendant identified by `tagPath` has content
+   * matching `contentPattern`. This is intended for iterating record-like child elements.
+   *
+   * The content pattern may contain `*` wildcards.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  findNextRecord(tagPath: string, contentPattern: string): Xml
+
+  /**
+   * Returns the child selected by `tagPath` if it already exists. If it does not exist, creates the
+   * required child path with empty content and returns the resulting child element.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath. Use `NewChild` instead when duplicate children with the same
+   * tag are intentional.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  findOrAddNewChild(tagPath: string): Xml
+
+  /**
+   * Returns an `Xml` object referencing the first direct child of the calling element.
+   *
+   * A common forward-iteration pattern is `FirstChild` followed by repeated calls to `NextSibling`.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  firstChild(): Xml
+
+  /**
+   * Moves the calling `Xml` object's internal reference to its first direct child. Returns `true`
+   * if a first child exists; otherwise returns `false`.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   */
+  firstChild2(): boolean
+
+  /**
+   * Returns the value of the attribute named `name` on the calling element.
+   *
+   * Use `HasAttribute` when the application must distinguish a missing attribute from an attribute
+   * whose value is empty.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getAttrValue(name: string): string
+
+  /**
+   * Returns the value of the attribute named `name` interpreted as a 32-bit integer. Returns `0` if
+   * the attribute does not exist.
+   *
+   * **Ambiguous zero:** Because a missing attribute and an attribute containing zero can both yield
+   * `0`, call `HasAttribute` first when that distinction matters.
+   */
+  getAttrValueInt(name: string): number
+
+  /**
+   * Returns the name of the attribute at zero-based `index`. Use `NumAttributes` to determine the
+   * valid index range.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getAttributeName(index: number): string
+
+  /**
+   * Returns the value of the attribute at zero-based `index`. Use `NumAttributes` to determine the
+   * valid index range.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getAttributeValue(index: number): string
+
+  /**
+   * Returns the value of the attribute at zero-based `index`, interpreted as a 32-bit integer.
+   */
+  getAttributeValueInt(index: number): number
+
+  /**
+   * Returns an `Xml` object referencing the direct child at zero-based `index`. The calling object
+   * remains positioned on its current element.
+   *
+   * Use `NumChildren` to determine the valid child range.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getChild(index: number): Xml
+
+  /**
+   * Moves the calling `Xml` object's internal reference to the direct child at zero-based `index`.
+   * Returns `true` on success and `false` if the child cannot be selected.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getChild2(index: number): void
+
+  /**
+   * Returns the integer content of the child selected by `tagPath` as a Boolean value: content
+   * equal to `0` yields `false`; a non-zero integer yields `true`.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   */
+  getChildBoolValue(tagPath: string): boolean
+
+  /**
+   * Returns the text content of the child selected by `tagPath`.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   *
+   * **Content only:** The returned value is the child element's direct `Content`; nested child
+   * elements are not serialized into this string.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getChildContent(tagPath: string): string
+
+  /**
+   * Returns the text content of the direct child at zero-based `index`. Use `NumChildren` to
+   * determine the valid range.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getChildContentByIndex(index: number): string
+
+  /**
+   * Returns the first direct child whose tag equals `tag` and whose text content exactly equals
+   * `content`.
+   *
+   * The calling object remains positioned on its current element.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getChildExact(tag: string, content: string): Xml
+
+  /**
+   * Returns the content of the child selected by `tagPath`, interpreted as a 32-bit integer.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   *
+   * **Integer range:** Use `GetChildContent` and parse the returned text separately when values may
+   * exceed the range of a 32-bit integer.
+   */
+  getChildIntValue(tagPath: string): number
+
+  /**
+   * Returns the tag name of the direct child at zero-based `index`. Use `NumChildren` to determine
+   * the valid index range.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getChildTag(index: number): string
+
+  /**
+   * Returns the tag name of the direct child at zero-based `index`. Use `NumChildren` to determine
+   * the valid index range.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getChildTagByIndex(index: number): string
+
+  /**
+   * Returns the child selected by `tagPath` that also has an attribute named `attrName` whose value
+   * exactly equals `attrValue`.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getChildWithAttr(tagPath: string, attrName: string, attrValue: string): Xml
+
+  /**
+   * Returns the first direct child whose text content exactly equals `content`. The child tag may
+   * be any value.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getChildWithContent(content: string): Xml
+
+  /**
+   * Returns an `Xml` object referencing the child selected by `tagPath`. The calling object remains
+   * positioned on its current element.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getChildWithTag(tagPath: string): Xml
+
+  /**
+   * Returns the zero-based `n`th direct child whose tag exactly equals `tag`. Children with other
+   * tag names are ignored when counting matches.
+   *
+   * Use `NumChildrenHavingTag` to determine how many matching children are available.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getNthChildWithTag(tag: string, n: number): Xml
+
+  /**
+   * Moves the calling `Xml` object's internal reference to the zero-based `n`th direct child whose
+   * tag equals `tag`. Returns `true` on success and `false` when no such child exists.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getNthChildWithTag2(tag: string, n: number): void
+
+  /**
+   * Returns an `Xml` object referencing this element's parent. Returns no parent when the current
+   * element is the document root.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getParent(): Xml
+
+  /**
+   * Moves the calling `Xml` object's internal reference to its parent. Returns `true` if a parent
+   * exists; otherwise returns `false` when already at the root.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getParent2(): void
+
+  /**
+   * Returns an `Xml` object referencing the root element of the XML tree that contains the current
+   * element. The calling object remains positioned on its current element.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getRoot(): Xml
+
+  /**
+   * Moves the calling `Xml` object's internal reference to the root element of its XML tree.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   */
+  getRoot2(): void
+
+  /**
+   * Returns a new `Xml` object that references the same underlying XML element as the calling
+   * object.
+   *
+   * **Shared element reference:** This is not a deep copy. Both objects reference the same element,
+   * so changes made through either object are changes to the same XML tree.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getSelf(): Xml
+
+  /**
+   * Serializes the XML tree or subtree rooted at the current element and returns the XML text.
+   *
+   * When called while positioned on the document root, the XML declaration is included if
+   * `EmitXmlDecl` is `true`. When called on a non-root element, only that subtree is emitted and
+   * the document declaration is not included.
+   *
+   * `EmitCompact`, `Encoding`, `Standalone`, and related document/output properties affect
+   * serialization as applicable.
+   *
+   * **String vs. bytes:** A language string is Unicode text. The `Encoding` declaration describes
+   * serialized XML encoding, while actual byte encoding matters when XML is written to a file or
+   * byte-oriented destination.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getXml(): string
+
+  /**
+   * Returns `true` if the calling element has an attribute named `name` whose value exactly equals
+   * `value`; otherwise returns `false`.
+   */
+  hasAttrWithValue(name: string, value: string): boolean
+
+  /**
+   * Returns `true` if the calling element has an attribute named `name`; otherwise returns `false`.
+   */
+  hasAttribute(name: string): boolean
+
+  /**
+   * Returns `true` if any direct child has text content exactly equal to `content`; otherwise
+   * returns `false`.
+   */
+  hasChildWithContent(content: string): boolean
+
+  /**
+   * Returns `true` if the child selected by `tagPath` exists; otherwise returns `false`.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   */
+  hasChildWithTag(tagPath: string): boolean
+
+  /**
+   * Returns `true` if the child selected by `tagPath` exists and its text content exactly equals
+   * `content`; otherwise returns `false`.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   */
+  hasChildWithTagAndContent(tagPath: string, content: string): boolean
+
+  /**
+   * Inserts the entire subtree referenced by `tree` as a direct child immediately after the
+   * existing child at zero-based `index`.
+   *
+   * If `tree` belongs to another XML document, the subtree is transferred to the destination tree.
+   *
+   * **Structural move:** The operation preserves the subtree structure. The supplied tree is not
+   * flattened into text content.
+   */
+  insertChildTreeAfter(index: number, tree: Xml): void
+
+  /**
+   * Inserts the entire subtree referenced by `tree` as a direct child immediately before the
+   * existing child at zero-based `index`.
+   *
+   * If `tree` belongs to another XML document, the subtree is transferred to the destination tree.
+   *
+   * **Structural move:** The operation preserves the subtree structure. The supplied tree is not
+   * flattened into text content.
+   */
+  insertChildTreeBefore(index: number, tree: Xml): void
+
+  /**
+   * Returns an `Xml` object referencing the last direct child of the calling element.
+   *
+   * A common reverse-iteration pattern is `LastChild` followed by repeated calls to
+   * `PreviousSibling`.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  lastChild(): Xml
+
+  /**
+   * Moves the calling `Xml` object's internal reference to its last direct child. Returns `true` if
+   * a last child exists; otherwise returns `false`.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  lastChild2(): void
+
+  /**
+   * Parses the XML text in `xmlData` and replaces the calling object's current XML tree content
+   * with the loaded document root. Returns `true` if parsing succeeds.
+   *
+   * **Replacement operation:** A successful load replaces the current document/tree state
+   * represented by this object; it does not append the loaded XML beneath the current element.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  loadXml(xmlData: string): void
+
+  /**
+   * Parses the XML text in `xmlData` and replaces the current XML tree, like `LoadXml`. The
+   * `autoTrim` argument additionally controls whether leading and trailing whitespace is removed
+   * from each leaf element's text content while loading.
+   *
+   * **Whitespace significance:** Set `autoTrim` to `false` when leading or trailing text whitespace
+   * is significant to the application.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  loadXml2(xmlData: string, autoTrim: boolean): void
+
+  /**
+   * Reads and parses an XML document from `fileName`, replacing the calling object's current XML
+   * tree with the loaded document root. Returns `true` on success.
+   *
+   * The file's XML declaration and byte encoding are used as part of normal XML parsing.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  loadXmlFile(fileName: string): void
+
+  /**
+   * Reads and parses an XML document from `fileName`, replacing the current XML tree. The
+   * `autoTrim` argument controls whether leading and trailing whitespace is removed from each leaf
+   * element's text content.
+   *
+   * **Whitespace significance:** Set `autoTrim` to `false` when leading or trailing text whitespace
+   * must be preserved exactly.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  loadXmlFile2(fileName: string, autoTrim: boolean): void
+
+  /**
+   * Creates and returns a new child at `tagPath` with the specified text `content`. A new child is
+   * created even when a child with the same tag already exists.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath. Intermediate elements in a multi-part path are created as
+   * needed. Use `FindOrAddNewChild` when duplicate final children should be avoided.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  newChild(tagPath: string, content: string): Xml
+
+  /**
+   * Creates a new child at `tagPath` with the specified text `content`, but does not return a
+   * separate `Xml` object for the new element.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath. Intermediate elements in a multi-part path are created as
+   * needed.
+   */
+  newChild2(tagPath: string, content: string): void
+
+  /**
+   * Creates a new direct child with the specified `tag` and `content`, inserts it immediately after
+   * the child at zero-based `index`, and returns the new child element.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  newChildAfter(index: number, tag: string, content: string): Xml
+
+  /**
+   * Creates a new direct child with the specified `tag` and `content`, inserts it immediately
+   * before the child at zero-based `index`, and returns the new child element.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  newChildBefore(index: number, tag: string, content: string): Xml
+
+  /**
+   * Creates a new child at `tagPath` whose content is the decimal representation of `value`. No
+   * separate child object is returned.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath. Intermediate elements in a multi-part path are created as
+   * needed.
+   */
+  newChildInt2(tagPath: string, value: number): void
+
+  /**
+   * Returns an `Xml` object referencing the current element's next sibling, or no object when there
+   * is no next sibling.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  nextSibling(): Xml
+
+  /**
+   * Moves the calling `Xml` object's internal reference to its next sibling. Returns `true` if one
+   * exists; otherwise returns `false`.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   */
+  nextSibling2(): boolean
+
+  /**
+   * Returns the number of direct children whose tag exactly equals `tag`. Descendants below those
+   * children are not included.
+   */
+  numChildrenHavingTag(tag: string): number
+
+  /**
+   * Returns an `Xml` object referencing the current element's previous sibling, or no object when
+   * there is no previous sibling.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  previousSibling(): Xml
+
+  /**
+   * Moves the calling `Xml` object's internal reference to its previous sibling. Returns `true` if
+   * one exists; otherwise returns `false`.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  previousSibling2(): void
+
+  /**
+   * Removes every attribute from the calling element. Returns `true` on success.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  removeAllAttributes(): void
+
+  /**
+   * Removes all direct child elements and their subtrees from the calling element. The calling
+   * element's own tag, attributes, and text content are retained.
+   */
+  removeAllChildren(): void
+
+  /**
+   * Removes the attribute named `name` from the calling element. Returns `true` when the operation
+   * succeeds.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  removeAttribute(name: string): void
+
+  /**
+   * Removes all child elements selected by `tagPath` beneath the calling element.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   *
+   * **All matches:** This method removes matching children rather than returning a removed subtree.
+   * Use an `ExtractChild...` method when the removed element must be retained.
+   */
+  removeChild(tagPath: string): void
+
+  /**
+   * Removes the direct child at zero-based `index`, including that child's entire subtree.
+   */
+  removeChildByIndex(index: number): void
+
+  /**
+   * Removes all direct children whose text content exactly equals `content`, including each removed
+   * child's subtree.
+   */
+  removeChildWithContent(content: string): void
+
+  /**
+   * Detaches the calling element and its entire subtree from its parent. The detached element
+   * becomes the root of its own independent XML tree.
+   *
+   * **Object remains usable:** This method removes the subtree from its former document but keeps
+   * the calling `Xml` object referencing the detached subtree.
+   */
+  removeFromTree(): void
+
+  /**
+   * Decodes the binary content stored in this element and writes the resulting bytes to `filename`.
+   * Set `unzipFlag` and `decryptFlag` to reverse the transformations originally applied, and supply
+   * the corresponding `password` when decrypting.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  saveBinaryContent(filename: string, unzipFlag: boolean, decryptFlag: boolean, password: string): void
+
+  /**
+   * Serializes the XML tree or subtree rooted at the current element and writes it to `fileName`.
+   *
+   * Document/output properties such as `Encoding`, `EmitBom`, `EmitXmlDecl`, and `EmitCompact`
+   * affect the generated output as applicable.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  saveXml(fileName: string): void
+
+  /**
+   * Returns the first element whose text content matches `contentPattern`, regardless of tag name.
+   *
+   * The search is breadth-first within the subtree rooted at the caller. The `afterPtr` argument
+   * identifies the element after which matching should begin, allowing repeated calls to continue
+   * an iteration. To begin at the first candidate, use _NULL_ where the language binding permits
+   * it; ActiveX callers should pass a reference to the caller's element instead.
+   *
+   * Wildcard patterns are case-sensitive and may contain `*`, where each asterisk matches zero or
+   * more characters.
+   *
+   * **Iteration:** Pass the element returned by one call as `afterPtr` on the next call to continue
+   * to the next match. Continue until no further element is returned.
+   *
+   * `after` may be omitted (Chilkat's null pointer). It is the first argument in other
+   * Chilkat bindings; here it comes last so that it can be left out.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  searchAllForContent(contentPattern: string, after?: Xml): Xml
+
+  /**
+   * Performs the same breadth-first content search as `SearchAllForContent`, but moves the calling
+   * `Xml` object's internal reference to the matching element instead of returning a separate
+   * element object.
+   *
+   * The search is breadth-first within the subtree rooted at the caller. The `afterPtr` argument
+   * identifies the element after which matching should begin, allowing repeated calls to continue
+   * an iteration. To begin at the first candidate, use _NULL_ where the language binding permits
+   * it; ActiveX callers should pass a reference to the caller's element instead.
+   *
+   * Wildcard patterns are case-sensitive and may contain `*`, where each asterisk matches zero or
+   * more characters.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   *
+   * `after` may be omitted (Chilkat's null pointer). It is the first argument in other
+   * Chilkat bindings; here it comes last so that it can be left out.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  searchAllForContent2(contentPattern: string, after?: Xml): void
+
+  /**
+   * Returns the first element whose tag equals `tag`, that has an attribute named `attr`, and whose
+   * attribute value matches `valuePattern`.
+   *
+   * The search is breadth-first within the subtree rooted at the caller. The `afterPtr` argument
+   * identifies the element after which matching should begin, allowing repeated calls to continue
+   * an iteration. To begin at the first candidate, use _NULL_ where the language binding permits
+   * it; ActiveX callers should pass a reference to the caller's element instead.
+   *
+   * Wildcard patterns are case-sensitive and may contain `*`, where each asterisk matches zero or
+   * more characters.
+   *
+   * **Iteration:** Pass the previous match as `afterPtr` to continue searching after that element.
+   *
+   * `after` may be omitted (Chilkat's null pointer). It is the first argument in other
+   * Chilkat bindings; here it comes last so that it can be left out.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  searchForAttribute(tag: string, attr: string, valuePattern: string, after?: Xml): Xml
+
+  /**
+   * Performs the same breadth-first tag/attribute search as `SearchForAttribute`, but moves the
+   * calling `Xml` object's internal reference to the matching element instead of returning a
+   * separate object.
+   *
+   * The search is breadth-first within the subtree rooted at the caller. The `afterPtr` argument
+   * identifies the element after which matching should begin, allowing repeated calls to continue
+   * an iteration. To begin at the first candidate, use _NULL_ where the language binding permits
+   * it; ActiveX callers should pass a reference to the caller's element instead.
+   *
+   * Wildcard patterns are case-sensitive and may contain `*`, where each asterisk matches zero or
+   * more characters.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   *
+   * `after` may be omitted (Chilkat's null pointer). It is the first argument in other
+   * Chilkat bindings; here it comes last so that it can be left out.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  searchForAttribute2(tag: string, attr: string, valuePattern: string, after?: Xml): void
+
+  /**
+   * Returns the first element whose tag equals `tag` and whose text content matches
+   * `contentPattern`.
+   *
+   * The search is breadth-first within the subtree rooted at the caller. The `afterPtr` argument
+   * identifies the element after which matching should begin, allowing repeated calls to continue
+   * an iteration. To begin at the first candidate, use _NULL_ where the language binding permits
+   * it; ActiveX callers should pass a reference to the caller's element instead.
+   *
+   * Wildcard patterns are case-sensitive and may contain `*`, where each asterisk matches zero or
+   * more characters.
+   *
+   * **Iteration:** Pass the previous match as `afterPtr` to continue searching after that element.
+   *
+   * `after` may be omitted (Chilkat's null pointer). It is the first argument in other
+   * Chilkat bindings; here it comes last so that it can be left out.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  searchForContent(tag: string, contentPattern: string, after?: Xml): Xml
+
+  /**
+   * Performs the same breadth-first tag/content search as `SearchForContent`, but moves the calling
+   * `Xml` object's internal reference to the matching element.
+   *
+   * The search is breadth-first within the subtree rooted at the caller. The `afterPtr` argument
+   * identifies the element after which matching should begin, allowing repeated calls to continue
+   * an iteration. To begin at the first candidate, use _NULL_ where the language binding permits
+   * it; ActiveX callers should pass a reference to the caller's element instead.
+   *
+   * Wildcard patterns are case-sensitive and may contain `*`, where each asterisk matches zero or
+   * more characters.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   *
+   * `after` may be omitted (Chilkat's null pointer). It is the first argument in other
+   * Chilkat bindings; here it comes last so that it can be left out.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  searchForContent2(tag: string, contentPattern: string, after?: Xml): void
+
+  /**
+   * Returns the first element whose tag exactly equals `tag`.
+   *
+   * The search is breadth-first within the subtree rooted at the caller. `afterPtr` identifies the
+   * element after which searching begins. To begin at the first candidate, use _NULL_ where the
+   * language binding permits it; ActiveX callers should pass a reference to the caller's element.
+   *
+   * **Iteration:** Pass the previous match as `afterPtr` to find the next matching tag. Continue
+   * until no further element is returned.
+   *
+   * `after` may be omitted (Chilkat's null pointer). It is the first argument in other
+   * Chilkat bindings; here it comes last so that it can be left out.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  searchForTag(tag: string, after?: Xml): Xml
+
+  /**
+   * Performs the same breadth-first tag search as `SearchForTag`, but moves the calling `Xml`
+   * object's internal reference to the matching element instead of returning a separate object.
+   *
+   * Use `afterPtr` in the same way as with `SearchForTag` to begin or continue the search.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   *
+   * `after` may be omitted (Chilkat's null pointer). It is the first argument in other
+   * Chilkat bindings; here it comes last so that it can be left out.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  searchForTag2(tag: string, after?: Xml): void
+
+  /**
+   * Reads the bytes from `filename` and stores them as this element's binary content, with optional
+   * ZIP compression and optional password-based encryption. The resulting stored data is
+   * represented as Base64 when XML text is generated.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  setBinaryContentFromFile(filename: string, zipFlag: boolean, encryptFlag: boolean, password: string): void
+
+  /**
+   * Sorts the calling element's direct children by the string value of attribute `attrName`. Set
+   * `ascending` to `true` for ascending order or `false` for descending order.
+   *
+   * `SortCaseInsensitive` controls case sensitivity for string sorting.
+   */
+  sortByAttribute(attrName: string, ascending: boolean): void
+
+  /**
+   * Sorts the calling element's direct children numerically by the value of attribute `attrName`,
+   * interpreting each sort value as an integer rather than comparing the text lexicographically.
+   *
+   * Set `ascending` to `true` for ascending order or `false` for descending order.
+   */
+  sortByAttributeInt(attrName: string, ascending: boolean): void
+
+  /**
+   * Sorts the calling element's direct children by their text content. Set `ascending` to `true`
+   * for ascending order or `false` for descending order.
+   *
+   * `SortCaseInsensitive` controls case sensitivity for the string comparison.
+   */
+  sortByContent(ascending: boolean): void
+
+  /**
+   * Sorts the calling element's direct children by tag name. Set `ascending` to `true` for
+   * ascending order or `false` for descending order.
+   *
+   * `SortCaseInsensitive` controls case sensitivity for the tag-name comparison.
+   */
+  sortByTag(ascending: boolean): void
+
+  /**
+   * Treats each direct child as a record and sorts those records by the value of attribute
+   * `attrName` on the record's child identified by `sortTag`.
+   *
+   * Set `ascending` to `true` for ascending order or `false` for descending order. String
+   * comparisons honor `SortCaseInsensitive`.
+   */
+  sortRecordsByAttribute(sortTag: string, attrName: string, ascending: boolean): void
+
+  /**
+   * Treats each direct child as a record and sorts those records by the text content of the
+   * record's child named `sortTag`.
+   *
+   * Set `ascending` to `true` for ascending order or `false` for descending order. String
+   * comparisons honor `SortCaseInsensitive`.
+   */
+  sortRecordsByContent(sortTag: string, ascending: boolean): void
+
+  /**
+   * Treats each direct child as a record and sorts those records numerically by the integer content
+   * of the record's child named `sortTag`.
+   *
+   * Numeric comparison is used instead of lexicographic string comparison. Set `ascending` to
+   * `true` for ascending order or `false` for descending order.
+   */
+  sortRecordsByContentInt(sortTag: string, ascending: boolean): void
+
+  /**
+   * Swaps the calling element's tag, text content, and attributes with those of `node`.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * **Children are not swapped:** Use `SwapTree` when child subtrees should also be exchanged.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  swapNode(node: Xml): void
+
+  /**
+   * Swaps the calling element's complete tree state with `tree`, including tag, text content,
+   * attributes, and children.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  swapTree(tree: Xml): void
+
+  /**
+   * Searches the subtree rooted at the calling element for the first element whose tag equals
+   * `tagName` and returns that element's text content.
+   *
+   * **Recursive search:** Unlike direct-child getters, this search is not limited to the caller's
+   * immediate children.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  tagContent(tagName: string): string
+
+  /**
+   * Returns `true` if the calling element's complete tag name, including any namespace prefix,
+   * exactly equals `tag`; otherwise returns `false`.
+   */
+  tagEquals(tag: string): boolean
+
+  /**
+   * Reverses `ZipContent`: decodes and decompresses the calling element's compressed content and
+   * replaces the stored Base64-compressed representation with the original content.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  unzipContent(): void
+
+  /**
+   * Reverses `ZipTree`: decompresses the stored representation and reconstructs the calling
+   * element's previously compressed subtree.
+   *
+   * The element's tag and attributes, which are not replaced by `ZipTree`, remain associated with
+   * the restored tree.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  unzipTree(): void
+
+  /**
+   * Sets attribute `attrName` to `attrValue`. If the attribute already exists its value is
+   * replaced; otherwise the attribute is added.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  updateAttribute(attrName: string, attrValue: string): void
+
+  /**
+   * Sets attribute `attrName` to the decimal representation of integer `value`. Use
+   * `UpdateAttribute` for string values.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  updateAttributeInt(attrName: string, value: number): void
+
+  /**
+   * Sets the text content of the child selected by `tagPath` to `value`. Missing elements along the
+   * path are automatically created as needed.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   */
+  updateChildContent(tagPath: string, value: string): void
+
+  /**
+   * Sets the content of the child selected by `tagPath` to the decimal representation of integer
+   * `value`.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   */
+  updateChildContentInt(tagPath: string, value: number): void
+
+  /**
+   * ZIP-compresses this element's text content and replaces the original content with
+   * Base64-encoded compressed data.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * **Reversible transformation:** Call `UnzipContent` to restore the original content.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  zipContent(): void
+
+  /**
+   * ZIP-compresses the calling element's content together with its entire child subtree and
+   * replaces that structure with Base64-encoded compressed data.
+   *
+   * The calling element's tag and attributes are not changed. Call `UnzipTree` to reconstruct the
+   * compressed subtree.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  zipTree(): void
+
+  /**
+   * Parses XML from the current contents of `sb` and replaces the calling object's current XML tree
+   * with the loaded document.
+   *
+   * If `autoTrim` is `true`, leading and trailing whitespace is removed from each leaf element's
+   * text content while loading.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  loadSb(sb: StringBuilder, autoTrim: boolean): void
+
+  /**
+   * Serializes the XML tree or subtree rooted at the current element and appends the resulting XML
+   * text to `sb`.
+   *
+   * The existing contents of `sb` are preserved. Output properties such as `EmitCompact` and
+   * `EmitXmlDecl` apply as appropriate.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getXmlSb(sb: StringBuilder): void
+
+  /**
+   * Returns the number of direct children of the element selected by `tagPath`. Returns `-1` if the
+   * path does not identify an existing element.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   */
+  numChildrenAt(tagPath: string): number
+
+  /**
+   * Sets the text content of the element selected by `tagPath` to `value`.
+   *
+   * If `autoCreate` is `true`, missing elements along the path are created as needed. If it is
+   * `false`, the update requires the target path to already exist.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  updateAt(tagPath: string, autoCreate: boolean, value: string): void
+
+  /**
+   * Sets attribute `attrName` to `attrValue` on the element selected by `tagPath`. The attribute is
+   * added when it does not already exist.
+   *
+   * If `autoCreate` is `true`, missing elements along the path are created as needed. If it is
+   * `false`, the target path must already exist.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  updateAttrAt(tagPath: string, autoCreate: boolean, attrName: string, attrValue: string): void
+
+  /**
+   * Finds the element selected by `tagPath` and appends that element's text content to `sb`.
+   *
+   * The existing contents of the `StringBuilder` are preserved.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getChildContentSb(tagPath: string, sb: StringBuilder): void
+
+  /**
+   * Returns the zero-based child index of the element selected by `tagPath`. Returns `-1` when no
+   * matching element is found at that path.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   *
+   * **Index meaning:** The returned index is the element's position among its parent's direct
+   * children, which is the index accepted by methods such as `GetChild`, `RemoveChildByIndex`, and
+   * the insertion methods.
+   */
+  tagIndex(tagPath: string): number
+
+  /**
+   * Returns `true` if this element's namespace-prefix portion exactly equals `ns`; otherwise
+   * returns `false`.
+   *
+   * For example, the namespace prefix of `soapenv:Body` is `soapenv`.
+   *
+   * **Prefix comparison:** This compares the lexical prefix, not the namespace URI bound to that
+   * prefix.
+   */
+  tagNsEquals(ns: string): boolean
+
+  /**
+   * Returns `true` if this element's unprefixed tag exactly equals `unprefixedTag`; otherwise
+   * returns `false`.
+   *
+   * For example, the unprefixed tag of `soapenv:Body` is `Body`.
+   */
+  tagUnpEquals(unprefixedTag: string): boolean
+
+  /**
+   * Returns the value of attribute `attrName` on the descendant element selected by `tagPath`.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getChildAttrValue(tagPath: string, attrName: string): string
+
+  /**
+   * Removes XML stylesheet processing instructions whose attribute named `attrName` has the value
+   * `attrValue`.
+   *
+   * Returns the number of matching stylesheet declarations removed, or `-1` if an error occurs.
+   */
+  removeStyleSheet(attrName: string, attrValue: string): number
+
+  /**
+   * Recursively traverses the subtree rooted at the calling element and removes every occurrence of
+   * the attribute named `attrName`.
+   *
+   * Returns the number of attributes removed.
+   */
+  pruneAttribute(attrName: string): number
+
+  /**
+   * Recursively traverses the subtree rooted at the calling element and removes every element whose
+   * tag equals `tag`. Each removed element's entire descendant subtree is removed with it.
+   *
+   * Returns the number of matching tag occurrences removed.
+   *
+   * **Subtree pruning:** When a matching parent is removed, its descendants disappear as part of
+   * that subtree; this method is intended for structural cleanup rather than text-only removal.
+   */
+  pruneTag(tag: string): number
+
+  /**
+   * Recursively normalizes the XML subtree rooted at the calling element according to the
+   * comma-separated keywords in `directives`.
+   *
+   * Supported directives are:
+   *
+   * - `AttrTrimEnds` - remove leading and trailing whitespace from attribute values.
+   *
+   * - `AttrTrimInside` - replace tabs, CR, and LF with spaces and collapse repeated spaces inside
+   *   attribute values.
+   *
+   * - `ContentTrimEnds` - remove leading and trailing whitespace from element content.
+   *
+   * - `ContentTrimInside` - normalize internal tabs/line breaks/spaces in element content.
+   *
+   * - `LowercaseAttrs` - convert attribute names to lowercase.
+   *
+   * - `LowercaseTags` - convert tag names to lowercase.
+   *
+   * - `RemoveCtrl` - remove US-ASCII control characters with values 0-31 except TAB, CR, and LF.
+   *
+   * **Destructive normalization:** Scrubbing modifies the tree. Use these options only when the
+   * corresponding whitespace, letter case, or control characters are not semantically significant
+   * to the application.
+   */
+  scrub(directives: string): void
+
+  /**
+   * Parses XML from the bytes contained in `bd` and replaces the calling object's current XML tree
+   * with the loaded document.
+   *
+   * If `autoTrim` is `true`, leading and trailing whitespace is removed from each leaf element's
+   * text content during loading.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  loadBd(bd: BinData, autoTrim: boolean): void
+
+  /**
+   * Serializes the XML tree or subtree rooted at the current element and appends the encoded XML
+   * bytes to `bd`.
+   *
+   * The existing contents of the `BinData` object are preserved. The XML output encoding is
+   * governed by the XML document's output settings, including `Encoding`.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getXmlBd(bd: BinData): void
+
+  /**
+   * Moves the calling `Xml` object to the next element in a depth-first traversal of the tree and
+   * updates `sbState` with the traversal state.
+   *
+   * Pass an empty `StringBuilder` when beginning a traversal, then reuse the same `sbState` for
+   * each subsequent call.
+   *
+   * **Why the name ends in 2:** This method changes the caller's internal element reference. There
+   * is no separate `NextInTraversal` method that returns another `Xml` object.
+   */
+  nextInTraversal2(sbState: StringBuilder): boolean
+
+  /**
+   * Stores the bytes in `data` as binary content on this element, with optional ZIP compression and
+   * optional password-based AES encryption. The stored binary representation is emitted as Base64
+   * text when XML is serialized.
+   *
+   * If `zipFlag` is `true`, the bytes are compressed first. If `encryptFlag` is `true`, the data is
+   * encrypted using Chilkat's 128-bit Rijndael/AES format and `password`.
+   *
+   * Returns `true` on success and `false` on failure.
+   *
+   * **Round trip:** Use the corresponding binary-content retrieval methods with matching
+   * decompression/decryption options to recover the original bytes.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  setBinaryContentBd(data: BinData, zipFlag: boolean, encryptFlag: boolean, password: string): void
+
+  /**
+   * Moves the calling `Xml` object's internal reference to the child selected by `tagPath`. Returns
+   * `true` when the child is found and the move succeeds; otherwise returns `false`.
+   *
+   * **Tag paths:** A tag path is Chilkat's `|`-separated child-navigation syntax, for example
+   * `tagA|tagB|tagC`. It is not XPath.
+   *
+   * **Element-reference behavior:** Methods that return an `Xml` object return another object
+   * referencing an element in the same underlying tree. Methods whose names end in `2` instead move
+   * the caller's internal reference.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Xml.lastErrorText}.
+   */
+  getChildWithTag2(tagPath: string): void
+}