@servicenow/sdk-build-core 3.0.3 → 4.0.0

package/dist/typescript.d.ts

@@ -0,0 +1,293 @@
+/**
+ * For some reason ts-morph.d.ts doesn't export these types even though they are actually
+ * exported by the runtime library, so we are declaring them here
+ *
+ * @version 23.0.0
+ */
+declare module 'ts-morph' {
+    abstract class BaseError extends Error {
+        protected constructor();
+    }
+    class PathNotFoundError extends BaseError {
+        readonly path: string;
+        constructor(path: string, prefix?: string);
+        readonly code: 'ENOENT';
+    }
+    class FileNotFoundError extends Error {
+        constructor(filePath: string);
+    }
+    class DirectoryNotFoundError extends Error {
+        constructor(dirPath: string);
+    }
+}
+import * as ts from 'ts-morph';
+import { ts as tsc } from 'ts-morph';
+export { ts, tsc };
+export declare function getValueDeclaration(node: ts.Node): ts.Node<ts.ts.Node> | undefined;
+export declare function parseType(type: ts.Type, location: ts.Node, unparsableTypeHandler?: (unparsableType: ts.Type) => unknown): unknown;
+/**
+ * A lot of the extra information here only exists because TypeScript doesn't
+ * export a union containing all the different node types, so you can't narrow
+ * a node's type by its kind. Narrowing based on kind is very useful for plugins
+ * since you can define a property using a kind name and the type of the 'node'
+ * argument can be inferred instead of every plugin needing to cast it manually.
+ * If you find yourself needing to parse any node kinds that aren't on this list,
+ * please add them here.
+ *
+ * See: https://github.com/microsoft/TypeScript/issues/13634
+ */
+export declare const SupportedKinds: {
+    265: {
+        name: "TypeAliasDeclaration";
+        node: ts.TypeAliasDeclaration;
+    };
+    183: {
+        name: "TypeReference";
+        node: ts.TypeReferenceNode;
+    };
+    187: {
+        name: "TypeLiteral";
+        node: ts.TypeLiteralNode;
+    };
+    171: {
+        name: "PropertySignature";
+        node: ts.PropertySignature;
+    };
+    189: {
+        name: "TupleType";
+        node: ts.TupleTypeNode;
+    };
+    226: {
+        name: "BinaryExpression";
+        node: ts.BinaryExpression;
+    };
+    218: {
+        name: "FunctionExpression";
+        node: ts.FunctionExpression;
+    };
+    262: {
+        name: "FunctionDeclaration";
+        node: ts.FunctionDeclaration;
+    };
+    209: {
+        name: "ArrayLiteralExpression";
+        node: ts.ArrayLiteralExpression;
+    };
+    213: {
+        name: "CallExpression";
+        node: ts.CallExpression;
+    };
+    11: {
+        name: "StringLiteral";
+        node: ts.StringLiteral;
+    };
+    9: {
+        name: "NumericLiteral";
+        node: ts.NumericLiteral;
+    };
+    112: {
+        name: "TrueKeyword";
+        node: ts.TrueLiteral;
+    };
+    97: {
+        name: "FalseKeyword";
+        node: ts.FalseLiteral;
+    };
+    106: {
+        name: "NullKeyword";
+        node: ts.NullLiteral;
+    };
+    80: {
+        name: "Identifier";
+        node: ts.Identifier;
+    };
+    307: {
+        name: "SourceFile";
+        node: ts.SourceFile;
+    };
+    260: {
+        name: "VariableDeclaration";
+        node: ts.VariableDeclaration;
+    };
+    263: {
+        name: "ClassDeclaration";
+        node: ts.ClassDeclaration;
+    };
+    278: {
+        name: "ExportDeclaration";
+        node: ts.ExportDeclaration;
+    };
+    210: {
+        name: "ObjectLiteralExpression";
+        node: ts.ObjectLiteralExpression;
+    };
+    234: {
+        name: "AsExpression";
+        node: ts.AsExpression;
+    };
+    167: {
+        name: "ComputedPropertyName";
+        node: ts.ComputedPropertyName;
+    };
+    303: {
+        name: "PropertyAssignment";
+        node: ts.PropertyAssignment;
+    };
+    211: {
+        name: "PropertyAccessExpression";
+        node: ts.PropertyAccessExpression;
+    };
+    15: {
+        name: "NoSubstitutionTemplateLiteral";
+        node: ts.NoSubstitutionTemplateLiteral;
+    };
+    244: {
+        name: "ExpressionStatement";
+        node: ts.ExpressionStatement;
+    };
+    215: {
+        name: "TaggedTemplateExpression";
+        node: ts.TaggedTemplateExpression;
+    };
+    277: {
+        name: "ExportAssignment";
+        node: ts.ExportAssignment;
+    };
+    279: {
+        name: "NamedExports";
+        node: ts.NamedExports;
+    };
+    281: {
+        name: "ExportSpecifier";
+        node: ts.ExportSpecifier;
+    };
+    212: {
+        name: "ElementAccessExpression";
+        node: ts.ElementAccessExpression;
+    };
+    228: {
+        name: "TemplateExpression";
+        node: ts.TemplateExpression;
+    };
+    273: {
+        name: "ImportClause";
+        node: ts.ImportClause;
+    };
+    276: {
+        name: "ImportSpecifier";
+        node: ts.ImportSpecifier;
+    };
+    272: {
+        name: "ImportDeclaration";
+        node: ts.ImportDeclaration;
+    };
+    275: {
+        name: "NamedImports";
+        node: ts.NamedImports;
+    };
+    243: {
+        name: "VariableStatement";
+        node: ts.VariableStatement;
+    };
+    261: {
+        name: "VariableDeclarationList";
+        node: ts.VariableDeclarationList;
+    };
+    40: {
+        name: "PlusToken";
+        node: ts.Node<tsc.PlusToken>;
+    };
+    1: {
+        name: "EndOfFileToken";
+        node: ts.Node<tsc.EndOfFileToken>;
+    };
+    95: {
+        name: "ExportKeyword";
+        node: ts.Node<tsc.ExportKeyword>;
+    };
+    133: {
+        name: "AnyKeyword";
+        node: ts.Node<tsc.KeywordTypeNode<tsc.SyntaxKind.AnyKeyword>>;
+    };
+    267: {
+        name: "ModuleDeclaration";
+        node: ts.ModuleDeclaration;
+    };
+    268: {
+        name: "ModuleBlock";
+        node: ts.ModuleBlock;
+    };
+    241: {
+        name: "Block";
+        node: ts.Block;
+    };
+    169: {
+        name: "Parameter";
+        node: ts.ParameterDeclaration;
+    };
+    64: {
+        name: "EqualsToken";
+        node: ts.Node<tsc.EqualsToken>;
+    };
+    39: {
+        name: "EqualsGreaterThanToken";
+        node: ts.Node<tsc.EqualsGreaterThanToken>;
+    };
+    219: {
+        name: "ArrowFunction";
+        node: ts.ArrowFunction;
+    };
+    16: {
+        name: "TemplateHead";
+        node: ts.TemplateHead;
+    };
+    17: {
+        name: "TemplateMiddle";
+        node: ts.TemplateMiddle;
+    };
+    239: {
+        name: "TemplateSpan";
+        node: ts.TemplateSpan;
+    };
+    18: {
+        name: "TemplateTail";
+        node: ts.TemplateTail;
+    };
+    224: {
+        name: "PrefixUnaryExpression";
+        node: ts.PrefixUnaryExpression;
+    };
+};
+export type SupportedKind = keyof typeof SupportedKinds;
+export type SupportedKindName = (typeof SupportedKinds)[SupportedKind]['name'];
+export type SupportedNode = (typeof SupportedKinds)[SupportedKind]['node'];
+export type SupportedNodeByKind<K extends SupportedKind> = (typeof SupportedKinds)[K]['node'];
+export type SupportedNodeByKindName<K extends SupportedKindName> = Extract<(typeof SupportedKinds)[SupportedKind], {
+    name: K;
+}>['node'];
+export declare function isSupportedKind(kind: ts.SyntaxKind): kind is SupportedKind;
+export declare function isSupportedNode(node: ts.Node | undefined): node is SupportedNode;
+export declare function getKind(node: SupportedNode): SupportedKind;
+export declare function getKindName(nodeOrKind: SupportedNode | SupportedKind): SupportedKindName;
+export declare function isUndefined(node: ts.Node): boolean;
+export declare function isOnlyChild(node: ts.Node | undefined): boolean;
+type RemovableNode = Extract<SupportedNode, {
+    remove(): void;
+}>;
+export declare function isRemovable(node: ts.Node | undefined): node is RemovableNode;
+/**
+ * Recursively walks up the tree to remove the furthest possible ancestor along a
+ * unary chain from this node, or the node itself if that's all we can do. This
+ * avoids leaving behind dead code as much as possible.
+ *
+ * @throws Error if the node cannot be removed
+ */
+export declare function remove(target: ts.Node): void;
+/**
+ * Recursively walks up the tree removing references to this node and any ancestors
+ * along a unary chain. In other words, if this node is the only child of its parent,
+ * we also remove references to the parent, and repeat that process recursively. This
+ * avoids leaving behind dead code as much as possible.
+ */
+export declare function removeReferences(target: ts.Node): void;
+export declare function getUnsupportedKindName(node: ts.Node): string | undefined;