import { Schema } from "effect";
import { ElicitationDeclinedError } from "./elicitation";
import type { StorageFailure } from "./fuma-runtime";
declare const ToolNotFoundError_base: Schema.Class<ToolNotFoundError, Schema.TaggedStruct<"ToolNotFoundError", {
    readonly address: Schema.brand<Schema.String, "ToolAddress">;
    readonly suggestions: Schema.optional<Schema.$Array<Schema.brand<Schema.String, "ToolAddress">>>;
}>, import("effect/Cause").YieldableError>;
export declare class ToolNotFoundError extends ToolNotFoundError_base {
    get message(): string;
}
declare const ToolInvocationError_base: Schema.Class<ToolInvocationError, Schema.TaggedStruct<"ToolInvocationError", {
    readonly address: Schema.brand<Schema.String, "ToolAddress">;
    readonly message: Schema.String;
    readonly cause: Schema.optional<Schema.Unknown>;
}>, import("effect/Cause").YieldableError>;
export declare class ToolInvocationError extends ToolInvocationError_base {
}
declare const ToolBlockedError_base: Schema.Class<ToolBlockedError, Schema.TaggedStruct<"ToolBlockedError", {
    readonly address: Schema.brand<Schema.String, "ToolAddress">;
    readonly pattern: Schema.String;
}>, import("effect/Cause").YieldableError>;
/** Tool invocation was rejected because a workspace `tool_policy` rule with
 *  `action: "block"` matched. `pattern` is the matched policy pattern. */
export declare class ToolBlockedError extends ToolBlockedError_base {
    get message(): string;
}
declare const PluginNotLoadedError_base: Schema.Class<PluginNotLoadedError, Schema.TaggedStruct<"PluginNotLoadedError", {
    readonly address: Schema.brand<Schema.String, "ToolAddress">;
    readonly pluginId: Schema.String;
}>, import("effect/Cause").YieldableError>;
/** Tool row exists but its owning plugin isn't loaded in this executor config. */
export declare class PluginNotLoadedError extends PluginNotLoadedError_base {
    get message(): string;
}
declare const NoHandlerError_base: Schema.Class<NoHandlerError, Schema.TaggedStruct<"NoHandlerError", {
    readonly address: Schema.brand<Schema.String, "ToolAddress">;
    readonly pluginId: Schema.String;
}>, import("effect/Cause").YieldableError>;
/** Tool was found but its owning plugin has no `invokeTool` handler. */
export declare class NoHandlerError extends NoHandlerError_base {
    get message(): string;
}
declare const IntegrationNotFoundError_base: Schema.Class<IntegrationNotFoundError, Schema.TaggedStruct<"IntegrationNotFoundError", {
    readonly slug: Schema.brand<Schema.String, "IntegrationSlug">;
}>, import("effect/Cause").YieldableError>;
export declare class IntegrationNotFoundError extends IntegrationNotFoundError_base {
    get message(): string;
}
declare const IntegrationAlreadyExistsError_base: Schema.Class<IntegrationAlreadyExistsError, Schema.TaggedStruct<"IntegrationAlreadyExistsError", {
    readonly slug: Schema.brand<Schema.String, "IntegrationSlug">;
}>, import("effect/Cause").YieldableError>;
/** An "add integration" operation targeted a slug (namespace) that is already
 *  registered. The core `integrations.register` primitive upserts by design
 *  (for idempotent boot re-registration); add-operation layers gate on this to
 *  prevent silently clobbering an existing integration's tools, connections,
 *  and policies. */
export declare class IntegrationAlreadyExistsError extends IntegrationAlreadyExistsError_base {
    get message(): string;
}
declare const IntegrationRemovalNotAllowedError_base: Schema.Class<IntegrationRemovalNotAllowedError, Schema.TaggedStruct<"IntegrationRemovalNotAllowedError", {
    readonly slug: Schema.brand<Schema.String, "IntegrationSlug">;
}>, import("effect/Cause").YieldableError>;
/** `integrations.remove` was called on an integration declared statically by a
 *  plugin at startup (`canRemove: false`). */
export declare class IntegrationRemovalNotAllowedError extends IntegrationRemovalNotAllowedError_base {
    get message(): string;
}
declare const ConnectionNotFoundError_base: Schema.Class<ConnectionNotFoundError, Schema.TaggedStruct<"ConnectionNotFoundError", {
    readonly owner: Schema.Literals<readonly ["org", "user"]>;
    readonly integration: Schema.brand<Schema.String, "IntegrationSlug">;
    readonly name: Schema.brand<Schema.String, "ConnectionName">;
}>, import("effect/Cause").YieldableError>;
export declare class ConnectionNotFoundError extends ConnectionNotFoundError_base {
    get message(): string;
}
declare const InvalidConnectionInputError_base: Schema.Class<InvalidConnectionInputError, Schema.TaggedStruct<"InvalidConnectionInputError", {
    readonly message: Schema.String;
}>, import("effect/Cause").YieldableError>;
/** A connection create request was rejected before anything was written: the
 *  input is structurally invalid (no credential inputs for a credentialed
 *  template, mixed pasted/external origins, …) or targets owner `user` in a
 *  context that has no user subject. The message says which — it is safe to
 *  show to the caller. */
export declare class InvalidConnectionInputError extends InvalidConnectionInputError_base {
}
declare const CredentialProviderNotRegisteredError_base: Schema.Class<CredentialProviderNotRegisteredError, Schema.TaggedStruct<"CredentialProviderNotRegisteredError", {
    readonly provider: Schema.brand<Schema.String, "ProviderKey">;
}>, import("effect/Cause").YieldableError>;
/** A connection references a credential provider key that isn't registered on
 *  the executor. */
export declare class CredentialProviderNotRegisteredError extends CredentialProviderNotRegisteredError_base {
    get message(): string;
}
declare const CredentialResolutionError_base: Schema.Class<CredentialResolutionError, Schema.TaggedStruct<"CredentialResolutionError", {
    readonly owner: Schema.Literals<readonly ["org", "user"]>;
    readonly integration: Schema.brand<Schema.String, "IntegrationSlug">;
    readonly name: Schema.brand<Schema.String, "ConnectionName">;
    readonly message: Schema.String;
    /** True when the stored grant is permanently invalid and the user must
     *  sign in again (RFC 6749 §5.2 invalid_grant and friends). */
    readonly reauthRequired: Schema.optional<Schema.Boolean>;
}>, import("effect/Cause").YieldableError>;
/** A connection's value could not be resolved — the provider returned nothing,
 *  or an OAuth token refresh failed and the user must re-auth. */
export declare class CredentialResolutionError extends CredentialResolutionError_base {
}
export type ExecuteError = ToolNotFoundError | ToolInvocationError | ToolBlockedError | PluginNotLoadedError | NoHandlerError | ConnectionNotFoundError | CredentialProviderNotRegisteredError | CredentialResolutionError | ElicitationDeclinedError | StorageFailure;
/** Convenience union spanning every typed error the SDK raises. */
export type ExecutorError = ExecuteError | IntegrationNotFoundError | IntegrationRemovalNotAllowedError;
export {};
//# sourceMappingURL=errors.d.ts.map