import 'reflect-metadata';
/**
 * Compute the descriptor for `target` by collapsing its inheritance chain,
 * WITHOUT storing the result.
 *
 * Only the NEAREST descriptor in the chain is merged, not every ancestor's.
 * That is load-bearing and worth spelling out: every stored descriptor is
 * itself already collapsed - `getInheritedDescriptor` only ever writes a
 * fully collapsed value - so the nearest one already carries every ancestor's
 * contribution. Merging the whole chain would fold those contributions in a
 * second time, and since the merger concatenates arrays, array fields would
 * gain a duplicate per inheritance level ( eg. a three level chain yielding
 * `['a', 'a', 'b', 'c']` ).
 *
 * The merge is seeded with `createDefault()` so every key is present with its
 * proper type. That matters: the merger branches on `_.isMap(a)` / `_.isArray(a)`,
 * which only holds if the accumulator already carries real Maps and arrays.
 * Seeding also means the caller gets a fresh copy rather than the stored object.
 */
export declare function collapseInheritedDescriptor<T extends object>(target: object, symbol: symbol, createDefault: () => T): T;
/**
 * Return the descriptor OWNED by `target`, creating it on first access by
 * collapsing the inheritance chain.
 *
 * Own metadata is the whole point: `Reflect.getMetadata` walks the prototype
 * chain, so a subclass would otherwise find - and mutate - its parent's
 * descriptor. With own metadata each class has its own copy, pre-populated
 * with everything it inherited.
 */
export declare function getInheritedDescriptor<T extends object>(target: object, symbol: symbol, createDefault: () => T): T;
//# sourceMappingURL=descriptor-inheritance.d.ts.map