import type { TuplePaths } from '@baseplate-dev/utils';
import type { RefContextSlot } from './ref-context-slot.js';
import type { DefinitionEntity, DefinitionEntityType, DefinitionReference } from './types.js';
/**
 * Allows the caller to resolve the name of an entity, optionally providing a
 * map of entity ids that need to be resolved prior to resolving the entity's
 * name.
 */
export interface DefinitionEntityNameResolver<TEntityIds extends Record<string, string | string[]> = Record<string, string | string[]>> {
    /**
     * Optional map of entity ids that need to be resolved prior to resolving the
     * entity's name.
     */
    idsToResolve?: TEntityIds;
    /**
     * Resolves the name of an entity from the provided entity names.
     * @param entityNames - A map of entity ids to their names.
     * @returns The name of the entity.
     */
    resolveName: (entityNames: TEntityIds) => string;
}
/**
 * Creates a definition entity name resolver.
 * @param entityNameResolver - The entity name resolver.
 * @returns The definition entity name resolver.
 */
export declare function createDefinitionEntityNameResolver<TEntityIds extends Record<string, string | string[]>>(entityNameResolver: DefinitionEntityNameResolver<TEntityIds>): DefinitionEntityNameResolver<TEntityIds>;
/**
 * Base definition for entity input.
 *
 * @template TInput - The overall input data type.
 * @template TEntityType - The entity type, extending DefinitionEntityType.
 * @template TPath - The type representing a path in TInput (e.g. a dot-separated string); defaults to undefined.
 * @template TIdKey - The key type for the entity's id; defaults to "id".
 */
interface DefinitionEntityInputBase<TInput, TEntityType extends DefinitionEntityType, TIdPath extends TuplePaths<TInput> | undefined = undefined> {
    /** The entity type definition. */
    type: TEntityType;
    /** Optional path key used to store the entity's id; if not provided, the id is assumed to be under the entity's path with key "id". */
    idPath?: TIdPath;
    /** Optional function used to get the name resolver from the input data. Otherwise, the entity's name is assumed to be under the entity's path with key "name". */
    getNameResolver?: (value: TInput) => DefinitionEntityNameResolver<any> | string;
    /** Optional ref context slot that this entity provides. Registers this entity's path in a shared context. */
    provides?: RefContextSlot<TEntityType>;
    /** When true, arrays of this entity type are sorted by name during serialization for deterministic output. */
    sortByName?: boolean;
}
/**
 * Entity input when a parent reference is required.
 */
interface DefinitionEntityInputWithParent<TInput, TEntityType extends DefinitionEntityType, TIdPath extends TuplePaths<TInput> | undefined = undefined> extends DefinitionEntityInputBase<TInput, TEntityType, TIdPath> {
    /** The slot from which to resolve the parent entity path. */
    parentSlot: RefContextSlot<NonNullable<TEntityType['parentType']>>;
}
/**
 * Entity input when no parent reference is expected.
 */
interface DefinitionEntityInputWithoutParent<TInput, TEntityType extends DefinitionEntityType, TIdPath extends TuplePaths<TInput> | undefined = undefined> extends DefinitionEntityInputBase<TInput, TEntityType, TIdPath> {
    parentSlot?: never;
}
/**
 * Depending on the entity type’s requirements, this type resolves to either the
 * with- or without-parent version.
 */
export type DefinitionEntityInput<TInput, TEntityType extends DefinitionEntityType, TIdPath extends TuplePaths<TInput> | undefined = undefined> = TEntityType['parentType'] extends undefined ? DefinitionEntityInputWithoutParent<TInput, TEntityType, TIdPath> : DefinitionEntityInputWithParent<TInput, TEntityType, TIdPath>;
/**
 * Base interface for defining a reference input.
 * @template TInput - The overall input type.
 * @template TEntityType - The entity type.
 */
interface DefinitionReferenceInputBase<TEntityType extends DefinitionEntityType> extends Pick<DefinitionReference, 'onDelete'> {
    type: TEntityType;
    /** Optional ref context slot that this reference provides. Registers this reference's path in a shared context. */
    provides?: RefContextSlot<TEntityType>;
}
interface DefinitionReferenceInputWithParent<TEntityType extends DefinitionEntityType> extends DefinitionReferenceInputBase<TEntityType> {
    /** The slot from which to resolve the parent entity path. */
    parentSlot: RefContextSlot<NonNullable<TEntityType['parentType']>>;
}
interface DefinitionReferenceInputWithoutParent<TEntityType extends DefinitionEntityType> extends DefinitionReferenceInputBase<TEntityType> {
    parentSlot?: never;
}
/**
 * Depending on the entity type’s requirements, defines the input required to create a definition reference.
 */
export type DefinitionReferenceInput<TEntityType extends DefinitionEntityType> = TEntityType['parentType'] extends undefined ? DefinitionReferenceInputWithoutParent<TEntityType> : DefinitionReferenceInputWithParent<TEntityType>;
/**
 * Entity with a name resolver.
 */
export interface DefinitionEntityWithNameResolver extends Omit<DefinitionEntity, 'name'> {
    nameResolver: DefinitionEntityNameResolver | string;
}
export {};
//# sourceMappingURL=definition-ref-builder.d.ts.map