nestjs-openapi-next 1.0.0

package/dist/interfaces/open-api-spec.interface.d.ts

@@ -0,0 +1,252 @@
+export interface OpenAPIObject {
+    openapi: string;
+    info: InfoObject;
+    servers?: ServerObject[];
+    paths: PathsObject;
+    components?: ComponentsObject;
+    security?: SecurityRequirementObject[];
+    tags?: TagObject[];
+    externalDocs?: ExternalDocumentationObject;
+}
+export interface InfoObject {
+    title: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: ContactObject;
+    license?: LicenseObject;
+    version: string;
+}
+export interface ContactObject {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+export interface LicenseObject {
+    name: string;
+    url?: string;
+}
+export interface ServerObject {
+    url: string;
+    description?: string;
+    variables?: Record<string, ServerVariableObject>;
+}
+export interface ServerVariableObject {
+    enum?: string[] | boolean[] | number[];
+    default: string | boolean | number;
+    description?: string;
+}
+export interface ComponentsObject {
+    schemas?: Record<string, SchemaObject | ReferenceObject>;
+    responses?: Record<string, ResponseObject | ReferenceObject>;
+    parameters?: Record<string, ParameterObject | ReferenceObject>;
+    examples?: Record<string, ExampleObject | ReferenceObject>;
+    requestBodies?: Record<string, RequestBodyObject | ReferenceObject>;
+    headers?: Record<string, HeaderObject | ReferenceObject>;
+    securitySchemes?: Record<string, SecuritySchemeObject | ReferenceObject>;
+    links?: Record<string, LinkObject | ReferenceObject>;
+    callbacks?: Record<string, CallbackObject | ReferenceObject>;
+}
+export type PathsObject = Record<string, PathItemObject>;
+export interface PathItemObject {
+    $ref?: string;
+    summary?: string;
+    description?: string;
+    get?: OperationObject;
+    search?: OperationObject;
+    query?: OperationObject;
+    put?: OperationObject;
+    post?: OperationObject;
+    delete?: OperationObject;
+    options?: OperationObject;
+    head?: OperationObject;
+    patch?: OperationObject;
+    trace?: OperationObject;
+    servers?: ServerObject[];
+    parameters?: (ParameterObject | ReferenceObject)[];
+}
+export interface OperationObject {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    operationId?: string;
+    parameters?: (ParameterObject | ReferenceObject)[];
+    requestBody?: RequestBodyObject | ReferenceObject;
+    responses: ResponsesObject;
+    callbacks?: CallbacksObject;
+    deprecated?: boolean;
+    security?: SecurityRequirementObject[];
+    servers?: ServerObject[];
+}
+export interface ExternalDocumentationObject {
+    description?: string;
+    url: string;
+}
+export type ParameterLocation = 'query' | 'header' | 'path' | 'cookie';
+export type ParameterStyle = 'matrix' | 'label' | 'form' | 'simple' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
+export interface BaseParameterObject {
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    style?: ParameterStyle;
+    explode?: boolean;
+    allowReserved?: boolean;
+    schema?: SchemaObject | ReferenceObject;
+    examples?: Record<string, ExampleObject | ReferenceObject>;
+    example?: any;
+    content?: ContentObject;
+}
+export interface ParameterObject extends BaseParameterObject {
+    name: string;
+    in: ParameterLocation;
+}
+export interface RequestBodyObject {
+    description?: string;
+    content: ContentObject;
+    required?: boolean;
+}
+export type ContentObject = Record<string, MediaTypeObject>;
+export interface MediaTypeObject {
+    schema?: SchemaObject | ReferenceObject;
+    itemSchema?: SchemaObject | ReferenceObject;
+    examples?: ExamplesObject;
+    example?: any;
+    encoding?: EncodingObject;
+}
+export type EncodingObject = Record<string, EncodingPropertyObject>;
+export interface EncodingPropertyObject {
+    contentType?: string;
+    headers?: Record<string, HeaderObject | ReferenceObject>;
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+}
+export interface ResponsesObject extends Record<string, ResponseObject | ReferenceObject | undefined> {
+    default?: ResponseObject | ReferenceObject;
+}
+export interface ResponseObject {
+    description: string;
+    headers?: HeadersObject;
+    content?: ContentObject;
+    links?: LinksObject;
+}
+export type CallbacksObject = Record<string, CallbackObject | ReferenceObject>;
+export type CallbackObject = Record<string, PathItemObject>;
+export type HeadersObject = Record<string, HeaderObject | ReferenceObject>;
+export interface ExampleObject {
+    summary?: string;
+    description?: string;
+    value?: any;
+    externalValue?: string;
+}
+export type LinksObject = Record<string, LinkObject | ReferenceObject>;
+export interface LinkObject {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: LinkParametersObject;
+    requestBody?: unknown;
+    description?: string;
+    server?: ServerObject;
+}
+export type LinkParametersObject = Record<string, unknown>;
+export type HeaderObject = BaseParameterObject;
+export interface TagObject {
+    name: string;
+    summary?: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    parent?: string;
+    kind?: 'audience' | 'badge' | 'nav' | (string & {});
+}
+export type ExamplesObject = Record<string, ExampleObject | ReferenceObject>;
+export interface ReferenceObject {
+    $ref: string;
+}
+export interface SchemaObject {
+    nullable?: boolean;
+    discriminator?: DiscriminatorObject;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    xml?: XmlObject;
+    externalDocs?: ExternalDocumentationObject;
+    example?: any;
+    examples?: any[] | Record<string, any>;
+    deprecated?: boolean;
+    type?: string;
+    allOf?: (SchemaObject | ReferenceObject)[];
+    oneOf?: (SchemaObject | ReferenceObject)[];
+    anyOf?: (SchemaObject | ReferenceObject)[];
+    not?: SchemaObject | ReferenceObject;
+    items?: SchemaObject | ReferenceObject;
+    properties?: Record<string, SchemaObject | ReferenceObject>;
+    additionalProperties?: SchemaObject | ReferenceObject | boolean;
+    patternProperties?: Record<string, SchemaObject | ReferenceObject> | undefined;
+    description?: string;
+    format?: string;
+    default?: any;
+    title?: string;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: boolean;
+    minimum?: number;
+    exclusiveMinimum?: boolean;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    enum?: any[];
+    'x-enumNames'?: string[];
+}
+export type SchemasObject = Record<string, SchemaObject>;
+export interface DiscriminatorObject {
+    propertyName: string;
+    mapping?: Record<string, string>;
+}
+export interface XmlObject {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+}
+export type SecuritySchemeType = 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+export interface SecuritySchemeObject {
+    type: SecuritySchemeType;
+    description?: string;
+    name?: string;
+    in?: string;
+    scheme?: string;
+    bearerFormat?: string;
+    flows?: OAuthFlowsObject;
+    openIdConnectUrl?: string;
+    'x-tokenName'?: string;
+    [extension: `x-${string}`]: any;
+}
+export interface OAuthFlowsObject {
+    implicit?: OAuthFlowObject;
+    password?: OAuthFlowObject;
+    clientCredentials?: OAuthFlowObject;
+    authorizationCode?: OAuthFlowObject;
+    deviceAuthorization?: OAuthDeviceAuthorizationFlowObject;
+}
+export interface OAuthFlowObject {
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    refreshUrl?: string;
+    scopes: ScopesObject;
+}
+export interface OAuthDeviceAuthorizationFlowObject {
+    deviceAuthorizationUrl: string;
+    tokenUrl: string;
+    refreshUrl?: string;
+    scopes: ScopesObject;
+}
+export type ScopesObject = Record<string, any>;
+export type SecurityRequirementObject = Record<string, string[]>;
+export type ExtensionLocation = 'root' | 'info';

package/dist/interfaces/open-api-spec.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/schema-object-metadata.interface.d.ts

@@ -0,0 +1,30 @@
+import { Type } from '@nestjs/common';
+import { EnumSchemaAttributes } from './enum-schema-attributes.interface';
+import { ReferenceObject, SchemaObject } from './open-api-spec.interface';
+export type EnumAllowedTypes = any[] | Record<string, any> | (() => any[] | Record<string, any>);
+interface SchemaObjectCommonMetadata extends Omit<SchemaObject, 'type' | 'required' | 'properties' | 'enum'> {
+    isArray?: boolean;
+    name?: string;
+    enum?: EnumAllowedTypes;
+}
+export type SchemaObjectMetadata = (SchemaObjectCommonMetadata & {
+    type?: Type<unknown> | Function | [Function] | 'array' | 'string' | 'number' | 'boolean' | 'integer' | 'null';
+    required?: boolean;
+}) | ({
+    type?: Type<unknown> | Function | [Function] | Record<string, any>;
+    required?: boolean;
+    enumName: string;
+    enumSchema?: EnumSchemaAttributes;
+} & SchemaObjectCommonMetadata) | ({
+    type: 'object';
+    properties: Record<string, SchemaObjectMetadata>;
+    required?: string[];
+    selfRequired?: boolean;
+} & SchemaObjectCommonMetadata) | ({
+    type: 'object';
+    properties?: Record<string, SchemaObjectMetadata>;
+    additionalProperties: SchemaObject | ReferenceObject | boolean;
+    required?: string[];
+    selfRequired?: boolean;
+} & SchemaObjectCommonMetadata);
+export {};

package/dist/interfaces/schema-object-metadata.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/swagger-custom-options.interface.d.ts

@@ -0,0 +1,24 @@
+import { OpenAPIObject } from './open-api-spec.interface';
+import { SwaggerUiOptions } from './swagger-ui-options.interface';
+export interface SwaggerCustomOptions {
+    useGlobalPrefix?: boolean;
+    swaggerUiEnabled?: boolean;
+    ui?: boolean;
+    raw?: boolean | Array<'json' | 'yaml'>;
+    swaggerUrl?: string;
+    jsonDocumentUrl?: string;
+    yamlDocumentUrl?: string;
+    patchDocumentOnRequest?: <TRequest = any, TResponse = any>(req: TRequest, res: TResponse, document: OpenAPIObject) => OpenAPIObject;
+    explorer?: boolean;
+    swaggerOptions?: SwaggerUiOptions;
+    customCss?: string;
+    customCssUrl?: string | string[];
+    customJs?: string | string[];
+    customJsStr?: string | string[];
+    customfavIcon?: string;
+    customSiteTitle?: string;
+    customSwaggerUiPath?: string;
+    validatorUrl?: string;
+    url?: string;
+    urls?: Record<'url' | 'name', string>[];
+}

package/dist/interfaces/swagger-custom-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/swagger-document-options.interface.d.ts

@@ -0,0 +1,10 @@
+export type OperationIdFactory = (controllerKey: string, methodKey: string, version?: string) => string;
+export interface SwaggerDocumentOptions {
+    include?: Function[];
+    extraModels?: Function[];
+    ignoreGlobalPrefix?: boolean;
+    deepScanRoutes?: boolean;
+    operationIdFactory?: OperationIdFactory;
+    linkNameFactory?: (controllerKey: string, methodKey: string, fieldKey: string) => string;
+    autoTagControllers?: boolean;
+}

package/dist/interfaces/swagger-document-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/swagger-ui-init-options.interface.d.ts

@@ -0,0 +1,7 @@
+import { OpenAPIObject } from './open-api-spec.interface';
+import { SwaggerUiOptions } from './swagger-ui-options.interface';
+export interface SwaggerUIInitOptions {
+    swaggerDoc: OpenAPIObject;
+    customOptions: SwaggerUiOptions;
+    swaggerUrl: string;
+}

package/dist/interfaces/swagger-ui-init-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interfaces/swagger-ui-options.interface.d.ts

@@ -0,0 +1,15 @@
+export interface SwaggerUiOptions {
+    initOAuth?: {
+        clientId?: string;
+        clientSecret?: string;
+        realm?: string;
+        appName?: string;
+        scopeSeparator?: string;
+        scopes?: string[];
+        additionalQueryStringParams?: Record<string, string>;
+        useBasicAuthenticationWithAccessCodeGrant?: boolean;
+        usePkceWithAuthorizationCodeGrant?: boolean;
+    };
+    persistAuthorization?: boolean;
+    [key: string]: any;
+}

package/dist/interfaces/swagger-ui-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/plugin/compiler-plugin.d.ts

@@ -0,0 +1,2 @@
+import * as ts from 'typescript';
+export declare const before: (options?: Record<string, any>, program?: ts.Program) => (ctx: ts.TransformationContext) => ts.Transformer<any>;

package/dist/plugin/compiler-plugin.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.before = void 0;
+const merge_options_1 = require("./merge-options");
+const plugin_debug_logger_1 = require("./plugin-debug-logger");
+const is_filename_matched_util_1 = require("./utils/is-filename-matched.util");
+const controller_class_visitor_1 = require("./visitors/controller-class.visitor");
+const model_class_visitor_1 = require("./visitors/model-class.visitor");
+const modelClassVisitor = new model_class_visitor_1.ModelClassVisitor();
+const controllerClassVisitor = new controller_class_visitor_1.ControllerClassVisitor();
+const before = (options, program) => {
+    options = (0, merge_options_1.mergePluginOptions)(options);
+    if (!program) {
+        const error = `The "program" reference must be provided when using the CLI Plugin. This error is likely caused by the "isolatedModules" compiler option being set to "true".`;
+        plugin_debug_logger_1.pluginDebugLogger.debug(error);
+        throw new Error(error);
+    }
+    return (ctx) => {
+        return (sf) => {
+            if ((0, is_filename_matched_util_1.isFilenameMatched)(options.dtoFileNameSuffix, sf.fileName)) {
+                return modelClassVisitor.visit(sf, ctx, program, options);
+            }
+            if ((0, is_filename_matched_util_1.isFilenameMatched)(options.controllerFileNameSuffix, sf.fileName)) {
+                return controllerClassVisitor.visit(sf, ctx, program, options);
+            }
+            return sf;
+        };
+    };
+};
+exports.before = before;

package/dist/plugin/index.d.ts

@@ -0,0 +1,2 @@
+export * from './compiler-plugin';
+export * from './visitors/readonly.visitor';

package/dist/plugin/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./compiler-plugin"), exports);
+__exportStar(require("./visitors/readonly.visitor"), exports);

package/dist/plugin/merge-options.d.ts

@@ -0,0 +1,17 @@
+export interface PluginOptions {
+    dtoFileNameSuffix?: string | string[];
+    controllerFileNameSuffix?: string | string[];
+    classValidatorShim?: boolean;
+    classTransformerShim?: boolean | 'exclusive';
+    dtoKeyOfComment?: string;
+    controllerKeyOfComment?: string;
+    introspectComments?: boolean;
+    esmCompatible?: boolean;
+    readonly?: boolean;
+    pathToSource?: string;
+    debug?: boolean;
+    parameterProperties?: boolean;
+    skipAutoHttpCode?: boolean;
+    skipDefaultValues?: boolean;
+}
+export declare const mergePluginOptions: (options?: Record<string, any>) => PluginOptions;

package/dist/plugin/merge-options.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergePluginOptions = void 0;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const plugin_debug_logger_1 = require("./plugin-debug-logger");
+const defaultOptions = {
+    dtoFileNameSuffix: ['.dto.ts', '.entity.ts'],
+    controllerFileNameSuffix: ['.controller.ts'],
+    classValidatorShim: true,
+    classTransformerShim: false,
+    dtoKeyOfComment: 'description',
+    controllerKeyOfComment: 'summary',
+    introspectComments: false,
+    esmCompatible: false,
+    readonly: false,
+    debug: false,
+    skipDefaultValues: false
+};
+const mergePluginOptions = (options = {}) => {
+    if ((0, shared_utils_1.isString)(options.dtoFileNameSuffix)) {
+        options.dtoFileNameSuffix = [options.dtoFileNameSuffix];
+    }
+    if ((0, shared_utils_1.isString)(options.controllerFileNameSuffix)) {
+        options.controllerFileNameSuffix = [options.controllerFileNameSuffix];
+    }
+    for (const key of ['dtoFileNameSuffix', 'controllerFileNameSuffix']) {
+        if (options[key] && options[key].includes('.ts')) {
+            plugin_debug_logger_1.pluginDebugLogger.warn(`Skipping ${key} option ".ts" because it can cause unwanted behaviour.`);
+            options[key] = options[key].filter((pattern) => pattern !== '.ts');
+            if (options[key].length == 0) {
+                delete options[key];
+            }
+        }
+    }
+    return Object.assign(Object.assign({}, defaultOptions), options);
+};
+exports.mergePluginOptions = mergePluginOptions;

package/dist/plugin/metadata-loader.d.ts

@@ -0,0 +1,7 @@
+export declare class MetadataLoader {
+    private static readonly refreshHooks;
+    static addRefreshHook(hook: () => void): number;
+    load(metadata: Record<string, any>): Promise<void>;
+    private applyMetadata;
+    private runHooks;
+}

package/dist/plugin/metadata-loader.js

@@ -0,0 +1,51 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataLoader = void 0;
+const plugin_constants_1 = require("./plugin-constants");
+class MetadataLoader {
+    static addRefreshHook(hook) {
+        return MetadataLoader.refreshHooks.push(hook);
+    }
+    load(metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pkgMetadata = metadata['@nestjs/swagger'];
+            if (!pkgMetadata) {
+                return;
+            }
+            const { models, controllers } = pkgMetadata;
+            if (models) {
+                yield this.applyMetadata(models);
+            }
+            if (controllers) {
+                yield this.applyMetadata(controllers);
+            }
+            this.runHooks();
+        });
+    }
+    applyMetadata(meta) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const loadPromises = meta.map((_a) => __awaiter(this, [_a], void 0, function* ([fileImport, fileMeta]) {
+                const fileRef = yield fileImport;
+                Object.keys(fileMeta).map((key) => {
+                    const clsRef = fileRef[key];
+                    clsRef[plugin_constants_1.METADATA_FACTORY_NAME] = () => fileMeta[key];
+                });
+            }));
+            yield Promise.all(loadPromises);
+        });
+    }
+    runHooks() {
+        MetadataLoader.refreshHooks.forEach((hook) => hook());
+    }
+}
+exports.MetadataLoader = MetadataLoader;
+MetadataLoader.refreshHooks = new Array();

package/dist/plugin/plugin-constants.d.ts

@@ -0,0 +1,3 @@
+export declare const OPENAPI_NAMESPACE = "openapi";
+export declare const OPENAPI_PACKAGE_NAME = "@nestjs/swagger";
+export declare const METADATA_FACTORY_NAME = "_OPENAPI_METADATA_FACTORY";

package/dist/plugin/plugin-constants.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METADATA_FACTORY_NAME = exports.OPENAPI_PACKAGE_NAME = exports.OPENAPI_NAMESPACE = void 0;
+exports.OPENAPI_NAMESPACE = 'openapi';
+exports.OPENAPI_PACKAGE_NAME = '@nestjs/swagger';
+exports.METADATA_FACTORY_NAME = '_OPENAPI_METADATA_FACTORY';

package/dist/plugin/plugin-debug-logger.d.ts

@@ -0,0 +1,5 @@
+import { ConsoleLogger } from '@nestjs/common';
+declare class PluginDebugLogger extends ConsoleLogger {
+}
+export declare const pluginDebugLogger: PluginDebugLogger;
+export {};

package/dist/plugin/plugin-debug-logger.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginDebugLogger = void 0;
+const common_1 = require("@nestjs/common");
+class PluginDebugLogger extends common_1.ConsoleLogger {
+}
+exports.pluginDebugLogger = new PluginDebugLogger('CLI Plugin');

package/dist/plugin/utils/ast-utils.d.ts

@@ -0,0 +1,30 @@
+import { DocComment, DocNode } from '@microsoft/tsdoc';
+import * as ts from 'typescript';
+import { Decorator, Node, ObjectFlags, Type, TypeChecker, TypeFlags, TypeFormatFlags, UnionTypeNode } from 'typescript';
+export declare function renderDocNode(docNode: DocNode): string;
+export declare function isArray(type: Type): boolean;
+export declare function getTypeArguments(type: Type): any;
+export declare function isBoolean(type: Type): boolean;
+export declare function isString(type: Type): boolean;
+export declare function isStringLiteral(type: Type): boolean;
+export declare function isStringMapping(type: Type): boolean;
+export declare function isNumber(type: Type): boolean;
+export declare function isBigInt(type: Type): boolean;
+export declare function isInterface(type: Type): boolean;
+export declare function isEnum(type: Type): boolean;
+export declare function isEnumLiteral(type: Type): boolean;
+export declare function hasFlag(type: Type, flag: TypeFlags): boolean;
+export declare function hasObjectFlag(type: Type, flag: ObjectFlags): boolean;
+export declare function getText(type: Type, typeChecker: TypeChecker, enclosingNode?: Node, typeFormatFlags?: TypeFormatFlags): string;
+export declare function getDefaultTypeFormatFlags(enclosingNode: Node): number;
+export declare function getDocComment(node: Node): DocComment;
+export declare function getMainCommentOfNode(node: Node): string;
+export declare function parseCommentDocValue(docValue: string, type: ts.Type): string;
+export declare function getTsDocTagsOfNode(node: Node, typeChecker: TypeChecker): any;
+export declare function getTsDocErrorsOfNode(node: Node): any[];
+export declare function getDecoratorArguments(decorator: Decorator): any[] | ts.NodeArray<ts.Expression>;
+export declare function getDecoratorName(decorator: Decorator): string;
+export declare function findNullableTypeFromUnion(typeNode: UnionTypeNode, typeChecker: TypeChecker): ts.TypeNode;
+export declare function createBooleanLiteral(factory: ts.NodeFactory, flag: boolean): ts.BooleanLiteral;
+export declare function createPrimitiveLiteral(factory: ts.NodeFactory, item: unknown, typeOfItem?: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"): ts.StringLiteral | ts.NumericLiteral | ts.PrefixUnaryExpression | ts.BooleanLiteral;
+export declare function createLiteralFromAnyValue(factory: ts.NodeFactory, item: unknown): any;