import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import type { CallContext, CallOptions } from "nice-grpc-common";
import { Guid } from "./protobuf-net/bcl";
export declare const protobufPackage = "Cratis.Chronicle.Contracts.Observation.Reactors";
export declare enum EventObservationState {
    EVENT_OBSERVATION_STATE_None = 0,
    Initial = 1,
    Replay = 2,
    UNRECOGNIZED = -1
}
export declare function eventObservationStateFromJSON(object: any): EventObservationState;
export declare function eventObservationStateToJSON(object: EventObservationState): string;
export declare enum ObservationState {
    OBSERVATION_STATE_None = 0,
    Success = 1,
    Failed = 2,
    UNRECOGNIZED = -1
}
export declare function observationStateFromJSON(object: any): ObservationState;
export declare function observationStateToJSON(object: ObservationState): string;
export declare enum ReplayState {
    REPLAY_STATE_None = 0,
    BeginReplay = 1,
    EndReplay = 2,
    BeginReplayPartition = 3,
    EndReplayPartition = 4,
    UNRECOGNIZED = -1
}
export declare function replayStateFromJSON(object: any): ReplayState;
export declare function replayStateToJSON(object: ReplayState): string;
export interface AppendedEvent {
    Context: EventContext | undefined;
    Content: string;
    OriginalContent: string;
    Revisions: EventRevision[];
    GenerationalContent: {
        [key: number]: string;
    };
}
export interface AppendedEvent_GenerationalContentEntry {
    key: number;
    value: string;
}
export interface Causation {
    Occurred: SerializableDateTimeOffset | undefined;
    Type: string;
    Properties: {
        [key: string]: string;
    };
}
export interface Causation_PropertiesEntry {
    key: string;
    value: string;
}
export interface EventContext {
    EventType: EventType | undefined;
    EventSourceType: string;
    EventSourceId: string;
    SequenceNumber: bigint;
    EventStreamType: string;
    EventStreamId: string;
    Occurred: SerializableDateTimeOffset | undefined;
    EventStore: string;
    Namespace: string;
    CorrelationId: Guid | undefined;
    Causation: Causation[];
    CausedBy: Identity | undefined;
    ObservationState: EventObservationState;
    Tags: string[];
    Hash: string;
    Subject: string;
}
export interface EventRevision {
    Generation: number;
    CorrelationId: string;
    CausedBy: Identity | undefined;
    Occurred: SerializableDateTimeOffset | undefined;
    Content: string;
}
export interface EventType {
    Id: string;
    Generation: number;
    Tombstone: boolean;
}
export interface EventTypeWithKeyExpression {
    EventType: EventType | undefined;
    Key: string;
}
export interface EventsToObserve {
    Partition: string;
    Events: AppendedEvent[];
    ReplayState: ReplayState;
}
export interface HasReactorRequest {
    EventStore: string;
    Namespace: string;
    ReactorId: string;
}
export interface HasReactorResponse {
    Exists: boolean;
    EventSequenceId: string;
}
export interface Identity {
    Subject: string;
    Name: string;
    UserName: string;
    OnBehalfOf: Identity | undefined;
}
export interface ObserverFilters {
    FilterTags: string[];
    EventSourceType: string;
    EventStreamType: string;
}
export interface OneOfRegisterReactorReactorResult {
    Value0: RegisterReactor | undefined;
    Value1: ReactorResult | undefined;
}
export interface ReactorDefinition {
    ReactorId: string;
    EventSequenceId: string;
    EventTypes: EventTypeWithKeyExpression[];
    IsReplayable: boolean;
    Tags: string[];
    Filters: ObserverFilters | undefined;
}
export interface ReactorMessage {
    Content: OneOfRegisterReactorReactorResult | undefined;
}
export interface ReactorResult {
    Partition: string;
    State: ObservationState;
    LastSuccessfulObservation: bigint;
    ExceptionMessages: string[];
    ExceptionStackTrace: string;
}
export interface RegisterReactor {
    ConnectionId: string;
    EventStore: string;
    Namespace: string;
    Reactor: ReactorDefinition | undefined;
}
export interface SerializableDateTimeOffset {
    Value: string;
}
export declare const AppendedEvent: MessageFns<AppendedEvent>;
export declare const AppendedEvent_GenerationalContentEntry: MessageFns<AppendedEvent_GenerationalContentEntry>;
export declare const Causation: MessageFns<Causation>;
export declare const Causation_PropertiesEntry: MessageFns<Causation_PropertiesEntry>;
export declare const EventContext: MessageFns<EventContext>;
export declare const EventRevision: MessageFns<EventRevision>;
export declare const EventType: MessageFns<EventType>;
export declare const EventTypeWithKeyExpression: MessageFns<EventTypeWithKeyExpression>;
export declare const EventsToObserve: MessageFns<EventsToObserve>;
export declare const HasReactorRequest: MessageFns<HasReactorRequest>;
export declare const HasReactorResponse: MessageFns<HasReactorResponse>;
export declare const Identity: MessageFns<Identity>;
export declare const ObserverFilters: MessageFns<ObserverFilters>;
export declare const OneOfRegisterReactorReactorResult: MessageFns<OneOfRegisterReactorReactorResult>;
export declare const ReactorDefinition: MessageFns<ReactorDefinition>;
export declare const ReactorMessage: MessageFns<ReactorMessage>;
export declare const ReactorResult: MessageFns<ReactorResult>;
export declare const RegisterReactor: MessageFns<RegisterReactor>;
export declare const SerializableDateTimeOffset: MessageFns<SerializableDateTimeOffset>;
export type ReactorsDefinition = typeof ReactorsDefinition;
export declare const ReactorsDefinition: {
    readonly name: "Reactors";
    readonly fullName: "Cratis.Chronicle.Contracts.Observation.Reactors.Reactors";
    readonly methods: {
        readonly hasReactor: {
            readonly name: "HasReactor";
            readonly requestType: typeof HasReactorRequest;
            readonly requestStream: false;
            readonly responseType: typeof HasReactorResponse;
            readonly responseStream: false;
            readonly options: {};
        };
        readonly observe: {
            readonly name: "Observe";
            readonly requestType: typeof ReactorMessage;
            readonly requestStream: true;
            readonly responseType: typeof EventsToObserve;
            readonly responseStream: true;
            readonly options: {};
        };
    };
};
export interface ReactorsServiceImplementation<CallContextExt = {}> {
    hasReactor(request: HasReactorRequest, context: CallContext & CallContextExt): Promise<DeepPartial<HasReactorResponse>>;
    observe(request: AsyncIterable<ReactorMessage>, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<EventsToObserve>>;
}
export interface ReactorsClient<CallOptionsExt = {}> {
    hasReactor(request: DeepPartial<HasReactorRequest>, options?: CallOptions & CallOptionsExt): Promise<HasReactorResponse>;
    observe(request: AsyncIterable<DeepPartial<ReactorMessage>>, options?: CallOptions & CallOptionsExt): AsyncIterable<EventsToObserve>;
}
type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
export type DeepPartial<T> = T extends bigint ? string | number | bigint : T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
    [K in keyof T]?: DeepPartial<T[K]>;
} : Partial<T>;
export type ServerStreamingMethodResult<Response> = {
    [Symbol.asyncIterator](): AsyncIterator<Response, void>;
};
export interface MessageFns<T> {
    encode(message: T, writer?: BinaryWriter): BinaryWriter;
    decode(input: BinaryReader | Uint8Array, length?: number): T;
    fromJSON(object: any): T;
    toJSON(message: T): unknown;
    create(base?: DeepPartial<T>): T;
    fromPartial(object: DeepPartial<T>): T;
}
export {};
//# sourceMappingURL=observation_reactors.d.ts.map