import * as CoreAssets from "../../Assets.js";
import type * as UTxO from "../../UTxO.js";
declare const CoinSelectionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
    readonly _tag: "CoinSelectionError";
} & Readonly<A>;
export declare class CoinSelectionError extends CoinSelectionError_base<{
    message?: string;
    cause?: unknown;
}> {
}
export interface CoinSelectionResult {
    readonly selectedUtxos: ReadonlyArray<UTxO.UTxO>;
}
export type CoinSelectionFunction = (availableUtxos: ReadonlyArray<UTxO.UTxO>, requiredAssets: CoreAssets.Assets) => CoinSelectionResult;
export type CoinSelectionAlgorithm = "largest-first" | "random-improve" | "optimal";
export declare const randomImproveSelection: CoinSelectionFunction;
export declare const optimalSelection: CoinSelectionFunction;
/**
 * Largest-first coin selection algorithm.
 *
 * Strategy:
 * 1. Sort UTxOs by total lovelace value (descending)
 * 2. Select UTxOs one by one until all required assets are covered
 * 3. Return selected UTxOs
 *
 * Advantages:
 * - Simple and predictable
 * - Minimizes number of inputs (uses largest UTxOs first)
 * - Fast execution
 *
 * Disadvantages:
 * - May select more value than needed (more change)
 * - Doesn't optimize for minimum fee
 * - Doesn't consider UTxO fragmentation
 *
 * Use cases:
 * - Default algorithm for simple transactions
 * - When minimizing input count is priority
 * - When speed is more important than optimization
 *
 * @since 2.0.0
 * @category coin-selection
 */
export declare const largestFirstSelection: CoinSelectionFunction;
export {};
//# sourceMappingURL=CoinSelection.d.ts.map