import { ICommand, _Iterator, _Result, ResultExecute, ResultObject } from "../types";
/**
 * @description The `Result` class represents the outcome of an operation, encapsulating both the success or failure state.
 * A `Result` instance can contain a payload (`data`), an error, and optional metadata for additional context.
 * This pattern encourages explicit handling of operation success or failure, making your code more robust and expressive.
 *
 * @typeParam T - The type of the payload when the result is successful.
 * @typeParam D - The type of the error when the result is a failure. Defaults to `string`.
 * @typeParam M - The type of the metadata object. Defaults to an empty object `{}`.
 *
 * @example
 * ```typescript
 * // Creating a success result with data
 * const successResult = Result.Ok({ name: "Alice" });
 * if (successResult.isOk()) {
 *   console.log("Success data:", successResult.value());
 * }
 *
 * // Creating a failure result with a custom error message
 * const failResult = Result.fail("An error occurred");
 * if (failResult.isFail()) {
 *   console.error("Error:", failResult.error());
 * }
 * ```
 */
export declare class Result<T = void, D = string, M = {}> implements _Result<T, D, M> {
    #private;
    private constructor();
    /**
     * @description Creates a success `Result` instance, optionally containing data and metadata.
     *
     * @returns A `Result` instance representing success.
     */
    static Ok(): Result<void>;
    static Ok(): _Result<void>;
    static Ok<T, M = {}, D = string>(data: T, metaData?: M): Result<T, D, M>;
    static Ok<T, M = {}, D = string>(data: T, metaData?: M): _Result<T, D, M>;
    /**
     * @description Creates a failure `Result` instance, optionally containing an error and metadata.
     *
     * @returns A `Result` instance representing failure.
     */
    static fail<D = string, M = {}, P = void>(error?: D, metaData?: M): Result<P, D, M>;
    /**
     * @description Creates an iterator over a collection of `Result` instances. This allows sequential processing of multiple results.
     * @param results An array of `Result` instances.
     * @returns An iterator over the provided results.
     */
    static iterate<A, B, M>(results?: Array<_Result<A, B, M>>): _Iterator<_Result<A, B, M>>;
    /**
     * @description Combines multiple `Result` instances into a single `Result`.
     * If any of the provided results is a failure, the combined `Result` is a failure.
     * If all results are successful, the combined `Result` is considered a success.
     *
     * @param results An array of `Result` instances to combine.
     * @returns A `Result` instance representing the combined outcome.
     */
    static combine<A = any, B = any, M = any>(results: Array<_Result<any, any, any>>): _Result<A, B, M>;
    /**
     * @description Executes a command based on the result state. You can specify whether the command executes on success, failure, or both.
     * Optionally, you can provide data to the command if required.
     *
     * @param command An object implementing `ICommand` interface.
     * @returns An object with methods to configure command execution based on the `Result` state.
     */
    execute<X, Y>(command: ICommand<X | void, Y>): ResultExecute<X, Y>;
    /**
     * @description Retrieves the payload of the `Result`. If the `Result` is a failure, `value()` returns `null`.
     * @returns The payload `T` or `null` if the result is a failure.
     */
    value(): T;
    /**
     * @description Retrieves the error of the `Result`. If the `Result` is a success, `error()` returns `null`.
     * @returns The error `D` or `null` if the result is a success.
     */
    error(): D;
    /**
     * @description Determines if the `Result` represents a failure state.
     * @returns `true` if the result is a failure, `false` if it is a success.
     */
    isFail(): boolean;
    /**
     * @description Checks if the `Result` payload is `null`.
     * This can be useful for confirming the presence or absence of a value before proceeding.
     * @returns `true` if the payload is `null`, `false` otherwise.
     */
    isNull(): boolean;
    /**
     * @description Determines if the `Result` represents a success state.
     * @returns `true` if the result is a success, `false` if it is a failure.
     */
    isOk(): boolean;
    /**
     * @description Retrieves the metadata associated with the `Result`.
     * @returns The metadata object `M`, or `{}` if no metadata was provided.
     */
    metaData(): M;
    /**
     * @description Converts the `Result` instance into a plain object for easier logging or serialization.
     * @returns An object containing `isOk`, `isFail`, `data`, `error`, and `metaData`.
     */
    toObject(): ResultObject<T, D, M>;
}
export default Result;
export declare const Combine: typeof Result.combine;
//# sourceMappingURL=result.d.ts.map