import type * as Effect from "effect/Effect";
import type * as Stream from "effect/Stream";
import type { Input } from "../../Input.ts";
import { type EventRecord, type EventRouteProps } from "../EventBridge/EventSource.ts";
/**
 * The `detail` payload Amazon CloudWatch Internet Monitor delivers to
 * EventBridge when a monitor creates or resolves a health event. Fields not
 * shared by every event are optional (the schema grows over time).
 */
export interface HealthEventDetail {
    /** The ARN of the health event. */
    eventArn?: string;
    /** The id of the health event. */
    eventId?: string;
    /** Human-readable summary of the health event. */
    summary?: string;
    /** When the health event started (ISO 8601). */
    startedAt?: string;
    /** When the health event ended, for resolved events (ISO 8601). */
    endedAt?: string;
    /**
     * The impact type: `AVAILABILITY`, `PERFORMANCE`, `LOCAL_AVAILABILITY`,
     * or `LOCAL_PERFORMANCE`.
     */
    impactType?: string;
    /** The health event status: `ACTIVE` or `RESOLVED`. */
    status?: string;
    /** Percentage of the application's total traffic that is impacted. */
    percentOfTotalTrafficImpacted?: number;
    /** The client city-networks impacted by the health event. */
    impactedLocations?: unknown[];
    /** Additional event fields (the schema grows over time). */
    [key: string]: unknown;
}
/** An Internet Monitor health event delivered to the handler. */
export type HealthEventRecord = EventRecord<HealthEventDetail>;
export interface HealthEventSourceProps extends EventRouteProps {
    /**
     * Logical id for the backing EventBridge rule.
     * @default "InternetMonitorHealthEvents"
     */
    id?: string;
    /**
     * Restrict to health events emitted by the given monitors (matched
     * against the event's `resources` — the monitor ARNs). Pass
     * `monitor.monitorArn`.
     * @default all monitors in the account
     */
    monitorArns?: readonly Input<string>[];
    /**
     * Restrict to health events of the given impact types (matched against
     * the event detail's `impactType`: `AVAILABILITY`, `PERFORMANCE`,
     * `LOCAL_AVAILABILITY`, `LOCAL_PERFORMANCE`).
     */
    impactTypes?: readonly string[];
    /**
     * Restrict to health events with the given statuses (matched against the
     * event detail's `status`: `ACTIVE`, `RESOLVED`).
     */
    statuses?: readonly string[];
}
/**
 * Event source connecting Amazon CloudWatch Internet Monitor health events
 * to the hosting compute. When a monitor detects an availability or
 * performance issue between your application and your users' city-networks,
 * Internet Monitor publishes a health event to the account's default
 * EventBridge bus (source `aws.internetmonitor`); this subscribes the host
 * Function to those events so it can page, reroute traffic, or annotate
 * incidents.
 *
 * Internet Monitor publishes to EventBridge automatically — no additional
 * resource is created besides the EventBridge rule targeting the host.
 * Provide the host-specific implementation layer (e.g.
 * `AWS.Lambda.EventSource`) on the Function effect.
 *
 * ### Consuming Health Events
 * **Example:** Page on Availability Drops
 * ```typescript
 * import * as AWS from "alchemy/AWS";
 *
 * export default AlertFunction.make(
 *   { main: import.meta.url },
 *   Effect.gen(function* () {
 *     const monitor = yield* AWS.InternetMonitor.Monitor("AppMonitor", {
 *       resources: [vpcArn],
 *       maxCityNetworksToMonitor: 100,
 *     });
 *
 *     yield* AWS.InternetMonitor.consumeHealthEvents(
 *       { monitorArns: [monitor.monitorArn], impactTypes: ["AVAILABILITY"] },
 *       (events) =>
 *         Stream.runForEach(events, (event) =>
 *           Effect.logError(
 *             `Internet Monitor health event: ${event.detail.summary}`,
 *           ),
 *         ),
 *     );
 *     return {};
 *   }).pipe(Effect.provide(AWS.Lambda.EventSource)),
 * );
 * ```
 */
export declare const consumeHealthEvents: <StreamReq = never, Req = never>(props: HealthEventSourceProps, process: (events: Stream.Stream<HealthEventRecord, never, StreamReq>) => Effect.Effect<void, never, Req>) => Effect.Effect<void, never, import("../EventBridge/EventSource.ts").EventSource>;
//# sourceMappingURL=HealthEventSource.d.ts.map