/**
 * TypeRegistry - Pure IR source of truth for type declarations
 *
 * ALICE'S SPEC (Step 3): This registry stores IrType (pure IR), NOT ts.TypeNode.
 * Types are converted at registration time, making queries deterministic.
 *
 * CANONICAL CLR IDENTITY: Well-known runtime types from compiler core globals,
 * Tsonic surface packages, @tsonic/core, and @tsonic/dotnet are registered
 * with canonical CLR FQ names
 * (e.g., String → System.String, String$instance → System.String$instance).
 *
 * Part of Alice's specification for deterministic IR typing.
 *
 * FACADE: This module re-exports from registry-helpers.ts and registry-builder.ts.
 * Type declarations are kept here so that all consumers can import from one path.
 */
import * as ts from "typescript";
import type { IrType, IrMethodSignature } from "../../types/index.js";
/**
 * Information about a type member (property or method) - PURE IR
 */
export type MemberInfo = {
    readonly kind: "property" | "method" | "indexSignature";
    readonly name: string;
    readonly type: IrType | undefined;
    readonly isOptional: boolean;
    readonly isReadonly: boolean;
    readonly methodSignatures?: readonly IrMethodSignature[];
};
/**
 * Heritage clause information (extends/implements) - PURE IR
 */
export type HeritageInfo = {
    readonly kind: "extends" | "implements";
    readonly baseType: IrType;
    readonly typeName: string;
};
/**
 * Type parameter info for generic types - PURE IR
 */
export type TypeParameterEntry = {
    readonly name: string;
    readonly constraint?: IrType;
    readonly defaultType?: IrType;
};
/**
 * Entry for a nominal type (class, interface, type alias) - PURE IR
 *
 * NOTE: No ts.Declaration, ts.SourceFile, or ts.TypeNode fields.
 */
export type TypeRegistryEntry = {
    readonly kind: "class" | "interface" | "typeAlias";
    readonly name: string;
    readonly fullyQualifiedName: string;
    readonly ownerIdentity: string;
    readonly isDeclarationFile: boolean;
    readonly preservesAssemblyIdentity?: boolean;
    readonly typeParameters: readonly TypeParameterEntry[];
    readonly members: ReadonlyMap<string, MemberInfo>;
    readonly heritage: readonly HeritageInfo[];
    readonly aliasedType?: IrType;
};
/**
 * TypeRegistry API - returns pure IR types
 */
export type TypeRegistry = {
    /**
     * Resolve a type by fully-qualified name. Returns undefined if not found.
     */
    readonly resolveNominal: (fqName: string) => TypeRegistryEntry | undefined;
    /**
     * Resolve a type by simple name.
     * Returns undefined when the simple name is ambiguous.
     */
    readonly resolveBySimpleName: (simpleName: string) => TypeRegistryEntry | undefined;
    /**
     * Get the fully-qualified name for a simple name.
     * Returns undefined if not found or ambiguous.
     */
    readonly getFQName: (simpleName: string) => string | undefined;
    /**
     * Get all fully-qualified names registered for a simple name.
     */
    readonly getFQNames: (simpleName: string) => readonly string[];
    /**
     * Get a member's type from a nominal type (by FQ name).
     * Returns pure IrType - no TypeNode access needed.
     */
    readonly getMemberType: (fqNominal: string, memberName: string) => IrType | undefined;
    /**
     * Get all heritage clauses for a nominal type (by FQ name).
     * Returns pure IrType heritage info.
     */
    readonly getHeritageTypes: (fqNominal: string) => readonly HeritageInfo[];
    /**
     * Get all registered type names (fully-qualified).
     */
    readonly getAllTypeNames: () => readonly string[];
    /**
     * Check if a type name is registered (by FQ name).
     */
    readonly hasType: (fqName: string) => boolean;
};
/**
 * Type conversion function - converts TypeNode to IrType
 */
export type ConvertTypeFn = (typeNode: ts.TypeNode) => IrType;
export type BuildTypeRegistryOptions = {
    readonly convertType?: ConvertTypeFn;
};
export { buildTypeRegistry } from "./registry-builder.js";
//# sourceMappingURL=type-registry.d.ts.map