/**
 * The records the module-interface assembly threads through its sections, and
 * the three mappings every section applies to a type on its way out of the
 * module.
 *
 * D115 §三: `resolveNominals`, `functionSignature` and `inferPublicExpression`
 * were three helpers at the tail of `index.ts`, read by both halves of the
 * assembly. They are the leaf of this directory: nothing here reads a draft or
 * writes one, so `./assembly.ts` and `./declarations.ts` both depend on it and
 * it depends on neither.
 */
import type { Expression, FunctionDeclaration, Statement, TypeReference } from "../../../ast.ts";
import { type ClassInfo } from "../../../contracts.ts";
import type { CompilerExtension, ModuleTest } from "../../../extension.ts";
import { type EnumInfo, type GenericTypeInfo, type ValueType } from "../../../types.ts";
/** The nominal identities a module publishes its own declarations under. */
export interface ModuleIdentities {
    readonly classIdentities: Map<string, string>;
    readonly enumNames: Map<string, EnumInfo>;
    readonly namedTypeIdentities: Map<string, string>;
    readonly aliasDeclarations: Map<string, Extract<Statement, {
        kind: "TypeAliasDeclaration";
    }>>;
}
/**
 * The resolvers every section reads a type through: `resolve` for a written
 * type reference, `resolveAnalyzed` for a type the analyzer already produced,
 * and the two await probes a class's `@dispose:` is classified with. They close
 * over one alias cache, so they are built once and shared rather than rebuilt
 * per declaration.
 */
export interface InterfaceResolution {
    readonly resolve: (reference: TypeReference | null) => ValueType;
    readonly resolveAnalyzed: (type: ValueType) => ValueType;
    readonly resolvedAnalyzedBindings: Map<string, ValueType>;
    readonly directAwaitExpression: (expression: Expression, contains: (expression: Expression) => boolean) => boolean | undefined;
    readonly directAwaitStatement: (statement: Statement, containsExpression: (expression: Expression) => boolean, containsBlock: (statements: readonly Statement[]) => boolean) => boolean | undefined;
}
/** The tables the assembly fills in, in the order the one function filled them. */
export interface InterfaceDraft {
    readonly namedTypes: Map<string, ReadonlyMap<string, ValueType>>;
    readonly namedTypeReadonlyFields: Map<string, ReadonlySet<string>>;
    readonly namedTypeBases: Map<string, ValueType>;
    readonly genericTypes: Map<string, GenericTypeInfo>;
    readonly typeAliases: Map<string, ValueType>;
    readonly enums: Map<string, EnumInfo>;
    readonly classes: Map<string, ClassInfo>;
    readonly exports: Map<string, ValueType>;
    readonly hoistedExports: Set<string>;
    readonly mutableExports: Set<string>;
    readonly reactiveExports: Map<string, "state">;
    readonly inspectionExtensions: readonly NonNullable<CompilerExtension["inspection"]>[];
    readonly tests: ModuleTest[];
    readonly extensionExports: Map<string, Map<string, unknown>>;
    readonly extensionData: Map<string, unknown>;
}
/**
 * What the analyzer already worked out for this module, when it ran. An
 * interface built without an analysis (`inspectModule`) passes empty tables and
 * every section falls back to what the declaration itself says.
 */
export interface AnalyzedModule {
    readonly classes: ReadonlyMap<string, ClassInfo>;
    readonly namedTypes: ReadonlyMap<string, ReadonlyMap<string, ValueType>>;
    readonly namedTypeReadonlyFields: ReadonlyMap<string, ReadonlySet<string>>;
    readonly namedTypeBases: ReadonlyMap<string, ValueType>;
    readonly genericTypes: ReadonlyMap<string, GenericTypeInfo>;
}
export declare function functionSignature(statement: Pick<FunctionDeclaration, "typeParameters" | "parameters" | "returnType" | "asynchronous">, resolve: (reference: TypeReference | null) => ValueType): ValueType;
export declare function resolveNominals(type: ValueType, classIdentities: ReadonlyMap<string, string>, enumNames: ReadonlyMap<string, EnumInfo>, namedTypeIdentities: ReadonlyMap<string, string>): ValueType;
export declare function inferPublicExpression(expression: Expression, extensions: readonly NonNullable<CompilerExtension["inspection"]>[]): ValueType;
//# sourceMappingURL=tables.d.ts.map