yaml 3.0.0-0 → 3.0.0-2

package/dist/directives-CGITitH5.d.ts

@@ -0,0 +1,1377 @@
+//#region src/parse/line-counter.d.ts
+/**
+ * Tracks newlines during parsing in order to provide an efficient API for
+ * determining the one-indexed `{ line, col }` position for any offset
+ * within the input.
+ */
+declare class LineCounter {
+  lineStarts: number[];
+  /**
+   * Should be called in ascending order. Otherwise, call
+   * `lineCounter.lineStarts.sort()` before calling `linePos()`.
+   */
+  addNewLine: (offset: number) => number;
+  /**
+   * Performs a binary search and returns the 1-indexed { line, col }
+   * position of `offset`. If `line === 0`, `addNewLine` has never been
+   * called or `offset` is before the first known newline.
+   */
+  linePos: (offset: number) => {
+    line: number;
+    col: number;
+  };
+}
+//#endregion
+//#region src/errors.d.ts
+type ErrorCode = "ALIAS_PROPS" | "BAD_ALIAS" | "BAD_DIRECTIVE" | "BAD_DQ_ESCAPE" | "BAD_INDENT" | "BAD_PROP_ORDER" | "BAD_SCALAR_START" | "BLOCK_AS_IMPLICIT_KEY" | "BLOCK_IN_FLOW" | "DUPLICATE_KEY" | "IMPOSSIBLE" | "KEY_OVER_1024_CHARS" | "MISSING_CHAR" | "MULTILINE_IMPLICIT_KEY" | "MULTIPLE_ANCHORS" | "MULTIPLE_DOCS" | "MULTIPLE_TAGS" | "NON_STRING_KEY" | "RESOURCE_EXHAUSTION" | "TAB_AS_INDENT" | "TAG_RESOLVE_FAILED" | "UNEXPECTED_TOKEN" | "BAD_COLLECTION_TYPE";
+type LinePos = {
+  line: number;
+  col: number;
+};
+declare class YAMLError extends Error {
+  name: "YAMLParseError" | "YAMLWarning";
+  code: ErrorCode;
+  message: string;
+  pos: [number, number];
+  linePos?: [LinePos] | [LinePos, LinePos];
+  constructor(name: YAMLError["name"], pos: [number, number], code: ErrorCode, message: string);
+}
+declare class YAMLParseError extends YAMLError {
+  constructor(pos: [number, number], code: ErrorCode, message: string);
+}
+declare class YAMLWarning extends YAMLError {
+  constructor(pos: [number, number], code: ErrorCode, message: string);
+}
+//#endregion
+//#region src/doc/applyReviver.d.ts
+type Reviver = (key: unknown, value: unknown) => unknown;
+//#endregion
+//#region src/log.d.ts
+type LogLevelId = "silent" | "error" | "warn" | "debug";
+declare function debug(logLevel: LogLevelId, ...messages: any[]): void;
+declare function warn(logLevel: LogLevelId, warning: string | Error): void;
+//#endregion
+//#region src/stringify/stringify.d.ts
+type StringifyContext = {
+  actualString?: boolean;
+  anchors: Set<string>;
+  doc: Document;
+  forceBlockIndent?: boolean;
+  implicitKey?: boolean;
+  indent: string;
+  indentStep: string;
+  indentAtStart?: number;
+  inFlow: boolean | null;
+  inStringifyKey?: boolean;
+  flowCollectionPadding: string;
+  options: Readonly<Required<Omit<ToStringOptions, "collectionStyle" | "indent">>>;
+  resolvedAliases?: Set<Alias>;
+  sortMapEntries: ((a: Pair, b: Pair) => number) | null;
+};
+//#endregion
+//#region src/nodes/toJS.d.ts
+/** A context used in `node.toJS()` implementations */
+declare class ToJSContext {
+  #private;
+  anchors: Map<Node, {
+    aliasCount: number;
+    count: number;
+    res: unknown;
+  }>;
+  /** Cached anchor and alias nodes in the order they occur in the document */
+  aliasResolveCache?: Node[];
+  mapAsMap: boolean;
+  mapKeyWarned: boolean;
+  maxAliasCount: number;
+  constructor(opt?: ToJSOptions);
+  setAnchor(node: Node, res: unknown): void;
+  resolveAlias(doc: Document, source: Node): unknown;
+}
+//#endregion
+//#region src/doc/NodeCreator.d.ts
+declare class NodeCreator {
+  #private;
+  keepUndefined: boolean;
+  replacer?: Replacer;
+  schema: Schema;
+  constructor(doc: Document<DocValue, boolean>, options?: CreateNodeOptions, replacer?: Replacer);
+  constructor(schema: Schema, options?: CreateNodeOptions);
+  create(value: unknown, tagName?: string): Node;
+  createPair(key: unknown, value: unknown): Pair<Node, Node | null>;
+  /**
+   * With circular references, the source node is only resolved after all
+   * of its child nodes are. This is why anchors are set only after all of
+   * the nodes have been created.
+   */
+  setAnchors(): void;
+}
+//#endregion
+//#region src/nodes/Scalar.d.ts
+declare namespace Scalar {
+  type BLOCK_FOLDED = "BLOCK_FOLDED";
+  type BLOCK_LITERAL = "BLOCK_LITERAL";
+  type PLAIN = "PLAIN";
+  type QUOTE_DOUBLE = "QUOTE_DOUBLE";
+  type QUOTE_SINGLE = "QUOTE_SINGLE";
+  type Type = BLOCK_FOLDED | BLOCK_LITERAL | PLAIN | QUOTE_DOUBLE | QUOTE_SINGLE;
+}
+declare class Scalar<T = unknown> implements NodeBase {
+  static readonly BLOCK_FOLDED = "BLOCK_FOLDED";
+  static readonly BLOCK_LITERAL = "BLOCK_LITERAL";
+  static readonly PLAIN = "PLAIN";
+  static readonly QUOTE_DOUBLE = "QUOTE_DOUBLE";
+  static readonly QUOTE_SINGLE = "QUOTE_SINGLE";
+  value: T;
+  /** An optional anchor on this node. Used by alias nodes. */
+  anchor?: string;
+  /** A comment on or immediately after this node. */
+  comment?: string | null;
+  /** A comment before this node. */
+  commentBefore?: string | null;
+  /**
+   * By default (undefined), numbers use decimal notation.
+   * The YAML 1.2 core schema only supports 'HEX' and 'OCT'.
+   * The YAML 1.1 schema also supports 'BIN' and 'TIME'
+   */
+  format?: string;
+  /**
+   * If `value` is a number that is serialized as a decimal string
+   * (i.e. not using exponential notation),
+   * use this value when stringifying this node.
+   */
+  minFractionDigits?: number;
+  /**
+   * The `[start, value-end, node-end]` character offsets for
+   * the part of the source parsed into this node (undefined if not parsed).
+   * The `value-end` and `node-end` positions are themselves not included in their respective ranges.
+   */
+  range?: Range | null;
+  /** A blank line before this node and its commentBefore */
+  spaceBefore?: boolean;
+  /** The CST token that was composed into this node.  */
+  srcToken?: FlowScalar | BlockScalar;
+  /** Set during parsing to the source string value */
+  source?: string;
+  /** A fully qualified tag, if required */
+  tag?: string;
+  /** The scalar style used for the node's string representation */
+  type?: Scalar.Type;
+  /**
+   * Customize the way that a key-value pair is resolved.
+   * Used for YAML 1.1 !!merge << handling.
+   */
+  addToJSMap?: (doc: Document<DocValue, boolean>, ctx: ToJSContext | undefined, map: MapLike, value: unknown, isPlainObject: boolean) => void;
+  constructor(value: T);
+  /** Create a copy of this node.  */
+  clone(): this;
+  /** A plain JavaScript representation of this node. */
+  toJS(_doc?: unknown, ctx?: ToJSContext): T;
+  toString(): string;
+}
+//#endregion
+//#region src/nodes/YAMLMap.d.ts
+type MapLike = Map<any, any> | Set<any> | Record<string | number | symbol, any>;
+type KeyArg<K extends Primitive | Node, V extends Primitive | Node> = K | NodeOf<K> | (K extends Scalar ? K["value"] : never) | Pair<K, V>;
+declare class YAMLMap<K extends Primitive | Node = Primitive | Node, V extends Primitive | Node = Primitive | Node> implements CollectionBase {
+  #private;
+  static readonly tagName = "tag:yaml.org,2002:map";
+  schema: Schema;
+  values: Map<unknown, Pair<K, V>>;
+  /** An optional anchor on this map. Used by alias nodes. */
+  anchor?: string;
+  /** If true, stringify this and all child nodes using flow rather than block styles. */
+  flow?: boolean;
+  /** A comment on or immediately after this map. */
+  comment?: string | null;
+  /** A comment before this map. */
+  commentBefore?: string | null;
+  /**
+   * The `[start, value-end, node-end]` character offsets for
+   * the part of the source parsed into this map (undefined if not parsed).
+   * The `value-end` and `node-end` positions are themselves not included in their respective ranges.
+   */
+  range?: Range | null;
+  /** A blank line before this map and its commentBefore */
+  spaceBefore?: boolean;
+  /** The CST token that was composed into this map.  */
+  srcToken?: BlockMap | FlowCollection;
+  /** A fully qualified tag, if required */
+  tag?: string;
+  /**
+   * A generic collection factory method that can be used
+   * by other node classes that inherit from YAMLMap
+   */
+  static create(nc: NodeCreator, obj: unknown): YAMLMap<any, any>;
+  constructor(schema: Schema, elements?: Array<Pair<K, V>>);
+  get size(): number;
+  /**
+   * Create a copy of this map.
+   *
+   * @param schema - If defined, overwrites the original's schema
+   */
+  clone(schema?: Schema): this;
+  /**
+   * Remove a value from the mapping.
+   * @returns `true` if the item was found and removed.
+   */
+  delete(key: KeyArg<K, V>): boolean;
+  /** Return value at `key`, or `undefined` if not found.  */
+  get(key: KeyArg<K, V>): NodeOf<V> | null | undefined;
+  /** Return pair at `key`, or `undefined` if not found.  */
+  getPair(key: KeyArg<K, V>): Pair<K, V> | undefined;
+  /** Check if the mapping includes a value with the key `key`.  */
+  has(key: KeyArg<K, V>): boolean;
+  /**
+   * Return the internal Map key matching `key`, or `undefined` if not found.
+   *
+   * @param allowMissing - If `true`, a key is always returned,
+   *                       even if the key is not in the map.
+   */
+  keyOf(key: KeyArg<K, V>, allowMissing?: boolean): unknown;
+  pairs(): Iterable<Pair<K, V>>;
+  set(key: K | NodeOf<K> | (K extends Scalar ? K["value"] : never), value: V | NodeOf<V> | (V extends Scalar ? V["value"] : never) | null, options?: Omit<CreateNodeOptions, "aliasDuplicateObjects">): this;
+  set(pair: Pair<K, V>): this;
+  /**
+   * A plain JavaScript representation of this node.
+   *
+   * @param Type - If set, forces the returned collection type
+   * @returns Instance of Type, Map, or Object
+   */
+  toJS<T extends MapLike = Map<any, any>>(doc: Document<DocValue, boolean>, ctx: ToJSContext | undefined, Type: {
+    new (): T;
+  }): T;
+  toJS(doc: Document<DocValue, boolean>, ctx?: ToJSContext): any;
+  toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
+}
+//#endregion
+//#region src/nodes/addPairToJSMap.d.ts
+declare function addPairToJSMap(doc: Document<DocValue, boolean>, ctx: ToJSContext, map: MapLike, { key, value }: Pair, isPlainObject: boolean): MapLike;
+//#endregion
+//#region src/nodes/Pair.d.ts
+declare class Pair<K extends Primitive | Node = Primitive | Node, V extends Primitive | Node = Primitive | Node> {
+  key: NodeOf<K>;
+  value: NodeOf<V> | null;
+  comment?: never;
+  commentBefore?: never;
+  spaceBefore?: never;
+  /** The CST token that was composed into this pair.  */
+  srcToken?: CollectionItem;
+  constructor(key: NodeOf<K>, value?: NodeOf<V> | null);
+  clone(schema?: Schema): Pair<K, V>;
+  toJS(doc: Document<DocValue, boolean>, ctx: ToJSContext): ReturnType<typeof addPairToJSMap>;
+  toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
+}
+//#endregion
+//#region src/schema/types.d.ts
+interface TagBase {
+  /**
+   * An optional factory function, used e.g. by collections when wrapping JS objects as AST nodes.
+   */
+  createNode?: (nc: NodeCreator, value: unknown) => Node;
+  /**
+   * If `true`, allows for values to be stringified without
+   * an explicit tag together with `test`.
+   * If `'key'`, this only applies if the value is used as a mapping key.
+   * For most cases, it's unlikely that you'll actually want to use this,
+   * even if you first think you do.
+   */
+  default?: boolean | "key";
+  /**
+   * If a tag has multiple forms that should be parsed and/or stringified
+   * differently, use `format` to identify them.
+   */
+  format?: string;
+  /**
+   * Used by `YAML.createNode` to detect your data type, e.g. using `typeof` or
+   * `instanceof`.
+   */
+  identify?: (value: unknown) => boolean;
+  /**
+   * The identifier for your data type, with which its stringified form will be
+   * prefixed. Should either be a !-prefixed local `!tag`, or a fully qualified
+   * `tag:domain,date:foo`.
+   */
+  tag: string;
+}
+interface ScalarTag extends TagBase {
+  collection?: never;
+  nodeClass?: never;
+  /**
+   * Turns a value into an AST node.
+   * If returning a non-`Node` value, the output will be wrapped as a `Scalar`.
+   */
+  resolve(value: string, onError: (message: string) => void, options: ParseOptions): unknown;
+  /**
+   * Optional function stringifying a Scalar node. If your data includes a
+   * suitable `.toString()` method, you can probably leave this undefined and
+   * use the default stringifier.
+   *
+   * @param item The node being stringified.
+   * @param ctx Contains the stringifying context variables.
+   * @param onComment Callback to signal that the stringifier includes the
+   *   item's comment in its output.
+   * @param onChompKeep Callback to signal that the output uses a block scalar
+   *   type with the `+` chomping indicator.
+   */
+  stringify?: (item: Scalar, ctx: StringifyContext, onComment?: () => void, onChompKeep?: () => void) => string;
+  /**
+   * Together with `default` allows for values to be stringified without an
+   * explicit tag and detected using a regular expression or a test function.
+   * For most cases, it's unlikely that you'll actually want to use these,
+   * even if you first think you do.
+   */
+  test?: (value: string) => boolean;
+}
+interface CollectionTag extends TagBase {
+  stringify?: never;
+  test?: never;
+  /** The source collection type supported by this tag. */
+  collection: "map" | "seq";
+  createNode: (nc: NodeCreator, value: unknown) => Node;
+  /**
+   * The `Node` child class that implements this tag.
+   * If set, used to select this tag when stringifying.
+   */
+  nodeClass?: {
+    new (schema: Schema): Node;
+  };
+  /**
+   * Turns a value into an AST node.
+   * If returning a non-`Node` value, the output will be wrapped as a `Scalar`.
+   *
+   * Note: this is required if nodeClass is not provided.
+   */
+  resolve?: (value: Collection, onError: (message: string) => void, options: ParseOptions) => unknown;
+}
+//#endregion
+//#region src/schema/tags.d.ts
+type WithScalarTagTest = {
+  test: (value: string) => boolean;
+};
+declare const tagsByName: {
+  binary: ScalarTag;
+  bool: ScalarTag & WithScalarTagTest;
+  float: ScalarTag & WithScalarTagTest;
+  floatExp: ScalarTag & WithScalarTagTest;
+  floatNaN: ScalarTag & WithScalarTagTest;
+  floatTime: ScalarTag & WithScalarTagTest;
+  int: ScalarTag & WithScalarTagTest;
+  intHex: ScalarTag & WithScalarTagTest;
+  intOct: ScalarTag & WithScalarTagTest;
+  intTime: ScalarTag & WithScalarTagTest;
+  map: CollectionTag;
+  merge: ScalarTag & {
+    identify(value: unknown): boolean;
+  } & WithScalarTagTest;
+  null: ScalarTag & WithScalarTagTest;
+  omap: CollectionTag;
+  pairs: CollectionTag;
+  seq: CollectionTag;
+  set: CollectionTag;
+  timestamp: ScalarTag & WithScalarTagTest;
+};
+type TagId = keyof typeof tagsByName;
+type Tags = Array<ScalarTag | CollectionTag | TagId>;
+//#endregion
+//#region src/options.d.ts
+type ParseOptions = {
+  /**
+   * Whether integers should be parsed into BigInt rather than number values.
+   *
+   * Default: `false`
+   *
+   * https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/BigInt
+   */
+  intAsBigInt?: boolean;
+  /**
+   * Include a `srcToken` value on each parsed `Node`, containing the CST token
+   * that was composed into this node.
+   *
+   * Default: `false`
+   */
+  keepSourceTokens?: boolean;
+  /**
+   * If set, newlines will be tracked, to allow for `lineCounter.linePos(offset)`
+   * to provide the `{ line, col }` positions within the input.
+   */
+  lineCounter?: LineCounter;
+  /**
+   * Include line/col position & node type directly in parse errors.
+   *
+   * Default: `true`
+   */
+  prettyErrors?: boolean;
+  /**
+   * Detect and report errors that are required by the YAML 1.2 spec,
+   * but are caused by unambiguous content.
+   *
+   * Default: `true`
+   */
+  strict?: boolean;
+  /**
+   * Parse all mapping keys as strings. Treat all non-scalar keys as errors.
+   *
+   * Default: `false`
+   */
+  stringKeys?: boolean;
+};
+type DocumentOptions = {
+  /**
+   * Control the logging level during parsing
+   *
+   * Default: `'warn'`
+   */
+  logLevel?: LogLevelId;
+  /**
+   * The YAML version used by documents without a `%YAML` directive.
+   *
+   * Default: `"1.2"`
+   */
+  version?: "1.1" | "1.2" | "next";
+};
+type SchemaOptions = {
+  /**
+   * When parsing, warn about compatibility issues with the given schema.
+   * When stringifying, use scalar styles that are parsed correctly
+   * by the `compat` schema as well as the actual schema.
+   *
+   * Default: `null`
+   */
+  compat?: string | Tags | null;
+  /**
+   * Array of additional tags to include in the schema, or a function that may
+   * modify the schema's base tag array.
+   */
+  customTags?: Tags | ((tags: Tags) => Tags) | null;
+  /**
+   * Determine an internal Map key representation for map and set values,
+   * which is used for detecting duplicates and to identify values.
+   *
+   * Key equality is based on the SameValueZero algorithm.
+   *
+   * If merge keys are enabled by the schema,
+   * multiple `<<` keys are each considered unique.
+   */
+  mapKey?: (value: unknown) => unknown;
+  /**
+   * Enable support for `<<` merge keys.
+   *
+   * Default: `false` for YAML 1.2, `true` for earlier versions
+   */
+  merge?: boolean;
+  /**
+   * When using the `'core'` schema, support parsing values with these
+   * explicit YAML 1.1 tags:
+   *
+   * `!!binary`, `!!omap`, `!!pairs`, `!!set`, `!!timestamp`.
+   *
+   * Default `true`
+   */
+  resolveKnownTags?: boolean;
+  /**
+   * The base schema to use.
+   *
+   * The core library has built-in support for the following:
+   * - `'failsafe'`: A minimal schema that parses all scalars as strings
+   * - `'core'`: The YAML 1.2 core schema
+   * - `'json'`: The YAML 1.2 JSON schema, with minimal rules for JSON compatibility
+   * - `'yaml-1.1'`: The YAML 1.1 schema
+   *
+   * If using another (custom) schema, the `customTags` array needs to
+   * fully define the schema's tags.
+   *
+   * Default: `'core'` for YAML 1.2, `'yaml-1.1'` for earlier versions
+   */
+  schema?: string | Schema;
+  /**
+   * Override default values for `toString()` options.
+   */
+  toStringDefaults?: ToStringOptions;
+};
+type CreateNodeOptions = {
+  /**
+   * During node construction, use anchors and aliases to keep strictly equal
+   * non-null objects as equivalent in YAML.
+   *
+   * Default: `true`
+   */
+  aliasDuplicateObjects?: boolean;
+  /**
+   * Default prefix for anchors.
+   *
+   * Default: `'a'`, resulting in anchors `a1`, `a2`, etc.
+   */
+  anchorPrefix?: string;
+  /** Force the top-level collection node to use flow style. */
+  flow?: boolean;
+  /**
+   * Keep `undefined` object values when creating mappings, rather than
+   * discarding them.
+   *
+   * Default: `false`
+   */
+  keepUndefined?: boolean | null;
+  onTagObj?: (tagObj: ScalarTag | CollectionTag) => void;
+  /**
+   * Specify the top-level collection type, e.g. `"!!omap"`. Note that this
+   * requires the corresponding tag to be available in this document's schema.
+   */
+  tag?: string;
+};
+type ToJSOptions = {
+  /**
+   * Use Map rather than Object to represent mappings.
+   *
+   * Default: `false`
+   */
+  mapAsMap?: boolean;
+  /**
+   * Prevent exponential entity expansion attacks by limiting data aliasing count;
+   * set to `-1` to disable checks; `0` disallows all alias nodes.
+   *
+   * Default: `100`
+   */
+  maxAliasCount?: number;
+  /**
+   * If defined, called with the resolved `value` and reference `count` for
+   * each anchor in the document.
+   */
+  onAnchor?: (value: unknown, count: number) => void;
+  /**
+   * Optional function that may filter or modify the output JS value
+   *
+   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#using_the_reviver_parameter
+   */
+  reviver?: Reviver;
+};
+type ToStringOptions = {
+  /**
+   * Use block quote styles for scalar values where applicable.
+   * Set to `false` to disable block quotes completely.
+   *
+   * Default: `true`
+   */
+  blockQuote?: boolean | "folded" | "literal";
+  /**
+   * Enforce `'block'` or `'flow'` style on maps and sequences.
+   * Empty collections will always be stringified as `{}` or `[]`.
+   *
+   * Default: `'any'`, allowing each node to set its style separately
+   * with its `flow: boolean` (default `false`) property.
+   */
+  collectionStyle?: "any" | "block" | "flow";
+  /**
+   * Comment stringifier.
+   * Output should be valid for the current schema.
+   *
+   * By default, empty comment lines are left empty,
+   * lines consisting of a single space are replaced by `#`,
+   * and all other lines are prefixed with a `#`.
+   */
+  commentString?: (comment: string) => string;
+  /**
+   * The default type of string literal used to stringify implicit key values.
+   * Output may use other types if required to fully represent the value.
+   *
+   * If `null`, the value of `defaultStringType` is used.
+   *
+   * Default: `null`
+   */
+  defaultKeyType?: Scalar.Type | null;
+  /**
+   * The default type of string literal used to stringify values in general.
+   * Output may use other types if required to fully represent the value.
+   *
+   * Default: `'PLAIN'`
+   */
+  defaultStringType?: Scalar.Type;
+  /**
+   * Include directives in the output.
+   *
+   * - If `true`, at least the document-start marker `---` is always included.
+   *   This does not force the `%YAML` directive to be included. To do that,
+   *   set `doc.directives.yaml.explicit = true`.
+   * - If `false`, no directives or marker is ever included. If using the `%TAG`
+   *   directive, you are expected to include it manually in the stream before
+   *   its use.
+   * - If `null`, directives and marker may be included if required.
+   *
+   * Default: `null`
+   */
+  directives?: boolean | null;
+  /**
+   * Restrict double-quoted strings to use JSON-compatible syntax.
+   *
+   * Default: `false`
+   */
+  doubleQuotedAsJSON?: boolean;
+  /**
+   * Minimum length for double-quoted strings to use multiple lines to
+   * represent the value. Ignored if `doubleQuotedAsJSON` is set.
+   *
+   * Default: `40`
+   */
+  doubleQuotedMinMultiLineLength?: number;
+  /**
+   * String representation for `false`.
+   * With the core schema, use `'false'`, `'False'`, or `'FALSE'`.
+   *
+   * Default: `'false'`
+   */
+  falseStr?: string;
+  /**
+   * When true, a single space of padding will be added inside the delimiters
+   * of non-empty single-line flow collections.
+   *
+   * Default: `true`
+   */
+  flowCollectionPadding?: boolean;
+  /**
+   * The number of spaces to use when indenting code.
+   *
+   * Default: `2`
+   */
+  indent?: number;
+  /**
+   * Whether block sequences should be indented.
+   *
+   * Default: `true`
+   */
+  indentSeq?: boolean;
+  /**
+   * Maximum line width (set to `0` to disable folding).
+   *
+   * This is a soft limit, as only double-quoted semantics allow for inserting
+   * a line break in the middle of a word, as well as being influenced by the
+   * `minContentWidth` option.
+   *
+   * Default: `80`
+   */
+  lineWidth?: number;
+  /**
+   * Minimum line width for highly-indented content (set to `0` to disable).
+   *
+   * Default: `20`
+   */
+  minContentWidth?: number;
+  /**
+   * String representation for `null`.
+   * With the core schema, use `'null'`, `'Null'`, `'NULL'`, `'~'`, or an empty
+   * string `''`.
+   *
+   * Default: `'null'`
+   */
+  nullStr?: string;
+  /**
+   * Require keys to be scalars and to use implicit rather than explicit notation.
+   *
+   * Default: `false`
+   */
+  simpleKeys?: boolean;
+  /**
+   * Use 'single quote' rather than "double quote" where applicable.
+   * Set to `false` to disable single quotes completely.
+   *
+   * Default: `null`
+   */
+  singleQuote?: boolean | null;
+  /**
+   * When stringifying a map or a set, sort the entries.
+   * If `true`, sort by comparing key values with `<`.
+   *
+   * Default: `false`
+   */
+  sortMapEntries?: boolean | ((a: Pair, b: Pair) => number);
+  /**
+   * Add a trailing comma after the last entry in a flow map or flow sequence that's split across multiple lines.
+   *
+   * Default: `'false'`
+   */
+  trailingComma?: boolean;
+  /**
+   * String representation for `true`.
+   * With the core schema, use `'true'`, `'True'`, or `'TRUE'`.
+   *
+   * Default: `'true'`
+   */
+  trueStr?: string;
+  /**
+   * The anchor used by an alias must be defined before the alias node. As it's
+   * possible for the document to be modified manually, the order may be
+   * verified during stringification.
+   *
+   * Default: `'true'`
+   */
+  verifyAliasOrder?: boolean;
+};
+//#endregion
+//#region src/schema/Schema.d.ts
+declare class Schema {
+  compat: Array<CollectionTag | ScalarTag> | null;
+  knownTags: Record<string, CollectionTag | ScalarTag>;
+  mapKey: (value: unknown) => unknown;
+  name: string;
+  tags: Array<CollectionTag | ScalarTag>;
+  toStringOptions: Readonly<ToStringOptions> | null;
+  constructor({ compat, customTags, mapKey, merge, resolveKnownTags, schema, toStringDefaults }: SchemaOptions);
+  clone(): Schema;
+}
+//#endregion
+//#region src/schema/common/map.d.ts
+declare const map: {
+  collection: "map";
+  default: true;
+  nodeClass: typeof YAMLMap;
+  tag: string;
+  createNode(nc: NodeCreator, obj: unknown): YAMLMap<any, any>;
+  resolve(map: Collection, onError: (message: string) => void): YAMLMap<any, any>;
+};
+//#endregion
+//#region src/nodes/YAMLSeq.d.ts
+declare class YAMLSeq<T extends Primitive | Node | Pair = Primitive | Node | Pair> extends Array<NodeOf<T>> implements CollectionBase {
+  #private;
+  static get tagName(): "tag:yaml.org,2002:seq";
+  schema: Schema;
+  /** An optional anchor on this collection. Used by alias nodes. */
+  anchor?: string;
+  /**
+   * If true, stringify this and all child nodes using flow rather than
+   * block styles.
+   */
+  flow?: boolean;
+  /** A comment on or immediately after this collection. */
+  comment?: string | null;
+  /** A comment before this collection. */
+  commentBefore?: string | null;
+  /**
+   * The `[start, value-end, node-end]` character offsets for
+   * the part of the source parsed into this collection (undefined if not parsed).
+   * The `value-end` and `node-end` positions are themselves not included in their respective ranges.
+   */
+  range?: Range | null;
+  /** A blank line before this collection and its commentBefore */
+  spaceBefore?: boolean;
+  /** The CST token that was composed into this collection.  */
+  srcToken?: BlockSequence | FlowCollection;
+  /** A fully qualified tag, if required */
+  tag?: string;
+  /**
+   * A generic collection factory method that can be extended
+   * to other node classes that inherit from YAMLSeq
+   */
+  static create(nc: NodeCreator, obj: unknown): YAMLSeq;
+  constructor(schema: Schema, elements?: Array<T | NodeOf<T>>);
+  get size(): number;
+  /**
+   * Create a copy of this collection.
+   *
+   * @param schema - If defined, overwrites the original's schema
+   */
+  clone(schema?: Schema): this;
+  /**
+   * Change all elements within a range of indices in this sequence to a static value.
+   *
+   * Non-node values are converted to Node values.
+   */
+  fill(value: T | NodeOf<T>, start?: number, end?: number): this;
+  /** @private */
+  _push(item: NodeOf<T>): void;
+  /**
+   * Append new elements to this sequence, and return its new length.
+   *
+   * Non-node values are converted to Node values.
+   */
+  push(...values: Array<T | NodeOf<T>>): number;
+  /**
+   * Set a value in this sequence.
+   *
+   * Non-node values are converted to Node values.
+   */
+  set(idx: number, value: T | NodeOf<T>, options?: Omit<CreateNodeOptions, "aliasDuplicateObjects">): void;
+  /**
+   * Changes the contents of this sequence by removing or replacing existing elements
+   * and/or adding new elements in place.
+   *
+   * Non-node values are converted to Node values.
+   */
+  splice(start: number, deleteCount?: number, ...values: Array<T | NodeOf<T>>): NodeOf<T>[];
+  /**
+   * Prepend new elements to this sequence, and return its new length.
+   *
+   * Non-node values are converted to Node values.
+   */
+  unshift(...values: Array<T | NodeOf<T>>): number;
+  /** A plain JavaScript representation of this node. */
+  toJS(doc: Document<DocValue, boolean>, ctx?: ToJSContext): any[];
+  toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
+}
+//#endregion
+//#region src/schema/common/seq.d.ts
+declare const seq: {
+  collection: "seq";
+  default: true;
+  nodeClass: typeof YAMLSeq;
+  tag: string;
+  createNode(nc: NodeCreator, obj: unknown): YAMLSeq;
+  resolve(seq: Collection, onError: (message: string) => void): YAMLSeq;
+};
+//#endregion
+//#region src/schema/common/string.d.ts
+declare const string: ScalarTag;
+//#endregion
+//#region src/stringify/foldFlowLines.d.ts
+/**
+ * `'block'` prevents more-indented lines from being folded;
+ * `'quoted'` allows for `\` escapes, including escaped newlines
+ */
+type FoldMode = "flow" | "block" | "quoted";
+interface FoldOptions {
+  /**
+   * Accounts for leading contents on the first line, defaulting to
+   * `indent.length`
+   */
+  indentAtStart?: number;
+  /** Default: `80` */
+  lineWidth?: number;
+  /**
+   * Allow highly indented lines to stretch the line width or indent content
+   * from the start.
+   *
+   * Default: `20`
+   */
+  minContentWidth?: number;
+  /** Called once if the text is folded */
+  onFold?: () => void;
+  /** Called once if any line of text exceeds lineWidth characters */
+  onOverflow?: () => void;
+}
+/**
+ * Tries to keep input at up to `lineWidth` characters, splitting only on spaces
+ * not followed by newlines or spaces unless `mode` is `'quoted'`. Lines are
+ * terminated with `\n` and started with `indent`.
+ */
+declare function foldFlowLines(text: string, indent: string, mode?: FoldMode, { indentAtStart, lineWidth, minContentWidth, onFold, onOverflow }?: FoldOptions): string;
+//#endregion
+//#region src/stringify/stringifyNumber.d.ts
+declare function stringifyNumber({ format, minFractionDigits, source, tag, value }: Scalar, version?: "1.1" | "1.2"): string;
+//#endregion
+//#region src/stringify/stringifyString.d.ts
+interface StringifyScalar {
+  value: string;
+  comment?: string | null;
+  type?: string;
+}
+declare function stringifyString(item: Scalar | StringifyScalar, ctx: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
+//#endregion
+//#region src/nodes/YAMLSet.d.ts
+declare class YAMLSet<T extends Primitive | Node = Primitive | Node> implements CollectionBase {
+  #private;
+  static readonly tagName = "tag:yaml.org,2002:set";
+  schema: Schema;
+  /** A fully qualified tag */
+  tag: string;
+  values: Map<unknown, NodeOf<T>>;
+  /** An optional anchor on this set. Used by alias nodes. */
+  anchor?: string;
+  /** If true, stringify this and all child nodes using flow rather than block styles.  */
+  flow?: boolean;
+  /** A comment on or immediately after this set. */
+  comment?: string | null;
+  /** A comment before this set. */
+  commentBefore?: string | null;
+  /**
+   * The `[start, value-end, node-end]` character offsets for
+   * the part of the source parsed into this set (undefined if not parsed).
+   * The `value-end` and `node-end` positions are themselves not included in their respective ranges.
+   */
+  range?: Range | null;
+  /** A blank line before this set and its commentBefore */
+  spaceBefore?: boolean;
+  /** The CST token that was composed into this set.  */
+  srcToken?: BlockMap | FlowCollection;
+  constructor(schema: Schema);
+  get size(): number;
+  add(value: T | NodeOf<T>, options?: Omit<CreateNodeOptions, "aliasDuplicateObjects">): this;
+  /**
+   * Create a copy of this set.
+   *
+   * @param schema - If defined, overwrites the original's schema
+   */
+  clone(schema?: Schema): this;
+  /**
+   * Remove `value` from the set.
+   * @returns `true` if the item was found and removed.
+   */
+  delete(value: T | NodeOf<T>): boolean;
+  /** Return the node matching `value`, if the set includes it.  */
+  get(value: T | NodeOf<T>): NodeOf<T> | undefined;
+  /** Check if the set includes `value`.  */
+  has(value: T | NodeOf<T>): boolean;
+  /**
+   * Return the internal Map key matching `value`, or `undefined` if not found.
+   *
+   * @param allowMissing - If `true`, a key is always returned,
+   *                       even if the value is not in the set.
+   */
+  keyOf(value: T | NodeOf<T>, allowMissing?: boolean): unknown;
+  /** A plain JavaScript representation of this set. */
+  toJS(doc: Document<DocValue, boolean>, ctx?: ToJSContext): Set<any>;
+  toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
+}
+//#endregion
+//#region src/nodes/types.d.ts
+type Collection = YAMLMap | YAMLSeq | YAMLSet;
+type Node = Scalar | Collection | Alias;
+type Primitive = boolean | number | bigint | string | null;
+type NodeOf<T> = T extends Primitive ? Scalar<T> : T;
+/** Utility type mapper */
+type NodeType<T> = T extends string | number | bigint | boolean | null | undefined ? Scalar<T> : T extends Date ? Scalar<string | Date> : T extends Array<any> ? YAMLSeq<NodeType<T[number]>> : T extends Set<any> ? YAMLSet<NodeType<keyof T>> : T extends {
+  [key: string | number]: any;
+} ? YAMLMap<NodeType<keyof T>, NodeType<T[keyof T]>> : Node;
+type Range = [start: number, valueEnd: number, nodeEnd: number];
+interface NodeBase {
+  /** A comment on or immediately after this */
+  comment?: string | null;
+  /** A comment before this */
+  commentBefore?: string | null;
+  /**
+   * The `[start, value-end, node-end]` character offsets for the part of the
+   * source parsed into this node (undefined if not parsed). The `value-end`
+   * and `node-end` positions are themselves not included in their respective
+   * ranges.
+   */
+  range?: Range | null;
+  /** A blank line before this node and its commentBefore */
+  spaceBefore?: boolean;
+  /** The CST token that was composed into this node.  */
+  srcToken?: Token;
+  /** A fully qualified tag, if required */
+  tag?: string;
+  /**
+   * Create a copy of this node.
+   *
+   * @param schema - If defined, overwrites the original's schema for cloned collections.
+   */
+  clone(schema?: Schema): this;
+  /** A plain JavaScript representation of this node. */
+  toJS(doc: Document<DocValue, boolean>, opt?: ToJSContext): any;
+  toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
+}
+interface CollectionBase extends NodeBase {
+  schema: Schema;
+  /** An optional anchor on this collection. Used by alias nodes. */
+  anchor?: string;
+  /** If true, stringify this and all child nodes using flow styles. */
+  flow?: boolean;
+  /** The number of items in this collection. */
+  readonly size: number;
+  /** Create a deep copy of this collection */
+  clone(schema?: Schema): this;
+}
+//#endregion
+//#region src/parse/cst-scalar.d.ts
+/**
+ * If `token` is a CST flow or block scalar, determine its string value and a few other attributes.
+ * Otherwise, return `null`.
+ */
+declare function resolveAsScalar(token: FlowScalar | BlockScalar, strict?: boolean, onError?: (offset: number, code: ErrorCode, message: string) => void): {
+  value: string;
+  type: Scalar.Type | null;
+  comment: string;
+  range: Range;
+};
+declare function resolveAsScalar(token: Token | null | undefined, strict?: boolean, onError?: (offset: number, code: ErrorCode, message: string) => void): {
+  value: string;
+  type: Scalar.Type | null;
+  comment: string;
+  range: Range;
+} | null;
+/**
+ * Create a new scalar token with `value`
+ *
+ * Values that represent an actual string but may be parsed as a different type should use a `type` other than `'PLAIN'`,
+ * as this function does not support any schema operations and won't check for such conflicts.
+ *
+ * @param value The string representation of the value, which will have its content properly indented.
+ * @param context.end Comments and whitespace after the end of the value, or after the block scalar header. If undefined, a newline will be added.
+ * @param context.implicitKey Being within an implicit key may affect the resolved type of the token's value.
+ * @param context.indent The indent level of the token.
+ * @param context.inFlow Is this scalar within a flow collection? This may affect the resolved type of the token's value.
+ * @param context.offset The offset position of the token.
+ * @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`.
+ */
+declare function createScalarToken(value: string, context: {
+  end?: SourceToken[];
+  implicitKey?: boolean;
+  indent: number;
+  inFlow?: boolean;
+  offset?: number;
+  type?: Scalar.Type;
+}): BlockScalar | FlowScalar;
+/**
+ * Set the value of `token` to the given string `value`, overwriting any previous contents and type that it may have.
+ *
+ * Best efforts are made to retain any comments previously associated with the `token`,
+ * though all contents within a collection's `items` will be overwritten.
+ *
+ * Values that represent an actual string but may be parsed as a different type should use a `type` other than `'PLAIN'`,
+ * as this function does not support any schema operations and won't check for such conflicts.
+ *
+ * @param token Any token. If it does not include an `indent` value, the value will be stringified as if it were an implicit key.
+ * @param value The string representation of the value, which will have its content properly indented.
+ * @param context.afterKey In most cases, values after a key should have an additional level of indentation.
+ * @param context.implicitKey Being within an implicit key may affect the resolved type of the token's value.
+ * @param context.inFlow Being within a flow collection may affect the resolved type of the token's value.
+ * @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`.
+ */
+declare function setScalarValue(token: Token, value: string, context?: {
+  afterKey?: boolean;
+  implicitKey?: boolean;
+  inFlow?: boolean;
+  type?: Scalar.Type;
+}): void;
+//#endregion
+//#region src/parse/cst-stringify.d.ts
+/**
+ * Stringify a CST document, token, or collection item
+ *
+ * Fair warning: This applies no validation whatsoever, and
+ * simply concatenates the sources in their logical order.
+ */
+declare const stringify: (cst: Token | CollectionItem) => string;
+//#endregion
+//#region src/parse/cst-visit.d.ts
+type VisitPath = readonly ["key" | "value", number][];
+type Visitor = (item: CollectionItem, path: VisitPath) => number | symbol | Visitor | void;
+/**
+ * Apply a visitor to a CST document or item.
+ *
+ * Walks through the tree (depth-first) starting from the root, calling a
+ * `visitor` function with two arguments when entering each item:
+ *   - `item`: The current item, which included the following members:
+ *     - `start: SourceToken[]` – Source tokens before the key or value,
+ *       possibly including its anchor or tag.
+ *     - `key?: Token | null` – Set for pair values. May then be `null`, if
+ *       the key before the `:` separator is empty.
+ *     - `sep?: SourceToken[]` – Source tokens between the key and the value,
+ *       which should include the `:` map value indicator if `value` is set.
+ *     - `value?: Token` – The value of a sequence item, or of a map pair.
+ *   - `path`: The steps from the root to the current node, as an array of
+ *     `['key' | 'value', number]` tuples.
+ *
+ * The return value of the visitor may be used to control the traversal:
+ *   - `undefined` (default): Do nothing and continue
+ *   - `visit.SKIP`: Do not visit the children of this token, continue with
+ *      next sibling
+ *   - `visit.BREAK`: Terminate traversal completely
+ *   - `visit.REMOVE`: Remove the current item, then continue with the next one
+ *   - `number`: Set the index of the next step. This is useful especially if
+ *     the index of the current token has changed.
+ *   - `function`: Define the next visitor for this item. After the original
+ *     visitor is called on item entry, next visitors are called after handling
+ *     a non-empty `key` and when exiting the item.
+ */
+declare const visit: {
+  (cst: Document$1 | CollectionItem, visitor: Visitor): void;
+  /** Terminate visit traversal completely */
+  BREAK: symbol;
+  /** Do not visit the children of the current item */
+  SKIP: symbol;
+  /** Remove the current item */
+  REMOVE: symbol;
+  /** Find the item at `path` from `cst` as the root */
+  itemAtPath(cst: Document$1 | CollectionItem, path: VisitPath): CollectionItem | undefined;
+  /**
+   * Get the immediate parent collection of the item at `path` from `cst` as the root.
+   *
+   * Throws an error if the collection is not found, which should never happen if the item itself exists.
+   */
+  parentCollection(cst: Document$1 | CollectionItem, path: VisitPath): BlockMap | BlockSequence | FlowCollection;
+};
+declare namespace cst_d_exports {
+  export { BOM, BlockMap, BlockScalar, BlockSequence, CollectionItem, DOCUMENT, Directive, Document$1 as Document, DocumentEnd, ErrorToken, FLOW_END, FlowCollection, FlowScalar, SCALAR, SourceToken, Token, TokenType, VisitPath, Visitor, createScalarToken, isCollection, isScalar, prettyToken, resolveAsScalar, setScalarValue, stringify, tokenType, visit };
+}
+interface SourceToken {
+  type: "byte-order-mark" | "doc-mode" | "doc-start" | "space" | "comment" | "newline" | "directive-line" | "anchor" | "tag" | "seq-item-ind" | "explicit-key-ind" | "map-value-ind" | "flow-map-start" | "flow-map-end" | "flow-seq-start" | "flow-seq-end" | "flow-error-end" | "comma" | "block-scalar-header";
+  offset: number;
+  indent: number;
+  source: string;
+}
+interface ErrorToken {
+  type: "error";
+  offset: number;
+  source: string;
+  message: string;
+}
+interface Directive {
+  type: "directive";
+  offset: number;
+  source: string;
+}
+interface Document$1 {
+  type: "document";
+  offset: number;
+  start: SourceToken[];
+  value?: Token;
+  end?: SourceToken[];
+}
+interface DocumentEnd {
+  type: "doc-end";
+  offset: number;
+  source: string;
+  end?: SourceToken[];
+}
+interface FlowScalar {
+  type: "alias" | "scalar" | "single-quoted-scalar" | "double-quoted-scalar";
+  offset: number;
+  indent: number;
+  source: string;
+  end?: SourceToken[];
+}
+interface BlockScalar {
+  type: "block-scalar";
+  offset: number;
+  indent: number;
+  props: Token[];
+  source: string;
+}
+interface BlockMap {
+  type: "block-map";
+  offset: number;
+  indent: number;
+  items: Array<{
+    start: SourceToken[];
+    explicitKey?: true;
+    key?: never;
+    sep?: never;
+    value?: never;
+  } | {
+    start: SourceToken[];
+    explicitKey?: true;
+    key: Token | null;
+    sep: SourceToken[];
+    value?: Token;
+  }>;
+}
+interface BlockSequence {
+  type: "block-seq";
+  offset: number;
+  indent: number;
+  items: Array<{
+    start: SourceToken[];
+    key?: never;
+    sep?: never;
+    value?: Token;
+  }>;
+}
+type CollectionItem = {
+  start: SourceToken[];
+  key?: Token | null;
+  sep?: SourceToken[];
+  value?: Token;
+};
+interface FlowCollection {
+  type: "flow-collection";
+  offset: number;
+  indent: number;
+  start: SourceToken;
+  items: CollectionItem[];
+  end: SourceToken[];
+}
+type Token = SourceToken | ErrorToken | Directive | Document$1 | DocumentEnd | FlowScalar | BlockScalar | BlockMap | BlockSequence | FlowCollection;
+type TokenType = SourceToken["type"] | DocumentEnd["type"] | FlowScalar["type"];
+/** The byte order mark */
+declare const BOM = "";
+/** Start of doc-mode */
+declare const DOCUMENT = "";
+/** Unexpected end of flow-mode */
+declare const FLOW_END = "";
+/** Next token is a scalar value */
+declare const SCALAR = "";
+/** @returns `true` if `token` is a flow or block collection */
+declare const isCollection: (token: Token | null | undefined) => token is BlockMap | BlockSequence | FlowCollection;
+/** @returns `true` if `token` is a flow or block scalar; not an alias */
+declare const isScalar: (token: Token | null | undefined) => token is FlowScalar | BlockScalar;
+/** Get a printable representation of a lexer token */
+declare function prettyToken(token: string): string;
+/** Identify the type of a lexer token. May return `null` for unknown tokens. */
+declare function tokenType(source: string): TokenType | null;
+//#endregion
+//#region src/nodes/Alias.d.ts
+declare class Alias implements NodeBase {
+  source: string;
+  anchor?: never;
+  /** A comment on or immediately after this node. */
+  comment?: string | null;
+  /** A comment before this node. */
+  commentBefore?: string | null;
+  /**
+   * The `[start, value-end, node-end]` character offsets for
+   * the part of the source parsed into this node (undefined if not parsed).
+   * The `value-end` and `node-end` positions are themselves not included in their respective ranges.
+   */
+  range?: Range | null;
+  /** A blank line before this node and its commentBefore */
+  spaceBefore?: boolean;
+  /** The CST token that was composed into this node.  */
+  srcToken?: FlowScalar & {
+    type: "alias";
+  };
+  tag?: never;
+  constructor(source: string);
+  /** Create a copy of this node.  */
+  clone(): this;
+  /**
+   * Resolve the value of this alias within `doc`, finding the last
+   * instance of the `source` anchor before this node.
+   */
+  resolve(doc: Document, ctx?: ToJSContext): Scalar | YAMLMap | YAMLSeq | YAMLSet | undefined;
+  /** A plain JavaScript representation of the resolved value of this alias. */
+  toJS(doc: Document<DocValue, boolean>, ctx?: ToJSContext): any;
+  toString(ctx?: StringifyContext, _onComment?: () => void, _onChompKeep?: () => void): string;
+}
+//#endregion
+//#region src/doc/Document.d.ts
+type DocValue = Scalar | YAMLSeq | YAMLMap | YAMLSet;
+type Replacer = any[] | ((key: any, value: any) => unknown);
+declare namespace Document {
+  /** @ts-ignore The typing of directives fails in TS <= 4.2 */
+  interface Parsed<Value extends DocValue = DocValue, Strict extends boolean = true> extends Document<Value, Strict> {
+    directives: Directives;
+    range: Range;
+  }
+}
+declare class Document<Value extends DocValue = DocValue, Strict extends boolean = true> {
+  /** A comment before this Document */
+  commentBefore: string | null;
+  /** A comment immediately after this Document */
+  comment: string | null;
+  /** The document value. */
+  value: Value;
+  directives: Strict extends true ? Directives | undefined : Directives;
+  /** Errors encountered during parsing. */
+  errors: YAMLError[];
+  options: Required<Omit<ParseOptions & DocumentOptions, "_directives" | "lineCounter" | "version">>;
+  /**
+   * The `[start, value-end, node-end]` character offsets for the part of the
+   * source parsed into this document (undefined if not parsed). The `value-end`
+   * and `node-end` positions are themselves not included in their respective
+   * ranges.
+   */
+  range?: Range;
+  /** The schema used with the document. Use `setSchema()` to change. */
+  schema: Schema;
+  /** Warnings encountered during parsing. */
+  warnings: YAMLWarning[];
+  /**
+   * @param value - The initial value for the document, which will be wrapped
+   *   in a Node container.
+   */
+  constructor(value?: any, options?: DocumentOptions & SchemaOptions & ParseOptions & CreateNodeOptions);
+  constructor(value: any, replacer: null | Replacer, options?: DocumentOptions & SchemaOptions & ParseOptions & CreateNodeOptions);
+  /**
+   * Create a deep copy of this Document and its value.
+   *
+   * Custom Node values that inherit from `Object` still refer to their original instances.
+   */
+  clone(): Document<Value, Strict>;
+  /**
+   * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
+   *
+   * If `node` already has an anchor, `name` is ignored.
+   * Otherwise, the `node.anchor` value will be set to `name`,
+   * or if an anchor with that name is already present in the document,
+   * `name` will be used as a prefix for a new unique anchor.
+   * If `name` is undefined, the generated anchor will use 'a' as a prefix.
+   */
+  createAlias(node: Strict extends true ? DocValue : Node, name?: string): Alias;
+  /**
+   * Convert any value into a `Node` using the current schema, recursively
+   * turning objects into collections.
+   */
+  createNode<T = unknown>(value: T, options?: CreateNodeOptions): NodeType<T>;
+  createNode<T = unknown>(value: T, replacer: Replacer | CreateNodeOptions | null, options?: CreateNodeOptions): NodeType<T>;
+  /**
+   * Convert a key and a value into a `Pair` using the current schema,
+   * recursively wrapping all values as `Scalar` or `Collection` nodes.
+   */
+  createPair<K = unknown, V = unknown>(key: K, value: V, options?: CreateNodeOptions): Pair<K extends Primitive | Node ? K : Node, V extends Primitive | Node ? V : Node>;
+  /**
+   * Returns item at `key`, or `undefined` if not found.
+   */
+  get(key: any): Strict extends true ? Node | Pair | null | undefined : any;
+  /**
+   * Returns pair at `key`, or `undefined` if not found.
+   */
+  getPair(key: any): Strict extends true ? Pair | undefined : any;
+  /**
+   * Sets a value in this document's top-level collection. For `!!set`, `value` is ignored.
+   */
+  set(key: any, value: any): void;
+  /**
+   * Change the YAML version and schema used by the document.
+   * A `null` version disables support for directives, explicit tags, anchors, and aliases.
+   * It also requires the `schema` option to be given as a `Schema` instance value.
+   *
+   * Overrides all previously set schema options.
+   */
+  setSchema(version: "1.1" | "1.2" | "next" | null, options?: SchemaOptions): void;
+  /** A plain JavaScript representation of the document `value`. */
+  toJS(opt?: ToJSOptions): any;
+  /** A JSON representation of the document `value`.  */
+  toJSON(): any;
+  /** A YAML representation of the document. */
+  toString(options?: ToStringOptions): string;
+}
+//#endregion
+//#region src/doc/directives.d.ts
+declare class Directives {
+  static defaultYaml: Directives["yaml"];
+  static defaultTags: Directives["tags"];
+  yaml: {
+    version: "1.1" | "1.2" | "next";
+    explicit?: boolean;
+  };
+  tags: Record<string, string>;
+  /**
+   * The directives-end/doc-start marker `---`. If `null`, a marker may still be
+   * included in the document's stringified representation.
+   */
+  docStart: true | null;
+  /** The doc-end marker `...`.  */
+  docEnd: boolean;
+  /**
+   * Used when parsing YAML 1.1, where:
+   * > If the document specifies no directives, it is parsed using the same
+   * > settings as the previous document. If the document does specify any
+   * > directives, all directives of previous documents, if any, are ignored.
+   */
+  private atNextDocument?;
+  constructor(yaml?: Directives["yaml"], tags?: Directives["tags"]);
+  clone(): Directives;
+  /**
+   * During parsing, get a Directives instance for the current document and
+   * update the stream state according to the current version's spec.
+   */
+  atDocument(): Directives;
+  /**
+   * @param onError - May be called even if the action was successful
+   * @returns `true` on success
+   */
+  add(line: string, onError: (offset: number, message: string, warning?: boolean) => void): boolean;
+  /**
+   * Resolves a tag, matching handles to those defined in %TAG directives.
+   *
+   * @returns Resolved tag, which may also be the non-specific tag `'!'` or a
+   *   `'!local'` tag, or `null` if unresolvable.
+   */
+  tagName(source: string, onError: (message: string) => void): string | null;
+  /**
+   * Given a fully resolved tag, returns its printable string form,
+   * taking into account current tag prefixes and defaults.
+   */
+  tagString(tag: string): string;
+  toString(doc?: Document): string;
+}
+//#endregion
+export { CollectionTag as A, debug as B, DocumentOptions as C, ToStringOptions as D, ToJSOptions as E, Scalar as F, YAMLParseError as G, Reviver as H, NodeCreator as I, YAMLWarning as K, ToJSContext as L, Pair as M, KeyArg as N, TagId as O, YAMLMap as P, StringifyContext as R, CreateNodeOptions as S, SchemaOptions as T, ErrorCode as U, warn as V, YAMLError as W, string as _, Alias as a, map as b, Node as c, Range as d, YAMLSet as f, foldFlowLines as g, FoldOptions as h, Replacer as i, ScalarTag as j, Tags as k, NodeBase as l, stringifyNumber as m, DocValue as n, Token as o, stringifyString as p, LineCounter as q, Document as r, cst_d_exports as s, Directives as t, Primitive as u, seq as v, ParseOptions as w, Schema as x, YAMLSeq as y, LogLevelId as z };