export function createDefaultMapFromCDN(options: any, prefix: any, ts: any): Promise<Map<any, any>>;
/**
 * Returns an array of exported nodes from a TypeScript source file.
 * @param {import('typescript').Program} program - The TypeScript program
 * @param {import('typescript').SourceFile} sourceFile - The TypeScript source file
 * @returns {let map: Map<string, Set<import('typescript').Node>>} - A Map of exported nodes
 */
export function getExportedNodes(program: import("typescript").Program, sourceFile: import("typescript").SourceFile): let;
/**
 * Checks if the node or its aliased symbol is a class declaration.
 *
 * @param {import('typescript').Node} node - The TypeScript node
 * @param {import('typescript').TypeChecker} typeChecker - The TypeScript type checker
 * @returns {boolean} - True if the node or its original declaration is a class declaration, false otherwise
 */
export function isAliasedClassDeclaration(node: import("typescript").Node, typeChecker: import("typescript").TypeChecker): boolean;
/**
 * Determines if a TypeScript node inherits from a specific base class.
 * @param {ts.ClassDeclaration} node - The TypeScript node to analyze
 * @param {ts.TypeChecker} typeChecker - The TypeScript type checker
 * @param {ts.Symbol} baseClassSymbol - The base class symbol to check inheritance against
 * @returns {boolean} - True if the node inherits from the base class
 */
export function inheritsFrom(node: ts.ClassDeclaration, typeChecker: ts.TypeChecker, baseClassSymbol: ts.Symbol): boolean;
/**
 * Recursively gathers and flat maps and nodes that meet a specific filter.
 * @param {import('typescript').Node} node - The TypeScript node to analyze
 * @param {function} filter - A function to filter the nodes
 * @returns {import('typescript').Node[]} - An array of exported class declarations
 */
export function flatMapAnyNodes(node: import("typescript").Node, filter?: Function): import("typescript").Node[];
/**
 * Retrieves the JSDoc-style comments associated with a specific AST node.
 *
 * @param {import('typescript').Node} node - The TypeScript node to analyze
 * @param {string} text - The full text content of the source file
 * @param {import('typescript').TypeChecker} typeChecker - The TypeScript type checker
 * @returns {{ memberName: string, member: Node, range: import('typescript').CommentRange}[]} - An array of comment ranges
 */
export function getJSDocTags(node: import("typescript").Node, typeChecker: import("typescript").TypeChecker): {
    memberName: string;
    member: Node;
    range: import("typescript").CommentRange;
}[];
/**
 * Determines if a TypeScript node is an enum.
 * @param {import('typescript').Node} node - The TypeScript node to analyze
 * @returns {boolean} - True if the node is an enum
 */
export function isEnum(node: import("typescript").Node): boolean;
/**
 * Determines the primitive type for enums, or falls back to the actual type name.
 *
 * @param {ts.Type} type - The type to inspect.
 * @param {ts.TypeChecker} typeChecker - The TypeScript type checker.
 * @returns {'string' | 'boolean' | 'number' | null} - The primitive type of the enum or the type's name.
 */
export function getPrimitiveEnumType(type: ts.Type, typeChecker: ts.TypeChecker): "string" | "boolean" | "number" | null;
/**
 * Gets the inferred type of a TypeScript node.
 *
 * @param {ts.Node} node - The TypeScript node to analyze
 * @param {ts.TypeChecker} typeChecker - The TypeScript type checker
 * @returns {{ array: boolean, name: string | undefined, type: Type | null }} - The inferred type of the node
 */
export function getType(node: ts.Node, typeChecker: ts.TypeChecker): {
    array: boolean;
    name: string | undefined;
    type: Type | null;
};
/**
 * Parses a numerical string into a number. Handles hexadecimal, binary,
 * octal, exponential notation and underscore notation
 *
 * @param {string} input - The string to parse
 * @returns {number} The parsed number, or NaN if the input is not a number
 */
export function parseNumber(input: string): number;
/**
 * Parses a string representation of a numerical array into an array of numbers.
 *
 * @param {string} input - The string to parse
 * @returns {number[]} - The parsed array of numbers
 * @throws {Error} - If the input contains invalid characters or is not a valid array
 */
export function parseStringToNumericalArray(input: string): number[];
/**
 * Attempts to extract a literal value from a TypeScript node. This function
 * supports various types of literals and expressions, including object literals,
 * array literals, identifiers, and unary expressions.
 *
 * @param {import('typescript').Node} node - The AST node to evaluate
 * @param {import('typescript').TypeChecker} typeChecker - The TypeScript type checker
 * @returns {any} - The extracted literal value
 */
export function getLiteralValue(node: import("typescript").Node, typeChecker: import("typescript").TypeChecker): any;
export function isNumericLiteral(node: import("typescript").Node): boolean;
export function parseFloatNode(node: import("typescript").Node, isArgument?: boolean): number;
export function parseBooleanNode(node: import("typescript").Node): boolean;
export function parseStringNode(node: import("typescript").Node): string;
export function parseArrayLiteralNode(node: any, isArgument?: boolean): any;
export function parseArrayLiteral(args: ts.Node[]): number[];
import * as ts from 'typescript';
