@quenk/preconditions/lib/async/index.d.ts

Make data satisfy constraints before using.

/**
 * The promise module provides primitives for async preconditions
 * via bluebirds Promise API.
 */
import * as sync from '../';
import { Type } from '@quenk/noni/lib/data/type';
import { Future } from '@quenk/noni/lib/control/monad/future';
import { Record } from '@quenk/noni/lib/data/record';
import { Result } from '../result';
/**
 * AsyncPrecondition (async).
 */
export type AsyncPrecondition<A, B> = (a: A) => Future<Result<A, B>>;
/**
 * AsyncPreconditions map (async).
 */
export type AsyncPreconditions<A, B> = Record<AsyncPrecondition<A, B>>;
export { AsyncPrecondition as Precondition, AsyncPreconditions as Preconditions };
/**
 * lift a sync precondition into an async one.
 */
export declare const lift: <A, B>(p: sync.Precondition<A, B>) => AsyncPrecondition<A, B>;
export { lift as async };
/**
 * or (async).
 */
export declare const or: <A, B>(l: AsyncPrecondition<A, B>, r: AsyncPrecondition<A, B>) => AsyncPrecondition<A, B>;
/**
 * and (async).
 *
 * TODO: using the any type until Either is fixed in afpl.
 */
export declare const and: <A, B, C>(l: AsyncPrecondition<A, B>, r: AsyncPrecondition<B, C>) => AsyncPrecondition<A, C>;
/**
 * every (async).
 */
export declare const every: <A, B>(p: AsyncPrecondition<A, B>, ...list: AsyncPrecondition<B, B>[]) => AsyncPrecondition<A, B>;
/**
 * optional (async).
 */
export declare const optional: <A, B>(p: AsyncPrecondition<A, A | B>) => AsyncPrecondition<A, A | B>;
/**
 * caseOf (async).
 */
export declare const caseOf: <A, B>(t: Type, p: AsyncPrecondition<A, B>) => AsyncPrecondition<A, B>;
/**
 * match (async version).
 */
export declare const match: <A, B>(p: AsyncPrecondition<A, B>, ...list: AsyncPrecondition<A, B>[]) => AsyncPrecondition<A, B>;
/**
 * identity precondtion.
 *
 * Succeeds with whatever value is passed.
 */
export declare const identity: <A>(value: A) => Future<Result<A, A>>;
export declare const id: <A>(value: A) => Future<Result<A, A>>;
/**
 * discard (async).
 */
export declare const discard: <A>(_: A) => Future<Result<A, undefined>>;
/**
 * reject always fails with reason no matter the value supplied.
 */
export declare const reject: <A>(reason: string) => AsyncPrecondition<A, A>;
/**
 * log the value to the console.
 */
export declare const log: <A>(value: A) => Result<A, A>;
/**
 * tee (async version)
 *
 * See sync version for description.
 */
export declare const tee: <A, B>(precs: AsyncPrecondition<A, B>[]) => AsyncPrecondition<A, B[]>;