import { Schema } from 'effect';

/**
 * Thrown by `WebhooksService.replay` when no delivery row exists for the
 * given `deliveryId` — the row can't be re-triggered because the
 * original payload + target are unknown.
 */
export declare class WebhookDeliveryNotFound extends WebhookDeliveryNotFound_base {
}

declare const WebhookDeliveryNotFound_base: Schema.TaggedErrorClass<WebhookDeliveryNotFound, "WebhookDeliveryNotFound", {
    readonly _tag: Schema.tag<"WebhookDeliveryNotFound">;
} & {
    /** The delivery id that did not resolve to a row. */
    deliveryId: typeof Schema.String;
}>;

/**
 * Thrown by `WebhooksService.emit` when the payload does not decode
 * against the outgoing event's declared `payload` schema (from its
 * declared event's `webhook:` block). The emit is rejected BEFORE any
 * delivery row is written or workflow triggered — a schema-violating
 * payload never reaches a subscriber.
 */
export declare class WebhookPayloadInvalid extends WebhookPayloadInvalid_base {
}

declare const WebhookPayloadInvalid_base: Schema.TaggedErrorClass<WebhookPayloadInvalid, "WebhookPayloadInvalid", {
    readonly _tag: Schema.tag<"WebhookPayloadInvalid">;
} & {
    /** The outgoing event id the payload was emitted for. */
    event: typeof Schema.String;
    /** Tree-formatted schema decode issues (one line per violation). */
    issues: typeof Schema.String;
}>;

/**
 * Raised by the delivery workflow's wire-encoder when the target's
 * `format` (`form` | `xml`) cannot honestly represent the payload
 * shape — e.g. a `form` target whose payload is a bare array/scalar
 * (form encoding is a flat key=value list with no top-level array
 * representation), or an `xml` target whose object key is not a valid
 * XML element name. Surfaced BEFORE any wire POST: the delivery row is
 * written `failed` with this reason, so a mis-formatted target never
 * silently ships JSON bytes under a wrong content-type.
 */
export declare class WebhookPayloadUnrepresentable extends WebhookPayloadUnrepresentable_base {
}

declare const WebhookPayloadUnrepresentable_base: Schema.TaggedErrorClass<WebhookPayloadUnrepresentable, "WebhookPayloadUnrepresentable", {
    readonly _tag: Schema.tag<"WebhookPayloadUnrepresentable">;
} & {
    /** The wire format that could not represent the payload. */
    format: Schema.Literal<["json", "form", "xml"]>;
    /** Human-readable detail — which shape/key defeated the encoder. */
    reason: typeof Schema.String;
}>;

/**
 * Thrown by `WebhooksService.updateTargetPayloadVersion` when the
 * requested version is not a positive integer.
 */
export declare class WebhookPayloadVersionInvalid extends WebhookPayloadVersionInvalid_base {
}

declare const WebhookPayloadVersionInvalid_base: Schema.TaggedErrorClass<WebhookPayloadVersionInvalid, "WebhookPayloadVersionInvalid", {
    readonly _tag: Schema.tag<"WebhookPayloadVersionInvalid">;
} & {
    /** The rejected version value (as supplied by the caller). */
    version: typeof Schema.Number;
}>;

/**
 * Thrown by `WebhooksService.subscribe` (via `validateSubscribe`) when
 * the subscribe input fails a policy check — a non-http(s) URL, a secret
 * shorter than the minimum, a degenerate retry policy, or an
 * out-of-range rate limit. `field` names the offending input field;
 * `reason` is the human-readable detail (carries the offending value).
 */
export declare class WebhookSubscribeInvalid extends WebhookSubscribeInvalid_base {
}

declare const WebhookSubscribeInvalid_base: Schema.TaggedErrorClass<WebhookSubscribeInvalid, "WebhookSubscribeInvalid", {
    readonly _tag: Schema.tag<"WebhookSubscribeInvalid">;
} & {
    /** The offending subscribe-input field: `'url'` | `'event'` |
     *  `'secret'` | `'retry'` | `'rateLimitPerMinute'`. */
    field: typeof Schema.String;
    /** Human-readable detail, including the offending value. */
    reason: typeof Schema.String;
}>;

/** A target selected for management no longer exists. */
export declare class WebhookTargetNotFound extends WebhookTargetNotFound_base {
}

declare const WebhookTargetNotFound_base: Schema.TaggedErrorClass<WebhookTargetNotFound, "WebhookTargetNotFound", {
    readonly _tag: Schema.tag<"WebhookTargetNotFound">;
} & {
    targetId: typeof Schema.String;
}>;

export { }