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;