@runtyped/type-compiler 1.0.20-alpha.1

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) up to 2026 Marc J. Schmidt <marc@marcjschmidt.de>
+Copyright (c) 2026 - present Jacopo Scazzosi <jacopo@scazzosi.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,4 @@
+# @runtyped/type-compiler
+
+The compiler/transformer companion to [@runtyped/type](https://npm.im/@runtyped/type).
+Check the documentation at [https://github.com/runtyped/runtyped](https://github.com/runtyped/runtyped).

package/compiler-debug.ts

@@ -0,0 +1,38 @@
+import { deepkitType } from './src/plugin.js';
+import { readFileSync } from 'fs';
+
+interface Arguments {
+    file: string;
+    config?: string;
+}
+
+function parseArguments(args: string[]): Arguments {
+    const result: Arguments = {
+        file: '',
+    };
+
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--config') {
+            result.config = args[i + 1];
+            i++;
+        } else {
+            result.file = arg;
+        }
+    }
+
+    return result;
+}
+
+const args = parseArguments(process.argv.slice(2));
+
+
+
+const transformer = deepkitType({
+    tsConfig: args.config,
+});
+
+const code = readFileSync(args.file, 'utf8');
+const transformed = transformer(code, args.file);
+
+console.log(transformed?.code);

package/deepkit-compiler-debug.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+try {
+    require('./dist/cjs/compiler-debug.js');
+} catch (error) {}

package/deepkit-type-install.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+try {
+    require('./dist/cjs/install-transformer.js');
+} catch (error) {}

package/dist/cjs/compiler-debug.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/compiler-debug.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const plugin_js_1 = require("./src/plugin.js");
+const fs_1 = require("fs");
+function parseArguments(args) {
+    const result = {
+        file: '',
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--config') {
+            result.config = args[i + 1];
+            i++;
+        }
+        else {
+            result.file = arg;
+        }
+    }
+    return result;
+}
+const args = parseArguments(process.argv.slice(2));
+const transformer = (0, plugin_js_1.deepkitType)({
+    tsConfig: args.config,
+});
+const code = (0, fs_1.readFileSync)(args.file, 'utf8');
+const transformed = transformer(code, args.file);
+console.log(transformed?.code);
+//# sourceMappingURL=compiler-debug.js.map

package/dist/cjs/compiler-debug.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler-debug.js","sourceRoot":"","sources":["../../compiler-debug.ts"],"names":[],"mappings":";;AAAA,+CAA8C;AAC9C,2BAAkC;AAOlC,SAAS,cAAc,CAAC,IAAc;IAClC,MAAM,MAAM,GAAc;QACtB,IAAI,EAAE,EAAE;KACX,CAAC;IAEF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QACpB,IAAI,GAAG,KAAK,UAAU,EAAE,CAAC;YACrB,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YAC5B,CAAC,EAAE,CAAC;QACR,CAAC;aAAM,CAAC;YACJ,MAAM,CAAC,IAAI,GAAG,GAAG,CAAC;QACtB,CAAC;IACL,CAAC;IAED,OAAO,MAAM,CAAC;AAClB,CAAC;AAED,MAAM,IAAI,GAAG,cAAc,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAInD,MAAM,WAAW,GAAG,IAAA,uBAAW,EAAC;IAC5B,QAAQ,EAAE,IAAI,CAAC,MAAM;CACxB,CAAC,CAAC;AAEH,MAAM,IAAI,GAAG,IAAA,iBAAY,EAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;AAC7C,MAAM,WAAW,GAAG,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;AAEjD,OAAO,CAAC,GAAG,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC"}

package/dist/cjs/index.d.ts

@@ -0,0 +1,7 @@
+import type { Program } from 'typescript';
+export * from './src/compiler.js';
+export * from './src/loader.js';
+export default function myTransformerPlugin(program: Program, opts: {}): {
+    before: import("typescript").CustomTransformerFactory;
+    afterDeclarations: import("typescript").CustomTransformerFactory;
+};

package/dist/cjs/index.js

@@ -0,0 +1,36 @@
+"use strict";
+/*
+ * Runtyped Framework
+ * Copyright (C) 2021 Deepkit UG, Marc J. Schmidt
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License.
+ *
+ * You should have received a copy of the MIT License along with this program.
+ */
+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 });
+exports.default = myTransformerPlugin;
+const compiler_js_1 = require("./src/compiler.js");
+__exportStar(require("./src/compiler.js"), exports);
+__exportStar(require("./src/loader.js"), exports);
+function myTransformerPlugin(program, opts) {
+    return {
+        before: compiler_js_1.transformer,
+        afterDeclarations: compiler_js_1.declarationTransformer,
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;;;;;;;;;;;;;;AAQH,sCAKC;AAXD,mDAAwE;AAGxE,oDAAkC;AAClC,kDAAgC;AAEhC,SAAwB,mBAAmB,CAAC,OAAgB,EAAE,IAAQ;IAClE,OAAO;QACH,MAAM,EAAE,yBAAW;QACnB,iBAAiB,EAAE,oCAAsB;KAC5C,CAAC;AACN,CAAC"}

package/dist/cjs/install-transformer.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * This script installs the deepkit/type transformer (that extracts automatically types and adds the correct @t decorator) to the typescript node_modules.
+ *
+ * The critical section that needs adjustment is in the `function getScriptTransformers` in `node_modules/typescript/lib/tsc.js`.
+ */
+export {};

package/dist/cjs/install-transformer.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * This script installs the deepkit/type transformer (that extracts automatically types and adds the correct @t decorator) to the typescript node_modules.
+ *
+ * The critical section that needs adjustment is in the `function getScriptTransformers` in `node_modules/typescript/lib/tsc.js`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const fs_1 = require("fs");
+let to = process.argv[2] || process.cwd();
+function getPatchId(id) {
+    return 'deepkit_type_patch_' + id;
+}
+function getCode(deepkitDistPath, varName, id) {
+    return `
+        //${getPatchId(id)}
+        try {
+            var typeTransformer;
+            try {
+                typeTransformer = require('@runtyped/type-compiler');
+            } catch (error) {
+                typeTransformer = require(${JSON.stringify(deepkitDistPath)});
+            }
+            if (typeTransformer) {
+                if (!customTransformers) ${varName} = {};
+                if (!${varName}.before) ${varName}.before = [];
+                let alreadyPatched = false;
+                for (let fn of ${varName}.before) {
+                    if (fn && fn.name === 'deepkitTransformer') alreadyPatched = true;
+                }
+                if (!alreadyPatched) {
+                    if (!${varName}.before.includes(typeTransformer.transformer)) ${varName}.before.push(typeTransformer.transformer);
+
+                    if (!${varName}.afterDeclarations) ${varName}.afterDeclarations = [];
+                    if (!${varName}.afterDeclarations.includes(typeTransformer.declarationTransformer)) {
+                        ${varName}.afterDeclarations.push(typeTransformer.declarationTransformer);
+                    }
+                }
+            }
+        } catch (e) {
+        }
+        //${getPatchId(id)}-end
+    `;
+}
+function isPatched(code, id) {
+    return code.includes(getPatchId(id));
+}
+function patchGetTransformers(deepkitDistPath, code) {
+    const id = 'patchGetTransformers';
+    if (isPatched(code, id))
+        return '';
+    const find = /function getTransformers\([^)]+\)\s*{/;
+    if (!code.match(find))
+        return '';
+    code = code.replace(find, function (a) {
+        return a + '\n    ' + getCode(deepkitDistPath, 'customTransformers', id);
+    });
+    return code;
+}
+if (to + '/dist/cjs' === __dirname) {
+    to = (0, path_1.join)(to, '..'); //we exclude type-compiler/node_modules
+}
+const typeScriptPath = (0, path_1.dirname)(require.resolve('typescript', { paths: [to] }));
+const deepkitDistPath = (0, path_1.relative)(typeScriptPath, __dirname);
+const paths = ['tsc.js', '_tsc.js', 'typescript.js'];
+for (const fileName of paths) {
+    const file = (0, path_1.join)(typeScriptPath, fileName);
+    if (!(0, fs_1.existsSync)(file))
+        continue;
+    const content = patchGetTransformers(deepkitDistPath, (0, fs_1.readFileSync)(file, 'utf8'));
+    if (!content)
+        continue;
+    (0, fs_1.writeFileSync)(file, content);
+    console.log('Deepkit Type: Injected TypeScript transformer at', file);
+}
+//# sourceMappingURL=install-transformer.js.map

package/dist/cjs/install-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"install-transformer.js","sourceRoot":"","sources":["../../install-transformer.ts"],"names":[],"mappings":";;AAEA;;;;GAIG;;AAEH,+BAA+C;AAC/C,2BAA6D;AAE7D,IAAI,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;AAE1C,SAAS,UAAU,CAAC,EAAU;IAC1B,OAAO,qBAAqB,GAAG,EAAE,CAAC;AACtC,CAAC;AAED,SAAS,OAAO,CAAC,eAAuB,EAAE,OAAe,EAAE,EAAU;IACjE,OAAO;YACC,UAAU,CAAC,EAAE,CAAC;;;;;;4CAMkB,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC;;;2CAGhC,OAAO;uBAC3B,OAAO,YAAY,OAAO;;iCAEhB,OAAO;;;;2BAIb,OAAO,kDAAkD,OAAO;;2BAEhE,OAAO,uBAAuB,OAAO;2BACrC,OAAO;0BACR,OAAO;;;;;;YAMrB,UAAU,CAAC,EAAE,CAAC;KACrB,CAAC;AACN,CAAC;AAED,SAAS,SAAS,CAAC,IAAY,EAAE,EAAU;IACvC,OAAO,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC;AACzC,CAAC;AAED,SAAS,oBAAoB,CAAC,eAAuB,EAAE,IAAY;IAC/D,MAAM,EAAE,GAAG,sBAAsB,CAAC;IAClC,IAAI,SAAS,CAAC,IAAI,EAAE,EAAE,CAAC;QAAE,OAAO,EAAE,CAAC;IAEnC,MAAM,IAAI,GAAG,uCAAuC,CAAC;IACrD,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC;QAAE,OAAO,EAAE,CAAC;IAEjC,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,UAAU,CAAC;QACjC,OAAO,CAAC,GAAG,QAAQ,GAAG,OAAO,CAAC,eAAe,EAAE,oBAAoB,EAAE,EAAE,CAAC,CAAC;IAC7E,CAAC,CAAC,CAAC;IAEH,OAAO,IAAI,CAAC;AAChB,CAAC;AAED,IAAI,EAAE,GAAG,WAAW,KAAK,SAAS,EAAE,CAAC;IACjC,EAAE,GAAG,IAAA,WAAI,EAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,uCAAuC;AAChE,CAAC;AAED,MAAM,cAAc,GAAG,IAAA,cAAO,EAAC,OAAO,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAC/E,MAAM,eAAe,GAAG,IAAA,eAAQ,EAAC,cAAc,EAAE,SAAS,CAAC,CAAC;AAE5D,MAAM,KAAK,GAAG,CAAC,QAAQ,EAAE,SAAS,EAAE,eAAe,CAAC,CAAC;AAErD,KAAK,MAAM,QAAQ,IAAI,KAAK,EAAE,CAAC;IAC3B,MAAM,IAAI,GAAG,IAAA,WAAI,EAAC,cAAc,EAAE,QAAQ,CAAC,CAAC;IAC5C,IAAI,CAAC,IAAA,eAAU,EAAC,IAAI,CAAC;QAAE,SAAS;IAChC,MAAM,OAAO,GAAG,oBAAoB,CAAC,eAAe,EAAE,IAAA,iBAAY,EAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;IAClF,IAAI,CAAC,OAAO;QAAE,SAAS;IACvB,IAAA,kBAAa,EAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC7B,OAAO,CAAC,GAAG,CAAC,kDAAkD,EAAE,IAAI,CAAC,CAAC;AAC1E,CAAC"}

package/dist/cjs/src/compiler.d.ts

@@ -0,0 +1,313 @@
+import ts, { ArrowFunction, Bundle, ClassDeclaration, ClassExpression, CompilerHost, CompilerOptions, ConstructorDeclaration, CustomTransformer, CustomTransformerFactory, Declaration, EntityName, ExportDeclaration, Expression, ExpressionWithTypeArguments, FunctionDeclaration, FunctionExpression, Identifier, ImportDeclaration, JSDocImportTag, MethodDeclaration, ModuleDeclaration, ModuleExportName, Node, NodeArray, NodeFactory, ParseConfigHost, PropertyAccessExpression, QualifiedName, Statement, TransformationContext, TypeAliasDeclaration, TypeChecker, TypeParameterDeclaration, TypeReferenceNode } from 'typescript';
+import { NodeConverter, PackExpression } from './reflection-ast.js';
+import { SourceFile } from './ts-types.js';
+import { ReflectionOp } from '@runtyped/type-spec';
+import { Resolver } from './resolver.js';
+import { ConfigResolver, MatchResult, ReflectionConfig, ReflectionConfigCache } from './config.js';
+export declare function encodeOps(ops: ReflectionOp[]): string;
+export declare const packSizeByte: number;
+/**
+ * It can't be more ops than this given number
+ */
+export declare const packSize: number;
+export declare function debugPackStruct(sourceFile: SourceFile, forType: Node, pack: {
+    ops: ReflectionOp[];
+    stack: PackExpression[];
+}): void;
+interface Frame {
+    variables: {
+        name: string;
+        index: number;
+    }[];
+    opIndex: number;
+    conditional?: true;
+    previous?: Frame;
+}
+type StackEntry = Expression | string | number | boolean;
+declare class CompilerProgram {
+    forNode: Node;
+    sourceFile?: SourceFile | undefined;
+    protected ops: ReflectionOp[];
+    protected stack: StackEntry[];
+    protected mainOffset: number;
+    protected stackPosition: number;
+    protected frame: Frame;
+    protected activeCoRoutines: {
+        ops: ReflectionOp[];
+    }[];
+    protected coRoutines: {
+        ops: ReflectionOp[];
+    }[];
+    constructor(forNode: Node, sourceFile?: SourceFile | undefined);
+    buildPackStruct(): {
+        ops: ReflectionOp[];
+        stack: StackEntry[];
+    };
+    isEmpty(): boolean;
+    pushConditionalFrame(): void;
+    pushStack(item: StackEntry): number;
+    pushCoRoutine(): void;
+    popCoRoutine(): number;
+    pushOp(...ops: ReflectionOp[]): void;
+    pushOpAtFrame(frame: Frame, ...ops: ReflectionOp[]): void;
+    /**
+     * Returns the index of the `entry` in the stack, if already exists. If not, add it, and return that new index.
+     */
+    findOrAddStackEntry(entry: any): number;
+    /**
+     * To make room for a stack entry expected on the stack as input for example.
+     */
+    increaseStackPosition(): number;
+    protected resolveFunctionParameters: Map<ts.Node, number>;
+    resolveFunctionParametersIncrease(fn: Node): void;
+    resolveFunctionParametersDecrease(fn: Node): void;
+    isResolveFunctionParameters(fn: Node): boolean;
+    /**
+     *
+     * Each pushFrame() call needs a popFrame() call.
+     */
+    pushFrame(implicit?: boolean): Frame;
+    findConditionalFrame(): Frame | undefined;
+    /**
+     * Remove stack without doing it as OP in the processor. Some other command calls popFrame() already, which makes popFrameImplicit() an implicit popFrame.
+     * e.g. union, class, etc. all call popFrame(). the current CompilerProgram needs to be aware of that, which this function is for.
+     */
+    popFrameImplicit(): void;
+    moveFrame(): void;
+    pushVariable(name: string, frame?: Frame): number;
+    pushTemplateParameter(name: string, withDefault?: boolean): number;
+    findVariable(name: string, frame?: Frame): {
+        frameOffset: number;
+        stackIndex: number;
+    } | undefined;
+}
+export declare class Cache {
+    resolver: ReflectionConfigCache;
+    sourceFiles: {
+        [fileName: string]: SourceFile;
+    };
+    globalSourceFiles?: SourceFile[];
+    /**
+     * Signals the cache to check if it needs to be cleared.
+     */
+    tick(): void;
+}
+/**
+ * Read the TypeScript AST and generate pack struct (instructions + pre-defined stack).
+ *
+ * This transformer extracts type and add the encoded (so its small and low overhead) at classes and functions as property.
+ *
+ * runtyped/type can then extract and decode them on-demand.
+ */
+export declare class ReflectionTransformer implements CustomTransformer {
+    protected context: TransformationContext;
+    protected cache: Cache;
+    sourceFile: SourceFile;
+    protected f: NodeFactory;
+    protected embedAssignType: boolean;
+    /**
+     * Types added to this map will get a type program directly under it.
+     * This is for types used in the very same file.
+     */
+    protected compileDeclarations: Map<ts.EnumDeclaration | ts.InterfaceDeclaration | ts.TypeAliasDeclaration, {
+        name: EntityName;
+        sourceFile: SourceFile;
+        compiled?: Statement[];
+    }>;
+    /**
+     * Types added to this map will get a type program at the top root level of the program.
+     * This is for imported types, which need to be inlined into the current file, as we do not emit type imports (TS will omit them).
+     */
+    protected embedDeclarations: Map<ts.Node, {
+        name: EntityName;
+        sourceFile?: SourceFile;
+    }>;
+    /**
+     * When a node was embedded or compiled (from the maps above), we store it here to know to not add it again.
+     */
+    protected compiledDeclarations: Set<ts.Node>;
+    protected addImports: {
+        importDeclaration: ImportDeclaration | JSDocImportTag;
+        identifier: Identifier;
+    }[];
+    protected additionalImports: Map<ts.ImportDeclaration | ts.JSDocImportTag, ts.Statement>;
+    protected nodeConverter: NodeConverter;
+    protected typeChecker?: TypeChecker;
+    protected resolver: Resolver;
+    protected host: CompilerHost;
+    protected overriddenHost: boolean;
+    protected overriddenConfigResolver?: ConfigResolver;
+    protected compilerOptions: CompilerOptions;
+    /**
+     * When a deep call expression was found a script-wide variable is necessary
+     * as temporary storage.
+     */
+    protected tempResultIdentifier?: Identifier;
+    protected parseConfigHost: ParseConfigHost;
+    protected intrinsicMetaDeclaration: TypeAliasDeclaration;
+    constructor(context: TransformationContext, cache?: Cache);
+    forHost(host: CompilerHost): this;
+    withReflection(config: ReflectionConfig): this;
+    transformBundle(node: Bundle): Bundle;
+    getTempResultIdentifier(): Identifier;
+    protected getConfigResolver(sourceFile: {
+        fileName: string;
+    }): ConfigResolver;
+    protected getReflectionConfig(sourceFile: {
+        fileName: string;
+    }): MatchResult;
+    protected isWithReflection(sourceFile: SourceFile | undefined, node: Node & {
+        __deepkitConfig?: ReflectionConfig;
+    }): boolean;
+    transformSourceFile(sourceFile: SourceFile): SourceFile;
+    attachAdditionalStatements(statements: NodeArray<Statement> | Statement[]): Statement[];
+    protected getModuleType(): 'cjs' | 'esm';
+    protected getArrowFunctionΩPropertyAccessIdentifier(node: ArrowFunction): Identifier | undefined;
+    protected injectResetΩ<T extends FunctionDeclaration | FunctionExpression | MethodDeclaration | ConstructorDeclaration | ArrowFunction>(node: T): T;
+    protected createProgramVarFromNode(node: Node, name: EntityName, sourceFile?: SourceFile): Statement[];
+    protected extractPackStructOfExpression(node: Expression, program: CompilerProgram): void;
+    protected extractPackStructOfType(node: Node | Declaration | ClassDeclaration | ClassExpression, program: CompilerProgram): void;
+    protected knownClasses: {
+        [name: string]: ReflectionOp;
+    };
+    protected getGlobalLibs(): SourceFile[];
+    /**
+     * This is a custom resolver based on populated `locals` from the binder. It uses a custom resolution algorithm since
+     * we have no access to the binder/TypeChecker directly and instantiating a TypeChecker per file/transformer is incredible slow.
+     */
+    protected resolveDeclaration(typeName: EntityName): {
+        declaration: Node;
+        importDeclaration?: ImportDeclaration | JSDocImportTag;
+        typeOnly?: boolean;
+    } | void;
+    protected getDeclarationVariableName(typeName: EntityName): Identifier;
+    /**
+     * The semantic of isExcluded is different from checking if the fileName is part
+     * of reflection config option. isExcluded checks if the file should be excluded
+     * via the exclude option. mainly used to exclude globals and external libraries.
+     */
+    protected isExcluded(fileName: string): boolean;
+    protected extractPackStructOfTypeReference(type: Identifier | TypeReferenceNode | ExpressionWithTypeArguments, program: CompilerProgram): void;
+    /**
+     * Returns the class declaration, function/arrow declaration, or block where type was used.
+     */
+    protected getTypeUser(type: Node): Node;
+    /**
+     * With this function we want to check if `type` is used in the signature itself from the parent of `declaration`.
+     * If so, we do not try to infer the type from runtime values.
+     *
+     * Examples where we do not infer from runtime, `type` being `T` and `declaration` being `<T>` (return false):
+     *
+     * ```typescript
+     * class User<T> {
+     *     config: T;
+     * }
+     *
+     * class User<T> {
+     *    constructor(public config: T) {}
+     * }
+     *
+     * function do<T>(item: T): void {}
+     * function do<T>(item: T): T {}
+     * ```
+     *
+     * Examples where we infer from runtime (return true):
+     *
+     * ```typescript
+     * function do<T>(item: T) {
+     *     return typeOf<T>; //<-- because of that
+     * }
+     *
+     * function do<T>(item: T) {
+     *     class A {
+     *         config: T; //<-- because of that
+     *     }
+     *     return A;
+     * }
+     *
+     * function do<T>(item: T) {
+     *     class A {
+     *         doIt() {
+     *             class B {
+     *                 config: T; //<-- because of that
+     *             }
+     *             return B;
+     *         }
+     *     }
+     *     return A;
+     * }
+     *
+     * function do<T>(item: T) {
+     *     class A {
+     *         doIt(): T { //<-- because of that
+     *         }
+     *     }
+     *     return A;
+     * }
+     * ```
+     */
+    protected needsToBeInferred(declaration: TypeParameterDeclaration, type: Identifier | TypeReferenceNode | ExpressionWithTypeArguments): boolean;
+    protected resolveTypeOnlyImport(entityName: EntityName, program: CompilerProgram): void;
+    protected resolveTypeName(typeName: string, program: CompilerProgram): void;
+    protected resolveTypeParameter(declaration: TypeParameterDeclaration, type: Identifier | TypeReferenceNode | ExpressionWithTypeArguments, program: CompilerProgram): void;
+    protected createAccessorForEntityName(e: QualifiedName): PropertyAccessExpression;
+    protected findDeclarationInFile(sourceFile: SourceFile | ModuleDeclaration, declarationName: string): Declaration | undefined;
+    protected resolveImportSpecifier(_declarationName: string | ModuleExportName, importOrExport: ExportDeclaration | ImportDeclaration | JSDocImportTag, sourceFile: SourceFile): Declaration | undefined;
+    protected followExport(declarationName: string, statement: ExportDeclaration, sourceFile: SourceFile): Declaration | undefined;
+    protected getTypeOfType(type: Node | Declaration): Expression | undefined;
+    protected packOpsAndStack(program: CompilerProgram): ts.Expression | undefined;
+    /**
+     * Note: We have to duplicate the expressions as it can be that incoming expression are from another file and contain wrong pos/end properties,
+     * so the code generation is then broken when we simply reuse them. Wrong code like ``User.__type = [.toEqual({`` is then generated.
+     * This function is probably not complete, but we add new copies when required.
+     */
+    protected valueToExpression(value: undefined | PackExpression | PackExpression[]): Expression;
+    /**
+     * A class is decorated with type information by adding a static variable.
+     *
+     * class Model {
+     *     static __types = pack(ReflectionOp.string); //<-- encoded type information
+     *     title: string;
+     * }
+     */
+    protected decorateClass(sourceFile: SourceFile, node: ClassDeclaration | ClassExpression): Node;
+    /**
+     * const fn = function() {}
+     *
+     * => const fn = __assignType(function() {}, [34])
+     */
+    protected decorateFunctionExpression(expression: FunctionExpression): ts.FunctionExpression | ts.CallExpression;
+    /**
+     * function name() {}
+     *
+     * => function name() {}; name.__type = 34;
+     */
+    protected decorateFunctionDeclaration(declaration: FunctionDeclaration): ts.ExportAssignment | ts.FunctionDeclaration | ts.Statement[] | undefined;
+    /**
+     * const fn = () => {}
+     * => const fn = __assignType(() => {}, [34])
+     */
+    protected decorateArrowFunction(expression: ArrowFunction): ts.ArrowFunction | ts.CallExpression;
+    /**
+     * Object.assign(fn, {__type: []}) is much slower than a custom implementation like
+     *
+     * assignType(fn, [])
+     *
+     * where we embed assignType() at the beginning of the type.
+     */
+    protected wrapWithAssignType(fn: Expression, type: Expression): ts.CallExpression;
+    /**
+     * Checks if reflection was disabled/enabled in file via JSDoc attribute for a particular
+     * Node, e.g `@reflection no`. If nothing is found, "reflection" config option needs to be used.
+     */
+    protected getExplicitReflectionMode(sourceFile: SourceFile | undefined, node: Node): boolean | undefined;
+}
+export declare class DeclarationTransformer extends ReflectionTransformer {
+    protected addExports: {
+        identifier: string;
+    }[];
+    transformSourceFile(sourceFile: SourceFile): SourceFile;
+}
+export declare const transformer: CustomTransformerFactory;
+export declare const declarationTransformer: CustomTransformerFactory;
+export {};