js-yaml

const binaryTag: ScalarTagDefinition<any>;

const boolCoreTag: ScalarTagDefinition<boolean>;

const boolJsonTag: ScalarTagDefinition<boolean>;

const boolYaml11Tag: ScalarTagDefinition<boolean>;

const CHOMPING_CLIP: number;

const CHOMPING_KEEP: number;

const CHOMPING_STRIP: number;

const COLLECTION_STYLE_BLOCK: number;

const COLLECTION_STYLE_FLOW: number;

const CORE_SCHEMA: Schema;

const EVENT_ALIAS: number;

const EVENT_DOCUMENT: number;

const EVENT_MAPPING: number;

const EVENT_POP: number;

const EVENT_SCALAR: number;

const EVENT_SEQUENCE: number;

const FAILSAFE_SCHEMA: Schema;

const floatCoreTag: ScalarTagDefinition<number>;

const floatJsonTag: ScalarTagDefinition<number>;

const floatYaml11Tag: ScalarTagDefinition<number>;

const intCoreTag: ScalarTagDefinition<number>;

const intJsonTag: ScalarTagDefinition<number>;

const intYaml11Tag: ScalarTagDefinition<number>;

const JSON_SCHEMA: Schema;

const legacyMapTag: MappingTagDefinition<StringMapping, StringMapping>;

const mapTag: MappingTagDefinition<StringMapping$1, StringMapping$1>;

const MERGE_KEY: Symbol;

const mergeTag: ScalarTagDefinition<typeof MERGE_KEY>;

const NOT_RESOLVED: Symbol;

const nullCoreTag: ScalarTagDefinition<null>;

const nullJsonTag: ScalarTagDefinition<null>;

const nullYaml11Tag: ScalarTagDefinition<null>;

const omapTag: SequenceTagDefinition<OmapCarrier, unknown[]>;

const pairsTag: SequenceTagDefinition<Pair[], Pair[]>;

const realMapTag: MappingTagDefinition<RealMapping, RealMapping>;

const SCALAR_STYLE_DOUBLE_QUOTED: number;

const SCALAR_STYLE_FOLDED_BLOCK: number;

const SCALAR_STYLE_LITERAL_BLOCK: number;

const SCALAR_STYLE_PLAIN: number;

const SCALAR_STYLE_SINGLE_QUOTED: number;

const seqTag: SequenceTagDefinition<unknown[], unknown[]>;

const setTag: MappingTagDefinition<Set<unknown>, Set<unknown>>;

const strTag: ScalarTagDefinition<string>;

const timestampTag: ScalarTagDefinition<Date>;

const VISIT_BREAK: Symbol;

const VISIT_SKIP: Symbol;

const YAML11_SCHEMA: Schema;

constructFromEvents: (events: Event[], options: ConstructorOptions) => unknown[];

defineMappingTag: <Carrier, Result = Carrier>(
    tagName: string,
    options: MappingTagOptions<Carrier, Result>
) => MappingTagDefinition<Carrier, Result>;

defineScalarTag: <Result>(
    tagName: string,
    options: ScalarTagOptions<Result>
) => ScalarTagDefinition<Result>;

defineSequenceTag: <Carrier, Result = Carrier>(
    tagName: string,
    options: SequenceTagOptions<Carrier, Result>
) => SequenceTagDefinition<Carrier, Result>;

dump: (input: any, options?: DumpOptions) => string;

eventsToAst: (events: Event[], options: FromEventsOptions) => Document[];

getScalarValue: (input: string, scalar: ScalarEvent) => string;

jsToAst: (input: unknown, schema: Schema, options?: FromJsOptions) => Document[];

load: (input: string, options?: LoadOptions) => unknown;

loadAll: {
    (input: string, options?: LoadOptions): unknown[];
    (input: string, iterator: null, options?: LoadOptions): unknown[];
    (input: string, iterator: LoadAllIterator, options?: LoadOptions): void;
};

parseEvents: (input: string, options: ParserOptions) => Event[];

present: (documents: Document[], options: PresenterOptions) => string;

visit: (documents: Document[], visitor: Visitor) => void;

type DocumentDirective =
    | {
          kind: 'yaml';
          version: string;
      }
    | {
          kind: 'tag';
          handle: string;
          prefix: string;
      };

type Event =
    | DocumentEvent
    | SequenceEvent
    | MappingEvent
    | ScalarEvent
    | AliasEvent
    | PopEvent;

type MappingTagOptions<Carrier, Result = Carrier> = {
    matchByTagPrefix?: boolean;
    create: MappingTagDefinition<Carrier, Result>['create'];
    addPair: MappingTagDefinition<Carrier, Result>['addPair'];
    has: MappingTagDefinition<Carrier, Result>['has'];
    keys: MappingTagDefinition<Carrier, Result>['keys'];
    get: MappingTagDefinition<Carrier, Result>['get'];
    finalize?: MappingTagDefinition<Carrier, Result>['finalize'];
} & RepresentOptions<Result, Map<unknown, unknown>, MappingRepresent>;

type Node = ScalarNode | SequenceNode | MappingNode | AliasNode;

type SequenceTagOptions<Carrier, Result = Carrier> = {
    matchByTagPrefix?: boolean;
    create: SequenceTagDefinition<Carrier, Result>['create'];
    addItem: SequenceTagDefinition<Carrier, Result>['addItem'];
    finalize?: SequenceTagDefinition<Carrier, Result>['finalize'];
} & RepresentOptions<Result, ArrayLike<unknown>, SequenceRepresent>;

type TagDefinition =
    | ScalarTagDefinition<any>
    | SequenceTagDefinition<any, any>
    | MappingTagDefinition<any, any>;

type Visitor = (node: Node, ctx: VisitContext) => VisitControl;