import { type Declarable } from "./declarable.js";
/**
 * Marker symbol for Composite type identification.
 */
export declare const COMPOSITE_MARKER: unique symbol;
/**
 * A record of named members produced by a composite factory.
 *
 * What a consumer reads off `instance.members`. Deliberately narrow: every
 * value here is a real Declarable, so `.entityType` and friends resolve without
 * narrowing. What a factory may RETURN is wider — see
 * {@link CompositeFactoryMembers}.
 */
export type CompositeMembers = Record<string, Declarable>;
/**
 * What a factory is allowed to RETURN — {@link CompositeMembers} plus
 * `undefined`, used only as the generic constraint.
 *
 * A member produced by a conditional spread (`...(cond ? { policy } : {})`) is
 * typed optional, and an optional property is not assignable to a
 * required-value record. Widening the constraint lets such a factory typecheck;
 * widening `CompositeMembers` itself would make every member possibly-undefined
 * for everyone reading `instance.members`, which is a worse trade.
 *
 * The key is absent at runtime rather than present-and-undefined, so nothing
 * reaches the validation in `Composite` below.
 */
export type CompositeFactoryMembers = Record<string, Declarable | CompositeInstance<any> | undefined> | CompositeInstance<any>;
/**
 * The result of instantiating a composite — contains the marker and expanded members.
 */
export interface CompositeInstance<M extends CompositeFactoryMembers = CompositeMembers> {
    readonly [COMPOSITE_MARKER]: true;
    readonly members: M;
    readonly _definition: CompositeDefinition<any, M>;
}
/**
 * A composite definition: a callable that produces a CompositeInstance.
 */
export interface CompositeDefinition<P, M extends CompositeFactoryMembers = CompositeMembers> {
    (props: P): CompositeInstance<M> & M;
    readonly compositeName: string;
    readonly _id: symbol;
}
/**
 * Type guard: is this value a CompositeInstance?
 */
export declare function isCompositeInstance(value: unknown): value is CompositeInstance;
/**
 * Global registry of composite definitions.
 */
export declare class CompositeRegistry {
    private static definitions;
    static register(definition: CompositeDefinition<unknown>): void;
    static getAll(): CompositeDefinition<unknown>[];
    static clear(): void;
    static get size(): number;
}
/**
 * Creates a composite definition from a factory closure.
 *
 * Usage:
 * ```ts
 * const SecureStorage = Composite<{ name: string }>((props) => {
 *   const bucket = new Bucket({ bucketName: props.name });
 *   const role = new Role({ policies: [{ resource: bucket.arn }] });
 *   return { bucket, role };
 * });
 * export const storage = SecureStorage({ name: "data" });
 * ```
 */
export declare function Composite<P, M extends CompositeFactoryMembers = CompositeMembers>(factory: (props: P) => M, name?: string): CompositeDefinition<P, M>;
/**
 * Expands a CompositeInstance into a flat Map of prefixed entity names to Declarables.
 * Handles nested composites recursively.
 */
export declare function expandComposite(prefix: string, instance: CompositeInstance): Map<string, Declarable>;
/**
 * Type helpers for withDefaults.
 */
type PartialByDefault<P, D extends Partial<P>> = Omit<P, keyof D> & Partial<Pick<P, keyof D & keyof P>>;
type Simplify<T> = {
    [K in keyof T]: T[K];
};
/**
 * Wraps a CompositeDefinition with pre-applied default values.
 * Props that have defaults become optional in the returned type.
 *
 * ```ts
 * const SecureApi = withDefaults(LambdaApi, { runtime: "nodejs20.x", timeout: 10 });
 * const api = SecureApi({ name: "myApi", code: "./dist" }); // runtime and timeout are optional
 * ```
 */
export declare function withDefaults<P, M extends CompositeMembers, D extends Partial<P>>(definition: CompositeDefinition<P, M>, defaults: D | ((props: Partial<P>) => D)): CompositeDefinition<Simplify<PartialByDefault<P, D>>, M>;
/**
 * Symbol key for shared props attached by propagate().
 */
export declare const SHARED_PROPS: unique symbol;
/**
 * Symbol key stashing a member's original (pre-merge) props, so expandComposite()
 * is idempotent across repeated expansions of the same singleton instance (#1032).
 */
export declare const ORIGINAL_PROPS: unique symbol;
/**
 * Attaches shared properties to a composite instance.
 * During expandComposite(), shared props are merged into every member's props.
 *
 * Merge semantics:
 * - Scalars: member-specific value wins
 * - Arrays (e.g. tags): concatenate shared + member-specific
 * - undefined values in shared props are stripped
 *
 * ```ts
 * export const storage = propagate(
 *   SecureStorage({ name: "data" }),
 *   { tags: [{ key: "env", value: "prod" }] },
 * );
 * ```
 */
export declare function propagate<M extends CompositeMembers>(instance: CompositeInstance<M> & M, sharedProps: Record<string, unknown>): CompositeInstance<M> & M;
/**
 * Marker function for resource declarations within composites.
 * At runtime, simply calls `new Type(props)` and returns the result.
 * Exists so lint tooling can validate composite member construction (EVL005).
 */
export declare function resource<T extends Declarable, P>(Type: new (props: P, attributes?: Record<string, unknown>) => T, props: P, attributes?: Record<string, unknown>): T;
/**
 * Shallow-merges override values into a base props object.
 *
 * Merge semantics:
 * - `undefined` values in overrides are skipped
 * - Arrays: concatenated (base + overrides), matching `propagate()` semantics
 * - Scalars / objects: override wins
 *
 * No deep merge — too dangerous with IaC props where nested objects
 * (e.g. policy documents) should be replaced wholesale.
 */
export declare function mergeDefaults<T extends Record<string, unknown>>(base: T, overrides?: Partial<T>): T;
export {};
//# sourceMappingURL=composite.d.ts.map