import type { ProcessedCodegenParameters } from "../parameters.js";
import type { CompiledTsType, JsonSchema, LogLevel } from "../shared.js";
import type { CompileContext } from "./compile.js";
import type { TypeDependencyMap } from "./shared.js";
import type { DataType, EntityType, PropertyType, VersionedUrl } from "@blockprotocol/type-system";
type IdentifierSource = {
    definingPath: string;
} & ({
    kind: "external";
} | {
    kind: "local";
    compiledContents: string;
    dependentOnIdentifiers: string[];
});
/**
 * Defines the source, or sources, associated with a given identifier.
 *
 * Duplicate identifiers can exist when they're defined but not importable during codegen.
 */
export type IdentifierSources = {
    locallyImportable: true;
    source: IdentifierSource;
} | {
    locallyImportable: false;
    source: IdentifierSource[];
};
export declare class PostprocessContext {
    readonly parameters: ProcessedCodegenParameters;
    readonly logLevel: LogLevel;
    readonly dataTypes: Record<VersionedUrl, DataType>;
    readonly propertyTypes: Record<VersionedUrl, PropertyType>;
    readonly entityTypes: Record<VersionedUrl, EntityType>;
    readonly metadataSchemas: Record<VersionedUrl, JsonSchema>;
    readonly allTypes: Record<VersionedUrl, DataType | PropertyType | EntityType | JsonSchema>;
    readonly typeDependencyMap: TypeDependencyMap;
    /** Map of entity type IDs to whether or not they are link entity types */
    readonly linkTypeMap: Record<keyof typeof this.entityTypes, boolean>;
    /** Map of sourceTypeIds to their compiled schemas */
    readonly typeIdsToCompiledTypes: Record<keyof typeof this.allTypes, CompiledTsType>;
    /**
     * Map of TypeScript identifiers, to their source (the file that exports them) and the contents required to define
     * them if they're a locally defined type
     */
    IdentifiersToSources: Record<string, IdentifierSources>;
    /** Map of files to the identifiers of types that they will **depend on**, either by defining or importing them */
    filesToDependentIdentifiers: Record<string, Set<string>>;
    /** Map of files to the identifiers of types that they will **define** */
    filesToDefinedIdentifiers: Record<string, Set<string>>;
    /** Map of files to the actual TypeScript contents */
    filesToContents: Record<string, string>;
    constructor(compileContext: CompileContext);
    logWarn(message: string): void;
    logInfo(message: string): void;
    logDebug(message: string): void;
    logTrace(message: string): void;
    addDependentIdentifierInFile(identifier: string, path: string): void;
    defineIdentifierInFile(identifier: string, { definingPath, compiledContents, dependentOnIdentifiers, }: {
        definingPath: string;
        compiledContents: string;
        dependentOnIdentifiers: string[];
    }, locallyImportable: boolean): void;
}
export {};