cdk8s 2.7.61 → 2.7.63

package/node_modules/yaml/dist/nodes/Collection.js

@@ -13,25 +13,21 @@ function collectionFromPath(schema, path, value) {
             v = a;
         }
         else {
-            const o = {};
-            Object.defineProperty(o, typeof k === 'symbol' ? k : String(k), {
-                value: v,
-                writable: true,
-                enumerable: true,
-                configurable: true
-            });
-            v = o;
+            v = new Map([[k, v]]);
         }
     }
     return createNode.createNode(v, undefined, {
-        onAnchor() {
-            throw new Error('Repeated objects are not supported here');
+        aliasDuplicateObjects: false,
+        keepUndefined: false,
+        onAnchor: () => {
+            throw new Error('This should not happen, please report a bug.');
         },
         schema,
         sourceObjects: new Map()
     });
 }
-// null, undefined, or an empty non-string iterable (e.g. [])
+// Type guard is intentionally a little wrong so as to be more useful,
+// as it does not cover untypable empty non-string iterables (e.g. []).
 const isEmptyPath = (path) => path == null ||
     (typeof path === 'object' && !!path[Symbol.iterator]().next().done);
 class Collection extends Node.NodeBase {
@@ -44,6 +40,20 @@ class Collection extends Node.NodeBase {
             writable: true
         });
     }
+    /**
+     * Create a copy of this collection.
+     *
+     * @param schema - If defined, overwrites the original's schema
+     */
+    clone(schema) {
+        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+        if (schema)
+            copy.schema = schema;
+        copy.items = copy.items.map(it => Node.isNode(it) || Node.isPair(it) ? it.clone(schema) : it);
+        if (this.range)
+            copy.range = this.range.slice();
+        return copy;
+    }
     /**
      * Adds a value to the collection. For `!!map` and `!!omap` the value must
      * be a Pair instance or a `{ key, value }` object, which may not have a key
@@ -67,7 +77,8 @@ class Collection extends Node.NodeBase {
      * Removes a value from the collection.
      * @returns `true` if the item was found and removed.
      */
-    deleteIn([key, ...rest]) {
+    deleteIn(path) {
+        const [key, ...rest] = path;
         if (rest.length === 0)
             return this.delete(key);
         const node = this.get(key, true);
@@ -81,7 +92,8 @@ class Collection extends Node.NodeBase {
      * scalar values from their surrounding node; to disable set `keepScalar` to
      * `true` (collections are always returned intact).
      */
-    getIn([key, ...rest], keepScalar) {
+    getIn(path, keepScalar) {
+        const [key, ...rest] = path;
         const node = this.get(key, true);
         if (rest.length === 0)
             return !keepScalar && Node.isScalar(node) ? node.value : node;
@@ -105,7 +117,8 @@ class Collection extends Node.NodeBase {
     /**
      * Checks if the collection includes a value with the key `key`.
      */
-    hasIn([key, ...rest]) {
+    hasIn(path) {
+        const [key, ...rest] = path;
         if (rest.length === 0)
             return this.has(key);
         const node = this.get(key, true);
@@ -115,7 +128,8 @@ class Collection extends Node.NodeBase {
      * Sets a value in this collection. For `!!set`, `value` needs to be a
      * boolean to add/remove the item from the set.
      */
-    setIn([key, ...rest], value) {
+    setIn(path, value) {
+        const [key, ...rest] = path;
         if (rest.length === 0) {
             this.set(key, value);
         }

package/node_modules/yaml/dist/nodes/Node.d.ts

@@ -1,13 +1,20 @@
 import type { Document } from '../doc/Document.js';
+import { Token } from '../parse/cst.js';
 import type { StringifyContext } from '../stringify/stringify.js';
 import type { Alias } from './Alias.js';
 import type { Pair } from './Pair.js';
 import type { Scalar } from './Scalar.js';
 import type { YAMLMap } from './YAMLMap.js';
 import type { YAMLSeq } from './YAMLSeq.js';
-export declare type Node = Alias | Scalar | YAMLMap | YAMLSeq;
-export declare type ParsedNode = Alias.Parsed | Scalar.Parsed | YAMLMap.Parsed | YAMLSeq.Parsed;
-export declare type Range = [number, number, number];
+export type Node<T = unknown> = Alias | Scalar<T> | YAMLMap<unknown, T> | YAMLSeq<T>;
+/** Utility type mapper */
+export type NodeType<T> = T extends string | number | bigint | boolean | null ? Scalar<T> : T extends Array<any> ? YAMLSeq<NodeType<T[number]>> : T extends {
+    [key: string]: any;
+} ? YAMLMap<NodeType<keyof T>, NodeType<T[keyof T]>> : T extends {
+    [key: number]: any;
+} ? YAMLMap<NodeType<keyof T>, NodeType<T[keyof T]>> : Node;
+export type ParsedNode = Alias.Parsed | Scalar.Parsed | YAMLMap.Parsed | YAMLSeq.Parsed;
+export type Range = [number, number, number];
 export declare const ALIAS: unique symbol;
 export declare const DOC: unique symbol;
 export declare const MAP: unique symbol;
@@ -16,14 +23,14 @@ export declare const SCALAR: unique symbol;
 export declare const SEQ: unique symbol;
 export declare const NODE_TYPE: unique symbol;
 export declare const isAlias: (node: any) => node is Alias;
-export declare const isDocument: (node: any) => node is Document<unknown>;
-export declare const isMap: (node: any) => node is YAMLMap<unknown, unknown>;
-export declare const isPair: (node: any) => node is Pair<unknown, unknown>;
-export declare const isScalar: (node: any) => node is Scalar<unknown>;
-export declare const isSeq: (node: any) => node is YAMLSeq<unknown>;
-export declare function isCollection(node: any): node is YAMLMap | YAMLSeq;
-export declare function isNode(node: any): node is Node;
-export declare const hasAnchor: (node: unknown) => node is YAMLMap<unknown, unknown> | YAMLSeq<unknown> | Scalar<unknown>;
+export declare const isDocument: <T extends Node<unknown> = Node<unknown>>(node: any) => node is Document<T>;
+export declare const isMap: <K = unknown, V = unknown>(node: any) => node is YAMLMap<K, V>;
+export declare const isPair: <K = unknown, V = unknown>(node: any) => node is Pair<K, V>;
+export declare const isScalar: <T = unknown>(node: any) => node is Scalar<T>;
+export declare const isSeq: <T = unknown>(node: any) => node is YAMLSeq<T>;
+export declare function isCollection<K = unknown, V = unknown>(node: any): node is YAMLMap<K, V> | YAMLSeq<V>;
+export declare function isNode<T = unknown>(node: any): node is Node<T>;
+export declare const hasAnchor: <K = unknown, V = unknown>(node: unknown) => node is Scalar<V> | YAMLMap<K, V> | YAMLSeq<V>;
 export declare abstract class NodeBase {
     readonly [NODE_TYPE]: symbol;
     /** A comment on or immediately after this */
@@ -39,10 +46,14 @@ export declare abstract class NodeBase {
     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;
     /** A plain JS representation of this node */
     abstract toJSON(): any;
     abstract toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
     constructor(type: symbol);
+    /** Create a copy of this node.  */
+    clone(): NodeBase;
 }

package/node_modules/yaml/dist/nodes/Node.js

@@ -38,6 +38,13 @@ class NodeBase {
     constructor(type) {
         Object.defineProperty(this, NODE_TYPE, { value: type });
     }
+    /** Create a copy of this node.  */
+    clone() {
+        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+        if (this.range)
+            copy.range = this.range.slice();
+        return copy;
+    }
 }
 
 exports.ALIAS = ALIAS;

package/node_modules/yaml/dist/nodes/Pair.d.ts

@@ -1,16 +1,21 @@
 import { CreateNodeContext } from '../doc/createNode.js';
-import { StringifyContext } from '../stringify/stringify.js';
+import type { CollectionItem } from '../parse/cst.js';
+import type { Schema } from '../schema/Schema.js';
+import type { StringifyContext } from '../stringify/stringify.js';
 import { addPairToJSMap } from './addPairToJSMap.js';
 import { NODE_TYPE } from './Node.js';
-import { ToJSContext } from './toJS.js';
-export declare function createPair(key: unknown, value: unknown, ctx: CreateNodeContext): Pair<import("./Node.js").Node, import("./Alias.js").Alias | import("./Scalar.js").Scalar<unknown> | import("./YAMLMap.js").YAMLMap<unknown, unknown> | import("./YAMLSeq.js").YAMLSeq<unknown>>;
+import type { ToJSContext } from './toJS.js';
+export declare function createPair(key: unknown, value: unknown, ctx: CreateNodeContext): Pair<import("./Node.js").Node<unknown>, import("./Alias.js").Alias | import("./Scalar.js").Scalar<unknown> | import("./YAMLMap.js").YAMLMap<unknown, unknown> | import("./YAMLSeq.js").YAMLSeq<unknown>>;
 export declare class Pair<K = unknown, V = unknown> {
     readonly [NODE_TYPE]: symbol;
     /** Always Node or null when parsed, but can be set to anything. */
     key: K;
     /** Always Node or null when parsed, but can be set to anything. */
     value: V | null;
+    /** The CST token that was composed into this pair.  */
+    srcToken?: CollectionItem;
     constructor(key: K, value?: V | null);
+    clone(schema?: Schema): Pair<K, V>;
     toJSON(_?: unknown, ctx?: ToJSContext): ReturnType<typeof addPairToJSMap>;
     toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
 }

package/node_modules/yaml/dist/nodes/Pair.js

@@ -16,12 +16,20 @@ class Pair {
         this.key = key;
         this.value = value;
     }
+    clone(schema) {
+        let { key, value } = this;
+        if (Node.isNode(key))
+            key = key.clone(schema);
+        if (Node.isNode(value))
+            value = value.clone(schema);
+        return new Pair(key, value);
+    }
     toJSON(_, ctx) {
-        const pair = ctx && ctx.mapAsMap ? new Map() : {};
+        const pair = ctx?.mapAsMap ? new Map() : {};
         return addPairToJSMap.addPairToJSMap(ctx, pair, this);
     }
     toString(ctx, onComment, onChompKeep) {
-        return ctx && ctx.doc
+        return ctx?.doc
             ? stringifyPair.stringifyPair(this, ctx, onComment, onChompKeep)
             : JSON.stringify(this);
     }

package/node_modules/yaml/dist/nodes/Scalar.d.ts

@@ -1,3 +1,4 @@
+import type { BlockScalar, FlowScalar } from '../parse/cst.js';
 import { NodeBase, Range } from './Node.js';
 import { ToJSContext } from './toJS.js';
 export declare const isScalarValue: (value: unknown) => boolean;
@@ -5,6 +6,7 @@ export declare namespace Scalar {
     interface Parsed extends Scalar {
         range: Range;
         source: string;
+        srcToken?: FlowScalar | BlockScalar;
     }
     type BLOCK_FOLDED = 'BLOCK_FOLDED';
     type BLOCK_LITERAL = 'BLOCK_LITERAL';

package/node_modules/yaml/dist/nodes/Scalar.js

@@ -10,7 +10,7 @@ class Scalar extends Node.NodeBase {
         this.value = value;
     }
     toJSON(arg, ctx) {
-        return ctx && ctx.keep ? this.value : toJS.toJS(this.value, arg, ctx);
+        return ctx?.keep ? this.value : toJS.toJS(this.value, arg, ctx);
     }
     toString() {
         return String(this.value);

package/node_modules/yaml/dist/nodes/YAMLMap.d.ts

@@ -1,14 +1,18 @@
+import type { BlockMap, FlowCollection } from '../parse/cst.js';
 import type { Schema } from '../schema/Schema.js';
 import type { StringifyContext } from '../stringify/stringify.js';
 import { Collection } from './Collection.js';
 import { ParsedNode, Range } from './Node.js';
 import { Pair } from './Pair.js';
+import { Scalar } from './Scalar.js';
 import type { ToJSContext } from './toJS.js';
+export type MapLike = Map<unknown, unknown> | Set<unknown> | Record<string | number | symbol, unknown>;
 export declare function findPair<K = unknown, V = unknown>(items: Iterable<Pair<K, V>>, key: unknown): Pair<K, V> | undefined;
 export declare namespace YAMLMap {
     interface Parsed<K extends ParsedNode = ParsedNode, V extends ParsedNode | null = ParsedNode | null> extends YAMLMap<K, V> {
         items: Pair<K, V>[];
         range: Range;
+        srcToken?: BlockMap | FlowCollection;
     }
 }
 export declare class YAMLMap<K = unknown, V = unknown> extends Collection {
@@ -25,15 +29,19 @@ export declare class YAMLMap<K = unknown, V = unknown> extends Collection {
         key: K;
         value: V;
     }, overwrite?: boolean): void;
-    delete(key: K): boolean;
-    get(key: K, keepScalar?: boolean): unknown;
-    has(key: K): boolean;
+    delete(key: unknown): boolean;
+    get(key: unknown, keepScalar: true): Scalar<V> | undefined;
+    get(key: unknown, keepScalar?: false): V | undefined;
+    get(key: unknown, keepScalar?: boolean): V | Scalar<V> | undefined;
+    has(key: unknown): boolean;
     set(key: K, value: V): void;
     /**
      * @param ctx - Conversion context, originally set in Document#toJS()
      * @param {Class} Type - If set, forces the returned collection type
      * @returns Instance of Type, Map, or Object
      */
-    toJSON(_?: unknown, ctx?: ToJSContext, Type?: any): any;
+    toJSON<T extends MapLike = Map<unknown, unknown>>(_?: unknown, ctx?: ToJSContext, Type?: {
+        new (): T;
+    }): any;
     toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
 }

package/node_modules/yaml/dist/nodes/YAMLMap.js

@@ -20,13 +20,13 @@ function findPair(items, key) {
     return undefined;
 }
 class YAMLMap extends Collection.Collection {
+    static get tagName() {
+        return 'tag:yaml.org,2002:map';
+    }
     constructor(schema) {
         super(Node.MAP, schema);
         this.items = [];
     }
-    static get tagName() {
-        return 'tag:yaml.org,2002:map';
-    }
     /**
      * Adds a value to the collection.
      *
@@ -39,12 +39,12 @@ class YAMLMap extends Collection.Collection {
             _pair = pair;
         else if (!pair || typeof pair !== 'object' || !('key' in pair)) {
             // In TypeScript, this never happens.
-            _pair = new Pair.Pair(pair, pair.value);
+            _pair = new Pair.Pair(pair, pair?.value);
         }
         else
             _pair = new Pair.Pair(pair.key, pair.value);
         const prev = findPair(this.items, _pair.key);
-        const sortEntries = this.schema && this.schema.sortMapEntries;
+        const sortEntries = this.schema?.sortMapEntries;
         if (prev) {
             if (!overwrite)
                 throw new Error(`Key ${_pair.key} already set`);
@@ -74,8 +74,8 @@ class YAMLMap extends Collection.Collection {
     }
     get(key, keepScalar) {
         const it = findPair(this.items, key);
-        const node = it && it.value;
-        return !keepScalar && Node.isScalar(node) ? node.value : node;
+        const node = it?.value;
+        return (!keepScalar && Node.isScalar(node) ? node.value : node) ?? undefined;
     }
     has(key) {
         return !!findPair(this.items, key);
@@ -89,8 +89,8 @@ class YAMLMap extends Collection.Collection {
      * @returns Instance of Type, Map, or Object
      */
     toJSON(_, ctx, Type) {
-        const map = Type ? new Type() : ctx && ctx.mapAsMap ? new Map() : {};
-        if (ctx && ctx.onCreate)
+        const map = Type ? new Type() : ctx?.mapAsMap ? new Map() : {};
+        if (ctx?.onCreate)
             ctx.onCreate(map);
         for (const item of this.items)
             addPairToJSMap.addPairToJSMap(ctx, map, item);
@@ -106,7 +106,7 @@ class YAMLMap extends Collection.Collection {
         if (!ctx.allNullValues && this.hasAllNullValues(false))
             ctx = Object.assign({}, ctx, { allNullValues: true });
         return stringifyCollection.stringifyCollection(this, ctx, {
-            blockItem: n => n.str,
+            blockItemPrefix: '',
             flowChars: { start: '{', end: '}' },
             itemIndent: ctx.indent || '',
             onChompKeep,

package/node_modules/yaml/dist/nodes/YAMLSeq.d.ts

@@ -1,13 +1,16 @@
+import type { BlockSequence, FlowCollection } from '../parse/cst.js';
 import type { Schema } from '../schema/Schema.js';
 import type { StringifyContext } from '../stringify/stringify.js';
 import { Collection } from './Collection.js';
 import { ParsedNode, Range } from './Node.js';
 import type { Pair } from './Pair.js';
+import { Scalar } from './Scalar.js';
 import { ToJSContext } from './toJS.js';
 export declare namespace YAMLSeq {
     interface Parsed<T extends ParsedNode | Pair<ParsedNode, ParsedNode | null> = ParsedNode> extends YAMLSeq<T> {
         items: T[];
         range: Range;
+        srcToken?: BlockSequence | FlowCollection;
     }
 }
 export declare class YAMLSeq<T = unknown> extends Collection {
@@ -32,7 +35,9 @@ export declare class YAMLSeq<T = unknown> extends Collection {
      * `key` must contain a representation of an integer for this to succeed.
      * It may be wrapped in a `Scalar`.
      */
-    get(key: unknown, keepScalar?: boolean): unknown;
+    get(key: unknown, keepScalar: true): Scalar<T> | undefined;
+    get(key: unknown, keepScalar?: false): T | undefined;
+    get(key: unknown, keepScalar?: boolean): T | Scalar<T> | undefined;
     /**
      * Checks if the collection includes a value with the key `key`.
      *

package/node_modules/yaml/dist/nodes/YAMLSeq.js

@@ -7,13 +7,13 @@ var Scalar = require('./Scalar.js');
 var toJS = require('./toJS.js');
 
 class YAMLSeq extends Collection.Collection {
+    static get tagName() {
+        return 'tag:yaml.org,2002:seq';
+    }
     constructor(schema) {
         super(Node.SEQ, schema);
         this.items = [];
     }
-    static get tagName() {
-        return 'tag:yaml.org,2002:seq';
-    }
     add(value) {
         this.items.push(value);
     }
@@ -32,14 +32,6 @@ class YAMLSeq extends Collection.Collection {
         const del = this.items.splice(idx, 1);
         return del.length > 0;
     }
-    /**
-     * Returns item at `key`, or `undefined` if not found. By default unwraps
-     * scalar values from their surrounding node; to disable set `keepScalar` to
-     * `true` (collections are always returned intact).
-     *
-     * `key` must contain a representation of an integer for this to succeed.
-     * It may be wrapped in a `Scalar`.
-     */
     get(key, keepScalar) {
         const idx = asItemIndex(key);
         if (typeof idx !== 'number')
@@ -76,7 +68,7 @@ class YAMLSeq extends Collection.Collection {
     }
     toJSON(_, ctx) {
         const seq = [];
-        if (ctx && ctx.onCreate)
+        if (ctx?.onCreate)
             ctx.onCreate(seq);
         let i = 0;
         for (const item of this.items)
@@ -87,7 +79,7 @@ class YAMLSeq extends Collection.Collection {
         if (!ctx)
             return JSON.stringify(this);
         return stringifyCollection.stringifyCollection(this, ctx, {
-            blockItem: n => (n.comment ? n.str : `- ${n.str}`),
+            blockItemPrefix: '- ',
             flowChars: { start: '[', end: ']' },
             itemIndent: (ctx.indent || '') + '  ',
             onChompKeep,

package/node_modules/yaml/dist/nodes/addPairToJSMap.d.ts

@@ -1,3 +1,4 @@
 import type { Pair } from './Pair.js';
 import { ToJSContext } from './toJS.js';
-export declare function addPairToJSMap(ctx: ToJSContext | undefined, map: Map<unknown, unknown> | Set<unknown> | Record<string | number | symbol, unknown>, { key, value }: Pair): Map<unknown, unknown> | Set<unknown> | Record<string | number | symbol, unknown>;
+import type { MapLike } from './YAMLMap.js';
+export declare function addPairToJSMap(ctx: ToJSContext | undefined, map: MapLike, { key, value }: Pair): MapLike;

package/node_modules/yaml/dist/nodes/addPairToJSMap.js

@@ -8,7 +8,8 @@ var toJS = require('./toJS.js');
 
 const MERGE_KEY = '<<';
 function addPairToJSMap(ctx, map, { key, value }) {
-    if (ctx && ctx.doc.schema.merge && isMergeKey(key)) {
+    if (ctx?.doc.schema.merge && isMergeKey(key)) {
+        value = Node.isAlias(value) ? value.resolve(ctx.doc) : value;
         if (Node.isSeq(value))
             for (const it of value.items)
                 mergeToJSMap(ctx, map, it);

package/node_modules/yaml/dist/nodes/toJS.js

@@ -13,9 +13,11 @@ var Node = require('./Node.js');
  *   stringification.
  */
 function toJS(value, arg, ctx) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     if (Array.isArray(value))
         return value.map((v, i) => toJS(v, String(i), ctx));
     if (value && typeof value.toJSON === 'function') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
         if (!ctx || !Node.hasAnchor(value))
             return value.toJSON(arg, ctx);
         const data = { aliasCount: 0, count: 1, res: undefined };
@@ -29,7 +31,7 @@ function toJS(value, arg, ctx) {
             ctx.onCreate(res);
         return res;
     }
-    if (typeof value === 'bigint' && !(ctx && ctx.keep))
+    if (typeof value === 'bigint' && !ctx?.keep)
         return Number(value);
     return value;
 }

package/node_modules/yaml/dist/options.d.ts

@@ -5,10 +5,10 @@ import type { ParsedNode } from './nodes/Node.js';
 import type { Pair } from './nodes/Pair.js';
 import type { Scalar } from './nodes/Scalar.js';
 import type { LineCounter } from './parse/line-counter.js';
-import type { SchemaName } from './schema/Schema.js';
+import type { Schema } from './schema/Schema.js';
 import type { Tags } from './schema/tags.js';
 import type { CollectionTag, ScalarTag } from './schema/types.js';
-export declare type ParseOptions = {
+export type ParseOptions = {
     /**
      * Whether integers should be parsed into BigInt rather than number values.
      *
@@ -17,6 +17,13 @@ export declare type ParseOptions = {
      * 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.
@@ -49,12 +56,13 @@ export declare type ParseOptions = {
      */
     uniqueKeys?: boolean | ((a: ParsedNode, b: ParsedNode) => boolean);
 };
-export declare type DocumentOptions = {
+export type DocumentOptions = {
     /**
+     * @internal
      * Used internally by Composer. If set and includes an explicit version,
      * that overrides the `version` option.
      */
-    directives?: Directives;
+    _directives?: Directives;
     /**
      * Control the logging level during parsing
      *
@@ -66,9 +74,17 @@ export declare type DocumentOptions = {
      *
      * Default: `"1.2"`
      */
-    version?: '1.1' | '1.2';
+    version?: '1.1' | '1.2' | 'next';
 };
-export declare type SchemaOptions = {
+export 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.
@@ -92,9 +108,18 @@ export declare type SchemaOptions = {
     /**
      * The base schema to use.
      *
-     * Default: `"core"` for YAML 1.2, `"yaml-1.1"` for earlier versions
+     * 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?: SchemaName;
+    schema?: string | Schema;
     /**
      * When adding to or stringifying a map, sort the entries.
      * If `true`, sort by comparing key values with `<`.
@@ -103,8 +128,19 @@ export declare type SchemaOptions = {
      * Default: `false`
      */
     sortMapEntries?: boolean | ((a: Pair, b: Pair) => number);
+    /**
+     * Override default values for `toString()` options.
+     */
+    toStringDefaults?: ToStringOptions;
 };
-export declare type CreateNodeOptions = {
+export 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.
      *
@@ -127,7 +163,7 @@ export declare type CreateNodeOptions = {
      */
     tag?: string;
 };
-export declare type ToJSOptions = {
+export type ToJSOptions = {
     /**
      * Use Map rather than Object to represent mappings.
      *
@@ -153,7 +189,31 @@ export declare type ToJSOptions = {
      */
     reviver?: Reviver;
 };
-export declare type ToStringOptions = {
+export 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.
@@ -204,6 +264,13 @@ export declare type ToStringOptions = {
      * 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.
      *
@@ -247,11 +314,12 @@ export declare type ToStringOptions = {
      */
     simpleKeys?: boolean;
     /**
-     * Prefer 'single quote' rather than "double quote" where applicable.
+     * Use 'single quote' rather than "double quote" where applicable.
+     * Set to `false` to disable single quotes completely.
      *
-     * Default: `false`
+     * Default: `null`
      */
-    singleQuote?: boolean;
+    singleQuote?: boolean | null;
     /**
      * String representation for `true`.
      * With the core schema, use `'true'`, `'True'`, or `'TRUE'`.
@@ -268,11 +336,3 @@ export declare type ToStringOptions = {
      */
     verifyAliasOrder?: boolean;
 };
-/**
- * `yaml` defines document-specific options in three places: as an argument of
- * parse, create and stringify calls, in the values of `YAML.defaultOptions`,
- * and in the version-dependent `YAML.Document.defaults` object. Values set in
- * `YAML.defaultOptions` override version-dependent defaults, and argument
- * options override both.
- */
-export declare const defaultOptions: Required<Omit<ParseOptions, 'lineCounter'> & Omit<DocumentOptions, 'directives'>>;