import type { TuplePaths } from '@baseplate-dev/utils';
import { z } from 'zod';
import type { DefinitionEntityType } from '#src/index.js';
import type { PluginSpecStore } from '#src/plugins/index.js';
import type { DefinitionEntityInput, DefinitionReferenceInput } from './definition-ref-builder.js';
import type { ExpressionParserRef } from './expression-parser-ref.js';
import type { ExpressionSlotMap } from './expression-types.js';
import type { RefContextSlotDefinition, RefContextSlotMap } from './ref-context-slot.js';
import { RefExpressionParser } from './expression-types.js';
type ZodTypeWithOptional<T extends z.ZodType> = T extends z.ZodOptional ? z.ZodOptional<z.ZodType<z.output<T>, z.input<T>>> : T extends z.ZodDefault ? z.ZodDefault<z.ZodType<z.output<T>, z.input<T>>> : T extends z.ZodPrefault ? z.ZodPrefault<z.ZodType<z.output<T>, z.input<T>>> : z.ZodType<z.output<T>, z.input<T>>;
export type WithRefType = <TEntityType extends DefinitionEntityType>(reference: DefinitionReferenceInput<TEntityType>) => z.ZodType<string, string>;
export type WithEntType = <TType extends z.ZodType, TEntityType extends DefinitionEntityType, TIdPath extends TuplePaths<z.output<TType>> | undefined = undefined>(schema: TType, entity: DefinitionEntityInput<z.output<TType>, TEntityType, TIdPath>) => ZodTypeWithOptional<TType>;
/**
 * Creates ref context slots for use within a schema definition.
 * Slots provide type-safe context for parent-child entity relationships.
 */
export type RefContextType = <TSlotDef extends RefContextSlotDefinition, TSchema extends z.ZodType>(slotDefinition: TSlotDef, schemaBuilder: (slots: RefContextSlotMap<TSlotDef>) => TSchema) => ZodTypeWithOptional<TSchema>;
/**
 * Wraps a value with a ref expression parser for deferred validation.
 * The parser handles all parsing, validation, and rename handling.
 *
 * If the parser declares required slots (via TRequiredSlots), they must be
 * provided as the second argument. TypeScript enforces this at compile time.
 */
export interface WithExpressionType {
    <TValue, TParseResult>(parser: RefExpressionParser<TValue, TParseResult>): z.ZodType<TValue, TValue>;
    <TValue, TParseResult, TRequiredSlots extends Record<string, DefinitionEntityType>>(parser: RefExpressionParser<TValue, TParseResult, TRequiredSlots>, slots: ExpressionSlotMap<TRequiredSlots>): z.ZodType<TValue, TValue>;
    <TValue>(parserRef: ExpressionParserRef<TValue>): z.ZodType<TValue, TValue>;
    <TValue, TRequiredSlots extends Record<string, DefinitionEntityType>>(parserRef: ExpressionParserRef<TValue, TRequiredSlots>, slots: ExpressionSlotMap<TRequiredSlots>): z.ZodType<TValue, TValue>;
}
/**
 * Creates a string schema annotated as a reference to another entity.
 *
 * Can be used standalone:
 * ```typescript
 * withRef({ type: modelEnumEntityType, onDelete: 'RESTRICT' })
 * ```
 *
 * Or on the parser context:
 * ```typescript
 * ctx.withRef({ type: modelEnumEntityType, onDelete: 'RESTRICT' })
 * ```
 */
export declare function withRef<TEntityType extends DefinitionEntityType>(reference: DefinitionReferenceInput<TEntityType>): z.ZodType<string, string>;
/**
 * Creates a schema decorator that marks a schema as defining an entity.
 *
 * Can be used with `.apply()`:
 * ```typescript
 * schema.apply(withEnt({ type: modelEntityType, provides: modelSlot }))
 * ```
 *
 * Or via the parser context (2-arg legacy form):
 * ```typescript
 * ctx.withEnt(schema, { type: modelEntityType, provides: modelSlot })
 * ```
 *
 * @param entity - The entity definition input
 * @returns A function that decorates a schema with entity metadata
 */
export declare function withEnt<TEntityType extends DefinitionEntityType>(entity: DefinitionEntityInput<unknown, TEntityType>): <TType extends z.ZodType>(schema: TType) => ZodTypeWithOptional<TType>;
export declare function extendParserContextWithRefs(plugins?: PluginSpecStore): {
    withRef: WithRefType;
    withEnt: WithEntType;
    refContext: RefContextType;
    withExpression: WithExpressionType;
};
export {};
//# sourceMappingURL=extend-parser-context-with-refs.d.ts.map