@kronos-ts/axon-server 0.1.0

package/dist/generated/event.d.ts

@@ -0,0 +1,667 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import type { CallContext, CallOptions } from "nice-grpc-common";
+import { InstructionAck, MetaDataValue, SerializedObject } from "./common.js";
+import { Empty } from "./google/protobuf/empty.js";
+export declare const protobufPackage = "io.axoniq.axonserver.grpc.event";
+/** The state of the transformation. */
+export declare enum TransformationState {
+    /** ACTIVE - The transformation is opened, able to receive request to transform events, or to be applied or cancelled. */
+    ACTIVE = 0,
+    /** CANCELLED - The transformation has been cancelled. This a final state. */
+    CANCELLED = 1,
+    /** APPLYING - The transformation is in progress of applying its actions to the event store. */
+    APPLYING = 2,
+    /** APPLIED - The transformation has been applied to the event store. This a final state. */
+    APPLIED = 3,
+    UNRECOGNIZED = -1
+}
+export declare function transformationStateFromJSON(object: any): TransformationState;
+export declare function transformationStateToJSON(object: TransformationState): string;
+/** Request to compact event store. */
+export interface CompactionRequest {
+}
+/** The transformation data. */
+export interface Transformation {
+    /** The identifier of the transformation. */
+    transformationId: TransformationId | undefined;
+    /** The state of the transformation */
+    state: TransformationState;
+    /** The sequence of the last transformation action stored. Needed for checking sequential consistency of requests. */
+    sequence: bigint;
+    /** The bounded context in which this transformation is being executed. */
+    context: string;
+    /** The description of the transformation. */
+    description: string;
+    /** The timestamp at which the transformation was applied. Set to -1 if the transformation was not applied. */
+    appliedAt: bigint;
+    /** The username of user who requested the transformation to be applied. Empty if the transformation was not applied. */
+    applyRequester: string;
+    /** The version of the transformation. The sequence */
+    version: number;
+}
+/** Request to start a transformation */
+export interface StartTransformationRequest {
+    /** A description of the purpose of this transformation, for reference only */
+    description: string;
+}
+/** Request to apply a transformation */
+export interface ApplyTransformationRequest {
+    /** The identification of the transformation */
+    transformationId: TransformationId | undefined;
+    /** The sequence of the last entry in this transformation */
+    lastSequence: bigint;
+}
+/** Message containing one event to transform within a transformation */
+export interface TransformRequest {
+    /** The identification of the transformation */
+    transformationId: TransformationId | undefined;
+    /** The sequence of the current transformation */
+    sequence: bigint;
+    /** Replaces the content of an event with the new content */
+    replaceEvent?: TransformedEvent | undefined;
+    /** Deletes the content of an event */
+    deleteEvent?: DeletedEvent | undefined;
+}
+/** Replaces the content of an event with the new content */
+export interface TransformedEvent {
+    /** The global index of the event to replace */
+    token: bigint;
+    /** The new content of the event */
+    event: Event | undefined;
+}
+/** Deletes the content of an event */
+export interface DeletedEvent {
+    /** The global index of the event to clear */
+    token: bigint;
+}
+/** Uniquely identifies a transformation */
+export interface TransformationId {
+    /** The value of the identifier. */
+    id: string;
+}
+/** Acknowledgement that event with given token has been transformed successfully */
+export interface TransformRequestAck {
+    /** The sequence of the transformation request */
+    sequence: bigint;
+}
+/** Request message to schedule an event */
+export interface ScheduleEventRequest {
+    /** timestamp when to publish the event */
+    instant: bigint;
+    /** the event to publish */
+    event: Event | undefined;
+}
+/** Request message to reschedule an event */
+export interface RescheduleEventRequest {
+    /** optional token of scheduled event to cancel */
+    token: string;
+    /** timestamp when to publish the event */
+    instant: bigint;
+    /** the event to publish */
+    event: Event | undefined;
+}
+/** Request message to cancel an event */
+export interface CancelScheduledEventRequest {
+    /** token of scheduled event to cancel */
+    token: string;
+}
+/** Token to manage a scheduled event */
+export interface ScheduleToken {
+    /** Field defining the token identifier */
+    token: string;
+}
+/** Request message to receive the first Token (Tail Token) of the Event Stream */
+export interface GetFirstTokenRequest {
+}
+/** Request message to receive the last Token (Head Token) of the Event Stream */
+export interface GetLastTokenRequest {
+}
+/** Request message to receive the Token that starts streaming events from the given timestamp */
+export interface GetTokenAtRequest {
+    /** Timestamp expressed as milliseconds since epoch */
+    instant: bigint;
+}
+/** Message containing the information necessary to track the position of events in the Event Stream */
+export interface TrackingToken {
+    /** The value of the Token */
+    token: bigint;
+}
+/** Message wrapping an Event and a Tracking Token */
+export interface EventWithToken {
+    /** The Token representing the position of this Event in the Stream */
+    token: bigint;
+    /** The actual Event Message */
+    event: Event | undefined;
+}
+/** Message providing the parameters for executing a Query against AxonServer. */
+export interface QueryEventsRequest {
+    /** The query to execute against the Event Stream */
+    query: string;
+    /** The number of results AxonServer may send before new permits need to be provided */
+    numberOfPermits: bigint;
+    /** Whether to keep the query running against incoming events once the Head of the Stream is reached */
+    liveEvents: boolean;
+    /**
+     * Indicates whether to force querying events from the leader node of an Axon Server. Forcing reads from leader
+     * reduces the staleness of the data read, but also puts extra burden on the leader, reducing overall scalability.
+     * <p>
+     * This property has no effect on connections to AxonServer SE.
+     * </p>
+     */
+    forceReadFromLeader: boolean;
+    /** If true, snapshots will be queried instead of events */
+    querySnapshots: boolean;
+    /** Query from this context, not from the default context of the connection */
+    contextName: string;
+}
+/** A message describing a response to a Query request */
+export interface QueryEventsResponse {
+    /** Provided when the response contains the names of the columns the response contains. This message typically arrives first. */
+    columns?: ColumnsResponse | undefined;
+    /** Provided when the response message contains results of the Query */
+    row?: RowResponse | undefined;
+    /** Provided when all historic events have been included in the query results */
+    filesCompleted?: Confirmation | undefined;
+}
+/** Message containing the names of the columns returned in a Query */
+export interface ColumnsResponse {
+    /** The names of the columns provided in the query */
+    column: string[];
+}
+/** Message providing Query Result data */
+export interface RowResponse {
+    /** The values which, when combined, uniquely update this row. Any previously received values with the same identifiers should be replaced with this value */
+    idValues: QueryValue[];
+    /** The sorting values to use when sorting this response compared to the others. */
+    sortValues: QueryValue[];
+    /** The actual data values for each of the columns, as a column name -> value mapping */
+    values: {
+        [key: string]: QueryValue;
+    };
+}
+export interface RowResponse_ValuesEntry {
+    key: string;
+    value: QueryValue | undefined;
+}
+/** Describes the combination of an Aggregate Identifier and first expected Sequence number when opening an Aggregate-specific Event Stream */
+export interface ReadHighestSequenceNrRequest {
+    /** The Identifier of the Aggregate for which to load events */
+    aggregateId: string;
+    /** The Sequence Number of the first event expected */
+    fromSequenceNr: bigint;
+}
+/** The highest Sequence Number found for the provided request */
+export interface ReadHighestSequenceNrResponse {
+    /** The sequence number of the latest event */
+    toSequenceNr: bigint;
+}
+/** A confirmation to a request from the client */
+export interface Confirmation {
+    /** True when successful, otherwise false */
+    success: boolean;
+}
+/**
+ * A confirmation to a request from the client, including an optional consistency marker to track the position of this confirmation in the Event Stream.
+ * The consistency_marker is only set for AppendEvent requests towards a DCB context.
+ */
+export interface ConfirmationWithConsistencyMarker {
+    /** True when successful, otherwise false */
+    success: boolean;
+    /** The consistency marker token */
+    consistencyMarker: ConsistencyMarker | undefined;
+}
+/** A marker to track the position of a Confirmation in the Event Stream, used for consistency tracking in DCB contexts */
+export interface ConsistencyMarker {
+    /** The token representing the position of this marker in the Stream */
+    token: bigint;
+}
+/** Request describing the desire to read events for a specific Aggregate */
+export interface GetAggregateEventsRequest {
+    /** The identifier of the aggregate to read events for */
+    aggregateId: string;
+    /** The sequence number of the first event to receive */
+    initialSequence: bigint;
+    /** Whether a snapshot may be returned as first element in the stream */
+    allowSnapshots: boolean;
+    /** The maximum sequence number (inclusive) of the events to retrieve, 0 means up to last event */
+    maxSequence: bigint;
+    /** Hint for a minimum token to search events from */
+    minToken: bigint;
+}
+/** Request message to retrieve Snapshot Events for a specific Aggregate instance */
+export interface GetAggregateSnapshotsRequest {
+    /** The identifier to fetch the snapshots for */
+    aggregateId: string;
+    /** The minimal sequence number of the snapshots to retrieve */
+    initialSequence: bigint;
+    /** The maximum sequence number of the snapshots to retrieve */
+    maxSequence: bigint;
+    /** The maximum number of results to stream */
+    maxResults: number;
+}
+/** Request message to open an Event Stream from the Event Store. */
+export interface GetEventsRequest {
+    /** The token to start streaming from */
+    trackingToken: bigint;
+    /** The number of messages the server may send before it needs to wait for more permits */
+    numberOfPermits: bigint;
+    /** The unique identifier of this client instance. Used for monitoring. */
+    clientId: string;
+    /** The component name of this client instance. Used for monitoring. */
+    componentName: string;
+    /** The name of the processor requesting this stream. Used for monitoring. */
+    processor: string;
+    /**
+     * An enumeration of payload types that need to be blacklisted. The Server will stop sending messages of these
+     * types in order to reduce I/O. Note that the Server may occasionally send a blacklisted message to prevent
+     * time-outs and stale tokens on clients.
+     */
+    blacklist: PayloadDescription[];
+    /**
+     * Indicates whether to force reading events from the leader node of an Axon Server. Forcing reads from leader
+     * reduces the staleness of the data read, but also puts extra burden on the leader, reducing overall scalability.
+     * <p>
+     * This property has no effect on connections to AxonServer SE.
+     * </p>
+     */
+    forceReadFromLeader: boolean;
+}
+/** Message containing the information of an Event */
+export interface Event {
+    /** The unique identifier of this event */
+    messageIdentifier: string;
+    /** The identifier of the Aggregate instance that published this event, if any */
+    aggregateIdentifier: string;
+    /** The sequence number of the Event in the Aggregate instance that published it, if any */
+    aggregateSequenceNumber: bigint;
+    /** The Type of the Aggregate instance that published this Event, if any */
+    aggregateType: string;
+    /** The timestamp of the Event */
+    timestamp: bigint;
+    /** The Payload of the Event */
+    payload: SerializedObject | undefined;
+    /** The Meta Data of the Event */
+    metaData: {
+        [key: string]: MetaDataValue;
+    };
+    /** Flag indicating whether the Event is a snapshot Event */
+    snapshot: boolean;
+}
+export interface Event_MetaDataEntry {
+    key: string;
+    value: MetaDataValue | undefined;
+}
+/** Value used in Query Responses to represent a value in its original type */
+export interface QueryValue {
+    /** The text value */
+    textValue?: string | undefined;
+    /** The (64 bits) integer value */
+    numberValue?: bigint | undefined;
+    /** The boolean value */
+    booleanValue?: boolean | undefined;
+    /** The (64 bits) floating point value */
+    doubleValue?: number | undefined;
+}
+/** Description of a Payload Type */
+export interface PayloadDescription {
+    /** The type identifier of the Payload */
+    type: string;
+    /** The revision of the Payload Type */
+    revision: string;
+}
+export declare const CompactionRequest: MessageFns<CompactionRequest>;
+export declare const Transformation: MessageFns<Transformation>;
+export declare const StartTransformationRequest: MessageFns<StartTransformationRequest>;
+export declare const ApplyTransformationRequest: MessageFns<ApplyTransformationRequest>;
+export declare const TransformRequest: MessageFns<TransformRequest>;
+export declare const TransformedEvent: MessageFns<TransformedEvent>;
+export declare const DeletedEvent: MessageFns<DeletedEvent>;
+export declare const TransformationId: MessageFns<TransformationId>;
+export declare const TransformRequestAck: MessageFns<TransformRequestAck>;
+export declare const ScheduleEventRequest: MessageFns<ScheduleEventRequest>;
+export declare const RescheduleEventRequest: MessageFns<RescheduleEventRequest>;
+export declare const CancelScheduledEventRequest: MessageFns<CancelScheduledEventRequest>;
+export declare const ScheduleToken: MessageFns<ScheduleToken>;
+export declare const GetFirstTokenRequest: MessageFns<GetFirstTokenRequest>;
+export declare const GetLastTokenRequest: MessageFns<GetLastTokenRequest>;
+export declare const GetTokenAtRequest: MessageFns<GetTokenAtRequest>;
+export declare const TrackingToken: MessageFns<TrackingToken>;
+export declare const EventWithToken: MessageFns<EventWithToken>;
+export declare const QueryEventsRequest: MessageFns<QueryEventsRequest>;
+export declare const QueryEventsResponse: MessageFns<QueryEventsResponse>;
+export declare const ColumnsResponse: MessageFns<ColumnsResponse>;
+export declare const RowResponse: MessageFns<RowResponse>;
+export declare const RowResponse_ValuesEntry: MessageFns<RowResponse_ValuesEntry>;
+export declare const ReadHighestSequenceNrRequest: MessageFns<ReadHighestSequenceNrRequest>;
+export declare const ReadHighestSequenceNrResponse: MessageFns<ReadHighestSequenceNrResponse>;
+export declare const Confirmation: MessageFns<Confirmation>;
+export declare const ConfirmationWithConsistencyMarker: MessageFns<ConfirmationWithConsistencyMarker>;
+export declare const ConsistencyMarker: MessageFns<ConsistencyMarker>;
+export declare const GetAggregateEventsRequest: MessageFns<GetAggregateEventsRequest>;
+export declare const GetAggregateSnapshotsRequest: MessageFns<GetAggregateSnapshotsRequest>;
+export declare const GetEventsRequest: MessageFns<GetEventsRequest>;
+export declare const Event: MessageFns<Event>;
+export declare const Event_MetaDataEntry: MessageFns<Event_MetaDataEntry>;
+export declare const QueryValue: MessageFns<QueryValue>;
+export declare const PayloadDescription: MessageFns<PayloadDescription>;
+/** Service providing operations against the EventStore functionality of Axon Server */
+export type EventStoreDefinition = typeof EventStoreDefinition;
+export declare const EventStoreDefinition: {
+    readonly name: "EventStore";
+    readonly fullName: "io.axoniq.axonserver.grpc.event.EventStore";
+    readonly methods: {
+        /** Accepts a stream of Events returning a Confirmation when completed. */
+        readonly appendEvent: {
+            readonly name: "AppendEvent";
+            readonly requestType: typeof Event;
+            readonly requestStream: true;
+            readonly responseType: typeof ConfirmationWithConsistencyMarker;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Accepts a Snapshot event returning a Confirmation when completed. */
+        readonly appendSnapshot: {
+            readonly name: "AppendSnapshot";
+            readonly requestType: typeof Event;
+            readonly requestStream: false;
+            readonly responseType: typeof Confirmation;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Retrieves the Events for a given aggregate. Results are streamed rather than returned at once. */
+        readonly listAggregateEvents: {
+            readonly name: "ListAggregateEvents";
+            readonly requestType: typeof GetAggregateEventsRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof Event;
+            readonly responseStream: true;
+            readonly options: {};
+        };
+        /** Retrieves the Snapshots for a given aggregate. Results are streamed rather than returned at once. */
+        readonly listAggregateSnapshots: {
+            readonly name: "ListAggregateSnapshots";
+            readonly requestType: typeof GetAggregateSnapshotsRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof Event;
+            readonly responseStream: true;
+            readonly options: {};
+        };
+        /**
+         * Retrieves the Events from a given tracking token. However, if several GetEventsRequests are sent in the stream
+         * only first one will create the tracker, others are used for increasing number of permits or blacklisting. Results
+         * are streamed rather than returned at once.
+         */
+        readonly listEvents: {
+            readonly name: "ListEvents";
+            readonly requestType: typeof GetEventsRequest;
+            readonly requestStream: true;
+            readonly responseType: typeof EventWithToken;
+            readonly responseStream: true;
+            readonly options: {};
+        };
+        /** Gets the highest sequence number for a specific aggregate. */
+        readonly readHighestSequenceNr: {
+            readonly name: "ReadHighestSequenceNr";
+            readonly requestType: typeof ReadHighestSequenceNrRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof ReadHighestSequenceNrResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /**
+         * Performs a query on the event store, returns a stream of results. Input is a stream to allow flow control from the
+         * client
+         */
+        readonly queryEvents: {
+            readonly name: "QueryEvents";
+            readonly requestType: typeof QueryEventsRequest;
+            readonly requestStream: true;
+            readonly responseType: typeof QueryEventsResponse;
+            readonly responseStream: true;
+            readonly options: {};
+        };
+        /** Retrieves the first token available in event store (typically 0). Returns 0 when no events in store. */
+        readonly getFirstToken: {
+            readonly name: "GetFirstToken";
+            readonly requestType: typeof GetFirstTokenRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof TrackingToken;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Retrieves the last committed token in event store. Returns -1 when no events in store. */
+        readonly getLastToken: {
+            readonly name: "GetLastToken";
+            readonly requestType: typeof GetLastTokenRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof TrackingToken;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Retrieves the token of the first token of an event from specified time in event store. Returns -1 when no events in store. */
+        readonly getTokenAt: {
+            readonly name: "GetTokenAt";
+            readonly requestType: typeof GetTokenAtRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof TrackingToken;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
+export interface EventStoreServiceImplementation<CallContextExt = {}> {
+    /** Accepts a stream of Events returning a Confirmation when completed. */
+    appendEvent(request: AsyncIterable<Event>, context: CallContext & CallContextExt): Promise<DeepPartial<ConfirmationWithConsistencyMarker>>;
+    /** Accepts a Snapshot event returning a Confirmation when completed. */
+    appendSnapshot(request: Event, context: CallContext & CallContextExt): Promise<DeepPartial<Confirmation>>;
+    /** Retrieves the Events for a given aggregate. Results are streamed rather than returned at once. */
+    listAggregateEvents(request: GetAggregateEventsRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<Event>>;
+    /** Retrieves the Snapshots for a given aggregate. Results are streamed rather than returned at once. */
+    listAggregateSnapshots(request: GetAggregateSnapshotsRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<Event>>;
+    /**
+     * Retrieves the Events from a given tracking token. However, if several GetEventsRequests are sent in the stream
+     * only first one will create the tracker, others are used for increasing number of permits or blacklisting. Results
+     * are streamed rather than returned at once.
+     */
+    listEvents(request: AsyncIterable<GetEventsRequest>, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<EventWithToken>>;
+    /** Gets the highest sequence number for a specific aggregate. */
+    readHighestSequenceNr(request: ReadHighestSequenceNrRequest, context: CallContext & CallContextExt): Promise<DeepPartial<ReadHighestSequenceNrResponse>>;
+    /**
+     * Performs a query on the event store, returns a stream of results. Input is a stream to allow flow control from the
+     * client
+     */
+    queryEvents(request: AsyncIterable<QueryEventsRequest>, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<QueryEventsResponse>>;
+    /** Retrieves the first token available in event store (typically 0). Returns 0 when no events in store. */
+    getFirstToken(request: GetFirstTokenRequest, context: CallContext & CallContextExt): Promise<DeepPartial<TrackingToken>>;
+    /** Retrieves the last committed token in event store. Returns -1 when no events in store. */
+    getLastToken(request: GetLastTokenRequest, context: CallContext & CallContextExt): Promise<DeepPartial<TrackingToken>>;
+    /** Retrieves the token of the first token of an event from specified time in event store. Returns -1 when no events in store. */
+    getTokenAt(request: GetTokenAtRequest, context: CallContext & CallContextExt): Promise<DeepPartial<TrackingToken>>;
+}
+export interface EventStoreClient<CallOptionsExt = {}> {
+    /** Accepts a stream of Events returning a Confirmation when completed. */
+    appendEvent(request: AsyncIterable<DeepPartial<Event>>, options?: CallOptions & CallOptionsExt): Promise<ConfirmationWithConsistencyMarker>;
+    /** Accepts a Snapshot event returning a Confirmation when completed. */
+    appendSnapshot(request: DeepPartial<Event>, options?: CallOptions & CallOptionsExt): Promise<Confirmation>;
+    /** Retrieves the Events for a given aggregate. Results are streamed rather than returned at once. */
+    listAggregateEvents(request: DeepPartial<GetAggregateEventsRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<Event>;
+    /** Retrieves the Snapshots for a given aggregate. Results are streamed rather than returned at once. */
+    listAggregateSnapshots(request: DeepPartial<GetAggregateSnapshotsRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<Event>;
+    /**
+     * Retrieves the Events from a given tracking token. However, if several GetEventsRequests are sent in the stream
+     * only first one will create the tracker, others are used for increasing number of permits or blacklisting. Results
+     * are streamed rather than returned at once.
+     */
+    listEvents(request: AsyncIterable<DeepPartial<GetEventsRequest>>, options?: CallOptions & CallOptionsExt): AsyncIterable<EventWithToken>;
+    /** Gets the highest sequence number for a specific aggregate. */
+    readHighestSequenceNr(request: DeepPartial<ReadHighestSequenceNrRequest>, options?: CallOptions & CallOptionsExt): Promise<ReadHighestSequenceNrResponse>;
+    /**
+     * Performs a query on the event store, returns a stream of results. Input is a stream to allow flow control from the
+     * client
+     */
+    queryEvents(request: AsyncIterable<DeepPartial<QueryEventsRequest>>, options?: CallOptions & CallOptionsExt): AsyncIterable<QueryEventsResponse>;
+    /** Retrieves the first token available in event store (typically 0). Returns 0 when no events in store. */
+    getFirstToken(request: DeepPartial<GetFirstTokenRequest>, options?: CallOptions & CallOptionsExt): Promise<TrackingToken>;
+    /** Retrieves the last committed token in event store. Returns -1 when no events in store. */
+    getLastToken(request: DeepPartial<GetLastTokenRequest>, options?: CallOptions & CallOptionsExt): Promise<TrackingToken>;
+    /** Retrieves the token of the first token of an event from specified time in event store. Returns -1 when no events in store. */
+    getTokenAt(request: DeepPartial<GetTokenAtRequest>, options?: CallOptions & CallOptionsExt): Promise<TrackingToken>;
+}
+/** Service to use AxonServer as a provider of an EventScheduler */
+export type EventSchedulerDefinition = typeof EventSchedulerDefinition;
+export declare const EventSchedulerDefinition: {
+    readonly name: "EventScheduler";
+    readonly fullName: "io.axoniq.axonserver.grpc.event.EventScheduler";
+    readonly methods: {
+        /** Schedule the given event for publication at the given time}. The returned ScheduleToken can be used to cancel the planned publication. */
+        readonly scheduleEvent: {
+            readonly name: "ScheduleEvent";
+            readonly requestType: typeof ScheduleEventRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof ScheduleToken;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Cancel a scheduled event and schedule another in its place. */
+        readonly rescheduleEvent: {
+            readonly name: "RescheduleEvent";
+            readonly requestType: typeof RescheduleEventRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof ScheduleToken;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Cancel the publication of a scheduled event. If the events has already been published, this method does nothing. */
+        readonly cancelScheduledEvent: {
+            readonly name: "CancelScheduledEvent";
+            readonly requestType: typeof CancelScheduledEventRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof InstructionAck;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
+export interface EventSchedulerServiceImplementation<CallContextExt = {}> {
+    /** Schedule the given event for publication at the given time}. The returned ScheduleToken can be used to cancel the planned publication. */
+    scheduleEvent(request: ScheduleEventRequest, context: CallContext & CallContextExt): Promise<DeepPartial<ScheduleToken>>;
+    /** Cancel a scheduled event and schedule another in its place. */
+    rescheduleEvent(request: RescheduleEventRequest, context: CallContext & CallContextExt): Promise<DeepPartial<ScheduleToken>>;
+    /** Cancel the publication of a scheduled event. If the events has already been published, this method does nothing. */
+    cancelScheduledEvent(request: CancelScheduledEventRequest, context: CallContext & CallContextExt): Promise<DeepPartial<InstructionAck>>;
+}
+export interface EventSchedulerClient<CallOptionsExt = {}> {
+    /** Schedule the given event for publication at the given time}. The returned ScheduleToken can be used to cancel the planned publication. */
+    scheduleEvent(request: DeepPartial<ScheduleEventRequest>, options?: CallOptions & CallOptionsExt): Promise<ScheduleToken>;
+    /** Cancel a scheduled event and schedule another in its place. */
+    rescheduleEvent(request: DeepPartial<RescheduleEventRequest>, options?: CallOptions & CallOptionsExt): Promise<ScheduleToken>;
+    /** Cancel the publication of a scheduled event. If the events has already been published, this method does nothing. */
+    cancelScheduledEvent(request: DeepPartial<CancelScheduledEventRequest>, options?: CallOptions & CallOptionsExt): Promise<InstructionAck>;
+}
+/** Service to transform events in an event store */
+export type EventTransformationServiceDefinition = typeof EventTransformationServiceDefinition;
+export declare const EventTransformationServiceDefinition: {
+    readonly name: "EventTransformationService";
+    readonly fullName: "io.axoniq.axonserver.grpc.event.EventTransformationService";
+    readonly methods: {
+        /** Returns the list of all transformations. */
+        readonly transformations: {
+            readonly name: "Transformations";
+            readonly requestType: typeof Empty;
+            readonly requestStream: false;
+            readonly responseType: typeof Transformation;
+            readonly responseStream: true;
+            readonly options: {};
+        };
+        /** Starts a new transformation. */
+        readonly startTransformation: {
+            readonly name: "StartTransformation";
+            readonly requestType: typeof StartTransformationRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof TransformationId;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Adds requests to transform an event to a transformation. */
+        readonly transformEvents: {
+            readonly name: "TransformEvents";
+            readonly requestType: typeof TransformRequest;
+            readonly requestStream: true;
+            readonly responseType: typeof TransformRequestAck;
+            readonly responseStream: true;
+            readonly options: {};
+        };
+        /** Cancels a transformation before it is applied. */
+        readonly cancelTransformation: {
+            readonly name: "CancelTransformation";
+            readonly requestType: typeof TransformationId;
+            readonly requestStream: false;
+            readonly responseType: typeof Empty;
+            readonly responseStream: true;
+            readonly options: {};
+        };
+        /** Applies the changes from a transformation in the event store. */
+        readonly applyTransformation: {
+            readonly name: "ApplyTransformation";
+            readonly requestType: typeof ApplyTransformationRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof Empty;
+            readonly responseStream: true;
+            readonly options: {};
+        };
+        /** Deletes old versions of events updated by a transformation. */
+        readonly compact: {
+            readonly name: "Compact";
+            readonly requestType: typeof CompactionRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof Empty;
+            readonly responseStream: true;
+            readonly options: {};
+        };
+    };
+};
+export interface EventTransformationServiceImplementation<CallContextExt = {}> {
+    /** Returns the list of all transformations. */
+    transformations(request: Empty, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<Transformation>>;
+    /** Starts a new transformation. */
+    startTransformation(request: StartTransformationRequest, context: CallContext & CallContextExt): Promise<DeepPartial<TransformationId>>;
+    /** Adds requests to transform an event to a transformation. */
+    transformEvents(request: AsyncIterable<TransformRequest>, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<TransformRequestAck>>;
+    /** Cancels a transformation before it is applied. */
+    cancelTransformation(request: TransformationId, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<Empty>>;
+    /** Applies the changes from a transformation in the event store. */
+    applyTransformation(request: ApplyTransformationRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<Empty>>;
+    /** Deletes old versions of events updated by a transformation. */
+    compact(request: CompactionRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<Empty>>;
+}
+export interface EventTransformationServiceClient<CallOptionsExt = {}> {
+    /** Returns the list of all transformations. */
+    transformations(request: DeepPartial<Empty>, options?: CallOptions & CallOptionsExt): AsyncIterable<Transformation>;
+    /** Starts a new transformation. */
+    startTransformation(request: DeepPartial<StartTransformationRequest>, options?: CallOptions & CallOptionsExt): Promise<TransformationId>;
+    /** Adds requests to transform an event to a transformation. */
+    transformEvents(request: AsyncIterable<DeepPartial<TransformRequest>>, options?: CallOptions & CallOptionsExt): AsyncIterable<TransformRequestAck>;
+    /** Cancels a transformation before it is applied. */
+    cancelTransformation(request: DeepPartial<TransformationId>, options?: CallOptions & CallOptionsExt): AsyncIterable<Empty>;
+    /** Applies the changes from a transformation in the event store. */
+    applyTransformation(request: DeepPartial<ApplyTransformationRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<Empty>;
+    /** Deletes old versions of events updated by a transformation. */
+    compact(request: DeepPartial<CompactionRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<Empty>;
+}
+type Builtin = Date | Function | Uint8Array | string | number | boolean | bigint | undefined;
+export type DeepPartial<T> = 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=event.d.ts.map