import { Kind } from '../../kinds/index.js';
import { Applicative } from './applicative';
import { TypeSkell } from '../../typeskell/index.js';
/**
 * Applicative is a typeclass that provides a way to apply a function in a context to a value in a context.
 *
 * Laws:
 * - Identity: (of id) <*> u = u
 * - Homomorphism: (of f) <*> (of x) = of (f x)
 * - Interchange: u <*> (of y) = of ($ y) <*> u
 * - Composition: ((of (.) <*> u) <*> v) <*> w = u <*> (v <*> w)
 */
declare namespace applicativeLaws {
    type $identity<F extends Kind> = TypeSkell<'F a ..e -> F a ..e', {
        F: F;
    }>;
    type $homomorphism<F extends Kind> = TypeSkell<'(a -> b) a -> F b ..e', {
        F: F;
    }>;
    type $interchange<F extends Kind> = TypeSkell<'(F (a -> b) ..e) a -> F b ..e', {
        F: F;
    }>;
    type $composition<F extends Kind> = TypeSkell<'(F (b -> c) ..e) (F (a -> b) ..e) (F a ..e) -> F c ..e', {
        F: F;
    }>;
}
export declare const applicativeLaws: <F extends Kind>(functor: Applicative<F>) => {
    identity: {
        left: applicativeLaws.$identity<F>;
        right: applicativeLaws.$identity<F>;
    };
    homomorphism: {
        left: applicativeLaws.$homomorphism<F>;
        right: applicativeLaws.$homomorphism<F>;
    };
    interchange: {
        left: applicativeLaws.$interchange<F>;
        right: applicativeLaws.$interchange<F>;
    };
    composition: {
        left: applicativeLaws.$composition<F>;
        right: applicativeLaws.$composition<F>;
    };
};
export {};