ConfigError

declare const And: (self: ConfigError, that: ConfigError) => ConfigError;

declare const InvalidData: (path: Array<string>, message: string, options?: Options) => ConfigError;

declare const MissingData: (path: Array<string>, message: string, options?: Options) => ConfigError;

declare const Or: (self: ConfigError, that: ConfigError) => ConfigError;

declare const SourceUnavailable: (
  path: Array<string>,
  message: string,
  cause: Cause<unknown>,
  options?: Options,
) => ConfigError;

declare const Unsupported: (path: Array<string>, message: string, options?: Options) => ConfigError;

declare const reduceWithContext: {
  <C, Z>(context: C, reducer: ConfigErrorReducer<C, Z>): (self: ConfigError) => Z;
  <C, Z>(self: ConfigError, context: C, reducer: ConfigErrorReducer<C, Z>): Z;
};

interface And extends Proto {
  readonly _op: "And";
  readonly left: ConfigError;
  readonly message: string;
  readonly right: ConfigError;
}

type ConfigError = And | Or | InvalidData | MissingData | SourceUnavailable | Unsupported;

interface ConfigErrorReducer<in C, in out Z> {
  andCase(context: C, left: Z, right: Z): Z;
  invalidDataCase(context: C, path: Array<string>, message: string): Z;
  missingDataCase(context: C, path: Array<string>, message: string): Z;
  orCase(context: C, left: Z, right: Z): Z;
  sourceUnavailableCase(context: C, path: Array<string>, message: string, cause: Cause<unknown>): Z;
  unsupportedCase(context: C, path: Array<string>, message: string): Z;
}

interface InvalidData extends Proto {
  readonly _op: "InvalidData";
  readonly message: string;
  readonly path: Array<string>;
}

interface MissingData extends Proto {
  readonly _op: "MissingData";
  readonly message: string;
  readonly path: Array<string>;
}

interface Options {
  readonly pathDelim: string;
}

interface Or extends Proto {
  readonly _op: "Or";
  readonly left: ConfigError;
  readonly message: string;
  readonly right: ConfigError;
}

interface SourceUnavailable extends Proto {
  readonly _op: "SourceUnavailable";
  readonly cause: Cause<unknown>;
  readonly message: string;
  readonly path: Array<string>;
}

interface Unsupported extends Proto {
  readonly _op: "Unsupported";
  readonly message: string;
  readonly path: Array<string>;
}

declare const isMissingDataOnly: (self: ConfigError) => boolean;

declare const isAnd: (self: ConfigError) => self is And;

declare const isConfigError: (u: unknown) => u is ConfigError;

declare const isInvalidData: (self: ConfigError) => self is InvalidData;

declare const isMissingData: (self: ConfigError) => self is MissingData;

declare const isOr: (self: ConfigError) => self is Or;

declare const isSourceUnavailable: (self: ConfigError) => self is SourceUnavailable;

declare const isUnsupported: (self: ConfigError) => self is Unsupported;

declare const ConfigErrorTypeId: unique symbol;

type ConfigErrorTypeId = typeof ConfigErrorTypeId;

declare const prefixed: {
  (prefix: Array<string>): (self: ConfigError) => ConfigError;
  (self: ConfigError, prefix: Array<string>): ConfigError;
};