ParseResult

declare const fail: (issue: ParseIssue) => Either.Either<never, ParseIssue>

declare const fromOption: {
  (onNone: () => ParseIssue): <A>(self: Option<A>) => Either<A, ParseIssue>;
  <A>(self: Option<A>, onNone: () => ParseIssue): Either<A, ParseIssue>;
}

declare function parseError(issue: ParseIssue): ParseError

declare const succeed: <A>(a: A) => Either.Either<A, ParseIssue>

declare const decode: <A, I, R>(schema: Schema.Schema<A, I, R>, options?: AST.ParseOptions) => (i: I, overrideOptions?: AST.ParseOptions) => Effect.Effect<A, ParseIssue, R>

declare const decodeEither: <A, I>(schema: Schema.Schema<A, I, never>, options?: AST.ParseOptions) => (i: I, overrideOptions?: AST.ParseOptions) => Either.Either<A, ParseIssue>

declare const decodeOption: <A, I>(schema: Schema.Schema<A, I, never>, options?: AST.ParseOptions) => (i: I, overrideOptions?: AST.ParseOptions) => Option.Option<A>

declare const decodePromise: <A, I>(schema: Schema.Schema<A, I, never>, options?: AST.ParseOptions) => (i: I, overrideOptions?: AST.ParseOptions) => Promise<A>

declare const decodeSync: <A, I>(schema: Schema.Schema<A, I, never>, options?: AST.ParseOptions) => (i: I, overrideOptions?: AST.ParseOptions) => A

declare function decodeUnknown<A, I, R>(schema: Schema<A, I, R>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Effect<A, ParseIssue, R>

declare function decodeUnknownEither<A, I>(schema: Schema<A, I, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Either<A, ParseIssue>

declare function decodeUnknownOption<A, I>(schema: Schema<A, I, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Option<A>

declare function decodeUnknownPromise<A, I>(schema: Schema<A, I, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Promise<A>

declare function decodeUnknownSync<A, I>(schema: Schema<A, I, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => A

declare const encode: <A, I, R>(schema: Schema.Schema<A, I, R>, options?: AST.ParseOptions) => (a: A, overrideOptions?: AST.ParseOptions) => Effect.Effect<I, ParseIssue, R>

declare const encodeEither: <A, I>(schema: Schema.Schema<A, I, never>, options?: AST.ParseOptions) => (a: A, overrideOptions?: AST.ParseOptions) => Either.Either<I, ParseIssue>

declare const encodeOption: <A, I>(schema: Schema.Schema<A, I, never>, options?: AST.ParseOptions) => (input: A, overrideOptions?: AST.ParseOptions) => Option.Option<I>

declare const encodePromise: <A, I>(schema: Schema.Schema<A, I, never>, options?: AST.ParseOptions) => (a: A, overrideOptions?: AST.ParseOptions) => Promise<I>

declare const encodeSync: <A, I>(schema: Schema.Schema<A, I, never>, options?: AST.ParseOptions) => (a: A, overrideOptions?: AST.ParseOptions) => I

declare function encodeUnknown<A, I, R>(schema: Schema<A, I, R>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Effect<I, ParseIssue, R>

declare function encodeUnknownEither<A, I>(schema: Schema<A, I, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Either<I, ParseIssue>

declare function encodeUnknownOption<A, I>(schema: Schema<A, I, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Option<I>

declare function encodeUnknownPromise<A, I>(schema: Schema<A, I, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Promise<I>

declare function encodeUnknownSync<A, I>(schema: Schema<A, I, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => I

declare const ArrayFormatter: ParseResultFormatter<Array<ArrayFormatterIssue>>

interface ParseResultFormatter<A> {
  readonly formatError: (error: ParseError) => Effect<A>;
  readonly formatErrorSync: (error: ParseError) => A;
  readonly formatIssue: (issue: ParseIssue) => Effect<A>;
  readonly formatIssueSync: (issue: ParseIssue) => A;
}

declare const TreeFormatter: ParseResultFormatter<string>

declare const isComposite: (issue: ParseIssue) => issue is Composite

interface ArrayFormatterIssue {
  readonly _tag: "Composite" | "Pointer" | "Unexpected" | "Missing" | "Refinement" | "Transformation" | "Type" | "Forbidden";
  readonly message: string;
  readonly path: readonly Array<PropertyKey>;
}

declare class Composite {
  constructor(ast: AST, actual: unknown, issues: SingleOrNonEmpty<ParseIssue>, output?: unknown);
  readonly _tag: "Composite";
  readonly actual: unknown;
  readonly ast: AST;
  readonly issues: SingleOrNonEmpty<ParseIssue>;
  readonly output?: unknown;
}

declare class Forbidden {
  constructor(ast: AST, actual: unknown, message?: string);
  readonly _tag: "Forbidden";
  readonly actual: unknown;
  readonly ast: AST;
  readonly message?: string;
}

declare class Missing {
  constructor(ast: Type, message?: string);
  readonly _tag: "Missing";
  readonly actual: undefined;
  readonly ast: Type;
  readonly message?: string;
}

type ParseIssue = Type | Missing | Unexpected | Forbidden | Pointer | Refinement | Transformation | Composite

type Path = SingleOrNonEmpty<PropertyKey>

declare class Pointer {
  constructor(path: Path, actual: unknown, issue: ParseIssue);
  readonly _tag: "Pointer";
  readonly actual: unknown;
  readonly issue: ParseIssue;
  readonly path: Path;
}

declare class Refinement {
  constructor(ast: Refinement, actual: unknown, kind: "From" | "Predicate", issue: ParseIssue);
  readonly _tag: "Refinement";
  readonly actual: unknown;
  readonly ast: Refinement;
  readonly issue: ParseIssue;
  readonly kind: "From" | "Predicate";
}

type SingleOrNonEmpty<A> = A | Arr.NonEmptyReadonlyArray<A>

declare class Transformation {
  constructor(ast: Transformation, actual: unknown, kind: "Encoded" | "Transformation" | "Type", issue: ParseIssue);
  readonly _tag: "Transformation";
  readonly actual: unknown;
  readonly ast: Transformation;
  readonly issue: ParseIssue;
  readonly kind: "Encoded" | "Transformation" | "Type";
}

declare class Type {
  constructor(ast: AST, actual: unknown, message?: string);
  readonly _tag: "Type";
  readonly actual: unknown;
  readonly ast: AST;
  readonly message?: string;
}

declare class Unexpected {
  constructor(actual: unknown, message?: string);
  readonly _tag: "Unexpected";
  readonly actual: unknown;
  readonly message?: string;
}

declare function eitherOrUndefined<A, E, R>(self: Effect<A, E, R>): Either<A, E> | undefined

declare const flatMap: {
  <A, B, E1, R1>(f: (a: A) => Effect<B, E1, R1>): <E, R>(self: Effect<A, E, R>) => Effect<B, E1 | E, R1 | R>;
  <A, E, R, B, E1, R1>(self: Effect<A, E, R>, f: (a: A) => Effect<B, E1, R1>): Effect<B, E | E1, R | R1>;
}

declare const map: {
  <A, B>(f: (a: A) => B): <E, R>(self: Effect<A, E, R>) => Effect<B, E, R>;
  <A, E, R, B>(self: Effect<A, E, R>, f: (a: A) => B): Effect<B, E, R>;
}

declare const mapBoth: {
  <E, E2, A, A2>(options: {
    readonly onFailure: (e: E) => E2;
    readonly onSuccess: (a: A) => A2;
  }): <R>(self: Effect<A, E, R>) => Effect<A2, E2, R>;
  <A, E, R, E2, A2>(self: Effect<A, E, R>, options: {
    readonly onFailure: (e: E) => E2;
    readonly onSuccess: (a: A) => A2;
  }): Effect<A2, E2, R>;
}

declare const mapError: {
  <E, E2>(f: (e: E) => E2): <A, R>(self: Effect<A, E, R>) => Effect<A, E2, R>;
  <A, E, R, E2>(self: Effect<A, E, R>, f: (e: E) => E2): Effect<A, E2, R>;
}

declare const orElse: {
  <E, A2, E2, R2>(f: (e: E) => Effect<A2, E2, R2>): <A, R>(self: Effect<A, E, R>) => Effect<A2 | A, E2, R2 | R>;
  <A, E, R, A2, E2, R2>(self: Effect<A, E, R>, f: (e: E) => Effect<A2, E2, R2>): Effect<A | A2, E2, R | R2>;
}

type DeclarationDecodeUnknown<Out, R> = (u: unknown, options: AST.ParseOptions, ast: AST.Declaration) => Effect.Effect<Out, ParseIssue, R>

type DecodeUnknown<Out, R> = (u: unknown, options?: AST.ParseOptions) => Effect.Effect<Out, ParseIssue, R>

declare function isParseError(u: unknown): u is ParseError

declare class ParseError extends YieldableError<this> & {
  readonly _tag: "ParseError";
} & Readonly<{
  readonly issue: ParseIssue;
}> {
  constructor(args: {
    readonly issue: ParseIssue;
  });
  readonly [ParseErrorTypeId]: symbol;
  message: string;
  [NodeInspectSymbol](): {
    _id: string;
    message: string;
  };
  toJSON(): {
    _id: string;
    message: string;
  };
  toString(): string;
}

declare const try: <A>(options: {
  catch: (e: unknown) => ParseIssue;
  try: LazyArg<A>;
}) => Either.Either<A, ParseIssue>

declare const ParseErrorTypeId: unique symbol

type ParseErrorTypeId = typeof ParseErrorTypeId

declare function asserts<A, I, R>(schema: Schema<A, I, R>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => asserts u is A

declare function is<A, I, R>(schema: Schema<A, I, R>, options?: ParseOptions): (u: unknown, overrideOptions?: number | ParseOptions) => u is A

declare function validate<A, I, R>(schema: Schema<A, I, R>, options?: ParseOptions): (a: unknown, overrideOptions?: ParseOptions) => Effect<A, ParseIssue, R>

declare function validateEither<A, I, R>(schema: Schema<A, I, R>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Either<A, ParseIssue>

declare function validateOption<A, I, R>(schema: Schema<A, I, R>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Option<A>

declare function validatePromise<A, I>(schema: Schema<A, I, never>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => Promise<A>

declare function validateSync<A, I, R>(schema: Schema<A, I, R>, options?: ParseOptions): (u: unknown, overrideOptions?: ParseOptions) => A