package @eventicle/eventiclejs

aggregateObservationAdapter: () => AggregateObservationAdapter

export class UserAggregate extends AggregateRoot {
  approved: boolean = false

  constructor() {
     super("User")

     this.reducers = []
     // persist the approval in the current aggregate state.
     // This avoids any potential race conditions between performing the action that requires
     // approval and the observer starting to monitor. See below.
     this.reducers["user.approved"] = (ev) => {
       this.approved = true
     }
  }

  approve() {
    this.raiseEvent({
      type: "user.approved",
      data: {}
      // other event fields
    })
  }
}

  await registerAdapter(createAggregateObservationAdapter([AnAggregate]));

// The userId is the domainId of the UserAggregate instance we want to observe
export doActionThatRequiresApproval(userId: string) {

  // perform some action that triggers async workflows

  // now wait for the User to be approved
  const user = await aggregateObserver(
                            UserAggregate,
                            userId,  // the UserAggregate domainId
                            10000,   // max time to wait for the User instance to come into the required state
                            (ar, ev) => {
          // this is called once straight away with just the current state of the User aggregate (ev is null)
          // then, every time an event is observed for the UserAggregate with the domainId == userId
          // check the current state of the aggregate is what you want to see, or the event being received
          // is the one you are waiting for.  Or, ideally, both of those things
          // doing both will avoid any race conditions.
     return ev && ev.type == "user.approved" || ar.approved
  });

  // user is now approved, or an Error has been thrown
  // perform any ops on the user as required.

}

export declare function aggregateObserver<AR extends AggregateRoot>(aggregateType: {
    new (...params: any[]): AR;
}, id: string, timeout: number, exec: (ar: AR, event?: EventicleEvent) => boolean): Promise<AR>;

export declare function allSagaInstances(workspaceId?: string): Promise<SagaInstance<any, any>[]>;

export declare function allSagas(): Promise<Saga<any, any>[]>;

export declare function apmJoinEvent(event: EventicleEvent, name: string, type: string, subtype: string): void;

export declare function connectBroker(config: KafkaConfig): Promise<void>;

export declare function consumeFullEventLog(stream: string): Promise<EventicleEvent[]>;

export declare function createAggregateObservationAdapter<AR extends AggregateRoot>(aggregates: {
    new (): AR;
}[]): AggregateObservationAdapter;

export declare function dispatchCommand<T>(commandIntent: CommandIntent<T>): Promise<CommandReturn<T>>;

export declare function dispatchDirectCommand<T>(command: () => Promise<CommandReturn<T>>, streamToEmit: string, transactionControl?: TransactionOptions): Promise<T>;

export declare function eventClient(): EventClient;

export declare function eventClientCodec(): EventClientCodec;

export declare function eventClientOnDatastore(): EventClient;

export declare function eventClientOnKafka(config: KafkaConfig, consumerConfig?: ConsumerConfigFactory, onTopicFailureConfig?: (topicName: any) => Promise<TopicFailureConfiguration>): Promise<EventClient>;

export declare function eventSourceName(): string;

export declare function metrics(): {
    "view-latency": any;
    "adapter-latency": any;
    "saga-latency": any;
};

export declare function registerAdapter(adapter: EventAdapter): Promise<EventSubscriptionControl>;

export declare function registerCommand<I, O>(command: Command<I, O>): void;

export declare function registerRawView(view: RawEventView): Promise<EventSubscriptionControl>;

export declare function registerSaga<TimeoutNames, Y>(saga: Saga<TimeoutNames, Y>): Promise<EventSubscriptionControl>;

export declare function registerView(view: EventView): Promise<EventSubscriptionControl>;

export declare function removeAllSagas(): Promise<void>;

export declare function saga<TimeoutNames, SagaInstanceData>(name: string): Saga<TimeoutNames, SagaInstanceData>;

export declare function scheduler(): ScheduleJobRunner;

export declare function setEventClient(cl: EventClient): void;

export declare function setEventClientCodec(cl: EventClientCodec): void;

export declare function setEventSourceName(name: string): void;

export declare function setScheduler(scheduler: ScheduleJobRunner): void;