import { type Result, type AsyncResult } from './result.ts';
/**
 * Step function signature - transforms value and returns Result
 * @param value - Current value
 * @param context - Current context
 * @returns Result or AsyncResult of new value with custom error type
 */
export type StepFunction<V, C, NV, SE extends Error = Error> = (value: V, context: C) => Result<NV, SE> | AsyncResult<NV, SE>;
/**
 * Context function signature - transforms context
 * @param context - Current context
 * @param value - Current value
 * @returns New context (sync or async)
 */
export type ContextFunction<C, V, NC> = (context: C, value: V) => NC | Promise<NC>;
/**
 * Assert function signature - validates value without transformation
 * @param value - Current value
 * @param context - Current context
 * @returns Boolean indicating if assertion passes (sync or async)
 */
export type AssertFunction<V, C> = (value: V, context: C) => boolean | Promise<boolean>;
/**
 * Error factory signature - matches standard Error constructor
 * @param message - Error message
 * @param options - Error options including cause
 * @returns New error instance
 */
export type ErrorFactory<E extends Error> = new (message: string, options?: {
    cause?: Error;
}) => E;
/**
 * Computes the updated result type when the value type changes from V to NV.
 * If R is Result<V, E>, it becomes Result<NV, E>.
 * If R is a custom type (from useResult), it is preserved.
 */
type UpdatedResultType<R, V, NV, E extends Error = Error> = R extends Result<V, E> ? Result<NV, E> : R;
/**
 * Updates the result type when the error type changes from E to NE.
 * If R is Result<V, E>, it becomes Result<V, NE>.
 * If R is a custom type (from useResult), it is preserved.
 */
type UpdatedErrorType<R, V, E extends Error, NE extends Error> = R extends Result<V, E> ? Result<V, NE> : R;
/**
 * Conditionally excludes undefined from type V if undefined is part of the union.
 * If undefined extends V (meaning undefined is in the union), exclude it.
 * Otherwise, return V unchanged.
 */
type ExcludeUndefinedIfPresent<V> = undefined extends V ? Exclude<V, undefined> : V;
type CompiledPipeline<IV, V, E extends Error = Error> = IV extends undefined ? (v?: IV) => AsyncResult<V, E> : (v: IV) => AsyncResult<V, E>;
/**
 * Type-safe Instruction interface - chainable pipeline builder
 * @param IV - Initial Value type (input type, preserved through chain)
 * @param IC - Initial Context type (input type, preserved through chain)
 * @param V - Current Value type (transforms through pipeline)
 * @param C - Current Context type (transforms through pipeline)
 * @param E - Error type (must extend Error)
 * @param R - Result type (defaults to Result<V, E>, can be changed by useResult)
 */
export interface Instruction<IV = undefined, IC = undefined, V = undefined, C = undefined, E extends Error = Error, R = Result<V, E>> {
    /**
     * Compile the pipeline with context override
     * @param overwriteContext - Context to bind (overrides initial context)
     * @returns Compiled function that only needs value
     */
    compile(overwriteContext: IC): CompiledPipeline<IV, V, E>;
    /**
     * Compile the pipeline with initial context
     * @returns Compiled function that only needs value
     */
    compile(): CompiledPipeline<IV, V, E>;
    /**
     * Run the pipeline with a value (uses initial context)
     * When IV is undefined, the value parameter is optional
     * @param v - Initial value to process (optional when IV is undefined)
     * @returns Result of the pipeline execution (Promise<R> where R defaults to Result<V, E>)
     */
    run(...args: IV extends undefined ? [] : [IV]): Promise<R>;
    /**
     * Set error transformation for the instruction with custom error class
     * @param errorClass - Error class constructor
     * @param message - Error message
     * @returns New instruction with updated error type
     */
    failsWith<NE extends Error>(errorClass: ErrorFactory<NE>, message: string): Instruction<IV, IC, V, C, NE, UpdatedErrorType<R, V, E, NE>>;
    /**
     * Set error transformation for the instruction with generic error
     * @param message - Error message string
     * @returns New instruction with updated error type
     */
    failsWith(message: string): Instruction<IV, IC, V, C, Error, UpdatedErrorType<R, V, E, Error>>;
    /**
     * Add a processing step to the pipeline
     * @param fn - Step function that transforms the value
     * @returns New instruction with updated value type
     * If R is the default Result<V, E>, it becomes Result<NV, E>
     * If R is a custom type (from useResult), it is preserved
     */
    step<NV, SE extends Error = Error>(fn: StepFunction<V, C, NV, SE>): Instruction<IV, IC, NV, C, E, UpdatedResultType<R, V, NV, E>>;
    /**
     * Add an assertion/validation step that doesn't transform the value
     * @param predicate - Predicate function that returns true if assertion passes
     * @param message - Optional error message if assertion fails
     * @returns New instruction with value type narrowed to exclude undefined (if undefined was part of V)
     * R type is updated to reflect the narrowed value type (custom type from useResult is preserved)
     */
    assert(predicate: AssertFunction<V, C>, message?: string): Instruction<IV, IC, ExcludeUndefinedIfPresent<V>, C, E, UpdatedResultType<R, V, ExcludeUndefinedIfPresent<V>, E>>;
    /**
     * Add a context transformation step to the pipeline
     * @param fn - Context function that transforms the context
     * @returns New instruction with updated context type
     * R type is preserved (custom type from useResult or default Result<V, E>)
     */
    context<NC>(fn: ContextFunction<C, V, NC>): Instruction<IV, IC, V, NC, E, R>;
    /**
     * Run the instruction and transform the result
     * @param fn - Function that receives the result of .run() and returns a new value
     * @param value - Optional initial value (required if IV is not undefined)
     * @returns Promise of the callback's return value
     */
    useResult<RR>(fn: (result: R) => RR | Promise<RR>, ...args: IV extends undefined ? [] : [value: IV]): Promise<RR>;
}
/**
 * Create a new instruction without initial context
 * @returns New instruction instance with undefined context
 *
 * @template IV - Initial Value type (defaults to undefined)
 *
 * Note: When IV is undefined, the initial value is optional when calling run() or compile()
 * When IV is specified, the first step receives IV as the value type
 */
export declare function instruction<IV = undefined>(): Instruction<IV, undefined, IV extends undefined ? undefined : IV, undefined, Error, Result<IV extends undefined ? undefined : IV, Error>>;
/**
 * Create a new instruction with initial context
 * @param initialContext - Initial context for the instruction pipeline
 * @returns New instruction instance
 *
 * @template IV - Initial Value type (defaults to undefined)
 * @template IC - Initial Context type (inferred from initialContext)
 *
 * Note: When IV is undefined, the initial value is optional when calling run() or compile()
 * When IV is specified, the first step receives IV as the value type
 */
export declare function instruction<IV = undefined, IC = undefined>(initialContext: IC): Instruction<IV, IC, IV extends undefined ? undefined : IV, IC, Error, Result<IV extends undefined ? undefined : IV, Error>>;
export {};
//# sourceMappingURL=instruction.d.ts.map