import type { TypeLambda } from "@fp-ts/core/HKT";
import * as contravariant from "@fp-ts/core/typeclass/Contravariant";
import * as invariant from "@fp-ts/core/typeclass/Invariant";
import * as monoid from "@fp-ts/core/typeclass/Monoid";
import * as of_ from "@fp-ts/core/typeclass/Of";
import * as product_ from "@fp-ts/core/typeclass/Product";
import * as semigroup from "@fp-ts/core/typeclass/Semigroup";
import type { Semigroup } from "@fp-ts/core/typeclass/Semigroup";
import * as semiProduct from "@fp-ts/core/typeclass/SemiProduct";
/**
 * @category models
 * @since 1.0.0
 */
export interface Predicate<A> {
    (a: A): boolean;
}
/**
 * @category type lambdas
 * @since 1.0.0
 */
export interface PredicateTypeLambda extends TypeLambda {
    readonly type: Predicate<this["Target"]>;
}
/**
 * @category models
 * @since 1.0.0
 */
export interface Refinement<A, B extends A> {
    (a: A): a is B;
}
/**
 * Tests if a value is a `string`.
 *
 * @param input - The value to test.
 *
 * @example
 * import { isString } from '@fp-ts/core/Predicate'
 *
 * assert.deepStrictEqual(isString("a"), true)
 *
 * assert.deepStrictEqual(isString(1), false)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isString: (input: unknown) => input is string;
/**
 * Tests if a value is a `number`.
 *
 * @param input - The value to test.
 *
 * @example
 * import { isNumber } from '@fp-ts/core/Predicate'
 *
 * assert.deepStrictEqual(isNumber(2), true)
 *
 * assert.deepStrictEqual(isNumber("2"), false)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isNumber: (input: unknown) => input is number;
/**
 * Tests if a value is a `boolean`.
 *
 * @param input - The value to test.
 *
 * @example
 * import { isBoolean } from '@fp-ts/core/Predicate'
 *
 * assert.deepStrictEqual(isBoolean(true), true)
 *
 * assert.deepStrictEqual(isBoolean("true"), false)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isBoolean: (input: unknown) => input is boolean;
/**
 * Tests if a value is a `bigint`.
 *
 * @param input - The value to test.
 *
 * @example
 * import { isBigint } from "@fp-ts/core/Predicate"
 *
 * assert.deepStrictEqual(isBigint(1n), true)
 *
 * assert.deepStrictEqual(isBigint(1), false)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isBigint: (input: unknown) => input is bigint;
/**
 * Tests if a value is a `symbol`.
 *
 * @param input - The value to test.
 *
 * @example
 * import { isSymbol } from "@fp-ts/core/Predicate"
 *
 * assert.deepStrictEqual(isSymbol(Symbol.for("a")), true)
 *
 * assert.deepStrictEqual(isSymbol("a"), false)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isSymbol: (input: unknown) => input is symbol;
/**
 * Tests if a value is a `function`.
 *
 * @param input - The value to test.
 *
 * @example
 * import { isFunction } from '@fp-ts/core/Predicate'
 *
 * assert.deepStrictEqual(isFunction(isFunction), true)
 *
 * assert.deepStrictEqual(isFunction("function"), false)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isFunction: (input: unknown) => input is Function;
/**
 * Tests if a value is `undefined`.
 *
 * @param input - The value to test.
 *
 * @example
 * import { isUndefined } from "@fp-ts/core/Predicate"
 *
 * assert.deepStrictEqual(isUndefined(undefined), true)
 *
 * assert.deepStrictEqual(isUndefined(null), false)
 * assert.deepStrictEqual(isUndefined("undefined"), false)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isUndefined: (input: unknown) => input is undefined;
/**
 * Tests if a value is not `undefined`.
 *
 * @param input - The value to test.
 *
 * @example
 * import { isNotUndefined } from "@fp-ts/core/Predicate"
 *
 * assert.deepStrictEqual(isNotUndefined(null), true)
 * assert.deepStrictEqual(isNotUndefined("undefined"), true)
 *
 * assert.deepStrictEqual(isNotUndefined(undefined), false)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isNotUndefined: <A>(input: A) => input is Exclude<A, undefined>;
/**
 * Tests if a value is `undefined`.
 *
 * @param input - The value to test.
 *
 * @example
 * import { isNull } from "@fp-ts/core/Predicate"
 *
 * assert.deepStrictEqual(isNull(null), true)
 *
 * assert.deepStrictEqual(isNull(undefined), false)
 * assert.deepStrictEqual(isNull("null"), false)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isNull: (input: unknown) => input is null;
/**
 * Tests if a value is not `undefined`.
 *
 * @param input - The value to test.
 *
 * @example
 * import { isNotNull } from "@fp-ts/core/Predicate"
 *
 * assert.deepStrictEqual(isNotNull(undefined), true)
 * assert.deepStrictEqual(isNotNull("null"), true)
 *
 * assert.deepStrictEqual(isNotNull(null), false)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isNotNull: <A>(input: A) => input is Exclude<A, null>;
/**
 * A guard that always fails.
 *
 * @param _ - The value to test.
 *
 * @example
 * import { isNever } from "@fp-ts/core/Predicate"
 *
 * assert.deepStrictEqual(isNever(null), false)
 * assert.deepStrictEqual(isNever(undefined), false)
 * assert.deepStrictEqual(isNever({}), false)
 * assert.deepStrictEqual(isNever([]), false)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isNever: (input: unknown) => input is never;
/**
 * A guard that always succeeds.
 *
 * @param _ - The value to test.
 *
 * @example
 * import { isUnknown } from "@fp-ts/core/Predicate"
 *
 * assert.deepStrictEqual(isUnknown(null), true)
 * assert.deepStrictEqual(isUnknown(undefined), true)
 *
 * assert.deepStrictEqual(isUnknown({}), true)
 * assert.deepStrictEqual(isUnknown([]), true)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isUnknown: (input: unknown) => input is unknown;
/**
 * Tests if a value is an `object`.
 *
 * @param input - The value to test.
 *
 * @example
 * import { isObject } from "@fp-ts/core/Predicate"
 *
 * assert.deepStrictEqual(isObject({}), true)
 * assert.deepStrictEqual(isObject([]), true)
 *
 * assert.deepStrictEqual(isObject(null), false)
 * assert.deepStrictEqual(isObject(undefined), false)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isObject: (input: unknown) => input is object;
/**
 * A guard that succeeds when the input is `null` or `undefined`.
 *
 * @param input - The value to test.
 *
 * @example
 * import { isNullable } from "@fp-ts/core/Predicate"
 *
 * assert.deepStrictEqual(isNullable(null), true)
 * assert.deepStrictEqual(isNullable(undefined), true)
 *
 * assert.deepStrictEqual(isNullable({}), false)
 * assert.deepStrictEqual(isNullable([]), false)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isNullable: <A>(input: A) => input is Extract<A, null | undefined>;
/**
 * A guard that succeeds when the input is not `null` or `undefined`.
 *
 * @param input - The value to test.
 *
 * @example
 * import { isNotNullable } from "@fp-ts/core/Predicate"
 *
 * assert.deepStrictEqual(isNotNullable({}), true)
 * assert.deepStrictEqual(isNotNullable([]), true)
 *
 * assert.deepStrictEqual(isNotNullable(null), false)
 * assert.deepStrictEqual(isNotNullable(undefined), false)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isNotNullable: <A>(input: A) => input is NonNullable<A>;
/**
 * A guard that succeeds when the input is an `Error`.
 *
 * @param input - The value to test.
 *
 * @example
 * import { isError } from "@fp-ts/core/Predicate"
 *
 * assert.deepStrictEqual(isError(new Error()), true)
 *
 * assert.deepStrictEqual(isError(null), false)
 * assert.deepStrictEqual(isError({}), false)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isError: (input: unknown) => input is Error;
/**
 * A guard that succeeds when the input is a `Date`.
 *
 * @param input - The value to test.
 *
 * @example
 * import { isDate } from "@fp-ts/core/Predicate"
 *
 * assert.deepStrictEqual(isDate(new Date()), true)
 *
 * assert.deepStrictEqual(isDate(null), false)
 * assert.deepStrictEqual(isDate({}), false)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isDate: (input: unknown) => input is Date;
/**
 * A guard that succeeds when the input is a record.
 *
 * @param input - The value to test.
 *
 * @example
 * import { isRecord } from "@fp-ts/core/Predicate"
 *
 * assert.deepStrictEqual(isRecord({}), true)
 * assert.deepStrictEqual(isRecord({ a: 1 }), true)
 *
 * assert.deepStrictEqual(isRecord([]), false)
 * assert.deepStrictEqual(isRecord([1, 2, 3]), false)
 * assert.deepStrictEqual(isRecord(null), false)
 * assert.deepStrictEqual(isRecord(undefined), false)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isRecord: (input: unknown) => input is {
    [x: string]: unknown;
    [x: symbol]: unknown;
};
/**
 * A guard that succeeds when the input is a readonly record.
 *
 * @param input - The value to test.
 *
 * @example
 * import { isReadonlyRecord } from "@fp-ts/core/Predicate"
 *
 * assert.deepStrictEqual(isReadonlyRecord({}), true)
 * assert.deepStrictEqual(isReadonlyRecord({ a: 1 }), true)
 *
 * assert.deepStrictEqual(isReadonlyRecord([]), false)
 * assert.deepStrictEqual(isReadonlyRecord([1, 2, 3]), false)
 * assert.deepStrictEqual(isReadonlyRecord(null), false)
 * assert.deepStrictEqual(isReadonlyRecord(undefined), false)
 *
 * @category guards
 * @since 1.0.0
 */
export declare const isReadonlyRecord: (input: unknown) => input is {
    readonly [x: string | symbol]: unknown;
};
/**
 * @since 1.0.0
 */
export declare const compose: {
    <A, B extends A, C extends B>(bc: Refinement<B, C>): (ab: Refinement<A, B>) => Refinement<A, C>;
    <A, B extends A, C extends B>(ab: Refinement<A, B>, bc: Refinement<B, C>): Refinement<A, C>;
};
/**
 * @category combinators
 * @since 1.0.0
 */
export declare const contramap: {
    <B, A>(f: (b: B) => A): (self: Predicate<A>) => Predicate<B>;
    <A, B>(self: Predicate<A>, f: (b: B) => A): Predicate<B>;
};
/**
 * @category instances
 * @since 1.0.0
 */
export declare const Contravariant: contravariant.Contravariant<PredicateTypeLambda>;
/**
 * @category instances
 * @since 1.0.0
 */
export declare const Invariant: invariant.Invariant<PredicateTypeLambda>;
/**
 * @since 1.0.0
 */
export declare const tupled: <A>(self: Predicate<A>) => Predicate<readonly [A]>;
/**
 * @since 1.0.0
 */
export declare const of: <A>(_: A) => Predicate<A>;
/**
 * @category instances
 * @since 1.0.0
 */
export declare const Of: of_.Of<PredicateTypeLambda>;
/**
 * @since 1.0.0
 */
export declare const unit: Predicate<void>;
/**
 * @category instances
 * @since 1.0.0
 */
export declare const SemiProduct: semiProduct.SemiProduct<PredicateTypeLambda>;
/**
 * @category instances
 * @since 1.0.0
 */
export declare const Product: product_.Product<PredicateTypeLambda>;
/**
 * Appends an element to the end of a tuple.
 *
 * @since 1.0.0
 */
export declare const appendElement: {
    <A extends ReadonlyArray<any>, B>(self: Predicate<A>, that: Predicate<B>): Predicate<readonly [...A, B]>;
    <B>(that: Predicate<B>): <A extends ReadonlyArray<any>>(self: Predicate<A>) => Predicate<readonly [...A, B]>;
};
/**
 * @since 1.0.0
 */
export declare const tuple: <T extends ReadonlyArray<Predicate<any>>>(...predicates: T) => Predicate<Readonly<{
    [I in keyof T]: [T[I]] extends [Predicate<infer A>] ? A : never;
}>>;
/**
 * @since 1.0.0
 */
export declare const struct: <R extends Record<string, Predicate<any>>>(predicates: R) => Predicate<{
    readonly [K in keyof R]: [R[K]] extends [Predicate<infer A>] ? A : never;
}>;
/**
 * @since 1.0.0
 */
export declare const not: <A>(self: Predicate<A>) => Predicate<A>;
/**
 * @since 1.0.0
 */
export declare const or: {
    <A>(that: Predicate<A>): (self: Predicate<A>) => Predicate<A>;
    <A>(self: Predicate<A>, that: Predicate<A>): Predicate<A>;
};
/**
 * @since 1.0.0
 */
export declare const and: {
    <A>(that: Predicate<A>): (self: Predicate<A>) => Predicate<A>;
    <A>(self: Predicate<A>, that: Predicate<A>): Predicate<A>;
};
/**
 * @category instances
 * @since 1.0.0
 */
export declare const getSemigroupAny: <A>() => semigroup.Semigroup<Predicate<A>>;
/**
 * @category instances
 * @since 1.0.0
 */
export declare const getMonoidAny: <A>() => monoid.Monoid<Predicate<A>>;
/**
 * @category instances
 * @since 1.0.0
 */
export declare const getSemigroupAll: <A>() => semigroup.Semigroup<Predicate<A>>;
/**
 * @category instances
 * @since 1.0.0
 */
export declare const getMonoidAll: <A>() => monoid.Monoid<Predicate<A>>;
/**
 * @since 1.0.0
 */
export declare const all: <A>(collection: Iterable<Predicate<A>>) => Predicate<A>;
/**
 * @since 1.0.0
 */
export declare const any: <A>(collection: Iterable<Predicate<A>>) => Predicate<A>;
/**
 * @category do notation
 * @since 1.0.0
 */
export declare const bindTo: {
    <N extends string>(name: N): <A>(self: Predicate<A>) => Predicate<{
        readonly [K in N]: A;
    }>;
    <A, N extends string>(self: Predicate<A>, name: N): Predicate<{
        readonly [K in N]: A;
    }>;
};
/**
 * @category do notation
 * @since 1.0.0
 */
export declare const Do: Predicate<{}>;
/**
 * A variant of `bind` that sequentially ignores the scope.
 *
 * @category do notation
 * @since 1.0.0
 */
export declare const andThenBind: {
    <N extends string, A extends object, B>(name: Exclude<N, keyof A>, that: Predicate<B>): (self: Predicate<A>) => Predicate<{
        readonly [K in N | keyof A]: K extends keyof A ? A[K] : B;
    }>;
    <A extends object, N extends string, B>(self: Predicate<A>, name: Exclude<N, keyof A>, that: Predicate<B>): Predicate<{
        readonly [K in N | keyof A]: K extends keyof A ? A[K] : B;
    }>;
};
//# sourceMappingURL=Predicate.d.ts.map