/**
 * Performs unsafe coercion of types
 *
 * @tsplus macro identity
 */
export declare function unsafeCoerce<A, B>(a: A): B;
/**
 * Models () => A
 */
export interface Lazy<A> {
    (): A;
}
/**
 * Models (a: A) => a is B
 */
export interface Refinement<A, B extends A> {
    (a: A): a is B;
}
/**
 * Models (a: A) => A
 */
export interface Endomorphism<A> {
    (a: A): A;
}
/**
 * Models (...args: A) => B
 */
export interface FunctionN<A extends ReadonlyArray<unknown>, B> {
    (...args: A): B;
}
/**
 * Models a function argument which is evaluated lazily.
 *
 * For example:
 *
 * ```typescript
 * declare function succeed<A>(a: () => A): Effect<unknown, never, A>
 * ```
 *
 * @tsplus type tsplus/LazyArgument
 */
export interface LazyArg<A> {
    (): A;
}
/**
 * Will raise if called
 */
export declare function absurd<A = never>(_: never): A;
/**
 * A constant function that always return A
 */
export declare function constant<A>(a: A): Lazy<A>;
/**
 * A thunk that returns always `false`
 */
export declare function constFalse(): boolean;
/**
 * A thunk that returns always `null`
 */
export declare function constNull(): null;
/**
 * A thunk that returns always `true`
 */
export declare function constTrue(): boolean;
/**
 * A thunk that returns always `undefined`
 */
export declare function constUndefined(): undefined;
/**
 * A thunk that returns always `void`
 */
export declare function constVoid(): void;
/**
 * Flips the order of the arguments of a function of two arguments.
 */
export declare function flip<A, B, C>(f: (a: A, b: B) => C): (b: B, a: A) => C;
/**
 * Identity function
 *
 * @tsplus macro identity
 */
export declare function identity<A>(a: A): A;
/**
 * Force string to be literal
 *
 * @tsplus macro identity
 */
export declare function literal<K extends string>(k: K): K;
/**
 * Type Hole, to be used while implementing functions where you need a placeholder
 */
export declare function hole<T>(): T;
export * from "@tsplus/stdlib/data/Function/pipe";
//# sourceMappingURL=Function.d.ts.map