function apply<T, R0, R1>(b:process<T, R0, R1>, a:transform<T, R0>) : transform<T, R1>;

export { all as allAsync, resolve } from "./async"
export { all, may } from "./sync"

function all<T, R, F>(fn:(value:T) => Promise<Maybe<R, F>>, values:readonly T[]) : Promise<Maybe<R[], F>>;
function resolve<T, R>(fn:(v:T) => Maybe<Promise<R>>, value:T) : Promise<Maybe<R>>;

function all<T, R, F>(fn:(v:T) => Maybe<R, F>, values:readonly T[]) : Maybe<R[], F>;
function may<T, R>(fn:(v:T) => Maybe<R>, value:T) : Maybe<R>;

export {
  and as andAsync,
  onFailure as onFailureAsync,
  onResult as onResultAsync,
  or as orAsync
} from "./async"
export {
  and,
  onFailure,
  onResult,
  or
} from "./sync"

function and<T, R>(fn:(value:T) => Promise<Maybe<R>>, maybe:Maybe<T>) : Promise<Maybe<R>>;
function onFailure<T, F>(fn:(failure:Failure<F>) => Promise<Maybe<unknown>>, maybe:Maybe<T, F>) : Promise<Maybe<T, F>>;
function onResult<T, F>(fn:(value:T) => Promise<Maybe<unknown>>, maybe:Maybe<T, F>) : Promise<Maybe<T, F>>;
function or<T, R, F0, F1>(fn:(failure:Failure<F0>) => Promise<Maybe<R, F1>>, maybe:Maybe<T, F0>) : Promise<Maybe<T | R, F1>>;

function and<T, R>(fn:(value:T) => Maybe<R>, maybe:Maybe<T>) : Maybe<R>;
function onFailure<T, F>(fn:(failure:Failure<F>) => Maybe<unknown>, maybe:Maybe<T, F>) : Maybe<T, F>;
function onResult<T, F>(fn:(value:T) => Maybe<unknown>, maybe:Maybe<T, F>) : Maybe<T, F>;
function or<T, R, F0, F1>(fn:(value:Failure<F0>) => Maybe<R, F1>, maybe:Maybe<T, F0>) : Maybe<T | R, F1>;

export { apply } from "./compose"
export { all as allAsync, resolve } from "./convert/async"
export { all, may } from "./convert/sync"
export {
  and as andAsync,
  onFailure as onFailureAsync,
  onResult as onResultAsync,
  or as orAsync
} from "./flow/async"
export {
  and,
  onFailure,
  onResult,
  or
} from "./flow/sync"
export {
  Failure,
  Maybe,
  Result,
  createFailure,
  createResult,
  isFailure,
  isResult
} from "./maybe"
export {
  CardinalMessage,
  DataMessage,
  ErrorMessage,
  Message,
  MessageSeverity,
  Messages,
  TextMessage,
  containsMessage,
  createCardinalMessage,
  createDataMessage,
  createErrorMessage,
  createMessage,
  createTextMessage,
  flattenMessage,
  flattenMessages,
  isCardinalMessage,
  isDataMessage,
  isErrorMessage,
  isTextMessage,
  messageSeverity,
  resolveMessageValue
} from "./message"
export { failureFrom as failureAsync, maybeFrom as maybeAsync, resultFrom as resultAsync } from "./native/async"
export { failureFrom, maybeFrom, resultFrom } from "./native/sync"

interface Result<T> extends MessageComposite {
  readonly value : T;
}

type Failure<T> = Message<T>;
type Maybe<T, F = unknown> = Result<T> | Failure<F>;

function createFailure<T>(value:T, severity:messageSeverity = messageSeverity.error, messages:Messages = []) : MessageDistinct<T>;  // 
function createResult<T>(value:T, messages:Messages = []) : Result<T>;
function isFailure<T, F>(maybe:Maybe<T, F>) : maybe is Failure<F>;
function isResult<T, F>(maybe:Maybe<T, F>) : maybe is Result<T>;
function mergeMessagesAb<T extends MessageComposite, F>(a:T, b:Maybe<unknown, F>) : T;
function mergeMessagesBa<T extends MessageComposite, F>(a:T, b:Maybe<unknown, F>) : T;

const enum messageSeverity {
  debug = 6,
  error = 1,
  fatal = 0,
  info = 4,
  notice = 3,
  verbose = 5,
  warn = 2
}

interface CardinalMessage extends MessageCommon {
  readonly code : number;
}
interface DataMessage<T extends Data> extends MessageCommon {
  readonly data : T;
}
interface ErrorMessage<T extends Error> extends MessageCommon {
  readonly error : T;
}
interface MessageComposite {
  readonly messages : Messages;
}
interface TextMessage extends MessageCommon {
  readonly text : string;
}

type Message<T = unknown> = ErrorMessage<Extract<T, Error>> | CardinalMessage | TextMessage | DataMessage<Extract<T, Data>> | DataMessage<{ readonly value : T }>;
type MessageSeverity = messageSeverity;
type Messages = readonly Message[];

function containsMessage(parent:MessageComposite, message:Message<unknown>) : boolean;
function createCardinalMessage(code:number, severity:messageSeverity = messageSeverity.error, messages:Messages = []) : CardinalMessage;
function createDataMessage<T>(data:T, severity:messageSeverity = messageSeverity.error, messages:Messages = []) : DataMessageDistinct<T>;
function createErrorMessage<T extends Error>(error:T, severity:messageSeverity = messageSeverity.error, messages:Messages = []) : ErrorMessage<T>;
function createMessage<T>(value:T, severity:messageSeverity = messageSeverity.error, messages:Messages = []) : MessageDistinct<T>;
function createTextMessage(text:string, severity:messageSeverity = messageSeverity.error, messages:Messages = []) : TextMessage;
function flattenMessage(message:Message<unknown>) : Messages;
function flattenMessages(messages:Messages) : Messages;
function isCardinalMessage<T>(message:Message<T>) : message is CardinalMessage;
function isDataMessage<T>(message:Message<T>) : message is DataMessage<Extract<T, Readonly<Record<string | symbol, unknown>>>>;
function isErrorMessage<T>(message:Message<T>) : message is ErrorMessage<Extract<T, Error>>;
function isTextMessage<T>(message:Message<T>) : message is TextMessage;
function mergeCompositeAb<T extends MessageComposite, U extends MessageComposite>(a:T, b:U) : T;
function mergeCompositeBa<T extends MessageComposite, U extends MessageComposite>(a:T, b:U) : T;
function resolveMessageValue<T>(message:Message<T>) : unknown;

export { failureFrom as failureAsync, maybeFrom as maybeAsync, resultFrom as resultAsync } from "./async"
export { failureFrom, maybeFrom, resultFrom } from "./sync"

function failureFrom<T, R>(fn:(v:T) => Promise<R>, value?:T) : Promise<Failure<R>>;
function maybeFrom<T, R>(fn:(v:T) => Promise<R>, isResult:filter<R> = filterAll, value?:T) : Promise<Maybe<R, R>>;
function resultFrom<T, R>(fn:(v:T) => Promise<R>, value?:T) : Promise<Maybe<R>>;

type filter<T> = (value:T) => boolean;

function filterAll() : boolean;

function failureFrom<T, R>(fn:(v:T) => R, value?:T) : Failure<R>;
function maybeFrom<T, R>(fn:(v:T) => R, isResult:filter<R> = filterAll, value?:T) : Maybe<R, R>;
function resultFrom<T, R>(fn:(v:T) => R, value?:T) : Result<R>;