import { E as EventObject, I as InspectedEventEvent, h as MachineSnapshot, i as AnyActorLogic, j as StateMachine, k as AnyActorRef, l as InspectionEvent, m as createActor, f as AnyEventObject, n as ActorSystem, o as ActorRefFrom, p as PromiseActorLogic, N as NonReducibleUnknown } from '../index.d-B8KPCV0w.js';
import { Y as YIterator } from '../ydoc-D56bpIow.js';
import * as Y from 'yjs';
import { B as BatchAsyncParams } from '../monads-DYUNSJVn.js';
import { O as ObservableActorLogic, a as ObservableActorRef } from '../observable.d-Crkcw02e.js';

type Emitted = {
    id?: string;
    format?: string;
    data?: any;
    type: string;
    offset?: number;
    timestamp: number;
    defer?: number;
} & EventObject;
declare function createYjsHub(doc?: Y.Doc | undefined): {
    doc: Y.Doc;
    emit: (event: Emitted) => void;
    inspected: YIterator<InspectedEventEvent>;
    emitted: YIterator<Emitted>;
    snapshot: YIterator<MachineSnapshot<any, any, any, any, any, any, any, any>>;
    array(key: string): YIterator<unknown>;
    state: {
        next: string;
        state: string;
        event: string;
    };
    children: Y.Map<Y.Doc>;
    child(id: string): {
        isNew: boolean;
        hub: /*elided*/ any;
    };
};
type serviceHub = ReturnType<typeof createYjsHub>;

type CreateServiceControllerOptions<TLogic extends AnyActorLogic> = {
    logic: TLogic;
    name?: string;
    doc?: Y.Doc;
    hub?: serviceHub;
} & Parameters<typeof createActor<TLogic>>[1] & Record<string, any>;
type ServiceControllerContext = {
    service: AnyActorRef;
    hub: serviceHub;
    logic: AnyActorLogic;
};
type Event = InspectionEvent;
type ServiceController$1<T extends AnyActorLogic = AnyActorLogic> = StateMachine<ServiceControllerContext, Event, any, any, any, any, any, any, any, CreateServiceControllerOptions<T>, any, any, any, any>;

type MergeEvents<TIn, TOut> = {
    (events: TIn[]): TOut;
};
type AsyncBatchEventsInput<TIn extends AnyEventObject, TOut extends AnyEventObject> = {
    merge?: MergeEvents<TIn, TOut>;
} & BatchAsyncParams<TIn>;
declare function fromAsyncBatchEventGenerator<TIn extends AnyEventObject = AnyEventObject, TOut extends AnyEventObject = AnyEventObject, TInput extends AsyncBatchEventsInput<TIn, TOut> = AsyncBatchEventsInput<TIn, TOut>>(generator: ({ input, system, self, emit }: {
    input: TInput;
    system: ActorSystem<any>;
    self: ActorRefFrom<ObservableActorLogic<TOut, TInput>>;
    emit: (emitted: AnyEventObject) => void;
}) => AsyncGenerator<TIn> | Promise<AsyncGenerator<TIn>>): ObservableActorLogic<TOut, TInput, EventObject>;
declare const asyncBatchEvents: ObservableActorLogic<AnyEventObject, AsyncBatchEventsInput<AnyEventObject, AnyEventObject>, EventObject>;

declare function fromAsyncEventEmitter<TInput extends AsyncIterable<TEmitted>, TEmitted extends EventObject = EventObject>(): PromiseActorLogic<void, TInput, TEmitted>;
declare const asyncEventEmitter: PromiseActorLogic<void, AsyncGenerator<EventObject, any, any>, EventObject>;

declare function filterEventAsync<T extends EventObject, TType extends T["type"], TFiltered extends T & {
    type: TType;
}>(stream: AsyncIterable<T>, ...type: TType[]): AsyncGenerator<TFiltered>;

declare function fromAsyncGenerator<TContext, TInput extends NonReducibleUnknown, TEmitted extends EventObject = EventObject>(generatorCreator: ({ input, system, self }: {
    input: TInput;
    system: ActorSystem<any>;
    self: ObservableActorRef<TContext>;
    emit: (emitted: TEmitted) => void;
}) => AsyncGenerator<TContext>): ObservableActorLogic<TContext, TInput, TEmitted>;
declare const asyncGenerator: ObservableActorLogic<any, AsyncIterable<any>, EventObject>;
declare function fromEventAsyncGenerator<TContext extends EventObject, TInput extends NonReducibleUnknown, TEmitted extends EventObject = EventObject>(generatorCreator: ({ input, system, self, emit }: {
    input: TInput;
    system: ActorSystem<any>;
    self: ObservableActorRef<TContext>;
    emit: (emitted: TEmitted) => void;
}) => AsyncGenerator<TContext> | Promise<AsyncGenerator<TContext>>): ObservableActorLogic<TContext, TInput, TEmitted>;
declare const asyncEventGenerator: ObservableActorLogic<AnyEventObject, AsyncIterable<AnyEventObject>, EventObject>;

declare const ServiceController: ServiceController$1<AnyActorLogic>;

export { type Emitted, ServiceController, asyncBatchEvents, asyncEventEmitter, asyncEventGenerator, asyncGenerator, createYjsHub, filterEventAsync, fromAsyncBatchEventGenerator, fromAsyncEventEmitter, fromAsyncGenerator, fromEventAsyncGenerator, type serviceHub };