import type { MetaField, MetaRoot } from "@metaobjectsdev/metadata";
/** A shared (root-level abstract) enum declaration the codegen must reason about. */
export interface SharedEnum {
    /** The materialized type name — the abstract declaration's PascalCase name (cross-port identity). */
    readonly name: string;
    /** Member symbols (the @values SSOT). */
    readonly values: string[];
    /** True when the declaration carries `@provided: true` (reference, don't materialize). */
    readonly provided: boolean;
}
/**
 * The root-level abstract `field.enum` a concrete enum field resolves to via
 * `extends`, or undefined when the field is an inline enum (no root-abstract
 * super). A super qualifies only when it is (a) an abstract field, AND (b) a
 * direct child of the metadata root (a package-level declaration) — NOT an
 * abstract field nested inside another object.
 */
export declare function resolveSharedEnumDecl(field: MetaField): MetaField | undefined;
/** The shared-enum descriptor a field resolves to, or undefined for inline enums. */
export declare function sharedEnumForField(field: MetaField): SharedEnum | undefined;
/**
 * All shared (root-level abstract) enum declarations in the loaded root that are
 * actually CONSUMED by at least one concrete entity field — keyed by the
 * materialized type name. A declaration nobody extends is not materialized (no
 * dangling type). Deterministic order: first-consumption order across entities.
 */
export declare function collectSharedEnums(root: MetaRoot): Map<string, SharedEnum>;
/** The shared enums that metaobjects MATERIALIZES (non-@provided, consumed). */
export declare function materializedSharedEnums(root: MetaRoot): SharedEnum[];
/** Whether any shared enum (materialized or provided) is consumed in the model. */
export declare function hasSharedEnums(root: MetaRoot): boolean;
//# sourceMappingURL=enum-shared.d.ts.map