export declare function getAsStrict<A>(value: A): Definement<unknown, A>

export declare function local<R, Q>(f: (q: Q) => R): <A>(fa: Definement<R, A>) => Definement<Q, A>

export declare function not<E, A>(definement: Definement<E, A>): Definement<E, Exclude<E, A>>

export declare const init: Definement<unknown, unknown>

export declare const literal: <A extends string | number>(literal: A) => <G extends A>(a: G) => a is Extract<G, unknown>

export declare function fromRefinement<E, A extends E>(predicate: RF.Refinement<E, A>): Definement<E, A>

export declare function toPredicate<E, A>(fa: Definement<E, A>): PR.Predicate<E>

export declare function toRefinement<E, A>(fa: Definement<E, A>): A extends E ? RF.Refinement<E, A> : never

export declare function getLattice<E, A extends E>(): Lattice<Definement<E, A>>

export declare function join<E, A extends E>(
  ab: Definement<E, A>
): <B extends E>(bc: Definement<E, B>) => Definement<E, A | B>

export declare function meet<A, B, C>(bc: Definement<A & B, C>): (ab: Definement<A, B>) => Definement<A, B & C>

export declare const asBoolean: Definement<unknown, boolean>

export declare const asFalse: Definement<unknown, false>

export declare const asNull: Definement<unknown, null>

export declare const asNumber: Definement<unknown, number>

export declare const asString: Definement<unknown, string>

export declare const asTrue: Definement<unknown, true>

export declare const asUndefined: Definement<unknown, undefined>

export declare const isArray: Definement<unknown, any[]>

export declare const isNullable: Definement<unknown, null>

export declare const isObject: Definement<unknown, object>

export declare const compose: <B, C>(bc: Definement<B, C>) => <A>(ab: Definement<A, B>) => Definement<A, C>

export interface Definement<E, A> {
  <G extends E>(a: G): a is Extract<G, A>
}