/**
 * Tagged errors for effect-claudecode.
 *
 * All cross-module errors are declared here and re-exported from
 * `src/index.ts` at the top level so consumers can import them directly
 * (e.g. `import { HookInputDecodeError } from 'effect-claudecode'`) and
 * use them in `Effect.catchTag`.
 *
 * @since 0.1.0
 */
import * as Schema from 'effect/Schema';
declare const HookStdinReadError_base: Schema.Class<HookStdinReadError, Schema.TaggedStruct<"HookStdinReadError", {
    readonly cause: Schema.Defect;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when reading from stdin fails.
 *
 * Exit-code mapping: 1 (non-blocking).
 *
 * @category Hook errors
 * @since 0.1.0
 */
export declare class HookStdinReadError extends HookStdinReadError_base {
}
declare const HookInputDecodeError_base: Schema.Class<HookInputDecodeError, Schema.TaggedStruct<"HookInputDecodeError", {
    readonly cause: Schema.Defect;
    readonly phase: Schema.Literals<readonly ["json", "schema"]>;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when decoding hook input fails. The `phase` field distinguishes
 * JSON parse failure (`'json'`) from schema validation failure (`'schema'`).
 *
 * Exit-code mapping: 2. Claude Code interprets exit 2 per event: it
 * blocks/denies some gate events and is feedback-only or ignored for
 * several observability events.
 *
 * @category Hook errors
 * @since 0.1.0
 */
export declare class HookInputDecodeError extends HookInputDecodeError_base {
}
declare const HookHandlerError_base: Schema.Class<HookHandlerError, Schema.TaggedStruct<"HookHandlerError", {
    readonly cause: Schema.Defect;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when the user-supplied hook handler fails.
 *
 * Exit-code mapping: 1 (non-blocking).
 *
 * @category Hook errors
 * @since 0.1.0
 */
export declare class HookHandlerError extends HookHandlerError_base {
}
declare const HookOutputEncodeError_base: Schema.Class<HookOutputEncodeError, Schema.TaggedStruct<"HookOutputEncodeError", {
    readonly cause: Schema.Defect;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when encoding the handler output to JSON fails.
 *
 * Exit-code mapping: 1 (non-blocking).
 *
 * @category Hook errors
 * @since 0.1.0
 */
export declare class HookOutputEncodeError extends HookOutputEncodeError_base {
}
declare const HookStdoutWriteError_base: Schema.Class<HookStdoutWriteError, Schema.TaggedStruct<"HookStdoutWriteError", {
    readonly cause: Schema.Defect;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when writing to stdout fails.
 *
 * Exit-code mapping: 1 (non-blocking).
 *
 * @category Hook errors
 * @since 0.1.0
 */
export declare class HookStdoutWriteError extends HookStdoutWriteError_base {
}
declare const HookControlledExit_base: Schema.Class<HookControlledExit, Schema.TaggedStruct<"HookControlledExit", {
    readonly code: Schema.Number;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised internally when a handler intentionally controls the command
 * process exit status (for example, an exit-2 hook response).
 *
 * @category Hook errors
 * @since 0.1.0
 */
export declare class HookControlledExit extends HookControlledExit_base {
}
declare const HookToolDecodeError_base: Schema.Class<HookToolDecodeError, Schema.TaggedStruct<"HookToolDecodeError", {
    readonly event: Schema.Literals<readonly ["PreToolUse", "PostToolUse"]>;
    readonly toolName: Schema.String;
    readonly payload: Schema.Literals<readonly ["tool_name", "tool_input", "tool_response"]>;
    readonly cause: Schema.Defect;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when decoding a known tool payload from `tool_input` or
 * `tool_response` fails.
 *
 * @category Hook errors
 * @since 0.1.0
 */
export declare class HookToolDecodeError extends HookToolDecodeError_base {
}
declare const TranscriptReadError_base: Schema.Class<TranscriptReadError, Schema.TaggedStruct<"TranscriptReadError", {
    readonly path: Schema.String;
    readonly cause: Schema.Defect;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when reading or parsing a transcript file fails.
 *
 * @category Transcript errors
 * @since 0.1.0
 */
export declare class TranscriptReadError extends TranscriptReadError_base {
}
declare const SettingsReadError_base: Schema.Class<SettingsReadError, Schema.TaggedStruct<"SettingsReadError", {
    readonly path: Schema.String;
    readonly cause: Schema.Defect;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when reading a settings.json file fails (I/O error, etc.).
 *
 * @category Settings errors
 * @since 0.1.0
 */
export declare class SettingsReadError extends SettingsReadError_base {
}
declare const SettingsParseError_base: Schema.Class<SettingsParseError, Schema.TaggedStruct<"SettingsParseError", {
    readonly path: Schema.String;
    readonly cause: Schema.Defect;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when a settings.json file contains invalid JSON.
 *
 * @category Settings errors
 * @since 0.1.0
 */
export declare class SettingsParseError extends SettingsParseError_base {
}
declare const SettingsDecodeError_base: Schema.Class<SettingsDecodeError, Schema.TaggedStruct<"SettingsDecodeError", {
    readonly path: Schema.String;
    readonly cause: Schema.Defect;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when a settings.json file parses as JSON but fails schema
 * validation.
 *
 * @category Settings errors
 * @since 0.1.0
 */
export declare class SettingsDecodeError extends SettingsDecodeError_base {
}
declare const PluginWriteError_base: Schema.Class<PluginWriteError, Schema.TaggedStruct<"PluginWriteError", {
    readonly path: Schema.String;
    readonly cause: Schema.Defect;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when materializing a plugin directory fails (I/O error during
 * `mkdir`, `writeFile`, or JSON encoding of the manifest).
 *
 * @category Plugin errors
 * @since 0.1.0
 */
export declare class PluginWriteError extends PluginWriteError_base {
}
declare const PluginDefinitionError_base: Schema.Class<PluginDefinitionError, Schema.TaggedStruct<"PluginDefinitionError", {
    readonly kind: Schema.String;
    readonly entryName: Schema.String;
    readonly frontmatterName: Schema.String;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when a plugin definition is internally inconsistent.
 *
 * @category Plugin errors
 * @since 0.1.0
 */
export declare class PluginDefinitionError extends PluginDefinitionError_base {
}
declare const PluginLoadError_base: Schema.Class<PluginLoadError, Schema.TaggedStruct<"PluginLoadError", {
    readonly path: Schema.String;
    readonly cause: Schema.Defect;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when reading, parsing, or decoding an existing plugin directory
 * fails.
 *
 * @category Plugin errors
 * @since 0.1.0
 */
export declare class PluginLoadError extends PluginLoadError_base {
}
declare const FrontmatterReadError_base: Schema.Class<FrontmatterReadError, Schema.TaggedStruct<"FrontmatterReadError", {
    readonly path: Schema.String;
    readonly cause: Schema.Defect;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when reading a markdown file with YAML frontmatter fails
 * (I/O error, etc.).
 *
 * @category Frontmatter errors
 * @since 0.1.0
 */
export declare class FrontmatterReadError extends FrontmatterReadError_base {
}
declare const FrontmatterParseError_base: Schema.Class<FrontmatterParseError, Schema.TaggedStruct<"FrontmatterParseError", {
    readonly path: Schema.String;
    readonly cause: Schema.Defect;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when a markdown file's YAML frontmatter fails to parse as
 * valid YAML, or when the frontmatter delimiters (`---`) are
 * malformed.
 *
 * @category Frontmatter errors
 * @since 0.1.0
 */
export declare class FrontmatterParseError extends FrontmatterParseError_base {
}
declare const FrontmatterDecodeError_base: Schema.Class<FrontmatterDecodeError, Schema.TaggedStruct<"FrontmatterDecodeError", {
    readonly path: Schema.String;
    readonly cause: Schema.Defect;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when a markdown file's frontmatter parses as YAML but fails
 * schema validation against the expected shape (Skill, Subagent,
 * Command, or OutputStyle).
 *
 * @category Frontmatter errors
 * @since 0.1.0
 */
export declare class FrontmatterDecodeError extends FrontmatterDecodeError_base {
}
declare const McpConfigError_base: Schema.Class<McpConfigError, Schema.TaggedStruct<"McpConfigError", {
    readonly path: Schema.String;
    readonly cause: Schema.Defect;
}>, import("effect/Cause").YieldableError>;
/**
 * Raised when a `.mcp.json` file fails to read, parse, or decode.
 *
 * @category MCP errors
 * @since 0.1.0
 */
export declare class McpConfigError extends McpConfigError_base {
}
export {};
//# sourceMappingURL=Errors.d.ts.map