@opencode-ai/core 0.0.0-next-17293

package/dist/types/v1/config/error.d.ts

@@ -0,0 +1,1773 @@
+export * as ConfigErrorV1 from "./error.js";
+import { Schema } from "effect";
+import { NamedError } from "../../util/error.js";
+export declare const JsonError: {
+    new (data: {
+        readonly path: string;
+        readonly message?: string | undefined;
+    }, options?: ErrorOptions): {
+        readonly name: "ConfigJsonError";
+        readonly data: {
+            readonly path: string;
+            readonly message?: string | undefined;
+        };
+        schema(): Schema.Struct<{
+            readonly name: Schema.Literal<"ConfigJsonError">;
+            readonly data: Schema.Struct<{
+                path: Schema.String;
+                message: Schema.optional<Schema.String>;
+            }>;
+        }>;
+        toObject(): {
+            name: "ConfigJsonError";
+            data: {
+                readonly path: string;
+                readonly message?: string | undefined;
+            };
+        };
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly "~effect/Runtime/errorExitCode"?: number;
+        readonly "~effect/Runtime/errorReported"?: boolean;
+        readonly "~effect/ErrorReporter/ignore"?: boolean;
+        readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+        readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+    };
+    readonly Schema: Schema.Struct<{
+        readonly name: Schema.Literal<"ConfigJsonError">;
+        readonly data: Schema.Struct<{
+            path: Schema.String;
+            message: Schema.optional<Schema.String>;
+        }>;
+    }>;
+    readonly EffectSchema: Schema.Struct<{
+        readonly name: Schema.Literal<"ConfigJsonError">;
+        readonly data: Schema.Struct<{
+            path: Schema.String;
+            message: Schema.optional<Schema.String>;
+        }>;
+    }>;
+    readonly tag: "ConfigJsonError";
+    isInstance(input: unknown): input is {
+        readonly name: "ConfigJsonError";
+        readonly data: {
+            readonly path: string;
+            readonly message?: string | undefined;
+        };
+        schema(): Schema.Struct<{
+            readonly name: Schema.Literal<"ConfigJsonError">;
+            readonly data: Schema.Struct<{
+                path: Schema.String;
+                message: Schema.optional<Schema.String>;
+            }>;
+        }>;
+        toObject(): {
+            name: "ConfigJsonError";
+            data: {
+                readonly path: string;
+                readonly message?: string | undefined;
+            };
+        };
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly "~effect/Runtime/errorExitCode"?: number;
+        readonly "~effect/Runtime/errorReported"?: boolean;
+        readonly "~effect/ErrorReporter/ignore"?: boolean;
+        readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+        readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+    };
+    hasName(error: unknown, name: string): boolean;
+    create<Name extends string, Fields extends Schema.Struct.Fields>(name: Name, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name, Schema.Struct<Fields>>>;
+    create<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): ReturnType<typeof NamedError.createSchemaClass<Name, DataSchema>>;
+    createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): {
+        new (data: Schema.Schema.Type<DataSchema>, options?: ErrorOptions): {
+            readonly name: Name;
+            readonly data: Schema.Schema.Type<DataSchema>;
+            schema(): Schema.Struct<{
+                readonly name: Schema.Literal<Name>;
+                readonly data: DataSchema;
+            }>;
+            toObject(): {
+                name: Name;
+                data: Schema.Schema.Type<DataSchema>;
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            readonly "~effect/Runtime/errorExitCode"?: number;
+            readonly "~effect/Runtime/errorReported"?: boolean;
+            readonly "~effect/ErrorReporter/ignore"?: boolean;
+            readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+            readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        };
+        readonly Schema: Schema.Struct<{
+            readonly name: Schema.Literal<Name>;
+            readonly data: DataSchema;
+        }>;
+        readonly EffectSchema: Schema.Struct<{
+            readonly name: Schema.Literal<Name>;
+            readonly data: DataSchema;
+        }>;
+        readonly tag: Name;
+        isInstance(input: unknown): input is InstanceType</*elided*/ any>;
+        hasName(error: unknown, name: string): boolean;
+        create<Name_1 extends string, Fields extends Schema.Struct.Fields>(name: Name_1, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name_1, Schema.Struct<Fields>>>;
+        create<Name_1 extends string, DataSchema_1 extends Schema.Top>(name: Name_1, data: DataSchema_1): ReturnType<typeof NamedError.createSchemaClass<Name_1, DataSchema_1>>;
+        createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): /*elided*/ any;
+        readonly Unknown: {
+            new (data: {
+                readonly message: string;
+                readonly ref?: string | undefined;
+            }, options?: ErrorOptions): {
+                readonly name: "UnknownError";
+                readonly data: {
+                    readonly message: string;
+                    readonly ref?: string | undefined;
+                };
+                schema(): Schema.Struct<{
+                    readonly name: Schema.Literal<"UnknownError">;
+                    readonly data: Schema.Struct<{
+                        message: Schema.String;
+                        ref: Schema.optional<Schema.String>;
+                    }>;
+                }>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        readonly message: string;
+                        readonly ref?: string | undefined;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+                readonly "~effect/Runtime/errorExitCode"?: number;
+                readonly "~effect/Runtime/errorReported"?: boolean;
+                readonly "~effect/ErrorReporter/ignore"?: boolean;
+                readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+                readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+            };
+            readonly Schema: Schema.Struct<{
+                readonly name: Schema.Literal<"UnknownError">;
+                readonly data: Schema.Struct<{
+                    message: Schema.String;
+                    ref: Schema.optional<Schema.String>;
+                }>;
+            }>;
+            readonly EffectSchema: Schema.Struct<{
+                readonly name: Schema.Literal<"UnknownError">;
+                readonly data: Schema.Struct<{
+                    message: Schema.String;
+                    ref: Schema.optional<Schema.String>;
+                }>;
+            }>;
+            readonly tag: "UnknownError";
+            isInstance(input: unknown): input is {
+                readonly name: "UnknownError";
+                readonly data: {
+                    readonly message: string;
+                    readonly ref?: string | undefined;
+                };
+                schema(): Schema.Struct<{
+                    readonly name: Schema.Literal<"UnknownError">;
+                    readonly data: Schema.Struct<{
+                        message: Schema.String;
+                        ref: Schema.optional<Schema.String>;
+                    }>;
+                }>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        readonly message: string;
+                        readonly ref?: string | undefined;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+                readonly "~effect/Runtime/errorExitCode"?: number;
+                readonly "~effect/Runtime/errorReported"?: boolean;
+                readonly "~effect/ErrorReporter/ignore"?: boolean;
+                readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+                readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+            };
+            hasName(error: unknown, name: string): boolean;
+            create<Name_1 extends string, Fields extends Schema.Struct.Fields>(name: Name_1, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name_1, Schema.Struct<Fields>>>;
+            create<Name_1 extends string, DataSchema_1 extends Schema.Top>(name: Name_1, data: DataSchema_1): ReturnType<typeof NamedError.createSchemaClass<Name_1, DataSchema_1>>;
+            createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): /*elided*/ any;
+            readonly Unknown: /*elided*/ any;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+            isError(value: unknown): value is Error;
+        };
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+        isError(value: unknown): value is Error;
+    };
+    readonly Unknown: {
+        new (data: {
+            readonly message: string;
+            readonly ref?: string | undefined;
+        }, options?: ErrorOptions): {
+            readonly name: "UnknownError";
+            readonly data: {
+                readonly message: string;
+                readonly ref?: string | undefined;
+            };
+            schema(): Schema.Struct<{
+                readonly name: Schema.Literal<"UnknownError">;
+                readonly data: Schema.Struct<{
+                    message: Schema.String;
+                    ref: Schema.optional<Schema.String>;
+                }>;
+            }>;
+            toObject(): {
+                name: "UnknownError";
+                data: {
+                    readonly message: string;
+                    readonly ref?: string | undefined;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            readonly "~effect/Runtime/errorExitCode"?: number;
+            readonly "~effect/Runtime/errorReported"?: boolean;
+            readonly "~effect/ErrorReporter/ignore"?: boolean;
+            readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+            readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        };
+        readonly Schema: Schema.Struct<{
+            readonly name: Schema.Literal<"UnknownError">;
+            readonly data: Schema.Struct<{
+                message: Schema.String;
+                ref: Schema.optional<Schema.String>;
+            }>;
+        }>;
+        readonly EffectSchema: Schema.Struct<{
+            readonly name: Schema.Literal<"UnknownError">;
+            readonly data: Schema.Struct<{
+                message: Schema.String;
+                ref: Schema.optional<Schema.String>;
+            }>;
+        }>;
+        readonly tag: "UnknownError";
+        isInstance(input: unknown): input is {
+            readonly name: "UnknownError";
+            readonly data: {
+                readonly message: string;
+                readonly ref?: string | undefined;
+            };
+            schema(): Schema.Struct<{
+                readonly name: Schema.Literal<"UnknownError">;
+                readonly data: Schema.Struct<{
+                    message: Schema.String;
+                    ref: Schema.optional<Schema.String>;
+                }>;
+            }>;
+            toObject(): {
+                name: "UnknownError";
+                data: {
+                    readonly message: string;
+                    readonly ref?: string | undefined;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            readonly "~effect/Runtime/errorExitCode"?: number;
+            readonly "~effect/Runtime/errorReported"?: boolean;
+            readonly "~effect/ErrorReporter/ignore"?: boolean;
+            readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+            readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        };
+        hasName(error: unknown, name: string): boolean;
+        create<Name extends string, Fields extends Schema.Struct.Fields>(name: Name, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name, Schema.Struct<Fields>>>;
+        create<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): ReturnType<typeof NamedError.createSchemaClass<Name, DataSchema>>;
+        createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): {
+            new (data: Schema.Schema.Type<DataSchema>, options?: ErrorOptions): {
+                readonly name: Name;
+                readonly data: Schema.Schema.Type<DataSchema>;
+                schema(): Schema.Struct<{
+                    readonly name: Schema.Literal<Name>;
+                    readonly data: DataSchema;
+                }>;
+                toObject(): {
+                    name: Name;
+                    data: Schema.Schema.Type<DataSchema>;
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+                readonly "~effect/Runtime/errorExitCode"?: number;
+                readonly "~effect/Runtime/errorReported"?: boolean;
+                readonly "~effect/ErrorReporter/ignore"?: boolean;
+                readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+                readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+            };
+            readonly Schema: Schema.Struct<{
+                readonly name: Schema.Literal<Name>;
+                readonly data: DataSchema;
+            }>;
+            readonly EffectSchema: Schema.Struct<{
+                readonly name: Schema.Literal<Name>;
+                readonly data: DataSchema;
+            }>;
+            readonly tag: Name;
+            isInstance(input: unknown): input is InstanceType</*elided*/ any>;
+            hasName(error: unknown, name: string): boolean;
+            create<Name_1 extends string, Fields extends Schema.Struct.Fields>(name: Name_1, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name_1, Schema.Struct<Fields>>>;
+            create<Name_1 extends string, DataSchema_1 extends Schema.Top>(name: Name_1, data: DataSchema_1): ReturnType<typeof NamedError.createSchemaClass<Name_1, DataSchema_1>>;
+            createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): /*elided*/ any;
+            readonly Unknown: /*elided*/ any;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+            isError(value: unknown): value is Error;
+        };
+        readonly Unknown: /*elided*/ any;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+        isError(value: unknown): value is Error;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+    isError(value: unknown): value is Error;
+};
+export declare const InvalidError: {
+    new (data: {
+        readonly path: string;
+        readonly message?: string | undefined;
+        readonly issues?: readonly {
+            readonly [x: string]: unknown;
+            readonly message: string;
+            readonly path: readonly string[];
+        }[] | undefined;
+    }, options?: ErrorOptions): {
+        readonly name: "ConfigInvalidError";
+        readonly data: {
+            readonly path: string;
+            readonly message?: string | undefined;
+            readonly issues?: readonly {
+                readonly [x: string]: unknown;
+                readonly message: string;
+                readonly path: readonly string[];
+            }[] | undefined;
+        };
+        schema(): Schema.Struct<{
+            readonly name: Schema.Literal<"ConfigInvalidError">;
+            readonly data: Schema.Struct<{
+                path: Schema.String;
+                issues: Schema.optional<Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+                    readonly message: Schema.String;
+                    readonly path: Schema.$Array<Schema.String>;
+                }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
+                message: Schema.optional<Schema.String>;
+            }>;
+        }>;
+        toObject(): {
+            name: "ConfigInvalidError";
+            data: {
+                readonly path: string;
+                readonly message?: string | undefined;
+                readonly issues?: readonly {
+                    readonly [x: string]: unknown;
+                    readonly message: string;
+                    readonly path: readonly string[];
+                }[] | undefined;
+            };
+        };
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly "~effect/Runtime/errorExitCode"?: number;
+        readonly "~effect/Runtime/errorReported"?: boolean;
+        readonly "~effect/ErrorReporter/ignore"?: boolean;
+        readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+        readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+    };
+    readonly Schema: Schema.Struct<{
+        readonly name: Schema.Literal<"ConfigInvalidError">;
+        readonly data: Schema.Struct<{
+            path: Schema.String;
+            issues: Schema.optional<Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+                readonly message: Schema.String;
+                readonly path: Schema.$Array<Schema.String>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
+            message: Schema.optional<Schema.String>;
+        }>;
+    }>;
+    readonly EffectSchema: Schema.Struct<{
+        readonly name: Schema.Literal<"ConfigInvalidError">;
+        readonly data: Schema.Struct<{
+            path: Schema.String;
+            issues: Schema.optional<Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+                readonly message: Schema.String;
+                readonly path: Schema.$Array<Schema.String>;
+            }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
+            message: Schema.optional<Schema.String>;
+        }>;
+    }>;
+    readonly tag: "ConfigInvalidError";
+    isInstance(input: unknown): input is {
+        readonly name: "ConfigInvalidError";
+        readonly data: {
+            readonly path: string;
+            readonly message?: string | undefined;
+            readonly issues?: readonly {
+                readonly [x: string]: unknown;
+                readonly message: string;
+                readonly path: readonly string[];
+            }[] | undefined;
+        };
+        schema(): Schema.Struct<{
+            readonly name: Schema.Literal<"ConfigInvalidError">;
+            readonly data: Schema.Struct<{
+                path: Schema.String;
+                issues: Schema.optional<Schema.$Array<Schema.StructWithRest<Schema.Struct<{
+                    readonly message: Schema.String;
+                    readonly path: Schema.$Array<Schema.String>;
+                }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
+                message: Schema.optional<Schema.String>;
+            }>;
+        }>;
+        toObject(): {
+            name: "ConfigInvalidError";
+            data: {
+                readonly path: string;
+                readonly message?: string | undefined;
+                readonly issues?: readonly {
+                    readonly [x: string]: unknown;
+                    readonly message: string;
+                    readonly path: readonly string[];
+                }[] | undefined;
+            };
+        };
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly "~effect/Runtime/errorExitCode"?: number;
+        readonly "~effect/Runtime/errorReported"?: boolean;
+        readonly "~effect/ErrorReporter/ignore"?: boolean;
+        readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+        readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+    };
+    hasName(error: unknown, name: string): boolean;
+    create<Name extends string, Fields extends Schema.Struct.Fields>(name: Name, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name, Schema.Struct<Fields>>>;
+    create<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): ReturnType<typeof NamedError.createSchemaClass<Name, DataSchema>>;
+    createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): {
+        new (data: Schema.Schema.Type<DataSchema>, options?: ErrorOptions): {
+            readonly name: Name;
+            readonly data: Schema.Schema.Type<DataSchema>;
+            schema(): Schema.Struct<{
+                readonly name: Schema.Literal<Name>;
+                readonly data: DataSchema;
+            }>;
+            toObject(): {
+                name: Name;
+                data: Schema.Schema.Type<DataSchema>;
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            readonly "~effect/Runtime/errorExitCode"?: number;
+            readonly "~effect/Runtime/errorReported"?: boolean;
+            readonly "~effect/ErrorReporter/ignore"?: boolean;
+            readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+            readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        };
+        readonly Schema: Schema.Struct<{
+            readonly name: Schema.Literal<Name>;
+            readonly data: DataSchema;
+        }>;
+        readonly EffectSchema: Schema.Struct<{
+            readonly name: Schema.Literal<Name>;
+            readonly data: DataSchema;
+        }>;
+        readonly tag: Name;
+        isInstance(input: unknown): input is InstanceType</*elided*/ any>;
+        hasName(error: unknown, name: string): boolean;
+        create<Name_1 extends string, Fields extends Schema.Struct.Fields>(name: Name_1, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name_1, Schema.Struct<Fields>>>;
+        create<Name_1 extends string, DataSchema_1 extends Schema.Top>(name: Name_1, data: DataSchema_1): ReturnType<typeof NamedError.createSchemaClass<Name_1, DataSchema_1>>;
+        createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): /*elided*/ any;
+        readonly Unknown: {
+            new (data: {
+                readonly message: string;
+                readonly ref?: string | undefined;
+            }, options?: ErrorOptions): {
+                readonly name: "UnknownError";
+                readonly data: {
+                    readonly message: string;
+                    readonly ref?: string | undefined;
+                };
+                schema(): Schema.Struct<{
+                    readonly name: Schema.Literal<"UnknownError">;
+                    readonly data: Schema.Struct<{
+                        message: Schema.String;
+                        ref: Schema.optional<Schema.String>;
+                    }>;
+                }>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        readonly message: string;
+                        readonly ref?: string | undefined;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+                readonly "~effect/Runtime/errorExitCode"?: number;
+                readonly "~effect/Runtime/errorReported"?: boolean;
+                readonly "~effect/ErrorReporter/ignore"?: boolean;
+                readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+                readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+            };
+            readonly Schema: Schema.Struct<{
+                readonly name: Schema.Literal<"UnknownError">;
+                readonly data: Schema.Struct<{
+                    message: Schema.String;
+                    ref: Schema.optional<Schema.String>;
+                }>;
+            }>;
+            readonly EffectSchema: Schema.Struct<{
+                readonly name: Schema.Literal<"UnknownError">;
+                readonly data: Schema.Struct<{
+                    message: Schema.String;
+                    ref: Schema.optional<Schema.String>;
+                }>;
+            }>;
+            readonly tag: "UnknownError";
+            isInstance(input: unknown): input is {
+                readonly name: "UnknownError";
+                readonly data: {
+                    readonly message: string;
+                    readonly ref?: string | undefined;
+                };
+                schema(): Schema.Struct<{
+                    readonly name: Schema.Literal<"UnknownError">;
+                    readonly data: Schema.Struct<{
+                        message: Schema.String;
+                        ref: Schema.optional<Schema.String>;
+                    }>;
+                }>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        readonly message: string;
+                        readonly ref?: string | undefined;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+                readonly "~effect/Runtime/errorExitCode"?: number;
+                readonly "~effect/Runtime/errorReported"?: boolean;
+                readonly "~effect/ErrorReporter/ignore"?: boolean;
+                readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+                readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+            };
+            hasName(error: unknown, name: string): boolean;
+            create<Name_1 extends string, Fields extends Schema.Struct.Fields>(name: Name_1, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name_1, Schema.Struct<Fields>>>;
+            create<Name_1 extends string, DataSchema_1 extends Schema.Top>(name: Name_1, data: DataSchema_1): ReturnType<typeof NamedError.createSchemaClass<Name_1, DataSchema_1>>;
+            createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): /*elided*/ any;
+            readonly Unknown: /*elided*/ any;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+            isError(value: unknown): value is Error;
+        };
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+        isError(value: unknown): value is Error;
+    };
+    readonly Unknown: {
+        new (data: {
+            readonly message: string;
+            readonly ref?: string | undefined;
+        }, options?: ErrorOptions): {
+            readonly name: "UnknownError";
+            readonly data: {
+                readonly message: string;
+                readonly ref?: string | undefined;
+            };
+            schema(): Schema.Struct<{
+                readonly name: Schema.Literal<"UnknownError">;
+                readonly data: Schema.Struct<{
+                    message: Schema.String;
+                    ref: Schema.optional<Schema.String>;
+                }>;
+            }>;
+            toObject(): {
+                name: "UnknownError";
+                data: {
+                    readonly message: string;
+                    readonly ref?: string | undefined;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            readonly "~effect/Runtime/errorExitCode"?: number;
+            readonly "~effect/Runtime/errorReported"?: boolean;
+            readonly "~effect/ErrorReporter/ignore"?: boolean;
+            readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+            readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        };
+        readonly Schema: Schema.Struct<{
+            readonly name: Schema.Literal<"UnknownError">;
+            readonly data: Schema.Struct<{
+                message: Schema.String;
+                ref: Schema.optional<Schema.String>;
+            }>;
+        }>;
+        readonly EffectSchema: Schema.Struct<{
+            readonly name: Schema.Literal<"UnknownError">;
+            readonly data: Schema.Struct<{
+                message: Schema.String;
+                ref: Schema.optional<Schema.String>;
+            }>;
+        }>;
+        readonly tag: "UnknownError";
+        isInstance(input: unknown): input is {
+            readonly name: "UnknownError";
+            readonly data: {
+                readonly message: string;
+                readonly ref?: string | undefined;
+            };
+            schema(): Schema.Struct<{
+                readonly name: Schema.Literal<"UnknownError">;
+                readonly data: Schema.Struct<{
+                    message: Schema.String;
+                    ref: Schema.optional<Schema.String>;
+                }>;
+            }>;
+            toObject(): {
+                name: "UnknownError";
+                data: {
+                    readonly message: string;
+                    readonly ref?: string | undefined;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            readonly "~effect/Runtime/errorExitCode"?: number;
+            readonly "~effect/Runtime/errorReported"?: boolean;
+            readonly "~effect/ErrorReporter/ignore"?: boolean;
+            readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+            readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        };
+        hasName(error: unknown, name: string): boolean;
+        create<Name extends string, Fields extends Schema.Struct.Fields>(name: Name, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name, Schema.Struct<Fields>>>;
+        create<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): ReturnType<typeof NamedError.createSchemaClass<Name, DataSchema>>;
+        createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): {
+            new (data: Schema.Schema.Type<DataSchema>, options?: ErrorOptions): {
+                readonly name: Name;
+                readonly data: Schema.Schema.Type<DataSchema>;
+                schema(): Schema.Struct<{
+                    readonly name: Schema.Literal<Name>;
+                    readonly data: DataSchema;
+                }>;
+                toObject(): {
+                    name: Name;
+                    data: Schema.Schema.Type<DataSchema>;
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+                readonly "~effect/Runtime/errorExitCode"?: number;
+                readonly "~effect/Runtime/errorReported"?: boolean;
+                readonly "~effect/ErrorReporter/ignore"?: boolean;
+                readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+                readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+            };
+            readonly Schema: Schema.Struct<{
+                readonly name: Schema.Literal<Name>;
+                readonly data: DataSchema;
+            }>;
+            readonly EffectSchema: Schema.Struct<{
+                readonly name: Schema.Literal<Name>;
+                readonly data: DataSchema;
+            }>;
+            readonly tag: Name;
+            isInstance(input: unknown): input is InstanceType</*elided*/ any>;
+            hasName(error: unknown, name: string): boolean;
+            create<Name_1 extends string, Fields extends Schema.Struct.Fields>(name: Name_1, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name_1, Schema.Struct<Fields>>>;
+            create<Name_1 extends string, DataSchema_1 extends Schema.Top>(name: Name_1, data: DataSchema_1): ReturnType<typeof NamedError.createSchemaClass<Name_1, DataSchema_1>>;
+            createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): /*elided*/ any;
+            readonly Unknown: /*elided*/ any;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+            isError(value: unknown): value is Error;
+        };
+        readonly Unknown: /*elided*/ any;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+        isError(value: unknown): value is Error;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+    isError(value: unknown): value is Error;
+};
+export declare const FrontmatterError: {
+    new (data: {
+        readonly path: string;
+        readonly message: string;
+    }, options?: ErrorOptions): {
+        readonly name: "ConfigFrontmatterError";
+        readonly data: {
+            readonly path: string;
+            readonly message: string;
+        };
+        schema(): Schema.Struct<{
+            readonly name: Schema.Literal<"ConfigFrontmatterError">;
+            readonly data: Schema.Struct<{
+                path: Schema.String;
+                message: Schema.String;
+            }>;
+        }>;
+        toObject(): {
+            name: "ConfigFrontmatterError";
+            data: {
+                readonly path: string;
+                readonly message: string;
+            };
+        };
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly "~effect/Runtime/errorExitCode"?: number;
+        readonly "~effect/Runtime/errorReported"?: boolean;
+        readonly "~effect/ErrorReporter/ignore"?: boolean;
+        readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+        readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+    };
+    readonly Schema: Schema.Struct<{
+        readonly name: Schema.Literal<"ConfigFrontmatterError">;
+        readonly data: Schema.Struct<{
+            path: Schema.String;
+            message: Schema.String;
+        }>;
+    }>;
+    readonly EffectSchema: Schema.Struct<{
+        readonly name: Schema.Literal<"ConfigFrontmatterError">;
+        readonly data: Schema.Struct<{
+            path: Schema.String;
+            message: Schema.String;
+        }>;
+    }>;
+    readonly tag: "ConfigFrontmatterError";
+    isInstance(input: unknown): input is {
+        readonly name: "ConfigFrontmatterError";
+        readonly data: {
+            readonly path: string;
+            readonly message: string;
+        };
+        schema(): Schema.Struct<{
+            readonly name: Schema.Literal<"ConfigFrontmatterError">;
+            readonly data: Schema.Struct<{
+                path: Schema.String;
+                message: Schema.String;
+            }>;
+        }>;
+        toObject(): {
+            name: "ConfigFrontmatterError";
+            data: {
+                readonly path: string;
+                readonly message: string;
+            };
+        };
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly "~effect/Runtime/errorExitCode"?: number;
+        readonly "~effect/Runtime/errorReported"?: boolean;
+        readonly "~effect/ErrorReporter/ignore"?: boolean;
+        readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+        readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+    };
+    hasName(error: unknown, name: string): boolean;
+    create<Name extends string, Fields extends Schema.Struct.Fields>(name: Name, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name, Schema.Struct<Fields>>>;
+    create<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): ReturnType<typeof NamedError.createSchemaClass<Name, DataSchema>>;
+    createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): {
+        new (data: Schema.Schema.Type<DataSchema>, options?: ErrorOptions): {
+            readonly name: Name;
+            readonly data: Schema.Schema.Type<DataSchema>;
+            schema(): Schema.Struct<{
+                readonly name: Schema.Literal<Name>;
+                readonly data: DataSchema;
+            }>;
+            toObject(): {
+                name: Name;
+                data: Schema.Schema.Type<DataSchema>;
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            readonly "~effect/Runtime/errorExitCode"?: number;
+            readonly "~effect/Runtime/errorReported"?: boolean;
+            readonly "~effect/ErrorReporter/ignore"?: boolean;
+            readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+            readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        };
+        readonly Schema: Schema.Struct<{
+            readonly name: Schema.Literal<Name>;
+            readonly data: DataSchema;
+        }>;
+        readonly EffectSchema: Schema.Struct<{
+            readonly name: Schema.Literal<Name>;
+            readonly data: DataSchema;
+        }>;
+        readonly tag: Name;
+        isInstance(input: unknown): input is InstanceType</*elided*/ any>;
+        hasName(error: unknown, name: string): boolean;
+        create<Name_1 extends string, Fields extends Schema.Struct.Fields>(name: Name_1, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name_1, Schema.Struct<Fields>>>;
+        create<Name_1 extends string, DataSchema_1 extends Schema.Top>(name: Name_1, data: DataSchema_1): ReturnType<typeof NamedError.createSchemaClass<Name_1, DataSchema_1>>;
+        createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): /*elided*/ any;
+        readonly Unknown: {
+            new (data: {
+                readonly message: string;
+                readonly ref?: string | undefined;
+            }, options?: ErrorOptions): {
+                readonly name: "UnknownError";
+                readonly data: {
+                    readonly message: string;
+                    readonly ref?: string | undefined;
+                };
+                schema(): Schema.Struct<{
+                    readonly name: Schema.Literal<"UnknownError">;
+                    readonly data: Schema.Struct<{
+                        message: Schema.String;
+                        ref: Schema.optional<Schema.String>;
+                    }>;
+                }>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        readonly message: string;
+                        readonly ref?: string | undefined;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+                readonly "~effect/Runtime/errorExitCode"?: number;
+                readonly "~effect/Runtime/errorReported"?: boolean;
+                readonly "~effect/ErrorReporter/ignore"?: boolean;
+                readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+                readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+            };
+            readonly Schema: Schema.Struct<{
+                readonly name: Schema.Literal<"UnknownError">;
+                readonly data: Schema.Struct<{
+                    message: Schema.String;
+                    ref: Schema.optional<Schema.String>;
+                }>;
+            }>;
+            readonly EffectSchema: Schema.Struct<{
+                readonly name: Schema.Literal<"UnknownError">;
+                readonly data: Schema.Struct<{
+                    message: Schema.String;
+                    ref: Schema.optional<Schema.String>;
+                }>;
+            }>;
+            readonly tag: "UnknownError";
+            isInstance(input: unknown): input is {
+                readonly name: "UnknownError";
+                readonly data: {
+                    readonly message: string;
+                    readonly ref?: string | undefined;
+                };
+                schema(): Schema.Struct<{
+                    readonly name: Schema.Literal<"UnknownError">;
+                    readonly data: Schema.Struct<{
+                        message: Schema.String;
+                        ref: Schema.optional<Schema.String>;
+                    }>;
+                }>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        readonly message: string;
+                        readonly ref?: string | undefined;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+                readonly "~effect/Runtime/errorExitCode"?: number;
+                readonly "~effect/Runtime/errorReported"?: boolean;
+                readonly "~effect/ErrorReporter/ignore"?: boolean;
+                readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+                readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+            };
+            hasName(error: unknown, name: string): boolean;
+            create<Name_1 extends string, Fields extends Schema.Struct.Fields>(name: Name_1, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name_1, Schema.Struct<Fields>>>;
+            create<Name_1 extends string, DataSchema_1 extends Schema.Top>(name: Name_1, data: DataSchema_1): ReturnType<typeof NamedError.createSchemaClass<Name_1, DataSchema_1>>;
+            createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): /*elided*/ any;
+            readonly Unknown: /*elided*/ any;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+            isError(value: unknown): value is Error;
+        };
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+        isError(value: unknown): value is Error;
+    };
+    readonly Unknown: {
+        new (data: {
+            readonly message: string;
+            readonly ref?: string | undefined;
+        }, options?: ErrorOptions): {
+            readonly name: "UnknownError";
+            readonly data: {
+                readonly message: string;
+                readonly ref?: string | undefined;
+            };
+            schema(): Schema.Struct<{
+                readonly name: Schema.Literal<"UnknownError">;
+                readonly data: Schema.Struct<{
+                    message: Schema.String;
+                    ref: Schema.optional<Schema.String>;
+                }>;
+            }>;
+            toObject(): {
+                name: "UnknownError";
+                data: {
+                    readonly message: string;
+                    readonly ref?: string | undefined;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            readonly "~effect/Runtime/errorExitCode"?: number;
+            readonly "~effect/Runtime/errorReported"?: boolean;
+            readonly "~effect/ErrorReporter/ignore"?: boolean;
+            readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+            readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        };
+        readonly Schema: Schema.Struct<{
+            readonly name: Schema.Literal<"UnknownError">;
+            readonly data: Schema.Struct<{
+                message: Schema.String;
+                ref: Schema.optional<Schema.String>;
+            }>;
+        }>;
+        readonly EffectSchema: Schema.Struct<{
+            readonly name: Schema.Literal<"UnknownError">;
+            readonly data: Schema.Struct<{
+                message: Schema.String;
+                ref: Schema.optional<Schema.String>;
+            }>;
+        }>;
+        readonly tag: "UnknownError";
+        isInstance(input: unknown): input is {
+            readonly name: "UnknownError";
+            readonly data: {
+                readonly message: string;
+                readonly ref?: string | undefined;
+            };
+            schema(): Schema.Struct<{
+                readonly name: Schema.Literal<"UnknownError">;
+                readonly data: Schema.Struct<{
+                    message: Schema.String;
+                    ref: Schema.optional<Schema.String>;
+                }>;
+            }>;
+            toObject(): {
+                name: "UnknownError";
+                data: {
+                    readonly message: string;
+                    readonly ref?: string | undefined;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            readonly "~effect/Runtime/errorExitCode"?: number;
+            readonly "~effect/Runtime/errorReported"?: boolean;
+            readonly "~effect/ErrorReporter/ignore"?: boolean;
+            readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+            readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        };
+        hasName(error: unknown, name: string): boolean;
+        create<Name extends string, Fields extends Schema.Struct.Fields>(name: Name, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name, Schema.Struct<Fields>>>;
+        create<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): ReturnType<typeof NamedError.createSchemaClass<Name, DataSchema>>;
+        createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): {
+            new (data: Schema.Schema.Type<DataSchema>, options?: ErrorOptions): {
+                readonly name: Name;
+                readonly data: Schema.Schema.Type<DataSchema>;
+                schema(): Schema.Struct<{
+                    readonly name: Schema.Literal<Name>;
+                    readonly data: DataSchema;
+                }>;
+                toObject(): {
+                    name: Name;
+                    data: Schema.Schema.Type<DataSchema>;
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+                readonly "~effect/Runtime/errorExitCode"?: number;
+                readonly "~effect/Runtime/errorReported"?: boolean;
+                readonly "~effect/ErrorReporter/ignore"?: boolean;
+                readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+                readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+            };
+            readonly Schema: Schema.Struct<{
+                readonly name: Schema.Literal<Name>;
+                readonly data: DataSchema;
+            }>;
+            readonly EffectSchema: Schema.Struct<{
+                readonly name: Schema.Literal<Name>;
+                readonly data: DataSchema;
+            }>;
+            readonly tag: Name;
+            isInstance(input: unknown): input is InstanceType</*elided*/ any>;
+            hasName(error: unknown, name: string): boolean;
+            create<Name_1 extends string, Fields extends Schema.Struct.Fields>(name: Name_1, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name_1, Schema.Struct<Fields>>>;
+            create<Name_1 extends string, DataSchema_1 extends Schema.Top>(name: Name_1, data: DataSchema_1): ReturnType<typeof NamedError.createSchemaClass<Name_1, DataSchema_1>>;
+            createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): /*elided*/ any;
+            readonly Unknown: /*elided*/ any;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+            isError(value: unknown): value is Error;
+        };
+        readonly Unknown: /*elided*/ any;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+        isError(value: unknown): value is Error;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+    isError(value: unknown): value is Error;
+};
+export declare const DirectoryTypoError: {
+    new (data: {
+        readonly path: string;
+        readonly dir: string;
+        readonly suggestion: string;
+    }, options?: ErrorOptions): {
+        readonly name: "ConfigDirectoryTypoError";
+        readonly data: {
+            readonly path: string;
+            readonly dir: string;
+            readonly suggestion: string;
+        };
+        schema(): Schema.Struct<{
+            readonly name: Schema.Literal<"ConfigDirectoryTypoError">;
+            readonly data: Schema.Struct<{
+                path: Schema.String;
+                dir: Schema.String;
+                suggestion: Schema.String;
+            }>;
+        }>;
+        toObject(): {
+            name: "ConfigDirectoryTypoError";
+            data: {
+                readonly path: string;
+                readonly dir: string;
+                readonly suggestion: string;
+            };
+        };
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly "~effect/Runtime/errorExitCode"?: number;
+        readonly "~effect/Runtime/errorReported"?: boolean;
+        readonly "~effect/ErrorReporter/ignore"?: boolean;
+        readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+        readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+    };
+    readonly Schema: Schema.Struct<{
+        readonly name: Schema.Literal<"ConfigDirectoryTypoError">;
+        readonly data: Schema.Struct<{
+            path: Schema.String;
+            dir: Schema.String;
+            suggestion: Schema.String;
+        }>;
+    }>;
+    readonly EffectSchema: Schema.Struct<{
+        readonly name: Schema.Literal<"ConfigDirectoryTypoError">;
+        readonly data: Schema.Struct<{
+            path: Schema.String;
+            dir: Schema.String;
+            suggestion: Schema.String;
+        }>;
+    }>;
+    readonly tag: "ConfigDirectoryTypoError";
+    isInstance(input: unknown): input is {
+        readonly name: "ConfigDirectoryTypoError";
+        readonly data: {
+            readonly path: string;
+            readonly dir: string;
+            readonly suggestion: string;
+        };
+        schema(): Schema.Struct<{
+            readonly name: Schema.Literal<"ConfigDirectoryTypoError">;
+            readonly data: Schema.Struct<{
+                path: Schema.String;
+                dir: Schema.String;
+                suggestion: Schema.String;
+            }>;
+        }>;
+        toObject(): {
+            name: "ConfigDirectoryTypoError";
+            data: {
+                readonly path: string;
+                readonly dir: string;
+                readonly suggestion: string;
+            };
+        };
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly "~effect/Runtime/errorExitCode"?: number;
+        readonly "~effect/Runtime/errorReported"?: boolean;
+        readonly "~effect/ErrorReporter/ignore"?: boolean;
+        readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+        readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+    };
+    hasName(error: unknown, name: string): boolean;
+    create<Name extends string, Fields extends Schema.Struct.Fields>(name: Name, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name, Schema.Struct<Fields>>>;
+    create<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): ReturnType<typeof NamedError.createSchemaClass<Name, DataSchema>>;
+    createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): {
+        new (data: Schema.Schema.Type<DataSchema>, options?: ErrorOptions): {
+            readonly name: Name;
+            readonly data: Schema.Schema.Type<DataSchema>;
+            schema(): Schema.Struct<{
+                readonly name: Schema.Literal<Name>;
+                readonly data: DataSchema;
+            }>;
+            toObject(): {
+                name: Name;
+                data: Schema.Schema.Type<DataSchema>;
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            readonly "~effect/Runtime/errorExitCode"?: number;
+            readonly "~effect/Runtime/errorReported"?: boolean;
+            readonly "~effect/ErrorReporter/ignore"?: boolean;
+            readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+            readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        };
+        readonly Schema: Schema.Struct<{
+            readonly name: Schema.Literal<Name>;
+            readonly data: DataSchema;
+        }>;
+        readonly EffectSchema: Schema.Struct<{
+            readonly name: Schema.Literal<Name>;
+            readonly data: DataSchema;
+        }>;
+        readonly tag: Name;
+        isInstance(input: unknown): input is InstanceType</*elided*/ any>;
+        hasName(error: unknown, name: string): boolean;
+        create<Name_1 extends string, Fields extends Schema.Struct.Fields>(name: Name_1, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name_1, Schema.Struct<Fields>>>;
+        create<Name_1 extends string, DataSchema_1 extends Schema.Top>(name: Name_1, data: DataSchema_1): ReturnType<typeof NamedError.createSchemaClass<Name_1, DataSchema_1>>;
+        createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): /*elided*/ any;
+        readonly Unknown: {
+            new (data: {
+                readonly message: string;
+                readonly ref?: string | undefined;
+            }, options?: ErrorOptions): {
+                readonly name: "UnknownError";
+                readonly data: {
+                    readonly message: string;
+                    readonly ref?: string | undefined;
+                };
+                schema(): Schema.Struct<{
+                    readonly name: Schema.Literal<"UnknownError">;
+                    readonly data: Schema.Struct<{
+                        message: Schema.String;
+                        ref: Schema.optional<Schema.String>;
+                    }>;
+                }>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        readonly message: string;
+                        readonly ref?: string | undefined;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+                readonly "~effect/Runtime/errorExitCode"?: number;
+                readonly "~effect/Runtime/errorReported"?: boolean;
+                readonly "~effect/ErrorReporter/ignore"?: boolean;
+                readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+                readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+            };
+            readonly Schema: Schema.Struct<{
+                readonly name: Schema.Literal<"UnknownError">;
+                readonly data: Schema.Struct<{
+                    message: Schema.String;
+                    ref: Schema.optional<Schema.String>;
+                }>;
+            }>;
+            readonly EffectSchema: Schema.Struct<{
+                readonly name: Schema.Literal<"UnknownError">;
+                readonly data: Schema.Struct<{
+                    message: Schema.String;
+                    ref: Schema.optional<Schema.String>;
+                }>;
+            }>;
+            readonly tag: "UnknownError";
+            isInstance(input: unknown): input is {
+                readonly name: "UnknownError";
+                readonly data: {
+                    readonly message: string;
+                    readonly ref?: string | undefined;
+                };
+                schema(): Schema.Struct<{
+                    readonly name: Schema.Literal<"UnknownError">;
+                    readonly data: Schema.Struct<{
+                        message: Schema.String;
+                        ref: Schema.optional<Schema.String>;
+                    }>;
+                }>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        readonly message: string;
+                        readonly ref?: string | undefined;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+                readonly "~effect/Runtime/errorExitCode"?: number;
+                readonly "~effect/Runtime/errorReported"?: boolean;
+                readonly "~effect/ErrorReporter/ignore"?: boolean;
+                readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+                readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+            };
+            hasName(error: unknown, name: string): boolean;
+            create<Name_1 extends string, Fields extends Schema.Struct.Fields>(name: Name_1, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name_1, Schema.Struct<Fields>>>;
+            create<Name_1 extends string, DataSchema_1 extends Schema.Top>(name: Name_1, data: DataSchema_1): ReturnType<typeof NamedError.createSchemaClass<Name_1, DataSchema_1>>;
+            createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): /*elided*/ any;
+            readonly Unknown: /*elided*/ any;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+            isError(value: unknown): value is Error;
+        };
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+        isError(value: unknown): value is Error;
+    };
+    readonly Unknown: {
+        new (data: {
+            readonly message: string;
+            readonly ref?: string | undefined;
+        }, options?: ErrorOptions): {
+            readonly name: "UnknownError";
+            readonly data: {
+                readonly message: string;
+                readonly ref?: string | undefined;
+            };
+            schema(): Schema.Struct<{
+                readonly name: Schema.Literal<"UnknownError">;
+                readonly data: Schema.Struct<{
+                    message: Schema.String;
+                    ref: Schema.optional<Schema.String>;
+                }>;
+            }>;
+            toObject(): {
+                name: "UnknownError";
+                data: {
+                    readonly message: string;
+                    readonly ref?: string | undefined;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            readonly "~effect/Runtime/errorExitCode"?: number;
+            readonly "~effect/Runtime/errorReported"?: boolean;
+            readonly "~effect/ErrorReporter/ignore"?: boolean;
+            readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+            readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        };
+        readonly Schema: Schema.Struct<{
+            readonly name: Schema.Literal<"UnknownError">;
+            readonly data: Schema.Struct<{
+                message: Schema.String;
+                ref: Schema.optional<Schema.String>;
+            }>;
+        }>;
+        readonly EffectSchema: Schema.Struct<{
+            readonly name: Schema.Literal<"UnknownError">;
+            readonly data: Schema.Struct<{
+                message: Schema.String;
+                ref: Schema.optional<Schema.String>;
+            }>;
+        }>;
+        readonly tag: "UnknownError";
+        isInstance(input: unknown): input is {
+            readonly name: "UnknownError";
+            readonly data: {
+                readonly message: string;
+                readonly ref?: string | undefined;
+            };
+            schema(): Schema.Struct<{
+                readonly name: Schema.Literal<"UnknownError">;
+                readonly data: Schema.Struct<{
+                    message: Schema.String;
+                    ref: Schema.optional<Schema.String>;
+                }>;
+            }>;
+            toObject(): {
+                name: "UnknownError";
+                data: {
+                    readonly message: string;
+                    readonly ref?: string | undefined;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            readonly "~effect/Runtime/errorExitCode"?: number;
+            readonly "~effect/Runtime/errorReported"?: boolean;
+            readonly "~effect/ErrorReporter/ignore"?: boolean;
+            readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+            readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        };
+        hasName(error: unknown, name: string): boolean;
+        create<Name extends string, Fields extends Schema.Struct.Fields>(name: Name, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name, Schema.Struct<Fields>>>;
+        create<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): ReturnType<typeof NamedError.createSchemaClass<Name, DataSchema>>;
+        createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): {
+            new (data: Schema.Schema.Type<DataSchema>, options?: ErrorOptions): {
+                readonly name: Name;
+                readonly data: Schema.Schema.Type<DataSchema>;
+                schema(): Schema.Struct<{
+                    readonly name: Schema.Literal<Name>;
+                    readonly data: DataSchema;
+                }>;
+                toObject(): {
+                    name: Name;
+                    data: Schema.Schema.Type<DataSchema>;
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+                readonly "~effect/Runtime/errorExitCode"?: number;
+                readonly "~effect/Runtime/errorReported"?: boolean;
+                readonly "~effect/ErrorReporter/ignore"?: boolean;
+                readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+                readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+            };
+            readonly Schema: Schema.Struct<{
+                readonly name: Schema.Literal<Name>;
+                readonly data: DataSchema;
+            }>;
+            readonly EffectSchema: Schema.Struct<{
+                readonly name: Schema.Literal<Name>;
+                readonly data: DataSchema;
+            }>;
+            readonly tag: Name;
+            isInstance(input: unknown): input is InstanceType</*elided*/ any>;
+            hasName(error: unknown, name: string): boolean;
+            create<Name_1 extends string, Fields extends Schema.Struct.Fields>(name: Name_1, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name_1, Schema.Struct<Fields>>>;
+            create<Name_1 extends string, DataSchema_1 extends Schema.Top>(name: Name_1, data: DataSchema_1): ReturnType<typeof NamedError.createSchemaClass<Name_1, DataSchema_1>>;
+            createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): /*elided*/ any;
+            readonly Unknown: /*elided*/ any;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+            isError(value: unknown): value is Error;
+        };
+        readonly Unknown: /*elided*/ any;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+        isError(value: unknown): value is Error;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+    isError(value: unknown): value is Error;
+};
+export declare const RemoteAuthError: {
+    new (data: {
+        readonly url: string;
+        readonly remote: string;
+    }, options?: ErrorOptions): {
+        readonly name: "ConfigRemoteAuthError";
+        readonly data: {
+            readonly url: string;
+            readonly remote: string;
+        };
+        schema(): Schema.Struct<{
+            readonly name: Schema.Literal<"ConfigRemoteAuthError">;
+            readonly data: Schema.Struct<{
+                url: Schema.String;
+                remote: Schema.String;
+            }>;
+        }>;
+        toObject(): {
+            name: "ConfigRemoteAuthError";
+            data: {
+                readonly url: string;
+                readonly remote: string;
+            };
+        };
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly "~effect/Runtime/errorExitCode"?: number;
+        readonly "~effect/Runtime/errorReported"?: boolean;
+        readonly "~effect/ErrorReporter/ignore"?: boolean;
+        readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+        readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+    };
+    readonly Schema: Schema.Struct<{
+        readonly name: Schema.Literal<"ConfigRemoteAuthError">;
+        readonly data: Schema.Struct<{
+            url: Schema.String;
+            remote: Schema.String;
+        }>;
+    }>;
+    readonly EffectSchema: Schema.Struct<{
+        readonly name: Schema.Literal<"ConfigRemoteAuthError">;
+        readonly data: Schema.Struct<{
+            url: Schema.String;
+            remote: Schema.String;
+        }>;
+    }>;
+    readonly tag: "ConfigRemoteAuthError";
+    isInstance(input: unknown): input is {
+        readonly name: "ConfigRemoteAuthError";
+        readonly data: {
+            readonly url: string;
+            readonly remote: string;
+        };
+        schema(): Schema.Struct<{
+            readonly name: Schema.Literal<"ConfigRemoteAuthError">;
+            readonly data: Schema.Struct<{
+                url: Schema.String;
+                remote: Schema.String;
+            }>;
+        }>;
+        toObject(): {
+            name: "ConfigRemoteAuthError";
+            data: {
+                readonly url: string;
+                readonly remote: string;
+            };
+        };
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        readonly "~effect/Runtime/errorExitCode"?: number;
+        readonly "~effect/Runtime/errorReported"?: boolean;
+        readonly "~effect/ErrorReporter/ignore"?: boolean;
+        readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+        readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+    };
+    hasName(error: unknown, name: string): boolean;
+    create<Name extends string, Fields extends Schema.Struct.Fields>(name: Name, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name, Schema.Struct<Fields>>>;
+    create<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): ReturnType<typeof NamedError.createSchemaClass<Name, DataSchema>>;
+    createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): {
+        new (data: Schema.Schema.Type<DataSchema>, options?: ErrorOptions): {
+            readonly name: Name;
+            readonly data: Schema.Schema.Type<DataSchema>;
+            schema(): Schema.Struct<{
+                readonly name: Schema.Literal<Name>;
+                readonly data: DataSchema;
+            }>;
+            toObject(): {
+                name: Name;
+                data: Schema.Schema.Type<DataSchema>;
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            readonly "~effect/Runtime/errorExitCode"?: number;
+            readonly "~effect/Runtime/errorReported"?: boolean;
+            readonly "~effect/ErrorReporter/ignore"?: boolean;
+            readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+            readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        };
+        readonly Schema: Schema.Struct<{
+            readonly name: Schema.Literal<Name>;
+            readonly data: DataSchema;
+        }>;
+        readonly EffectSchema: Schema.Struct<{
+            readonly name: Schema.Literal<Name>;
+            readonly data: DataSchema;
+        }>;
+        readonly tag: Name;
+        isInstance(input: unknown): input is InstanceType</*elided*/ any>;
+        hasName(error: unknown, name: string): boolean;
+        create<Name_1 extends string, Fields extends Schema.Struct.Fields>(name: Name_1, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name_1, Schema.Struct<Fields>>>;
+        create<Name_1 extends string, DataSchema_1 extends Schema.Top>(name: Name_1, data: DataSchema_1): ReturnType<typeof NamedError.createSchemaClass<Name_1, DataSchema_1>>;
+        createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): /*elided*/ any;
+        readonly Unknown: {
+            new (data: {
+                readonly message: string;
+                readonly ref?: string | undefined;
+            }, options?: ErrorOptions): {
+                readonly name: "UnknownError";
+                readonly data: {
+                    readonly message: string;
+                    readonly ref?: string | undefined;
+                };
+                schema(): Schema.Struct<{
+                    readonly name: Schema.Literal<"UnknownError">;
+                    readonly data: Schema.Struct<{
+                        message: Schema.String;
+                        ref: Schema.optional<Schema.String>;
+                    }>;
+                }>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        readonly message: string;
+                        readonly ref?: string | undefined;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+                readonly "~effect/Runtime/errorExitCode"?: number;
+                readonly "~effect/Runtime/errorReported"?: boolean;
+                readonly "~effect/ErrorReporter/ignore"?: boolean;
+                readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+                readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+            };
+            readonly Schema: Schema.Struct<{
+                readonly name: Schema.Literal<"UnknownError">;
+                readonly data: Schema.Struct<{
+                    message: Schema.String;
+                    ref: Schema.optional<Schema.String>;
+                }>;
+            }>;
+            readonly EffectSchema: Schema.Struct<{
+                readonly name: Schema.Literal<"UnknownError">;
+                readonly data: Schema.Struct<{
+                    message: Schema.String;
+                    ref: Schema.optional<Schema.String>;
+                }>;
+            }>;
+            readonly tag: "UnknownError";
+            isInstance(input: unknown): input is {
+                readonly name: "UnknownError";
+                readonly data: {
+                    readonly message: string;
+                    readonly ref?: string | undefined;
+                };
+                schema(): Schema.Struct<{
+                    readonly name: Schema.Literal<"UnknownError">;
+                    readonly data: Schema.Struct<{
+                        message: Schema.String;
+                        ref: Schema.optional<Schema.String>;
+                    }>;
+                }>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        readonly message: string;
+                        readonly ref?: string | undefined;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+                readonly "~effect/Runtime/errorExitCode"?: number;
+                readonly "~effect/Runtime/errorReported"?: boolean;
+                readonly "~effect/ErrorReporter/ignore"?: boolean;
+                readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+                readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+            };
+            hasName(error: unknown, name: string): boolean;
+            create<Name_1 extends string, Fields extends Schema.Struct.Fields>(name: Name_1, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name_1, Schema.Struct<Fields>>>;
+            create<Name_1 extends string, DataSchema_1 extends Schema.Top>(name: Name_1, data: DataSchema_1): ReturnType<typeof NamedError.createSchemaClass<Name_1, DataSchema_1>>;
+            createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): /*elided*/ any;
+            readonly Unknown: /*elided*/ any;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+            isError(value: unknown): value is Error;
+        };
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+        isError(value: unknown): value is Error;
+    };
+    readonly Unknown: {
+        new (data: {
+            readonly message: string;
+            readonly ref?: string | undefined;
+        }, options?: ErrorOptions): {
+            readonly name: "UnknownError";
+            readonly data: {
+                readonly message: string;
+                readonly ref?: string | undefined;
+            };
+            schema(): Schema.Struct<{
+                readonly name: Schema.Literal<"UnknownError">;
+                readonly data: Schema.Struct<{
+                    message: Schema.String;
+                    ref: Schema.optional<Schema.String>;
+                }>;
+            }>;
+            toObject(): {
+                name: "UnknownError";
+                data: {
+                    readonly message: string;
+                    readonly ref?: string | undefined;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            readonly "~effect/Runtime/errorExitCode"?: number;
+            readonly "~effect/Runtime/errorReported"?: boolean;
+            readonly "~effect/ErrorReporter/ignore"?: boolean;
+            readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+            readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        };
+        readonly Schema: Schema.Struct<{
+            readonly name: Schema.Literal<"UnknownError">;
+            readonly data: Schema.Struct<{
+                message: Schema.String;
+                ref: Schema.optional<Schema.String>;
+            }>;
+        }>;
+        readonly EffectSchema: Schema.Struct<{
+            readonly name: Schema.Literal<"UnknownError">;
+            readonly data: Schema.Struct<{
+                message: Schema.String;
+                ref: Schema.optional<Schema.String>;
+            }>;
+        }>;
+        readonly tag: "UnknownError";
+        isInstance(input: unknown): input is {
+            readonly name: "UnknownError";
+            readonly data: {
+                readonly message: string;
+                readonly ref?: string | undefined;
+            };
+            schema(): Schema.Struct<{
+                readonly name: Schema.Literal<"UnknownError">;
+                readonly data: Schema.Struct<{
+                    message: Schema.String;
+                    ref: Schema.optional<Schema.String>;
+                }>;
+            }>;
+            toObject(): {
+                name: "UnknownError";
+                data: {
+                    readonly message: string;
+                    readonly ref?: string | undefined;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+            readonly "~effect/Runtime/errorExitCode"?: number;
+            readonly "~effect/Runtime/errorReported"?: boolean;
+            readonly "~effect/ErrorReporter/ignore"?: boolean;
+            readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+            readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+        };
+        hasName(error: unknown, name: string): boolean;
+        create<Name extends string, Fields extends Schema.Struct.Fields>(name: Name, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name, Schema.Struct<Fields>>>;
+        create<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): ReturnType<typeof NamedError.createSchemaClass<Name, DataSchema>>;
+        createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): {
+            new (data: Schema.Schema.Type<DataSchema>, options?: ErrorOptions): {
+                readonly name: Name;
+                readonly data: Schema.Schema.Type<DataSchema>;
+                schema(): Schema.Struct<{
+                    readonly name: Schema.Literal<Name>;
+                    readonly data: DataSchema;
+                }>;
+                toObject(): {
+                    name: Name;
+                    data: Schema.Schema.Type<DataSchema>;
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+                readonly "~effect/Runtime/errorExitCode"?: number;
+                readonly "~effect/Runtime/errorReported"?: boolean;
+                readonly "~effect/ErrorReporter/ignore"?: boolean;
+                readonly "~effect/ErrorReporter/severity"?: import("effect/LogLevel").Severity;
+                readonly "~effect/ErrorReporter/attributes"?: import("effect/Record").ReadonlyRecord<string, unknown>;
+            };
+            readonly Schema: Schema.Struct<{
+                readonly name: Schema.Literal<Name>;
+                readonly data: DataSchema;
+            }>;
+            readonly EffectSchema: Schema.Struct<{
+                readonly name: Schema.Literal<Name>;
+                readonly data: DataSchema;
+            }>;
+            readonly tag: Name;
+            isInstance(input: unknown): input is InstanceType</*elided*/ any>;
+            hasName(error: unknown, name: string): boolean;
+            create<Name_1 extends string, Fields extends Schema.Struct.Fields>(name: Name_1, fields: Fields): ReturnType<typeof NamedError.createSchemaClass<Name_1, Schema.Struct<Fields>>>;
+            create<Name_1 extends string, DataSchema_1 extends Schema.Top>(name: Name_1, data: DataSchema_1): ReturnType<typeof NamedError.createSchemaClass<Name_1, DataSchema_1>>;
+            createSchemaClass<Name extends string, DataSchema extends Schema.Top>(name: Name, data: DataSchema): /*elided*/ any;
+            readonly Unknown: /*elided*/ any;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+            isError(value: unknown): value is Error;
+        };
+        readonly Unknown: /*elided*/ any;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+        isError(value: unknown): value is Error;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+    isError(value: unknown): value is Error;
+};