import { type ArrayElement } from '@augment-vir/common';
declare const ObservableValueUpdateEvent_base: (new (eventInitDict: {
    bubbles?: boolean;
    cancelable?: boolean;
    composed?: boolean;
    detail: [unknown, unknown];
}) => import("typed-event-target").TypedCustomEvent<[unknown, unknown], "observable-value-update">) & Pick<{
    new (type: string, eventInitDict?: EventInit): Event;
    prototype: Event;
    readonly NONE: 0;
    readonly CAPTURING_PHASE: 1;
    readonly AT_TARGET: 2;
    readonly BUBBLING_PHASE: 3;
}, "prototype" | "NONE" | "CAPTURING_PHASE" | "AT_TARGET" | "BUBBLING_PHASE"> & Pick<import("typed-event-target").TypedCustomEvent<[unknown, unknown], "observable-value-update">, "type">;
/**
 * This event is emitted from observables when their internal value is updated.
 *
 * Observables abstract this event away, you can simply call `.listen()` to listen to an
 * observable's value rather than listening to this specific event.
 *
 * @category Event
 */
export declare class ObservableValueUpdateEvent extends ObservableValueUpdateEvent_base {
}
declare const ObservableValueResolveEvent_base: (new (eventInitDict: {
    bubbles?: boolean;
    cancelable?: boolean;
    composed?: boolean;
    detail: unknown;
}) => import("typed-event-target").TypedCustomEvent<unknown, "observable-value-resolve">) & Pick<{
    new (type: string, eventInitDict?: EventInit): Event;
    prototype: Event;
    readonly NONE: 0;
    readonly CAPTURING_PHASE: 1;
    readonly AT_TARGET: 2;
    readonly BUBBLING_PHASE: 3;
}, "prototype" | "NONE" | "CAPTURING_PHASE" | "AT_TARGET" | "BUBBLING_PHASE"> & Pick<import("typed-event-target").TypedCustomEvent<unknown, "observable-value-resolve">, "type">;
/**
 * This event is emitted from async observables when their value is resolved.
 *
 * @category Event
 */
export declare class ObservableValueResolveEvent extends ObservableValueResolveEvent_base {
}
declare const ObservableValueErrorEvent_base: (new (eventInitDict: {
    bubbles?: boolean;
    cancelable?: boolean;
    composed?: boolean;
    detail: Error;
}) => import("typed-event-target").TypedCustomEvent<Error, "observable-value-error">) & Pick<{
    new (type: string, eventInitDict?: EventInit): Event;
    prototype: Event;
    readonly NONE: 0;
    readonly CAPTURING_PHASE: 1;
    readonly AT_TARGET: 2;
    readonly BUBBLING_PHASE: 3;
}, "prototype" | "NONE" | "CAPTURING_PHASE" | "AT_TARGET" | "BUBBLING_PHASE"> & Pick<import("typed-event-target").TypedCustomEvent<Error, "observable-value-error">, "type">;
/**
 * This event is emitted from async observables when awaiting their value throws an error.
 *
 * @category Event
 */
export declare class ObservableValueErrorEvent extends ObservableValueErrorEvent_base {
}
declare const ObservableDestroyEvent_base: (new (eventInitDict?: EventInit) => Event & import("typed-event-target").TypedEvent<"observable-destroy">) & Pick<{
    new (type: string, eventInitDict?: EventInit): Event;
    prototype: Event;
    readonly NONE: 0;
    readonly CAPTURING_PHASE: 1;
    readonly AT_TARGET: 2;
    readonly BUBBLING_PHASE: 3;
}, "prototype" | "NONE" | "CAPTURING_PHASE" | "AT_TARGET" | "BUBBLING_PHASE"> & Pick<import("typed-event-target").TypedEvent<"observable-destroy">, "type">;
/**
 * This event is emitted from observables when they are destroyed.
 *
 * @category Event
 */
export declare class ObservableDestroyEvent extends ObservableDestroyEvent_base {
}
declare const ObservableCallbackCallEvent_base: (new (eventInitDict?: EventInit) => Event & import("typed-event-target").TypedEvent<"observable-callback-call">) & Pick<{
    new (type: string, eventInitDict?: EventInit): Event;
    prototype: Event;
    readonly NONE: 0;
    readonly CAPTURING_PHASE: 1;
    readonly AT_TARGET: 2;
    readonly BUBBLING_PHASE: 3;
}, "prototype" | "NONE" | "CAPTURING_PHASE" | "AT_TARGET" | "BUBBLING_PHASE"> & Pick<import("typed-event-target").TypedEvent<"observable-callback-call">, "type">;
/**
 * This event is emitted from callback observables when their callback is called.
 *
 * @category Event
 */
export declare class ObservableCallbackCallEvent extends ObservableCallbackCallEvent_base {
}
declare const ObservableParamsUpdateEvent_base: (new (eventInitDict: {
    bubbles?: boolean;
    cancelable?: boolean;
    composed?: boolean;
    detail: unknown;
}) => import("typed-event-target").TypedCustomEvent<unknown, "observable-params-update">) & Pick<{
    new (type: string, eventInitDict?: EventInit): Event;
    prototype: Event;
    readonly NONE: 0;
    readonly CAPTURING_PHASE: 1;
    readonly AT_TARGET: 2;
    readonly BUBBLING_PHASE: 3;
}, "prototype" | "NONE" | "CAPTURING_PHASE" | "AT_TARGET" | "BUBBLING_PHASE"> & Pick<import("typed-event-target").TypedCustomEvent<unknown, "observable-params-update">, "type">;
/**
 * This event is emitted from callback observables when their params are updated.
 *
 * @category Event
 */
export declare class ObservableParamsUpdateEvent extends ObservableParamsUpdateEvent_base {
}
declare const ObservableIntervalRunEvent_base: (new (eventInitDict: {
    bubbles?: boolean;
    cancelable?: boolean;
    composed?: boolean;
    detail: unknown;
}) => import("typed-event-target").TypedCustomEvent<unknown, "observable-interval-run">) & Pick<{
    new (type: string, eventInitDict?: EventInit): Event;
    prototype: Event;
    readonly NONE: 0;
    readonly CAPTURING_PHASE: 1;
    readonly AT_TARGET: 2;
    readonly BUBBLING_PHASE: 3;
}, "prototype" | "NONE" | "CAPTURING_PHASE" | "AT_TARGET" | "BUBBLING_PHASE"> & Pick<import("typed-event-target").TypedCustomEvent<unknown, "observable-interval-run">, "type">;
/**
 * This event is emitted from interval observables when the interval is run.
 *
 * @category Event
 */
export declare class ObservableIntervalRunEvent extends ObservableIntervalRunEvent_base {
}
declare const ObservableIntervalSkipEvent_base: (new (eventInitDict: {
    bubbles?: boolean;
    cancelable?: boolean;
    composed?: boolean;
    detail: Record<string, boolean>;
}) => import("typed-event-target").TypedCustomEvent<Record<string, boolean>, "observable-interval-skip">) & Pick<{
    new (type: string, eventInitDict?: EventInit): Event;
    prototype: Event;
    readonly NONE: 0;
    readonly CAPTURING_PHASE: 1;
    readonly AT_TARGET: 2;
    readonly BUBBLING_PHASE: 3;
}, "prototype" | "NONE" | "CAPTURING_PHASE" | "AT_TARGET" | "BUBBLING_PHASE"> & Pick<import("typed-event-target").TypedCustomEvent<Record<string, boolean>, "observable-interval-skip">, "type">;
/**
 * This event is emitted from interval observables when the interval is skipped for whatever reason.
 * The event detail will contain information about why the interval was skipped.
 *
 * @category Event
 */
export declare class ObservableIntervalSkipEvent extends ObservableIntervalSkipEvent_base {
}
declare const ObservableIntervalRateLimitedEvent_base: (new (eventInitDict: {
    bubbles?: boolean;
    cancelable?: boolean;
    composed?: boolean;
    detail: {
        hour: import("date-vir").Hour;
        minute: import("date-vir").Minute;
        millisecond: number;
        year: number;
        month: import("date-vir").MonthNumber;
        day: import("date-vir").DayOfMonth;
        second: import("date-vir").Second;
        timezone: string;
    };
}) => import("typed-event-target").TypedCustomEvent<{
    hour: import("date-vir").Hour;
    minute: import("date-vir").Minute;
    millisecond: number;
    year: number;
    month: import("date-vir").MonthNumber;
    day: import("date-vir").DayOfMonth;
    second: import("date-vir").Second;
    timezone: string;
}, "observable-interval-rate-limited">) & Pick<{
    new (type: string, eventInitDict?: EventInit): Event;
    prototype: Event;
    readonly NONE: 0;
    readonly CAPTURING_PHASE: 1;
    readonly AT_TARGET: 2;
    readonly BUBBLING_PHASE: 3;
}, "prototype" | "NONE" | "CAPTURING_PHASE" | "AT_TARGET" | "BUBBLING_PHASE"> & Pick<import("typed-event-target").TypedCustomEvent<{
    hour: import("date-vir").Hour;
    minute: import("date-vir").Minute;
    millisecond: number;
    year: number;
    month: import("date-vir").MonthNumber;
    day: import("date-vir").DayOfMonth;
    second: import("date-vir").Second;
    timezone: string;
}, "observable-interval-rate-limited">, "type">;
/**
 * This event is emitted from interval observables when and update or value set is blocked due to
 * rate limiting.
 *
 * @category Event
 */
export declare class ObservableIntervalRateLimitedEvent extends ObservableIntervalRateLimitedEvent_base {
}
/**
 * All possible observable event constructors in a single array.
 *
 * @category Event
 */
export declare const allObservableEvents: readonly [typeof ObservableValueUpdateEvent, typeof ObservableValueResolveEvent, typeof ObservableValueErrorEvent, typeof ObservableDestroyEvent, typeof ObservableCallbackCallEvent, typeof ObservableParamsUpdateEvent, typeof ObservableIntervalRunEvent, typeof ObservableIntervalSkipEvent, typeof ObservableIntervalRateLimitedEvent];
/**
 * A union of all possible observable event class types.
 *
 * @category Event
 */
export type ObservableEvents = InstanceType<ArrayElement<typeof allObservableEvents>>;
/**
 * A union of all possible event type strings from each observable event class.
 *
 * @category Event
 */
export type ObservableEventTypes = ObservableEvents['type'];
export {};