import { Observable } from 'rxjs';
import * as _angular_core from '@angular/core';
import { InjectionToken, Provider, provideAppInitializer, EnvironmentProviders } from '@angular/core';

/**
 * Construction data shared by {@link OmegaObject} derivatives.
 */
interface OmegaObjectInit {
    /** Correlation / tracing id (often uuid-prefixed by factories). */
    readonly id: string;
    /** Arbitrary metadata bag; shallow-frozen on the instance. */
    readonly meta?: Readonly<Record<string, unknown>>;
}
/**
 * Base type for {@link OmegaEvent}, {@link OmegaIntent}, and {@link OmegaFailure}.
 */
declare abstract class OmegaObject {
    readonly id: string;
    readonly meta: Readonly<Record<string, unknown>>;
    protected constructor(init: OmegaObjectInit);
}

/** Initialization shape for {@link OmegaFailure}. */
interface OmegaFailureInit extends OmegaObjectInit {
    readonly message: string;
    readonly details?: unknown;
}
/**
 * Structured failure value (distinct from thrown `Error`) for domain-level error reporting.
 *
 * @remarks
 * Carries {@link OmegaObject.id} / {@link OmegaObject.meta} for correlation with intents or events.
 */
declare class OmegaFailure extends OmegaObject {
    readonly message: string;
    readonly details?: unknown;
    constructor(init: OmegaFailureInit);
    /** Human-readable single-line summary for logs. */
    toString(): string;
}

/** Typed event name contract (enums / const objects implement this). */
interface OmegaEventName {
    readonly name: string;
}

/** Typed intent name contract (enums / const objects implement this). */
interface OmegaIntentName {
    readonly name: string;
}

/** Typed flow id contract (same string as [OmegaFlow.id]). */
interface OmegaFlowId {
    readonly id: string;
}

/** Typed agent id contract. */
interface OmegaAgentId {
    readonly id: string;
}

/**
 * camelCase enum member → dotted lower wire (`ordersCreate` → `orders.create`).
 * Omega dotted wire names from camelCase enum members (e.g. ordersCreate → orders.create).
 */
declare function omegaWireNameFromCamelCaseEnumMember(enumMemberName: string): string;

/** Payload object that is also its own event name (emit via [OmegaEventBus.emitTyped]). */
type OmegaTypedEvent = OmegaEventName;

type OmegaIntentWireName = OmegaIntentName | string;
/**
 * Options for {@link OmegaIntent.fromName}.
 *
 * @typeParam P — Shape of {@link OmegaIntent.payload} when supplied.
 */
interface OmegaIntentCreateOptions<P = unknown> {
    readonly payload?: P;
    /** Caller-supplied id; otherwise a time/uuid-based id is generated. */
    readonly id?: string;
    readonly namespace?: string | null;
    readonly meta?: Readonly<Record<string, unknown>>;
}
/**
 * Imperative request (UI action, command, navigation) routed by {@link OmegaFlowManager}
 * to every **active** {@link OmegaFlow}.
 *
 * @typeParam P — Payload type. The `out` variance keeps concrete intents assignable where an
 *   untyped {@link OmegaIntent} (`unknown`) is accepted, matching typical handler patterns.
 *
 * @remarks
 * Prefer {@link OmegaIntent.fromName} over `new OmegaIntent` so wire names and ids stay
 * consistent with ESLint rules in consumer apps.
 */
declare class OmegaIntent<out P = unknown> extends OmegaObject {
    readonly name: string;
    readonly payload?: P;
    readonly namespace?: string | null;
    constructor(init: {
        readonly id: string;
        readonly name: string;
        readonly payload?: P;
        readonly namespace?: string | null;
        readonly meta?: Readonly<Record<string, unknown>>;
    });
    /**
     * Factory for intents resolved from an enum-like wire name or string literal.
     *
     * @param name — Semantic intent name (dotted wire convention when using enums).
     * @param options — Optional `payload`, `id`, `namespace`, `meta`.
     */
    static fromName<P = unknown>(name: OmegaIntentWireName, options?: OmegaIntentCreateOptions<P>): OmegaIntent<P>;
    /**
     * Safe cast helper for `payload` when additional narrowing is required.
     *
     * @returns `null` when `payload` is `undefined`; otherwise `payload as T`.
     */
    payloadAs<T extends P = P>(): T | null;
    private static nextId;
}

/** Wire name from a branded {@link OmegaEventName} enum member or a plain string. */
type OmegaEventWireName = OmegaEventName | string;
/** Options for {@link OmegaEvent.fromName}. */
interface OmegaEventCreateOptions {
    readonly payload?: unknown;
    readonly id?: string;
    readonly namespace?: string | null;
    readonly meta?: Readonly<Record<string, unknown>>;
}
/**
 * Notification that something happened, broadcast on {@link OmegaChannel}.
 *
 * @remarks
 * Events are **facts** (past tense domain signals); pair with {@link OmegaIntent} for commands.
 * Prefer {@link OmegaEvent.fromName} in application code for stable ids and lint alignment.
 */
declare class OmegaEvent extends OmegaObject {
    readonly name: string;
    readonly payload?: unknown;
    readonly namespace?: string | null;
    constructor(init: {
        readonly id: string;
        readonly name: string;
        readonly payload?: unknown;
        readonly namespace?: string | null;
        readonly meta?: Readonly<Record<string, unknown>>;
    });
    /**
     * @param name — Wire event name.
     * @param options — Optional `payload`, `id`, `namespace`, `meta`.
     */
    static fromName(name: OmegaEventWireName, options?: OmegaEventCreateOptions): OmegaEvent;
    /**
     * @returns `null` if `payload` is missing; otherwise casts `payload` to `T`.
     */
    payloadAs<T>(): T | null;
    /**
     * JSON-serializable representation suitable for logging or persistence adapters.
     *
     * @remarks
     * Omits `payload` when `undefined`; omits `namespace` when `null`; omits `meta` when empty.
     */
    toJson(): Record<string, unknown>;
    /**
     * Best-effort parser for persisted or wire JSON; validates `meta` shape lightly.
     *
     * @param json — Plain object; missing fields become empty strings / `null` as implemented.
     */
    static fromJson(json: Record<string, unknown>): OmegaEvent;
    private static nextId;
}

/**
 * Minimal contract implemented by {@link OmegaChannel} and {@link OmegaChannelNamespace}.
 *
 * @remarks
 * Lets flows or services depend on a scoped bus without taking a hard dependency on the
 * concrete root channel type.
 */
interface OmegaEventBus {
    /** Publish a fully constructed {@link OmegaEvent}. */
    emit(event: OmegaEvent): void;
    /** Publish a typed payload object as an {@link OmegaEvent} (see channel implementations). */
    emitTyped(event: OmegaTypedEvent): void;
    /** Multicast stream of events visible to this bus (global or namespace-filtered). */
    readonly events: Observable<OmegaEvent>;
}

/**
 * Optional sink for errors raised while emitting on {@link OmegaChannel} or
 * {@link OmegaChannelNamespace} (including post-{@link OmegaChannel.dispose dispose} emits).
 */
type OmegaEmitErrorHandler = (error: unknown, stack?: string) => void;
/**
 * Application-wide {@link OmegaEvent} bus backed by a `Subject` **multicasted** to subscribers
 * (no replay; subscribers only see events emitted after they subscribe).
 *
 * @remarks
 * - **Threading:** Intended for single-threaded Angular/RxJS usage within one zone.
 * - **Errors:** Subscriber errors propagate; use {@link OmegaEmitErrorHandler} via constructor
 *   options to log or report without crashing the pipeline when possible.
 * - **Scoping:** {@link OmegaChannelNamespace} tags emits with a namespace string and filters
 *   {@link OmegaChannelNamespace.events} to global events plus that namespace.
 *
 * @see {@link OmegaEventBus}
 */
declare class OmegaChannel implements OmegaEventBus {
    private readonly hub;
    private closed;
    readonly events: Observable<OmegaEvent>;
    /** Optional handler invoked when {@link emit} fails or the channel is already disposed. */
    readonly onEmitError?: OmegaEmitErrorHandler;
    /**
     * @param options — Optional `{ onEmitError }` callback for emit-time failures.
     */
    constructor(options?: {
        onEmitError?: OmegaEmitErrorHandler;
    });
    /**
     * Returns a view that prefixes emitted events with `namespace` and filters the stream
     * to global (`namespace == null`) plus this namespace’s events.
     *
     * @param name — Non-empty namespace segment (conventionally feature or bounded-context name).
     */
    namespace(name: string): OmegaChannelNamespace;
    /**
     * Pushes one event to all current subscribers of {@link events}.
     *
     * @param event — Fully built {@link OmegaEvent}; prefer {@link emitNamed} or {@link emitTyped} when possible.
     */
    emit(event: OmegaEvent): void;
    /**
     * Wraps a typed payload object as `payload` on a fresh {@link OmegaEvent} with `namespace: null`.
     *
     * @param event — Must include a discriminating `name` compatible with {@link OmegaTypedEvent}.
     */
    emitTyped(event: OmegaTypedEvent): void;
    /**
     * Shorthand for {@link OmegaEvent.fromName} plus {@link emit} with a generated id.
     *
     * @param name — Wire-level event name.
     * @param payload — Optional JSON-like payload (stored by reference; clone if immutability matters).
     */
    emitNamed(name: string, payload?: Record<string, unknown>): void;
    /**
     * @param name — Event name to filter on (equality).
     * @returns Filtered view of {@link events} for a single `name`.
     */
    on(name: string): Observable<OmegaEvent>;
    /**
     * Completes the underlying subject; further {@link emit} calls are ignored (or reported via {@link onEmitError}).
     */
    dispose(): void;
    private static nextEventId;
}
/**
 * Scoped {@link OmegaEventBus} view over an {@link OmegaChannel}.
 *
 * @remarks
 * {@link emit} / {@link emitTyped} / {@link emitNamed} set `namespace` on the outgoing
 * {@link OmegaEvent}. {@link events} (and {@link on}) merge the root stream but only pass
 * through events whose `namespace` is `null` **or** equals this namespace.
 */
declare class OmegaChannelNamespace implements OmegaEventBus {
    private readonly channel;
    readonly namespace: string;
    /**
     * @param channel — Parent channel that receives re-tagged events.
     * @param namespace — Namespace string applied to all emits from this view.
     */
    constructor(channel: OmegaChannel, namespace: string);
    /**
     * Re-emits on the root channel with `namespace` forced to this namespace.
     *
     * @param event — Source event; `id`, `name`, `payload`, and `meta` are preserved.
     */
    emit(event: OmegaEvent): void;
    /**
     * Same as {@link OmegaChannel.emitTyped} but sets `namespace` to this namespace.
     *
     * @param event — Typed payload carrying `name`.
     */
    emitTyped(event: OmegaTypedEvent): void;
    /**
     * Like {@link OmegaChannel.emitNamed} with `namespace` defaulted to this namespace.
     */
    emitNamed(name: string, payload?: Record<string, unknown>): void;
    /**
     * Stream of root events where `namespace` is `null` (global) or equals {@link namespace}.
     */
    get events(): Observable<OmegaEvent>;
    /**
     * @param name — Event name filter (equality) on {@link events}.
     */
    on(name: string): Observable<OmegaEvent>;
    private static nextEventId;
}

/**
 * Application feature orchestration unit: receives {@link OmegaIntent} from the
 * {@link OmegaFlowManager} and {@link OmegaEvent} from the shared {@link OmegaChannel}.
 *
 * @remarks
 * Subclasses expose a stable string {@link id} used with {@link OmegaFlowManager.activate},
 * {@link OmegaFlowManager.switchTo}, and registration. Use the protected {@link emit} helper
 * to publish domain events without reaching for the channel directly from deep call stacks.
 */
declare abstract class OmegaFlow {
    protected readonly channel: OmegaChannel;
    /**
     * Unique key for registration and activation (e.g. `'auth'`, `'orders'`).
     */
    abstract readonly id: string;
    /**
     * @param channel — Inject and store for {@link emit}; must be the app’s singleton channel.
     */
    protected constructor(channel: OmegaChannel);
    /**
     * Handle user or system intents while this flow is in the manager’s active set.
     *
     * @param intent — Narrow with {@link OmegaIntent.payloadAs} when needed.
     */
    abstract onIntent(intent: OmegaIntent): void;
    /**
     * Called for each {@link OmegaEvent} on the channel while this flow is active on the
     * {@link OmegaFlowManager}. Override to react to cross-flow or infrastructure events.
     *
     * @param _event — Unused in the default no-op implementation.
     */
    onEvent(_event: OmegaEvent): void;
    /**
     * Emit a named {@link OmegaEvent} on the injected {@link OmegaChannel}.
     *
     * @param name — Wire event name.
     * @param payload — Optional payload; passed by reference.
     * @param namespace — Optional namespace override; forwarded to {@link OmegaEvent.fromName}.
     */
    protected emit(name: string, payload?: Record<string, unknown>, namespace?: string | null): void;
}

/**
 * Optional hooks for debugging tools (e.g. {@link provideOmegaInspector}).
 * Production apps can omit this entirely.
 */
interface OmegaFlowManagerInstrumentation {
    /** Called after a flow id is registered. */
    onFlowRegistered?(flowId: string): void;
    /** Called after activate / deactivate / switchTo changes the active set. */
    onActiveSetChanged?(activeFlowIds: readonly string[]): void;
    /** Called when {@link OmegaFlowManager.handleIntent} runs (before flows handle the intent). */
    onIntentHandled?(intent: OmegaIntent, activeFlowIds: readonly string[]): void;
}
/** Injected when {@link provideOmegaInspector} is used together with {@link provideOmega}. */
declare const OMEGA_FLOW_MANAGER_INSTRUMENTATION: InjectionToken<OmegaFlowManagerInstrumentation | undefined>;

/**
 * Routes {@link OmegaIntent} instances to **active** flows and forwards every
 * {@link OmegaEvent} on the {@link OmegaChannel} to those flows’ {@link OmegaFlow.onEvent}.
 *
 * @remarks
 * **Construction:** Subscribes to `channel.events` for the lifetime of the manager.
 * Unregister flows by design is not provided; the manager is usually app-scoped.
 *
 * **Active set:** {@link activate} adds a flow id; {@link deactivate} removes one;
 * {@link switchTo} replaces the whole set with a single id (common “one main flow” mode).
 * {@link handleIntent} iterates the active set in insertion order and calls {@link OmegaFlow.onIntent}.
 *
 * **Events:** Each channel event is delivered to every active flow; flows should filter
 * quickly if they only care about a subset of names.
 */
declare class OmegaFlowManager {
    private readonly channel;
    private readonly instrumentation?;
    private readonly flows;
    private readonly activeFlowIds;
    /**
     * @param channel — Channel whose `events` stream this manager subscribes to for its whole lifetime.
     *   The subscription is not unsubscribed by the library; align manager and channel lifecycle with the app.
     * @param instrumentation — Optional debug hooks (e.g. Omega Inspector); omit in production if unused.
     */
    constructor(channel: OmegaChannel, instrumentation?: OmegaFlowManagerInstrumentation | undefined);
    private forwardEventToActiveFlows;
    /** @returns The same {@link OmegaChannel} instance passed to the constructor. */
    getChannel(): OmegaChannel;
    /**
     * Stores a flow by {@link OmegaFlow.id}. Later calls with the same id replace the previous flow.
     *
     * @param flow — Flow instance; `flow.id` must be stable for activate/switchTo lookups.
     */
    registerFlow(flow: OmegaFlow): void;
    /** Registered flow ids (for devtools / inspector). */
    getRegisteredFlowIds(): readonly string[];
    /** Currently active flow ids (for devtools / inspector). */
    getActiveFlowIds(): readonly string[];
    /**
     * @deprecated Use {@link registerFlow} instead. Will be removed in a future major version.
     */
    register(flow: OmegaFlow): void;
    /**
     * Adds a flow id to the active set so it receives intents and channel events.
     *
     * @param flowId — {@link OmegaFlow.id} previously {@link registerFlow registered}.
     */
    activate(flowId: string): void;
    /**
     * Removes a flow id from the active set without disposing the flow instance.
     *
     * @param flowId — Id to remove from the active set; no-op if not active.
     */
    deactivate(flowId: string): void;
    /**
     * Clears the active set, then activates exactly one flow (typical “current screen flow” pattern).
     *
     * @param flowId — {@link OmegaFlow.id} to make the sole active flow.
     */
    switchTo(flowId: string): void;
    /**
     * Delivers the intent to every active flow, in activation order.
     *
     * @param intent — Typically created with {@link OmegaIntent.fromName}.
     */
    handleIntent(intent: OmegaIntent): void;
    /**
     * @deprecated Use {@link handleIntent} instead. Will be removed in a future major version.
     */
    dispatch(intent: OmegaIntent): void;
}

/** Input to {@link OmegaAgentBehaviorEngine.evaluate}. */
interface OmegaAgentBehaviorContext {
    /** The channel event currently being processed. */
    readonly event: OmegaEvent;
}
/**
 * Declarative outcome from a behavior engine (e.g. `LOG`, `OPEN_MODAL`, route guard side effect).
 */
interface OmegaAgentReaction {
    /** Stable action key interpreted by the host {@link OmegaAgent}. */
    readonly action: string;
    readonly payload?: unknown;
}
/** Callback invoked by {@link OmegaAgent} for each non-null {@link OmegaAgentReaction}. */
type OmegaAgentReactionHandler = (reaction: OmegaAgentReaction) => void;
/**
 * Pluggable rule evaluated on every {@link OmegaEvent} handled by {@link OmegaAgent}.
 *
 * @remarks
 * Engines run in registration order. Returning `null` means “no reaction”; returning an
 * object forwards it to {@link OmegaAgentReactionHandler} immediately (no batching).
 */
declare abstract class OmegaAgentBehaviorEngine {
    /**
     * @param ctx — Current event context.
     * @returns A reaction to dispatch, or `null` to skip.
     */
    abstract evaluate(ctx: OmegaAgentBehaviorContext): OmegaAgentReaction | null;
}

interface OmegaAgentErrorContext {
    readonly phase: 'evaluate' | 'reaction';
    readonly event: OmegaEvent;
    readonly behavior?: OmegaAgentBehaviorEngine;
    readonly reaction?: unknown;
}
type OmegaAgentErrorHandler = (error: unknown, context: OmegaAgentErrorContext) => void;
/**
 * Side-effect coordinator that listens to **all** {@link OmegaEvent} values on a channel
 * and runs one or more {@link OmegaAgentBehaviorEngine} instances per tick.
 *
 * @remarks
 * Unlike {@link OmegaFlow}, agents are not selected by the {@link OmegaFlowManager}; they
 * subscribe directly. **Each** {@link OmegaAgentBehaviorEngine} runs for every event; any
 * non-null {@link OmegaAgentBehaviorEngine.evaluate} result triggers {@link OmegaAgentReactionHandler}
 * in array order (multiple reactions per event are allowed). Call {@link destroy} when tearing
 * down a session scope to avoid duplicate subscriptions.
 */
declare class OmegaAgent {
    private readonly channel;
    private readonly behaviors;
    private readonly onReaction;
    private readonly onError?;
    private subscription?;
    /**
     * @param channel — Source of events (typically the app singleton).
     * @param behaviors — Engines evaluated in array order for every event.
     * @param onReaction — Invoked for each non-null {@link OmegaAgentBehaviorEngine.evaluate} result.
     */
    constructor(channel: OmegaChannel, behaviors: readonly OmegaAgentBehaviorEngine[], onReaction: OmegaAgentReactionHandler, onError?: OmegaAgentErrorHandler | undefined);
    private tick;
    /**
     * Unsubscribes from {@link OmegaChannel.events}; the agent must not be used afterward.
     */
    destroy(): void;
}

/**
 * Stable handles available during {@link OmegaProvideOptions.bootstrap} and
 * {@link OmegaProvideOptions.createAgents}.
 *
 * @remarks
 * Both services are singletons for the injector that registered `provideOmega`.
 * Use `ctx.manager` to activate flows or dispatch intents from startup code;
 * use `ctx.channel` when agents or bootstrap need to emit or subscribe directly.
 */
interface OmegaRuntimeContext {
    /** Shared bus for {@link OmegaEvent} traffic between flows and agents. */
    readonly channel: OmegaChannel;
    /** Routes intents to active flows; holds registered {@link OmegaFlow} instances. */
    readonly manager: OmegaFlowManager;
}
/**
 * Configuration for {@link provideOmega}.
 */
interface OmegaProvideOptions {
    /**
     * Factory that builds every {@link OmegaFlow} for the app, all wired to the same
     * {@link OmegaChannel} instance the library registers.
     *
     * @remarks
     * - **channel** — The injected {@link OmegaChannel}; pass it into each flow’s constructor.
     * - **Return value** — A readonly list of flows; each {@link OmegaFlow.id} must be unique.
     */
    createFlows: (channel: OmegaChannel) => readonly OmegaFlow[];
    /**
     * Optional sink for channel emit errors (disposed channel emit, observer errors, etc).
     *
     * @remarks
     * Use this to centralize diagnostics (`console.error`, telemetry) for internal channel failures.
     */
    onChannelEmitError?: OmegaEmitErrorHandler;
    /**
     * Optional one-shot hook after flows are {@link OmegaFlowManager.registerFlow registered}
     * on the manager but before the application finishes bootstrapping.
     *
     * @remarks
     * Typical uses: {@link OmegaFlowManager.switchTo}, {@link OmegaFlowManager.activate},
     * seeding session state, or dispatching an initial {@link OmegaIntent}.
     * Runs inside Angular app initialization; keep work fast and avoid blocking UI.
     */
    bootstrap?: (ctx: OmegaRuntimeContext) => void;
    /**
     * Optional hook to construct {@link OmegaAgent} instances or other channel listeners
     * that are not modeled as flows.
     *
     * @remarks
     * Runs in the same app-initialization hook as `bootstrap`, after `bootstrap` if both are set.
     * Prefer constructing agents here so they share the same channel/manager as flows.
     */
    createAgents?: (ctx: OmegaRuntimeContext) => void;
}
/**
 * Registers {@link OmegaChannel} and {@link OmegaFlowManager}, registers all flows from
 * {@link OmegaProvideOptions.createFlows}, then runs optional `bootstrap` / `createAgents`
 * hooks when Angular’s injector is ready.
 *
 * @param options — Flow factory plus optional startup hooks.
 * @returns A {@link Provider} array suitable for `ApplicationConfig.providers` or `NgModule.providers`.
 *
 * @remarks
 * Registration order: `OmegaChannel` → `OmegaFlowManager` (with flows) → app initializer
 * that invokes `bootstrap` then `createAgents`. Consumers on **Angular 19+** can spread
 * the result into `providers: [...]`.
 *
 * @see {@link OmegaProvideOptions}
 */
declare function provideOmega(options: OmegaProvideOptions): Array<Provider | ReturnType<typeof provideAppInitializer>>;

interface OmegaInspectorChannelEntry {
    readonly id: string;
    readonly t: number;
    readonly name: string;
    readonly namespace: string | null;
    /** Active flows at the moment this event was observed by the inspector. */
    readonly deliveredToFlowIds: readonly string[];
    readonly payloadPreview: string;
    readonly raw: OmegaEvent;
}
interface OmegaInspectorIntentEntry {
    readonly id: string;
    readonly t: number;
    readonly name: string;
    readonly activeFlowIds: readonly string[];
    readonly payloadPreview: string;
    readonly raw: OmegaIntent;
}

/**
 * Exposed on `window.__OMEGA_INSPECTOR__` when {@link OmegaInspectorService.exposeGlobal} runs
 * (dev / optional). Lets you query logs from the browser console, similar to typing
 * commands against a Redux store inspector.
 */
interface OmegaInspectorGlobalApi {
    readonly version: 1;
    /** Last buffered channel events (same data as the UI panel). */
    getChannelLog(): readonly OmegaInspectorChannelEntry[];
    /** Last buffered intents from {@link OmegaFlowManager.handleIntent}. */
    getIntentLog(): readonly OmegaInspectorIntentEntry[];
    getRegisteredFlowIds(): readonly string[];
    getActiveFlowIds(): readonly string[];
    clear(): void;
    /** Enable or disable styled `console` output (grouped logs). */
    setConsoleLog(on: boolean): void;
    /** Whether console logging is currently enabled. */
    getConsoleLogEnabled(): boolean;
}
declare global {
    interface Window {
        /** Present when {@link OmegaInspectorService.exposeGlobal} was called (typical dev setup). */
        __OMEGA_INSPECTOR__?: OmegaInspectorGlobalApi;
    }
}

/** @internal */
declare const OMEGA_INSPECTOR_MAX_EVENTS = 500;
declare class OmegaInspectorService {
    private readonly channel;
    private readonly injector;
    private readonly destroyRef;
    private readonly maxEvents;
    /** Channel events (most recent last). */
    readonly channelLog: _angular_core.WritableSignal<readonly OmegaInspectorChannelEntry[]>;
    /** Intents passed to {@link OmegaFlowManager.handleIntent}. */
    readonly intentLog: _angular_core.WritableSignal<readonly OmegaInspectorIntentEntry[]>;
    readonly registeredFlowIds: _angular_core.WritableSignal<readonly string[]>;
    readonly activeFlowIds: _angular_core.WritableSignal<readonly string[]>;
    readonly selectedChannelEntry: _angular_core.WritableSignal<OmegaInspectorChannelEntry | null>;
    readonly selectedIntentEntry: _angular_core.WritableSignal<OmegaInspectorIntentEntry | null>;
    readonly detailsJson: _angular_core.Signal<string>;
    private broadcast;
    /** When true, each channel event / intent is also printed with `console.groupCollapsed` (Redux-style). */
    private consoleLogEnabled;
    private globalAttached;
    constructor();
    /** Call from app bootstrap if you want a second tab / static page to listen (same origin). */
    enableBroadcastChannel(name?: string): void;
    setMaxEvents(n: number): void;
    /**
     * Print each channel event and intent to the **browser console** using grouped, styled logs
     * (similar in spirit to Redux middleware logging — not the Redux DevTools browser extension).
     */
    setConsoleLog(enabled: boolean): void;
    getConsoleLog(): boolean;
    /**
     * Attaches {@link OmegaInspectorGlobalApi} to `window.__OMEGA_INSPECTOR__` so you can run
     * `__OMEGA_INSPECTOR__.getIntentLog()` from DevTools. No-op on non-browser platforms.
     */
    exposeGlobal(): void;
    private detachGlobal;
    createInstrumentation(): OmegaFlowManagerInstrumentation;
    clearLogs(): void;
    selectChannelEntry(entry: OmegaInspectorChannelEntry | null): void;
    selectIntentEntry(entry: OmegaInspectorIntentEntry | null): void;
    private refreshFlowListsSoon;
    private appendChannelEvent;
    private getCurrentActiveFlowIds;
    private appendIntent;
    private postBroadcast;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OmegaInspectorService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<OmegaInspectorService>;
}

interface OmegaInspectorProvideOptions {
    /** Max rows kept for channel + intent logs (default 500). */
    maxEvents?: number;
    /** If true, mirror traffic to `BroadcastChannel` `omega-inspector` (same origin only). See MDN: BroadcastChannel. */
    broadcastChannel?: boolean;
    /**
     * If true, log each channel event and intent to the browser **console** with grouped, styled
     * output (Redux-middleware style — not the Redux DevTools extension).
     * @default false
     */
    consoleLog?: boolean;
    /**
     * If true (default), set `window.__OMEGA_INSPECTOR__` with `getIntentLog()`, `setConsoleLog()`, etc.
     * @default true
     */
    exposeGlobal?: boolean;
    /**
     * Enable inspector providers in production builds.
     *
     * @remarks
     * Defaults to `false` so inspector instrumentation is dev-only.
     */
    allowInProd?: boolean;
}
/**
 * Dev-only wiring for the Omega Inspector UI: instruments {@link OmegaFlowManager} and
 * subscribes to {@link OmegaChannel} events. Add **before** {@link provideOmega} in `providers`:
 *
 * ```ts
 * providers: [
 *   ...provideOmegaInspector({ broadcastChannel: true }),
 *   ...provideOmega(createOptions()),
 * ]
 * ```
 */
declare function provideOmegaInspector(options?: OmegaInspectorProvideOptions): Provider[];

declare class OmegaInspectorPanelComponent {
    protected readonly inspector: OmegaInspectorService;
    protected clear(): void;
    protected isChannelActive(entry: {
        id: string;
    }): boolean;
    protected isIntentActive(entry: {
        id: string;
    }): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OmegaInspectorPanelComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OmegaInspectorPanelComponent, "omega-inspector-panel", never, {}, {}, never, never, true, never>;
}

/**
 * Dev overlay independent of the Angular {@link Router}, toggled by keyboard shortcut.
 * Window-like behavior: drag, resize, maximize/restore.
 * Mount with {@link provideOmegaInspectorFloatingUi}.
 */
declare class OmegaInspectorFloatingComponent {
    protected readonly expanded: _angular_core.WritableSignal<boolean>;
    protected readonly maximized: _angular_core.WritableSignal<boolean>;
    protected readonly rect: _angular_core.WritableSignal<Rect>;
    private restoreRect;
    private dragState;
    private resizeState;
    protected onWindowKeydown(event: KeyboardEvent): void;
    protected onEscape(): void;
    protected onWindowResize(): void;
    protected onPointerMove(event: PointerEvent): void;
    protected onPointerUp(): void;
    protected onDragStart(event: PointerEvent): void;
    protected onResizeStart(event: PointerEvent): void;
    protected toggleMaximize(): void;
    private ensureRectWithinViewport;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OmegaInspectorFloatingComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OmegaInspectorFloatingComponent, "omega-inspector-floating", never, {}, {}, never, never, true, never>;
}
interface Rect {
    readonly x: number;
    readonly y: number;
    readonly width: number;
    readonly height: number;
}

/**
 * Mounts {@link OmegaInspectorFloatingComponent} on `document.body` after bootstrap — **no Router route**.
 * Requires {@link provideOmegaInspector} (and thus {@link provideOmega}) to be registered first.
 *
 * ```ts
 * providers: [
 *   ...provideOmegaInspector({ consoleLog: true }),
 *   ...provideOmega(createOptions()),
 *   ...provideOmegaInspectorFloatingUi(),
 * ]
 * ```
 */
interface OmegaInspectorFloatingUiOptions {
    /**
     * Enable floating inspector window in production builds.
     *
     * @remarks
     * Defaults to `false` so UI is dev-only.
     */
    allowInProd?: boolean;
}
declare function provideOmegaInspectorFloatingUi(options?: OmegaInspectorFloatingUiOptions): Array<Provider | EnvironmentProviders>;

export { OMEGA_FLOW_MANAGER_INSTRUMENTATION, OMEGA_INSPECTOR_MAX_EVENTS, OmegaAgent, OmegaAgentBehaviorEngine, OmegaChannel, OmegaChannelNamespace, OmegaEvent, OmegaFailure, OmegaFlow, OmegaFlowManager, OmegaInspectorFloatingComponent, OmegaInspectorPanelComponent, OmegaInspectorService, OmegaIntent, OmegaObject, omegaWireNameFromCamelCaseEnumMember, provideOmega, provideOmegaInspector, provideOmegaInspectorFloatingUi };
export type { OmegaAgentBehaviorContext, OmegaAgentErrorContext, OmegaAgentErrorHandler, OmegaAgentId, OmegaAgentReaction, OmegaAgentReactionHandler, OmegaEmitErrorHandler, OmegaEventBus, OmegaEventCreateOptions, OmegaEventName, OmegaEventWireName, OmegaFailureInit, OmegaFlowId, OmegaFlowManagerInstrumentation, OmegaInspectorChannelEntry, OmegaInspectorFloatingUiOptions, OmegaInspectorGlobalApi, OmegaInspectorIntentEntry, OmegaInspectorProvideOptions, OmegaIntentCreateOptions, OmegaIntentName, OmegaIntentWireName, OmegaObjectInit, OmegaProvideOptions, OmegaRuntimeContext, OmegaTypedEvent };