import { ReactElement } from 'react';
import { Either } from 'fp-ts/lib/Either';
import { HKT, HKT2, HKT3, HKT4, URIS, URIS2, URIS3, URIS4 } from 'fp-ts/lib/HKT';
import { Option } from 'fp-ts/lib/Option';
import { NaN } from './newtypes';
/**
 * Type representing possible TypeScript primitive types
 */
export declare type Primitive = string | number | boolean | undefined | null | void | {};
/**
 * Type representing possible TypeScript primitive types we consider safe
 */
export declare type SafePrimitive = string | number | boolean | object;
/**
 * Type representing all possible falsy values, uses a newtype
 * to represent NaN
 */
export declare type Falsy = null | undefined | false | '' | 0 | NaN;
/**
 * Type representing all truthy values
 */
export declare type Truthy<T> = T extends Falsy ? never : T;
/**
 * Type-level utils to extract types from HKTs
 */
export declare type HKT1S<A = unknown> = HKT<URIS, A>;
export declare type HKT2S<L = unknown, A = unknown> = HKT2<URIS2, L, A>;
export declare type HKT3S<U = unknown, L = unknown, A = unknown> = HKT3<URIS3, U, L, A>;
export declare type HKT4S<X = unknown, U = unknown, L = unknown, A = unknown> = HKT4<URIS4, X, U, L, A>;
export declare type HKTS = HKT1S | HKT2S | HKT3S | HKT4S;
export declare type ExtractFromHKT1<F> = F extends HKT1S<infer A> ? A : never;
export declare type ExtractFromHKT2<F> = F extends HKT2S<infer L, infer A> ? [L, A] : never;
export declare type ExtractFromHKT3<F> = F extends HKT3S<infer U, infer L, infer A> ? [U, L, A] : never;
export declare type ExtractFromHKT4<F> = F extends HKT4S<infer X, infer U, infer L, infer A> ? [X, U, L, A] : never;
export declare type ExtractFromHKTS<F extends HKTS> = F extends HKT1S ? ExtractFromHKT1<F> : F extends HKT2S ? ExtractFromHKT2<F> : F extends HKT3S ? ExtractFromHKT3<F> : F extends HKT4S ? ExtractFromHKT4<F> : never;
export declare type ExtractAFromHKT<F extends HKT1S> = ExtractFromHKT1<F>;
export declare type ExtractLFromHKT2<F extends HKT2S> = ExtractFromHKT2<F>['0'];
export declare type ExtractAFromHKT2<F extends HKT2S> = ExtractFromHKT2<F>['1'];
export declare type ExtractUFromHKT3<F extends HKT3S> = ExtractFromHKT3<F>['0'];
export declare type ExtractLFromHKT3<F extends HKT3S> = ExtractFromHKT3<F>['1'];
export declare type ExtractAFromHKT3<F extends HKT3S> = ExtractFromHKT3<F>['2'];
export declare type ExtractXFromHKT4<F extends HKT4S> = ExtractFromHKT4<F>['0'];
export declare type ExtractUFromHKT4<F extends HKT4S> = ExtractFromHKT4<F>['1'];
export declare type ExtractLFromHKT4<F extends HKT4S> = ExtractFromHKT4<F>['2'];
export declare type ExtractAFromHKT4<F extends HKT4S> = ExtractFromHKT4<F>['3'];
/**
 * Type-level util to extract the type A in Option<A>
 */
export declare type ExtractAFromOption<O> = O extends Option<infer U> ? U : never;
/**
 * Type-level util to extract the type T in Array<T>
 */
export declare type ExtractTFromArray<A> = A extends Array<infer U> ? U : never;
/**
 * Type-level utils to extract the types L and A in Either<L, A>
 */
export declare type ExtractLFromEither<E> = E extends Either<infer U, unknown> ? U : never;
export declare type ExtractAFromEither<E> = E extends Either<unknown, infer U> ? U : never;
/**
 * Generic nullable type for unions with `null`
 */
export declare type Nullable<A> = A | null;
/**
 * Generic undefinedable type for unions with `undefined`
 */
export declare type Undefinedable<A> = A | undefined;
/**
 * A type representing either null or undefined
 */
export declare type Nil = null | undefined;
/**
 * Generic nillable type for unions with Nil (`null` and `undefined`)
 */
export declare type Nilable<A> = A | Nil;
/**
 * Equivalent to TypeScript's built-in NonNullable, but with consistent naming
 */
export declare type NonNilable<T> = T extends Nil ? never : T;
/**
 * A reusable, flexible conditional type utlity which let's you express a
 * conditional return type based on whether or not generic `A` is a subtype of
 * generic `B` in a concise way
 */
export declare type IfIsThenElse<A, B, Then, Else> = [A] extends [B] ? Then : Else;
/**
 * A partially applied version of IfIsThenElse where generic `B` is `never`
 */
export declare type IfIsNeverThenElse<A, Then, Else> = IfIsThenElse<A, never, Then, Else>;
/**
 * Like TypeScript's native Required, but also disallows null
 * (All props must be defined & non-null)
 */
export declare type RequireNonNilable<A> = {
    [P in keyof A]-?: NonNilable<A[P]>;
};
/**
 * Map over `Record` property values and unbox those of type `Option<A>` to type `A`
 */
export declare type UnboxRecordPropertyOptionValues<R extends Record<PropertyKey, unknown>> = {
    [K in keyof R]: R[K] extends Option<infer A> ? A : R[K];
};
/**
 * Alias of ReactElement | null, similar to ReactNode, but compatible with FunctionComponent
 */
export declare type ReactRenderable = Nullable<ReactElement>;
/**
 * Gets a union of all the value types associated with an obj type (interface, Record, etc.)
 */
export declare type ObjectValues<A extends object> = A[keyof A];
/**
 * Extracts the union of the types of values contained in any native JS collection,
 * including:
 * - Record
 * - Array
 * - Map
 * - WeakMap
 * - Set
 * - WeakSet
 */
export declare type Values<T extends object> = T extends Record<string | number | symbol, infer A> ? A : T extends Array<infer B> ? B : T extends Map<unknown, infer C> ? C : T extends WeakMap<object, infer D> ? D : T extends Set<infer E> ? E : T extends WeakSet<infer F> ? F : unknown;
/**
 * A version of `keyof` that distributes over union types
 *
 * Example:
 *
 * type Person =
 * | { name: string }
 * | { age: number}
 *
 * type Keys = DistributiveKeyOf<Person> // 'name' | 'age'
 */
export declare type DistributiveKeyOf<T extends object> = T extends unknown ? keyof T : never;
/**
 * Applies an optional type of never for keys that exist on the distributive type but not in
 * the union type
 *
 * This is so that you don't have to explicitly add the type, but even if you do
 * it will error because it is of type never (unless you cast as never)
 *
 * Behaves in a similar way to Exact from typelevel-ts but on unions and not records
 *
 * Example:
 *
 * type Person =
 * | { name: string }
 * | { age: number }
 *
 * type Keys = DistributiveExact<Person, Person> //
 * ({
 *   name: string;
 * } & Partial<Record<"age", never>>) | ({
 *  age: number;
 * } & Partial<Record<"name", never>>)
 */
export declare type DistributiveExact<A extends object, B extends A> = A extends unknown ? A & Partial<Record<Exclude<DistributiveKeyOf<B>, DistributiveKeyOf<A>>, never>> : never;
/**
 * Given a union of objects it will enforce that only one is used. Does the
 * same thing as DistributiveExact so it's just additional helper. Should *likely*
 * only be used on React components in order to specify the props it should accept.
 * For other data types a ADT should be used instead, i.e. { tag: 'label', etc...}.
 *
 * Example:
 * type Person =
 *   | { name: string }
 *   | { age: number}
 *
 * const person: ExactRecordsUnion<Person> = {
 *   name: 'Adam"
 * } // works!
 *
 * const person: ExactRecordsUnion<Person> = {
 *   name: 'Adam'
 *   age: 33,
 * } // errors!
 *
 * Taken and modified from: https://stackoverflow.com/questions/52677576/typescript-discriminated-union-allows-invalid-state/52678379#52678379
 */
export declare type ExactRecordsUnion<A extends object> = DistributiveExact<A, A>;
/**
 * Select the member of a union type by matching on the the provided key, `K`,
 * and value, `V`. Returns `never` if no match occurs.
 */
export declare type SelectUnionMember<K extends PropertyKey, T, U extends object> = U extends {
    [P in K]: T;
} & infer A ? unknown extends A ? U : A : never;
/**
 * A specialization of `SelectUnionMember`, matching on the `tag` field with
 * a given type-level string literal, `T`. Returns `never` if no match occurs.
 */
export declare type SelectUnionMemberByTag<T extends string, U extends object> = SelectUnionMember<'tag', T, U>;
/**
 * A specialization of `SelectUnionMember`, matching on the `contents` field
 * with a given value, `C`. Returns `never` if no match occurs.
 */
export declare type SelectUnionMemberByContents<C, U extends object> = SelectUnionMember<'contents', C, U>;
/**
 * A version of `Pick` that distributes over union types.
 */
export declare type DistributivePick<U extends object, K extends DistributiveKeyOf<U>> = {
    [P in K]: unknown extends U[P] ? {
        [P2 in P]: P2 extends keyof SelectUnionMember<P2, unknown, U> ? SelectUnionMember<P2, unknown, U>[P2] : never;
    }[P] : {
        [P2 in P]: U[P2];
    }[P];
};
/**
 * A version of `Omit` that distributes over union types.
 */
export declare type DistributiveOmit<U extends object, K extends DistributiveKeyOf<U>> = DistributivePick<U, Exclude<DistributiveKeyOf<U>, K>>;
export declare type ExtractMemberFromUnion<A extends object, B extends ExactRecordsUnion<A>> = B;
/**
 * Check if a type is never.
 */
export declare type IsNever<A> = [A] extends [never] ? true : false;
/**
 * Extracts a union of key-name/value-type pairs from an object type
 *
 * @example
 * type Foo = { bar: number, baz: string, zot: boolean }
 * type Quux = ExtractKeyValuePairs<Foo>
 * // Quux : { key: 'bar', value: number }
 *         | { key: 'baz', value: string }
 *         | { key: 'zot', value: boolean }
 *
 * // you can also narrow the fields you care about
 * type Xyzzy = ExtractKeyValuePairs<Foo, 'bar' | 'baz'>
 * // Xyzzy : { key: 'bar', value: number }
 *          | { key: 'baz', value: string }
 */
export declare type ExtractKeyValuePairs<T, K extends keyof T = keyof T> = K extends keyof T ? {
    key: K;
    value: T[K];
} : never;
/**
 * Elevates a sub-property to the level of the property of an object, leaving
 * everything else the same.
 *
 * @example
 * type Foo = { key: string, value: { tag: string, value: number } }
 * type Bar = RaiseSubProperty<Foo, 'value', 'tag'>
 * // Bar : { key: string, value: string }
 */
export declare type RaiseSubProperty<T, K extends keyof T, SK extends keyof T[K]> = Pick<T, Exclude<keyof T, K>> & {
    [k in K]: T[K][SK];
};
/**
 * RaiseSubProperty but for union types; useful in conjunction with
 * ExtractKeyValuePairs
 *
 * @link RaiseSubProperty
 */
export declare type DistributiveRaiseSubProperty<T, K extends keyof T, SK extends keyof T[K]> = T extends {} ? RaiseSubProperty<T, K, SK> : never;
/**
 * The opposite of Exclude, checks to see what values extends a given value.
 * @example
 *
 * type OneTwoThree = 1 | 2 | 3
 * type A = OneTwoThree | 4
 * type B = Include<A, OneTwoThree> // B === OneTwoThree
 */
export declare type Include<A, B> = A extends B ? A : never;
export declare type OptionalToOption<T> = {
    [K in keyof T]-?: undefined extends T[K] ? Option<OptionalToOption<Exclude<T[K], undefined>>> : OptionalToOption<T[K]>;
};