@vertz/compiler 0.0.2

package/dist/index.d.ts

@@ -0,0 +1,724 @@
+type DiagnosticSeverity = "error" | "warning" | "info";
+type DiagnosticCode = "VERTZ_SCHEMA_NAMING" | "VERTZ_SCHEMA_PLACEMENT" | "VERTZ_SCHEMA_EXECUTION" | "VERTZ_SCHEMA_MISSING_ID" | "VERTZ_SCHEMA_DYNAMIC_NAME" | "VERTZ_MODULE_CIRCULAR" | "VERTZ_MODULE_EXPORT_INVALID" | "VERTZ_MODULE_IMPORT_MISSING" | "VERTZ_MODULE_DUPLICATE_NAME" | "VERTZ_MODULE_DYNAMIC_NAME" | "VERTZ_MODULE_OPTIONS_INVALID" | "VERTZ_MODULE_WRONG_OWNERSHIP" | "VERTZ_SERVICE_INJECT_MISSING" | "VERTZ_SERVICE_UNUSED" | "VERTZ_SERVICE_DYNAMIC_NAME" | "VERTZ_ENV_MISSING_DEFAULT" | "VERTZ_ENV_DUPLICATE" | "VERTZ_ENV_DYNAMIC_CONFIG" | "VERTZ_MW_MISSING_NAME" | "VERTZ_MW_MISSING_HANDLER" | "VERTZ_MW_DYNAMIC_NAME" | "VERTZ_MW_NON_OBJECT_CONFIG" | "VERTZ_MW_REQUIRES_UNSATISFIED" | "VERTZ_MW_PROVIDES_COLLISION" | "VERTZ_MW_ORDER_INVALID" | "VERTZ_RT_UNKNOWN_MODULE_DEF" | "VERTZ_RT_DYNAMIC_PATH" | "VERTZ_RT_MISSING_HANDLER" | "VERTZ_RT_MISSING_PREFIX" | "VERTZ_RT_DYNAMIC_CONFIG" | "VERTZ_RT_INVALID_PATH" | "VERTZ_ROUTE_DUPLICATE" | "VERTZ_ROUTE_PARAM_MISMATCH" | "VERTZ_ROUTE_MISSING_RESPONSE" | "VERTZ_APP_MISSING" | "VERTZ_APP_NOT_FOUND" | "VERTZ_APP_DUPLICATE" | "VERTZ_APP_BASEPATH_FORMAT" | "VERTZ_APP_INLINE_MODULE" | "VERTZ_DEP_CYCLE" | "VERTZ_DEP_CIRCULAR" | "VERTZ_DEP_UNRESOLVED_INJECT" | "VERTZ_DEP_INIT_ORDER" | "VERTZ_CTX_COLLISION" | "VERTZ_DEAD_CODE";
+interface SourceContext {
+	lines: {
+		number: number;
+		text: string;
+	}[];
+	highlightStart: number;
+	highlightLength: number;
+}
+interface Diagnostic {
+	severity: DiagnosticSeverity;
+	code: DiagnosticCode;
+	message: string;
+	file?: string;
+	line?: number;
+	column?: number;
+	endLine?: number;
+	endColumn?: number;
+	suggestion?: string;
+	sourceContext?: SourceContext;
+}
+type CreateDiagnosticOptions = Diagnostic;
+declare function createDiagnostic(options: CreateDiagnosticOptions): Diagnostic;
+declare function createDiagnosticFromLocation(location: SourceLocation, options: Omit<CreateDiagnosticOptions, "file" | "line" | "column">): Diagnostic;
+declare function hasErrors(diagnostics: readonly Diagnostic[]): boolean;
+declare function filterBySeverity(diagnostics: readonly Diagnostic[], severity: DiagnosticSeverity): Diagnostic[];
+declare function mergeDiagnostics(a: readonly Diagnostic[], b: readonly Diagnostic[]): Diagnostic[];
+interface SourceLocation {
+	sourceFile: string;
+	sourceLine: number;
+	sourceColumn: number;
+}
+interface AppIR {
+	app: AppDefinition;
+	env?: EnvIR;
+	modules: ModuleIR[];
+	middleware: MiddlewareIR[];
+	schemas: SchemaIR[];
+	dependencyGraph: DependencyGraphIR;
+	diagnostics: Diagnostic[];
+}
+interface AppDefinition extends SourceLocation {
+	basePath: string;
+	version?: string;
+	globalMiddleware: MiddlewareRef[];
+	moduleRegistrations: ModuleRegistration[];
+}
+interface ModuleRegistration {
+	moduleName: string;
+	options?: Record<string, unknown>;
+}
+interface EnvIR extends SourceLocation {
+	loadFiles: string[];
+	schema?: SchemaRef;
+	variables: EnvVariableIR[];
+}
+interface EnvVariableIR {
+	name: string;
+	type: string;
+	hasDefault: boolean;
+	required: boolean;
+}
+interface ModuleIR extends SourceLocation {
+	name: string;
+	imports: ImportRef[];
+	options?: SchemaRef;
+	services: ServiceIR[];
+	routers: RouterIR[];
+	exports: string[];
+}
+interface ImportRef {
+	localName: string;
+	sourceModule?: string;
+	sourceExport?: string;
+	isEnvImport: boolean;
+}
+interface ServiceIR extends SourceLocation {
+	name: string;
+	moduleName: string;
+	inject: InjectRef[];
+	methods: ServiceMethodIR[];
+}
+interface InjectRef {
+	localName: string;
+	resolvedToken: string;
+}
+interface ServiceMethodIR {
+	name: string;
+	parameters: ServiceMethodParam[];
+	returnType: string;
+}
+interface ServiceMethodParam {
+	name: string;
+	type: string;
+}
+interface RouterIR extends SourceLocation {
+	name: string;
+	moduleName: string;
+	prefix: string;
+	inject: InjectRef[];
+	routes: RouteIR[];
+}
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
+interface RouteIR extends SourceLocation {
+	method: HttpMethod;
+	path: string;
+	fullPath: string;
+	operationId: string;
+	params?: SchemaRef;
+	query?: SchemaRef;
+	body?: SchemaRef;
+	headers?: SchemaRef;
+	response?: SchemaRef;
+	middleware: MiddlewareRef[];
+	description?: string;
+	tags: string[];
+}
+interface MiddlewareIR extends SourceLocation {
+	name: string;
+	inject: InjectRef[];
+	headers?: SchemaRef;
+	params?: SchemaRef;
+	query?: SchemaRef;
+	body?: SchemaRef;
+	requires?: SchemaRef;
+	provides?: SchemaRef;
+}
+interface MiddlewareRef {
+	name: string;
+	sourceFile: string;
+}
+interface SchemaIR extends SourceLocation {
+	name: string;
+	id?: string;
+	namingConvention: SchemaNameParts;
+	jsonSchema?: Record<string, unknown>;
+	isNamed: boolean;
+}
+interface SchemaNameParts {
+	operation?: string;
+	entity?: string;
+	part?: string;
+}
+type SchemaRef = NamedSchemaRef | InlineSchemaRef;
+interface NamedSchemaRef {
+	kind: "named";
+	schemaName: string;
+	sourceFile: string;
+	jsonSchema?: Record<string, unknown>;
+}
+interface InlineSchemaRef {
+	kind: "inline";
+	sourceFile: string;
+	jsonSchema?: Record<string, unknown>;
+}
+interface ModuleDefContext {
+	moduleDefVariables: Map<string, string>;
+}
+interface DependencyGraphIR {
+	nodes: DependencyNode[];
+	edges: DependencyEdge[];
+	initializationOrder: string[];
+	circularDependencies: string[][];
+}
+type DependencyNodeKind = "module" | "service" | "router" | "middleware";
+interface DependencyNode {
+	id: string;
+	kind: DependencyNodeKind;
+	name: string;
+	moduleName?: string;
+}
+type DependencyEdgeKind = "imports" | "inject" | "uses-middleware" | "exports";
+interface DependencyEdge {
+	from: string;
+	to: string;
+	kind: DependencyEdgeKind;
+}
+import { Project } from "ts-morph";
+interface SchemaConfig {
+	enforceNaming: boolean;
+	enforcePlacement: boolean;
+}
+interface OpenAPIConfig {
+	output: string;
+	info: {
+		title: string;
+		version: string;
+		description?: string;
+	};
+}
+interface ValidationConfig {
+	requireResponseSchema: boolean;
+	detectDeadCode: boolean;
+}
+interface CompilerConfig {
+	sourceDir: string;
+	outputDir: string;
+	entryFile: string;
+	schemas: SchemaConfig;
+	openapi: OpenAPIConfig;
+	validation: ValidationConfig;
+}
+interface VertzConfig {
+	strict?: boolean;
+	forceGenerate?: boolean;
+	compiler?: Partial<CompilerConfig>;
+}
+interface ResolvedConfig {
+	strict: boolean;
+	forceGenerate: boolean;
+	compiler: CompilerConfig;
+}
+declare function defineConfig(config: VertzConfig): VertzConfig;
+declare function resolveConfig(config?: VertzConfig): ResolvedConfig;
+interface Analyzer<T> {
+	analyze(): Promise<T>;
+}
+declare abstract class BaseAnalyzer<T> implements Analyzer<T> {
+	protected readonly project: Project;
+	protected readonly config: ResolvedConfig;
+	private readonly _diagnostics;
+	constructor(project: Project, config: ResolvedConfig);
+	protected addDiagnostic(diagnostic: Diagnostic): void;
+	getDiagnostics(): Diagnostic[];
+}
+interface AppAnalyzerResult {
+	app: AppDefinition;
+}
+declare class AppAnalyzer extends BaseAnalyzer<AppAnalyzerResult> {
+	analyze(): Promise<AppAnalyzerResult>;
+	private collectChainedCalls;
+	private extractMiddlewares;
+	private extractRegistrations;
+	private extractOptions;
+}
+interface DependencyGraphInput {
+	modules: ModuleIR[];
+	middleware: MiddlewareIR[];
+}
+interface DependencyGraphResult {
+	graph: DependencyGraphIR;
+}
+declare class DependencyGraphAnalyzer extends BaseAnalyzer<DependencyGraphResult> {
+	private input;
+	setInput(input: DependencyGraphInput): void;
+	analyze(input?: DependencyGraphInput): Promise<DependencyGraphResult>;
+	private buildNodes;
+	private buildServiceTokenMap;
+	private buildEdges;
+	private addInjectEdges;
+	private computeModuleOrder;
+	private detectCycles;
+	private emitCycleDiagnostics;
+	private emitUnresolvedInjectDiagnostics;
+	private warnUnresolvedInjects;
+}
+interface EnvAnalyzerResult {
+	env: EnvIR | undefined;
+}
+declare class EnvAnalyzer extends BaseAnalyzer<EnvAnalyzerResult> {
+	analyze(): Promise<EnvAnalyzerResult>;
+}
+interface MiddlewareAnalyzerResult {
+	middleware: MiddlewareIR[];
+}
+declare class MiddlewareAnalyzer extends BaseAnalyzer<MiddlewareAnalyzerResult> {
+	analyze(): Promise<MiddlewareAnalyzerResult>;
+	private resolveSchemaRef;
+}
+import { Expression, ObjectLiteralExpression } from "ts-morph";
+interface ModuleAnalyzerResult {
+	modules: ModuleIR[];
+}
+declare class ModuleAnalyzer extends BaseAnalyzer<ModuleAnalyzerResult> {
+	analyze(): Promise<ModuleAnalyzerResult>;
+}
+declare function parseImports(obj: ObjectLiteralExpression): ImportRef[];
+declare function extractIdentifierNames(expr: Expression): string[];
+interface RouteAnalyzerResult {
+	routers: RouterIR[];
+}
+declare class RouteAnalyzer extends BaseAnalyzer<RouteAnalyzerResult> {
+	analyze(): Promise<RouteAnalyzerResult>;
+	analyzeForModules(context: ModuleDefContext): Promise<RouteAnalyzerResult>;
+	private detectUnknownRouterCalls;
+	private extractRoutes;
+	private findChainedHttpCalls;
+	private chainResolvesToVariable;
+	private extractRoute;
+	private resolveSchemaRef;
+	private extractMiddlewareRefs;
+	private generateOperationId;
+}
+import { Expression as Expression2, SourceFile } from "ts-morph";
+interface SchemaAnalyzerResult {
+	schemas: SchemaIR[];
+}
+declare class SchemaAnalyzer extends BaseAnalyzer<SchemaAnalyzerResult> {
+	analyze(): Promise<SchemaAnalyzerResult>;
+}
+declare function parseSchemaName2(name: string): SchemaNameParts;
+declare function isSchemaExpression(_file: SourceFile, expr: Expression2): boolean;
+declare function extractSchemaId(expr: Expression2): string | null;
+declare function isSchemaFile(file: SourceFile): boolean;
+declare function createNamedSchemaRef(schemaName: string, sourceFile: string): NamedSchemaRef;
+declare function createInlineSchemaRef(sourceFile: string): InlineSchemaRef;
+import { Expression as Expression3, ObjectLiteralExpression as ObjectLiteralExpression2 } from "ts-morph";
+interface ServiceAnalyzerResult {
+	services: ServiceIR[];
+}
+declare class ServiceAnalyzer extends BaseAnalyzer<ServiceAnalyzerResult> {
+	analyze(): Promise<ServiceAnalyzerResult>;
+	analyzeForModule(moduleDefVarName: string, moduleName: string): Promise<ServiceIR[]>;
+}
+declare function parseInjectRefs(obj: ObjectLiteralExpression2): InjectRef[];
+declare function extractMethodSignatures(expr: Expression3): ServiceMethodIR[];
+interface Generator {
+	generate(ir: AppIR, outputDir: string): Promise<void>;
+}
+declare abstract class BaseGenerator implements Generator {
+	protected readonly config: ResolvedConfig;
+	constructor(config: ResolvedConfig);
+	protected resolveOutputPath(outputDir: string, fileName: string): string;
+}
+interface Validator {
+	validate(ir: AppIR): Promise<Diagnostic[]>;
+}
+interface CompileResult {
+	success: boolean;
+	ir: AppIR;
+	diagnostics: Diagnostic[];
+}
+interface CompilerDependencies {
+	analyzers: {
+		env: Analyzer<EnvAnalyzerResult>;
+		schema: Analyzer<SchemaAnalyzerResult>;
+		middleware: Analyzer<MiddlewareAnalyzerResult>;
+		module: Analyzer<ModuleAnalyzerResult>;
+		app: Analyzer<AppAnalyzerResult>;
+		dependencyGraph: Analyzer<DependencyGraphResult>;
+	};
+	validators: Validator[];
+	generators: Generator[];
+}
+declare class Compiler {
+	private readonly config;
+	private readonly deps;
+	constructor(config: ResolvedConfig, dependencies: CompilerDependencies);
+	getConfig(): ResolvedConfig;
+	analyze(): Promise<AppIR>;
+	validate(ir: AppIR): Promise<Diagnostic[]>;
+	generate(ir: AppIR): Promise<void>;
+	compile(): Promise<CompileResult>;
+}
+declare function createCompiler(config?: VertzConfig): Compiler;
+interface BootModuleEntry {
+	name: string;
+	importPath: string;
+	variableName: string;
+	options?: Record<string, unknown>;
+}
+interface BootMiddlewareEntry {
+	name: string;
+	importPath: string;
+	variableName: string;
+}
+interface BootManifest {
+	initializationOrder: string[];
+	modules: BootModuleEntry[];
+	globalMiddleware: BootMiddlewareEntry[];
+}
+declare function buildBootManifest(ir: AppIR): BootManifest;
+declare function resolveImportPath(from: string, to: string): string;
+declare function renderBootFile(manifest: BootManifest, outputDir: string): string;
+declare class BootGenerator extends BaseGenerator {
+	readonly name = "boot";
+	generate(ir: AppIR, outputDir: string): Promise<void>;
+}
+interface ManifestModule {
+	name: string;
+	services: string[];
+	routers: string[];
+	exports: string[];
+	imports: {
+		from: string;
+		items: string[];
+	}[];
+}
+interface ManifestRoute {
+	method: HttpMethod;
+	path: string;
+	operationId: string;
+	module: string;
+	router: string;
+	middleware: string[];
+	params?: Record<string, unknown>;
+	query?: Record<string, unknown>;
+	body?: Record<string, unknown>;
+	headers?: Record<string, unknown>;
+	response?: Record<string, unknown>;
+}
+interface ManifestMiddleware {
+	name: string;
+	provides?: Record<string, unknown>;
+	requires?: Record<string, unknown>;
+}
+interface ManifestDependencyEdge {
+	from: string;
+	to: string;
+	type: DependencyEdgeKind;
+}
+interface ManifestDiagnostic {
+	severity: "error" | "warning" | "info";
+	code: string;
+	message: string;
+	file?: string;
+	line?: number;
+	suggestion?: string;
+}
+interface AppManifest {
+	version: string;
+	app: {
+		basePath: string;
+		version?: string;
+	};
+	modules: ManifestModule[];
+	routes: ManifestRoute[];
+	schemas: Record<string, Record<string, unknown>>;
+	middleware: ManifestMiddleware[];
+	dependencyGraph: {
+		initializationOrder: string[];
+		edges: ManifestDependencyEdge[];
+	};
+	diagnostics: {
+		errors: number;
+		warnings: number;
+		items: ManifestDiagnostic[];
+	};
+}
+declare function buildManifest(ir: AppIR): AppManifest;
+declare class ManifestGenerator extends BaseGenerator {
+	readonly name = "manifest";
+	generate(ir: AppIR, outputDir: string): Promise<void>;
+}
+interface OpenAPIDocument {
+	openapi: "3.1.0";
+	info: OpenAPIInfo;
+	servers: OpenAPIServer[];
+	paths: Record<string, OpenAPIPathItem>;
+	components: {
+		schemas: Record<string, JSONSchemaObject>;
+	};
+	tags: OpenAPITag[];
+}
+interface OpenAPIInfo {
+	title: string;
+	version: string;
+	description?: string;
+}
+interface OpenAPIServer {
+	url: string;
+	description?: string;
+}
+interface OpenAPITag {
+	name: string;
+	description?: string;
+}
+interface OpenAPIPathItem {
+	[method: string]: OpenAPIOperation | undefined;
+	get?: OpenAPIOperation;
+	post?: OpenAPIOperation;
+	put?: OpenAPIOperation;
+	delete?: OpenAPIOperation;
+	patch?: OpenAPIOperation;
+	head?: OpenAPIOperation;
+	options?: OpenAPIOperation;
+}
+interface OpenAPIOperation {
+	operationId: string;
+	summary?: string;
+	description?: string;
+	tags: string[];
+	parameters: OpenAPIParameter[];
+	requestBody?: OpenAPIRequestBody;
+	responses: Record<string, OpenAPIResponse>;
+}
+interface OpenAPIParameter {
+	name: string;
+	in: "path" | "query" | "header";
+	required: boolean;
+	schema: JSONSchemaObject;
+	description?: string;
+}
+interface OpenAPIRequestBody {
+	required: boolean;
+	content: {
+		"application/json": {
+			schema: JSONSchemaObject;
+		};
+	};
+}
+interface OpenAPIResponse {
+	description: string;
+	content?: {
+		"application/json": {
+			schema: JSONSchemaObject;
+		};
+	};
+}
+type JSONSchemaObject = {
+	$ref?: string;
+	type?: string | string[];
+	properties?: Record<string, JSONSchemaObject>;
+	required?: string[];
+	items?: JSONSchemaObject;
+	oneOf?: JSONSchemaObject[];
+	allOf?: JSONSchemaObject[];
+	anyOf?: JSONSchemaObject[];
+	discriminator?: {
+		propertyName: string;
+		mapping?: Record<string, string>;
+	};
+	enum?: (string | number | boolean | null)[];
+	const?: string | number | boolean | null;
+	format?: string;
+	description?: string;
+	default?: unknown;
+	$defs?: Record<string, JSONSchemaObject>;
+	additionalProperties?: boolean | JSONSchemaObject;
+	[key: string]: unknown;
+};
+declare class OpenAPIGenerator extends BaseGenerator {
+	readonly name = "openapi";
+	generate(ir: AppIR, outputDir: string): Promise<void>;
+	buildDocument(ir: AppIR): OpenAPIDocument;
+	private buildOperation;
+	private buildResponses;
+	private resolveAndLift;
+	private getSuccessStatusCode;
+	convertPath(routePath: string): string;
+	buildParameters(route: RouteIR, middlewareMap: Map<string, MiddlewareIR>): OpenAPIParameter[];
+	resolveSchemaRef(schemaRef: SchemaRef): JSONSchemaObject;
+	private extractParamsFromSchema;
+	private extractHeaderParams;
+	liftDefsToComponents(schema: JSONSchemaObject, components: Record<string, JSONSchemaObject>): JSONSchemaObject;
+	private rewriteRefs;
+	collectTags(ir: AppIR): OpenAPITag[];
+}
+interface RouteTableSchemas {
+	params?: string;
+	query?: string;
+	body?: string;
+	headers?: string;
+	response?: string;
+}
+interface RouteTableEntry {
+	method: HttpMethod;
+	path: string;
+	operationId: string;
+	moduleName: string;
+	routerName: string;
+	middleware: string[];
+	schemas: RouteTableSchemas;
+}
+interface RouteTableManifest {
+	routes: RouteTableEntry[];
+}
+declare function buildRouteTable(ir: AppIR): RouteTableManifest;
+declare function renderRouteTableFile(manifest: RouteTableManifest): string;
+declare class RouteTableGenerator extends BaseGenerator {
+	readonly name = "route-table";
+	generate(ir: AppIR, outputDir: string): Promise<void>;
+}
+interface SchemaRegistryEntry {
+	name: string;
+	id?: string;
+	importPath: string;
+	variableName: string;
+	jsonSchema?: Record<string, unknown>;
+}
+interface SchemaRegistryManifest {
+	schemas: SchemaRegistryEntry[];
+}
+declare function buildSchemaRegistry(ir: AppIR): SchemaRegistryManifest;
+declare function renderSchemaRegistryFile(manifest: SchemaRegistryManifest, outputDir: string): string;
+declare class SchemaRegistryGenerator extends BaseGenerator {
+	readonly name = "schema-registry";
+	generate(ir: AppIR, outputDir: string): Promise<void>;
+}
+interface FileChange {
+	path: string;
+	kind: "added" | "modified" | "deleted";
+}
+type FileCategory = "schema" | "router" | "service" | "module" | "middleware" | "app-entry" | "env" | "config";
+interface CategorizedChanges {
+	schema: FileChange[];
+	router: FileChange[];
+	service: FileChange[];
+	module: FileChange[];
+	middleware: FileChange[];
+	requiresFullRecompile: boolean;
+	requiresReboot: boolean;
+	rebootReason?: string;
+}
+interface CategorizeOptions {
+	entryFile?: string;
+}
+declare function categorizeChanges(changes: FileChange[], options?: CategorizeOptions): CategorizedChanges;
+declare function findAffectedModules(categorized: CategorizedChanges, ir: AppIR): string[];
+type IncrementalResult = {
+	kind: "incremental";
+	affectedModules: string[];
+	diagnostics: Diagnostic[];
+} | {
+	kind: "full-recompile";
+} | {
+	kind: "reboot";
+	reason: string;
+};
+declare class IncrementalCompiler {
+	private currentIR;
+	private readonly compiler;
+	constructor(compiler: Compiler);
+	initialCompile(): Promise<CompileResult>;
+	handleChanges(changes: FileChange[]): Promise<IncrementalResult>;
+	getCurrentIR(): AppIR;
+}
+declare function createEmptyDependencyGraph(): DependencyGraphIR;
+declare function createEmptyAppIR(): AppIR;
+declare function addDiagnosticsToIR(ir: AppIR, diagnostics: readonly Diagnostic[]): AppIR;
+declare function mergeIR(base: AppIR, partial: Partial<AppIR>): AppIR;
+import { ChildProcess } from "node:child_process";
+interface TypecheckDiagnostic {
+	file: string;
+	line: number;
+	column: number;
+	message: string;
+	code: number;
+}
+interface TypecheckResult {
+	success: boolean;
+	diagnostics: TypecheckDiagnostic[];
+}
+interface TypecheckOptions {
+	tsconfigPath?: string;
+}
+declare function parseTscOutput(output: string): TypecheckDiagnostic[];
+declare function parseWatchBlock(block: string): TypecheckResult;
+interface TypecheckWatchOptions extends TypecheckOptions {
+	spawner?: () => ChildProcess;
+}
+declare function typecheckWatch(options?: TypecheckWatchOptions): AsyncGenerator<TypecheckResult>;
+declare function typecheck(options?: TypecheckOptions): Promise<TypecheckResult>;
+import { CallExpression, Expression as Expression4, Node, ObjectLiteralExpression as ObjectLiteralExpression3, SourceFile as SourceFile2 } from "ts-morph";
+declare function findCallExpressions(file: SourceFile2, objectName: string, methodName: string): CallExpression[];
+declare function findMethodCallsOnVariable(file: SourceFile2, variableName: string, methodName: string): CallExpression[];
+declare function extractObjectLiteral(callExpr: CallExpression, argIndex: number): ObjectLiteralExpression3 | null;
+declare function getPropertyValue(obj: ObjectLiteralExpression3, key: string): Expression4 | null;
+declare function getProperties(obj: ObjectLiteralExpression3): {
+	name: string;
+	value: Expression4;
+}[];
+declare function getStringValue(expr: Expression4): string | null;
+declare function getBooleanValue(expr: Expression4): boolean | null;
+declare function getNumberValue(expr: Expression4): number | null;
+declare function getArrayElements(expr: Expression4): Expression4[];
+declare function getVariableNameForCall(callExpr: CallExpression): string | null;
+declare function getSourceLocation(node: Node): SourceLocation;
+import { Identifier, Node as Node2, Project as Project2, SourceFile as SourceFile3 } from "ts-morph";
+interface ResolvedImport {
+	declaration: Node2;
+	sourceFile: SourceFile3;
+	exportName: string;
+}
+declare function resolveIdentifier(identifier: Identifier, project: Project2): ResolvedImport | null;
+declare function resolveExport(file: SourceFile3, exportName: string, project: Project2): ResolvedImport | null;
+declare function isFromImport(identifier: Identifier, moduleSpecifier: string): boolean;
+interface SchemaExecutionResult {
+	jsonSchema: Record<string, unknown>;
+}
+interface SchemaExecutor {
+	execute(schemaName: string, sourceFile: string): Promise<SchemaExecutionResult | null>;
+	getDiagnostics(): Diagnostic[];
+}
+declare function createSchemaExecutor(_rootDir: string): SchemaExecutor;
+declare class CompletenessValidator implements Validator {
+	validate(ir: AppIR): Promise<Diagnostic[]>;
+	private checkResponseSchemas;
+	private checkUnusedServices;
+	private checkUnreferencedSchemas;
+	private checkDIWiring;
+	private checkInjectTokens;
+	private checkMiddlewareChains;
+	private checkModuleOptions;
+	private checkRoutePathFormat;
+	private checkPathParamMatch;
+	private checkDuplicateRoutes;
+	private checkCtxKeyCollisions;
+}
+declare class ModuleValidator implements Validator {
+	validate(ir: AppIR): Promise<Diagnostic[]>;
+	private checkExports;
+	private checkOwnership;
+	private checkCircularDependencies;
+}
+interface ParsedSchemaName {
+	operation: string | null;
+	entity: string | null;
+	part: string | null;
+}
+type ValidOperation = "create" | "read" | "update" | "list" | "delete";
+type ValidPart = "Body" | "Response" | "Query" | "Params" | "Headers";
+declare class NamingValidator implements Validator {
+	validate(ir: AppIR): Promise<Diagnostic[]>;
+	parseSchemaName(name: string): ParsedSchemaName;
+	private suggestFix;
+}
+declare class PlacementValidator implements Validator {
+	validate(ir: AppIR): Promise<Diagnostic[]>;
+	private checkFileLocation;
+	private checkMixedExports;
+}
+export { typecheckWatch, typecheck, resolveImportPath, resolveIdentifier, resolveExport, resolveConfig, renderSchemaRegistryFile, renderRouteTableFile, renderBootFile, parseWatchBlock, parseTscOutput, parseSchemaName2 as parseSchemaName, parseInjectRefs, parseImports, mergeIR, mergeDiagnostics, isSchemaFile, isSchemaExpression, isFromImport, hasErrors, getVariableNameForCall, getStringValue, getSourceLocation, getPropertyValue, getProperties, getNumberValue, getBooleanValue, getArrayElements, findMethodCallsOnVariable, findCallExpressions, findAffectedModules, filterBySeverity, extractSchemaId, extractObjectLiteral, extractMethodSignatures, extractIdentifierNames, defineConfig, createSchemaExecutor, createNamedSchemaRef, createInlineSchemaRef, createEmptyDependencyGraph, createEmptyAppIR, createDiagnosticFromLocation, createDiagnostic, createCompiler, categorizeChanges, buildSchemaRegistry, buildRouteTable, buildManifest, buildBootManifest, addDiagnosticsToIR, VertzConfig, Validator, ValidationConfig, ValidPart, ValidOperation, TypecheckWatchOptions, TypecheckResult, TypecheckOptions, TypecheckDiagnostic, SourceLocation, SourceContext, ServiceMethodParam, ServiceMethodIR, ServiceIR, ServiceAnalyzerResult, ServiceAnalyzer, SchemaRegistryManifest, SchemaRegistryGenerator, SchemaRegistryEntry, SchemaRef, SchemaNameParts, SchemaIR, SchemaExecutor, SchemaExecutionResult, SchemaConfig, SchemaAnalyzerResult, SchemaAnalyzer, RouterIR, RouteTableSchemas, RouteTableManifest, RouteTableGenerator, RouteTableEntry, RouteIR, RouteAnalyzerResult, RouteAnalyzer, ResolvedImport, ResolvedConfig, PlacementValidator, ParsedSchemaName, OpenAPITag, OpenAPIServer, OpenAPIResponse, OpenAPIRequestBody, OpenAPIPathItem, OpenAPIParameter, OpenAPIOperation, OpenAPIInfo, OpenAPIGenerator, OpenAPIDocument, OpenAPIConfig, NamingValidator, NamedSchemaRef, ModuleValidator, ModuleRegistration, ModuleIR, ModuleDefContext, ModuleAnalyzerResult, ModuleAnalyzer, MiddlewareRef, MiddlewareIR, MiddlewareAnalyzerResult, MiddlewareAnalyzer, ManifestRoute, ManifestModule, ManifestMiddleware, ManifestGenerator, ManifestDiagnostic, ManifestDependencyEdge, JSONSchemaObject, InlineSchemaRef, InjectRef, IncrementalResult, IncrementalCompiler, ImportRef, HttpMethod, Generator, FileChange, FileCategory, EnvVariableIR, EnvIR, EnvAnalyzerResult, EnvAnalyzer, DiagnosticSeverity, DiagnosticCode, Diagnostic, DependencyNodeKind, DependencyNode, DependencyGraphResult, DependencyGraphInput, DependencyGraphIR, DependencyGraphAnalyzer, DependencyEdgeKind, DependencyEdge, CreateDiagnosticOptions, CompletenessValidator, CompilerDependencies, CompilerConfig, Compiler, CompileResult, CategorizedChanges, CategorizeOptions, BootModuleEntry, BootMiddlewareEntry, BootManifest, BootGenerator, BaseGenerator, BaseAnalyzer, AppManifest, AppIR, AppDefinition, AppAnalyzerResult, AppAnalyzer, Analyzer };