import * as P from "@principia/prelude";
import * as HKT from "@principia/prelude/HKT";
import type { Option, URI, V } from "./model";
/**
 * ```haskell
 * ap_ :: Apply f => (f (a -> b), f a) -> f b
 * ```
 *
 * Apply a function to an argument under a type constructor
 *
 * @category Apply
 * @since 1.0.0
 */
export declare const ap_: <A, B>(fab: Option<(a: A) => B>, fa: Option<A>) => Option<B>;
/**
 * ```haskell
 * ap :: Apply f => f a -> f (a -> b) -> f b
 * ```
 *
 * Apply a function to an argument under a type constructor
 *
 * @category Apply
 * @since 1.0.0
 */
export declare const ap: <A>(fa: Option<A>) => <B>(fab: Option<(a: A) => B>) => Option<B>;
export declare const apFirst_: <A, B>(fa: Option<A>, fb: Option<B>) => Option<A>;
export declare const apFirst: <B>(fb: Option<B>) => <A>(fa: Option<A>) => Option<A>;
export declare const apSecond_: <A, B>(fa: Option<A>, fb: Option<B>) => Option<B>;
export declare const apSecond: <B>(fb: Option<B>) => <A>(fa: Option<A>) => Option<B>;
/**
 * ```haskell
 * mapBoth_ :: Apply f => (f a, f b, ((a, b) -> c)) -> f c
 * ```
 *
 * Applies both `Maybe`s and if both are `Some`,  maps their results with function `f`, otherwise returns `Nothing`
 *
 * @category Apply
 * @since 1.0.0
 */
export declare const mapBoth_: <A, B, C>(fa: Option<A>, fb: Option<B>, f: (a: A, b: B) => C) => Option<C>;
/**
 * ```haskell
 * mapBoth :: Apply f => (f b, ((a, b) -> c)) -> f a -> f c
 * ```
 *
 * Applies both `Maybe`s and if both are `Some`, maps their results with function `f`, otherwise returns `Nothing`
 *
 * @category Apply
 * @since 1.0.0
 */
export declare const mapBoth: <A, B, C>(fb: Option<B>, f: (a: A, b: B) => C) => (fa: Option<A>) => Option<C>;
/**
 * ```haskell
 * liftA2 :: Apply f => (a -> b -> c) -> f a -> f b -> f c
 * ```
 *
 * Lifts a binary function to actions
 *
 * @category Apply
 * @since 1.0.0
 */
export declare const liftA2: <A, B, C>(f: (a: A) => (b: B) => C) => (fa: Option<A>) => (fb: Option<B>) => Option<C>;
/**
 * ```haskell
 * apS :: (Apply f, Nominal n) =>
 *    (n n3, f c)
 *    -> f ({ n1: a, n2: b, ... })
 *    -> f ({ n1: a, n2: b, n3: c })
 * ```
 *
 * A pipeable version of `sequenceS`
 *
 * @category Apply
 * @since 1.0.0
 */
export declare const apS: <N extends string, A, B>(
   name: Exclude<N, keyof A>,
   fb: Option<B>
) => (fa: Option<A>) => Option<{ [K in N | keyof A]: K extends keyof A ? A[K] : B }>;
export declare const Apply: P.Apply<[URI], V>;
export declare const sequenceS: P.SequenceSFn<["Option"], HKT.Auto>;
export declare const sequenceT: P.SequenceTFn<["Option"], HKT.Auto>;
export declare const mapN: P.MapNFn<["Option"], HKT.Auto>;
//# sourceMappingURL=apply.d.ts.map