@swagger-api/apidom-ast 1.0.0-alpha.8 → 1.0.0-beta.0

package/types/apidom-ast.d.ts

@@ -0,0 +1,826 @@
+import type { ApiDOMErrorOptions } from '@swagger-api/apidom-error';
+import { ApiDOMStructuredError } from '@swagger-api/apidom-error';
+
+/**
+ * @public
+ */
+export declare const BREAK: {};
+
+/**
+ * @public
+ */
+export declare const cloneNode: (node: any) => any;
+
+/**
+ * @public
+ */
+declare class Error_2 extends Node_2 {
+    static readonly type: string;
+    readonly value: unknown;
+    readonly isUnexpected: boolean;
+    constructor({ value, isUnexpected, ...rest }?: ErrorOptions_2);
+}
+export { Error_2 as Error }
+
+/**
+ * @public
+ */
+declare interface ErrorOptions_2 extends NodeOptions {
+    readonly value?: unknown;
+    readonly isUnexpected?: boolean;
+}
+export { ErrorOptions_2 as ErrorOptions }
+
+/**
+ * @public
+ */
+export declare const getNodeType: (node: any) => string | undefined;
+
+/**
+ * @public
+ */
+export declare const getVisitFn: (visitor: any, type: string | undefined, isLeaving: boolean) => ((...args: any[]) => any) | null;
+
+/**
+ * @public
+ */
+export declare const isJsonArray: (node: unknown) => node is JsonArray;
+
+/**
+ * @public
+ */
+export declare const isJsonDocument: (node: unknown) => node is JsonDocument;
+
+/**
+ * @public
+ */
+export declare const isJsonEscapeSequence: (node: unknown) => node is JsonEscapeSequence;
+
+/**
+ * @public
+ */
+export declare const isJsonFalse: (node: unknown) => node is JsonFalse;
+
+/**
+ * @public
+ */
+export declare const isJsonKey: (node: unknown) => node is JsonKey;
+
+/**
+ * @public
+ */
+export declare const isJsonNull: (node: unknown) => node is JsonNull;
+
+/**
+ * @public
+ */
+export declare const isJsonNumber: (node: unknown) => node is JsonNumber;
+
+/**
+ * @public
+ */
+export declare const isJsonObject: (node: unknown) => node is JsonObject;
+
+/**
+ * @public
+ */
+export declare const isJsonProperty: (node: unknown) => node is JsonProperty;
+
+/**
+ * @public
+ */
+export declare const isJsonString: (node: unknown) => node is JsonString;
+
+/**
+ * @public
+ */
+export declare const isJsonStringContent: (node: unknown) => node is JsonStringContent;
+
+/**
+ * @public
+ */
+export declare const isJsonTrue: (node: unknown) => node is JsonTrue;
+
+/**
+ * @public
+ */
+export declare const isLiteral: (node: unknown) => node is Literal;
+
+/**
+ * @public
+ */
+export declare const isNode: (node: any) => boolean;
+
+/**
+ * @public
+ */
+export declare const isParseResult: (node: unknown) => node is ParseResult;
+
+/**
+ * @public
+ */
+export declare const isPoint: (node: unknown) => node is Point;
+
+/**
+ * @public
+ */
+export declare const isPosition: (node: unknown) => node is Position;
+
+/**
+ * @public
+ */
+export declare const isYamlAlias: (node: unknown) => node is YamlAlias;
+
+/**
+ * @public
+ */
+export declare const isYamlAnchor: (node: unknown) => node is YamlAnchor;
+
+/**
+ * @public
+ */
+export declare const isYamlComment: (node: unknown) => node is YamlComment;
+
+/**
+ * @public
+ */
+export declare const isYamlDirective: (node: unknown) => node is YamlDirective;
+
+/**
+ * @public
+ */
+export declare const isYamlDocument: (node: unknown) => node is YamlDocument;
+
+/**
+ * @public
+ */
+export declare const isYamlKeyValuePair: (node: unknown) => node is YamlKeyValuePair;
+
+/**
+ * @public
+ */
+export declare const isYamlMapping: (node: unknown) => node is YamlMapping;
+
+/**
+ * @public
+ */
+export declare const isYamlScalar: (node: unknown) => node is YamlScalar;
+
+/**
+ * @public
+ */
+export declare const isYamlSequence: (node: unknown) => node is YamlSequence;
+
+/**
+ * @public
+ */
+export declare const isYamlStream: (node: unknown) => node is YamlStream;
+
+/**
+ * @public
+ */
+export declare const isYamlTag: (node: unknown) => node is YamlTag;
+
+/**
+ * @public
+ */
+export declare class JsonArray extends JsonNode {
+    static readonly type = "array";
+    get items(): unknown[];
+}
+
+/**
+ * @public
+ */
+export declare class JsonDocument extends JsonNode {
+    static readonly type = "document";
+    get child(): unknown;
+}
+
+/**
+ * @public
+ */
+export declare class JsonEscapeSequence extends JsonValue {
+    static readonly type = "escapeSequence";
+}
+
+/**
+ * @public
+ */
+export declare class JsonFalse extends JsonValue {
+    static readonly type = "false";
+}
+
+/**
+ * @public
+ */
+export declare class JsonKey extends JsonString {
+    static readonly type = "key";
+}
+
+/**
+ * @public
+ */
+export declare class JsonNode extends Node_2 {
+}
+
+/**
+ * @public
+ */
+export declare class JsonNull extends JsonValue {
+    static readonly type = "null";
+}
+
+/**
+ * @public
+ */
+export declare class JsonNumber extends JsonValue {
+    static readonly type = "number";
+}
+
+/**
+ * @public
+ */
+export declare class JsonObject extends JsonNode {
+    static readonly type = "object";
+    get properties(): Array<JsonProperty>;
+}
+
+/**
+ * @public
+ */
+export declare class JsonProperty extends JsonNode {
+    static readonly type = "property";
+    get key(): JsonKey | undefined;
+    get value(): JsonPropertyValue | undefined;
+}
+
+/**
+ * @public
+ */
+export declare type JsonPropertyValue = JsonFalse | JsonTrue | JsonNull | JsonNumber | JsonString | JsonArray | JsonObject;
+
+/**
+ * @public
+ */
+export declare class JsonString extends JsonNode {
+    static readonly type: string;
+    get value(): string;
+}
+
+/**
+ * @public
+ */
+export declare class JsonStringContent extends JsonValue {
+    static readonly type = "stringContent";
+}
+
+/**
+ * @public
+ */
+export declare class JsonTrue extends JsonValue {
+    static readonly type = "true";
+}
+
+/**
+ * @public
+ */
+export declare class JsonValue extends JsonNode {
+    static readonly type: string;
+    readonly value: string;
+    constructor({ value, ...rest }: JsonValueOptions);
+}
+
+/**
+ * @public
+ */
+export declare interface JsonValueOptions extends NodeOptions {
+    value: string;
+}
+
+/**
+ * @public
+ */
+export declare class Literal extends Node_2 {
+    static readonly type: string;
+    readonly value: unknown;
+    constructor({ value, ...rest }?: LiteralOptions);
+}
+
+/**
+ * @public
+ */
+export declare interface LiteralOptions extends NodeOptions {
+    readonly value?: unknown;
+}
+
+/**
+ * @public
+ */
+export declare interface MergeAllAsync {
+    (visitors: any[], options?: {
+        visitFnGetter?: typeof getVisitFn;
+        nodeTypeGetter?: typeof getNodeType;
+        breakSymbol?: typeof BREAK;
+        deleteNodeSymbol?: any;
+        skipVisitingNodeSymbol?: boolean;
+        exposeEdits?: boolean;
+    }): {
+        enter: (node: any, ...rest: any[]) => Promise<any>;
+        leave: (node: any, ...rest: any[]) => Promise<any>;
+    };
+}
+
+/**
+ * Creates a new visitor instance which delegates to many visitors to run in
+ * parallel. Each visitor will be visited for each node before moving on.
+ *
+ * If a prior visitor edits a node, no following visitors will see that node.
+ * `exposeEdits=true` can be used to expose the edited node from the previous visitors.
+ * @public
+ */
+export declare interface MergeAllSync {
+    (visitors: any[], options?: {
+        visitFnGetter?: typeof getVisitFn;
+        nodeTypeGetter?: typeof getNodeType;
+        breakSymbol?: typeof BREAK;
+        deleteNodeSymbol?: any;
+        skipVisitingNodeSymbol?: boolean;
+        exposeEdits?: boolean;
+    }): {
+        enter: (node: any, ...rest: any[]) => any;
+        leave: (node: any, ...rest: any[]) => any;
+    };
+    [key: symbol]: MergeAllAsync;
+}
+
+/**
+ * @public
+ */
+export declare const mergeAllVisitors: MergeAllSync;
+
+/**
+ * @public
+ */
+declare class Node_2 {
+    static readonly type: string;
+    readonly type: string;
+    readonly isMissing: boolean;
+    children: unknown[];
+    position?: Position;
+    constructor({ children, position, isMissing }?: NodeOptions);
+    clone(): Node_2;
+}
+export { Node_2 as Node }
+
+/**
+ * @public
+ */
+export declare interface NodeOptions {
+    readonly children?: unknown[];
+    readonly position?: Position;
+    readonly isMissing?: boolean;
+}
+
+/**
+ * @public
+ */
+export declare class ParseResult extends Node_2 {
+    static readonly type: string;
+    get rootNode(): unknown;
+}
+
+/**
+ * @public
+ */
+export declare class Point {
+    static readonly type: string;
+    readonly type: string;
+    readonly row: number;
+    readonly column: number;
+    readonly char: number;
+    constructor({ row, column, char }: PointOptions);
+}
+
+/**
+ * @public
+ */
+export declare interface PointOptions {
+    readonly row: number;
+    readonly column: number;
+    readonly char: number;
+}
+
+/**
+ * @public
+ */
+export declare class Position {
+    static readonly type: string;
+    readonly type: string;
+    readonly start: Point;
+    readonly end: Point;
+    constructor({ start, end }: PositionOptions_2);
+}
+
+/**
+ * @public
+ */
+declare interface PositionOptions_2 {
+    readonly start: Point;
+    readonly end: Point;
+}
+export { PositionOptions_2 as PositionOptions }
+
+/**
+ * visit() will walk through an AST using a preorder depth first traversal, calling
+ * the visitor's enter function at each node in the traversal, and calling the
+ * leave function after visiting that node and all of its child nodes.
+ *
+ * By returning different values from the enter and leave functions, the
+ * behavior of the visitor can be altered, including skipping over a sub-tree of
+ * the AST (by returning false), editing the AST by returning a value or null
+ * to remove the value, or to stop the whole traversal by returning BREAK.
+ *
+ * When using visit() to edit an AST, the original AST will not be modified, and
+ * a new version of the AST with the changes applied will be returned from the
+ * visit function.
+ *
+ * @example
+ * ```
+ *     const editedAST = visit(ast, {
+ *       enter(node, key, parent, path, ancestors) {
+ *         // return
+ *         //   undefined: no action
+ *         //   false: skip visiting this node
+ *         //   BREAK: stop visiting altogether
+ *         //   null: delete this node
+ *         //   any value: replace this node with the returned value
+ *       },
+ *       leave(node, key, parent, path, ancestors) {
+ *         // return
+ *         //   undefined: no action
+ *         //   false: no action
+ *         //   BREAK: stop visiting altogether
+ *         //   null: delete this node
+ *         //   any value: replace this node with the returned value
+ *       }
+ *     });
+ *```
+ * Alternatively to providing enter() and leave() functions, a visitor can
+ * instead provide functions named the same as the kinds of AST nodes, or
+ * enter/leave visitors at a named key, leading to four permutations of
+ * visitor API:
+ *
+ * 1) Named visitors triggered when entering a node a specific kind.
+ * ```
+ *     visit(ast, {
+ *       Kind(node) {
+ *         // enter the "Kind" node
+ *       }
+ *     })
+ * ```
+ * 2) Named visitors that trigger upon entering and leaving a node of
+ *    a specific kind.
+ * ```
+ *     visit(ast, {
+ *       Kind: {
+ *         enter(node) {
+ *           // enter the "Kind" node
+ *         }
+ *         leave(node) {
+ *           // leave the "Kind" node
+ *         }
+ *       }
+ *     })
+ * ```
+ * 3) Generic visitors that trigger upon entering and leaving any node.
+ * ```
+ *     visit(ast, {
+ *       enter(node) {
+ *         // enter any node
+ *       },
+ *       leave(node) {
+ *         // leave any node
+ *       }
+ *     })
+ * ```
+ * 4) Parallel visitors for entering and leaving nodes of a specific kind.
+ * ```
+ *     visit(ast, {
+ *       enter: {
+ *         Kind(node) {
+ *           // enter the "Kind" node
+ *         }
+ *       },
+ *       leave: {
+ *         Kind(node) {
+ *           // leave the "Kind" node
+ *         }
+ *       }
+ *     })
+ * ```
+ *  sig `visit :: (Node, Visitor, Options)`
+ *
+ *  sig `Options = { keyMap: Object, state: Object }`
+ *
+ *  @public
+ */
+export declare const visit: (root: any, visitor: any, { keyMap, state, breakSymbol, deleteNodeSymbol, skipVisitingNodeSymbol, visitFnGetter, nodeTypeGetter, nodePredicate, nodeCloneFn, detectCycles, }?: {
+    keyMap?: null | undefined;
+    state?: {} | undefined;
+    breakSymbol?: {} | undefined;
+    deleteNodeSymbol?: null | undefined;
+    skipVisitingNodeSymbol?: boolean | undefined;
+    visitFnGetter?: ((visitor: any, type: string | undefined, isLeaving: boolean) => ((...args: any[]) => any) | null) | undefined;
+    nodeTypeGetter?: ((node: any) => string | undefined) | undefined;
+    nodePredicate?: ((node: any) => boolean) | undefined;
+    nodeCloneFn?: ((node: any) => any) | undefined;
+    detectCycles?: boolean | undefined;
+}) => any;
+
+/**
+ * @public
+ */
+export declare class YamlAlias extends Node_2 {
+    static readonly type = "alias";
+    readonly content: string;
+    constructor({ content, ...rest }: YamlAliasOptions);
+}
+
+/**
+ * @public
+ */
+export declare interface YamlAliasOptions extends NodeOptions {
+    readonly content: string;
+}
+
+/**
+ * @public
+ */
+export declare class YamlAnchor extends Node_2 {
+    static readonly type = "anchor";
+    readonly name: string;
+    constructor({ name, ...rest }: YamlAnchorOptions);
+}
+
+/**
+ * @public
+ */
+export declare interface YamlAnchorOptions extends NodeOptions {
+    readonly name: string;
+}
+
+/**
+ * @public
+ */
+export declare class YamlCollection extends YamlNode {
+}
+
+/**
+ * @public
+ */
+export declare class YamlComment extends Node_2 {
+    static readonly type = "comment";
+    readonly content: string;
+    constructor({ content, ...rest }: YamlCommentOptions);
+}
+
+/**
+ * @public
+ */
+export declare interface YamlCommentOptions extends NodeOptions {
+    readonly content: string;
+}
+
+/**
+ * @public
+ */
+export declare class YamlDirective extends Node_2 {
+    static readonly type = "directive";
+    readonly name?: string;
+    readonly parameters: YamlDirectiveParameters;
+    constructor({ name, parameters, ...rest }: YamlDirectiveOptions);
+}
+
+/**
+ * @public
+ */
+export declare interface YamlDirectiveOptions extends NodeOptions {
+    readonly name?: string;
+    readonly parameters: YamlDirectiveParameters;
+}
+
+/**
+ * @public
+ */
+export declare interface YamlDirectiveParameters {
+    readonly version?: string;
+    readonly handle?: string;
+    readonly prefix?: string;
+}
+
+/**
+ * @public
+ */
+export declare class YamlDocument extends Node_2 {
+    static readonly type = "document";
+}
+
+/**
+ * @public
+ */
+export declare class YamlError extends ApiDOMStructuredError {
+}
+
+/**
+ * @public
+ */
+export declare class YamlFailsafeSchema {
+    tags: any[];
+    tagDirectives: YamlDirective[];
+    constructor();
+    toSpecificTagName(node: any): string;
+    registerTagDirective(tagDirective: YamlDirective): void;
+    registerTag(tag: any, beginning?: boolean): this;
+    overrideTag(tag: any): this;
+    resolve(node: any): any;
+}
+
+/**
+ * @public
+ */
+export declare class YamlJsonSchema extends YamlFailsafeSchema {
+    constructor();
+    toSpecificTagName(node: any): any;
+}
+
+/**
+ * @public
+ */
+export declare class YamlKeyValuePair extends Node_2 {
+    static readonly type = "keyValuePair";
+    readonly styleGroup: YamlStyleGroup;
+    constructor({ styleGroup, ...rest }: YamlKeyValuePairOptions);
+}
+
+/**
+ * @public
+ */
+export declare interface YamlKeyValuePairOptions extends NodeOptions {
+    readonly styleGroup: YamlStyleGroup;
+}
+
+/**
+ * @public
+ */
+export declare class YamlMapping extends YamlCollection {
+    static readonly type = "mapping";
+}
+
+/**
+ * @public
+ */
+export declare class YamlNode extends Node_2 {
+    readonly anchor?: YamlAnchor;
+    readonly tag?: YamlTag;
+    readonly style: YamlStyle;
+    readonly styleGroup: YamlStyleGroup;
+    constructor({ anchor, tag, style, styleGroup, ...rest }: YamlNodeOptions);
+}
+
+/**
+ * @public
+ */
+export declare enum YamlNodeKind {
+    Scalar = "Scalar",
+    Sequence = "Sequence",
+    Mapping = "Mapping"
+}
+
+/**
+ * @public
+ */
+export declare interface YamlNodeOptions extends NodeOptions {
+    readonly anchor?: YamlAnchor;
+    readonly tag?: YamlTag;
+    readonly style: YamlStyle;
+    readonly styleGroup: YamlStyleGroup;
+}
+
+/**
+ * @public
+ */
+export declare class YamlReferenceError extends YamlError {
+}
+
+/**
+ * @public
+ */
+export declare class YamlReferenceManager {
+    addAnchor(node: YamlNode): void;
+    resolveAlias(alias: YamlAlias): YamlScalar;
+}
+
+/**
+ * @public
+ */
+export declare class YamlScalar extends YamlNode {
+    static readonly type = "scalar";
+    readonly content: string;
+    constructor({ content, ...rest }: YamlScalarOptions);
+}
+
+/**
+ * @public
+ */
+export declare interface YamlScalarOptions extends YamlNodeOptions {
+    readonly content: string;
+}
+
+/**
+ * @public
+ */
+export declare class YamlSchemaError extends YamlError {
+}
+
+/**
+ * @public
+ */
+export declare class YamlSequence extends YamlCollection {
+    static readonly type = "sequence";
+}
+
+/**
+ * @public
+ */
+export declare class YamlStream extends Node_2 {
+    static readonly type = "stream";
+}
+
+/**
+ * @public
+ */
+export declare enum YamlStyle {
+    Plain = "Plain",
+    SingleQuoted = "SingleQuoted",
+    DoubleQuoted = "DoubleQuoted",
+    Literal = "Literal",
+    Folded = "Folded",
+    Explicit = "Explicit",
+    SinglePair = "SinglePair",
+    NextLine = "NextLine",
+    InLine = "InLine"
+}
+
+/**
+ * @public
+ */
+export declare enum YamlStyleGroup {
+    Flow = "Flow",
+    Block = "Block"
+}
+
+/**
+ * @public
+ */
+export declare class YamlTag extends Node_2 {
+    static readonly type = "tag";
+    readonly explicitName: string;
+    readonly kind: YamlNodeKind;
+    constructor({ explicitName, kind, ...rest }: YamlTagOptions);
+}
+
+/**
+ * @public
+ */
+export declare class YamlTagError extends YamlSchemaError {
+    readonly specificTagName: string;
+    readonly explicitTagName: string;
+    readonly tagKind: string;
+    readonly tagPosition?: Position;
+    readonly nodeCanonicalContent?: string;
+    readonly node?: unknown;
+    constructor(message?: string, structuredOptions?: YamlTagErrorOptions);
+}
+
+/**
+ * @public
+ */
+export declare interface YamlTagErrorOptions<T extends Node_2 = Node_2> extends ApiDOMErrorOptions {
+    readonly specificTagName: string;
+    readonly explicitTagName: string;
+    readonly tagKind: string;
+    readonly tagPosition?: Position;
+    readonly nodeCanonicalContent?: string;
+    readonly node?: T;
+}
+
+/**
+ * @public
+ */
+export declare interface YamlTagOptions extends NodeOptions {
+    readonly explicitName: string;
+    readonly kind: YamlNodeKind;
+}
+
+export { }