@kronos-ts/axon-server 0.1.0

package/dist/generated/dcb.d.ts

@@ -0,0 +1,650 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import type { CallContext, CallOptions } from "nice-grpc-common";
+import { InstructionAck } from "./common.js";
+export declare const protobufPackage = "io.axoniq.axonserver.grpc.event.dcb";
+/** 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 {
+    /** schedule token of the event to reschedule */
+    token: string;
+    /** timestamp when to publish the event */
+    instant: bigint;
+    /** optionally provide a new 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;
+}
+/** The event message. */
+export interface Event {
+    /** The unique identifier of the event. */
+    identifier: string;
+    /** The timestamp of the event. */
+    timestamp: bigint;
+    /** The name of the event. */
+    name: string;
+    /** The version of the event. */
+    version: string;
+    /** The payload of the event. */
+    payload: Uint8Array;
+    /** The metadata of the event. */
+    metadata: {
+        [key: string]: string;
+    };
+}
+export interface Event_MetadataEntry {
+    key: string;
+    value: string;
+}
+/** The tag. Describes an event with more details. Usually using concepts from the Domain. */
+export interface Tag {
+    /** The key of the tag. */
+    key: Uint8Array;
+    /** The value of the tag. */
+    value: Uint8Array;
+}
+/** The event described in more details by a list of tags. */
+export interface TaggedEvent {
+    /** The event. */
+    event: Event | undefined;
+    /** List of tags describing the given event in more details. */
+    tag: Tag[];
+}
+/** The event retrieved from the event store with its corresponding sequence. */
+export interface SequencedEvent {
+    /** The sequence of the event. */
+    sequence: bigint;
+    /** The event. */
+    event: Event | undefined;
+}
+/** The message representing the request to append events to the event store. */
+export interface AppendEventsRequest {
+    /** The condition used to check the validity of this request. If omitted, events will be appended unconditionally. */
+    condition: ConsistencyCondition | undefined;
+    /**
+     * A list of tagged events to be appended to the event store if the condition is met.
+     * These events are considered as a transaction - they are either all appended or none of them are appended.
+     * The event store will index the events based on provided tags for future faster retrieval.
+     */
+    event: TaggedEvent[];
+}
+/**
+ * The response of a successful append events request. If there was an issue with the append events request,
+ * the stream will complete with an error.
+ */
+export interface AppendEventsResponse {
+    /**
+     * The sequence of the first event stored in the event store.
+     * Corresponding to the list of events (a transaction) passed in the AppendEventsRequest.
+     */
+    sequenceOfTheFirstEvent: bigint;
+    /** The number of events appended. Matches the number of events passed in the AppendEventsRequest. */
+    transactionSize: number;
+    /**
+     * The consistency marker which may be used for a subsequent append events requests. Do note that during the time this
+     * consistency marker may get far behind the head of the event store which will increase the time needed for the append
+     * events request to be validated. If you don't plan to do subsequent append events requests in a "short" period of time,
+     * use the Source RPC to refresh the consistency marker.
+     */
+    consistencyMarker: bigint;
+}
+/**
+ * The request to source events from the event store. It results in a finite stream of events completed by
+ * the event store. It may also be cancelled by the client. Only events matching the given criteria
+ * (a provided list of criterions) will be present in the stream. The stream is capped by the HEAD of the event store.
+ */
+export interface SourceEventsRequest {
+    /** An inclusive sequence of the first event to be included in the resulting stream. */
+    fromSequence: bigint;
+    /**
+     * The criteria consisting of the list of criterions. If at least one of these criterions is met,
+     * the criteria is met.
+     */
+    criterion: Criterion[];
+}
+/**
+ * The response to the SourceEventsRequest. It consists either of an event (with its corresponding sequence) or a
+ * consistency marker. The consistency marker should be used in a following AppendEventsRequest related to the criteria used in the SourceEventsRequest this response originates from.
+ */
+export interface SourceEventsResponse {
+    /** The event matching the criteria with its corresponding sequence. */
+    event?: SequencedEvent | undefined;
+    /** The consistency marker to be used for the following append related to the same criteria. */
+    consistencyMarker?: bigint | undefined;
+}
+/**
+ * The condition for an AppendEventsRequest. Consists of the consistency marker and the criteria
+ * (a list of criterions).
+ */
+export interface ConsistencyCondition {
+    /**
+     * The sequence used to start checking for the consistency of an append. If there are events with a sequence greater
+     * or equal than the consistency marker and those are matching the given criteria, the condition is not met and the transaction
+     * is rejected. Otherwise, it is accepted.
+     */
+    consistencyMarker: bigint;
+    /** The criteria. Consists of a list of criterions. If a single criterion is met, the whole criteria is met. */
+    criterion: Criterion[];
+}
+/** The integral part of the criteria. */
+export interface Criterion {
+    /** The criterion based on event tags and event names. */
+    tagsAndNames: TagsAndNamesCriterion | undefined;
+}
+/**
+ * The criterion based on event tags and event names. The event meets this criterion if ALL tags from this criterion
+ * are present in the tags of the event AND if the event name is present in one of the names of the this criterion.
+ */
+export interface TagsAndNamesCriterion {
+    /** A list of event names. The event meets this criterion if its name is in one of the names in this list. */
+    name: string[];
+    /**
+     * A list of event tags. The event meets this criterion if it contains all the tags from this list. It meets the
+     * criterion if it contains more than provided list here, but it MUST contain all from the list.
+     */
+    tag: Tag[];
+}
+/**
+ * The request to provide an infinite stream of events from the event store. The client may cancel the stream at any
+ * time.
+ */
+export interface StreamEventsRequest {
+    /** The inclusive sequence to start streaming from. */
+    fromSequence: bigint;
+    /**
+     * The criteria used to filter out events. Represented by a list of criterions. If at least one is met, the whole
+     * criteria is met.
+     */
+    criterion: Criterion[];
+}
+/** The response to the StreamEventsRequest. */
+export interface StreamEventsResponse {
+    /** The event with its corresponding sequence. */
+    event: SequencedEvent | undefined;
+}
+/** The request to retrieve the current HEAD of the event store. */
+export interface GetHeadRequest {
+}
+/** The current HEAD of the event store. */
+export interface GetHeadResponse {
+    /**
+     * The sequence of the current head. Points to the position of the first event to be appended. The HEAD of an empty
+     * event store is 0.
+     */
+    sequence: bigint;
+}
+/** The request to retrieve the current TAIL of the event store. */
+export interface GetTailRequest {
+}
+/** The current TAIL of the event store. */
+export interface GetTailResponse {
+    /**
+     * The sequence of the first event in the event store. 0 for an empty event store. 0 for a non-truncated event store.
+     * Non-zero for a truncated event store.
+     */
+    sequence: bigint;
+}
+/**
+ * The request to get the sequence of the event whose timestamp is the same as the timestamp provided in the request.
+ * If there are no events with the exact timestamp, then the sequence of the first one after the provided timestamp is
+ * returned. If the provided timestamp is greater that the sequence of the last event in the event store,
+ * the HEAD is returned.
+ */
+export interface GetSequenceAtRequest {
+    /** The timestamp. */
+    timestamp: bigint;
+}
+/** The sequence of the event approximately close to the provided timestamp. */
+export interface GetSequenceAtResponse {
+    /** The sequence of the event. */
+    sequence: bigint;
+}
+/** The request to add tags to the event. */
+export interface AddTagsRequest {
+    /** The sequence of the event whose tags list will be expanded with the tags from the request. */
+    sequence: bigint;
+    /**
+     * The tags to be added to the event. If the event already contains a tag from the same list
+     * (with the same key and the value) the new one will be ignored.
+     */
+    tag: Tag[];
+}
+/** The response indicating a successful addition of tags to the event. */
+export interface AddTagsResponse {
+}
+/** The request to remove tags from the event. */
+export interface RemoveTagsRequest {
+    /** The sequence of the event whose tags should be removed. */
+    sequence: bigint;
+    /** Tags to be removed. If the event is not tagged with listed tags, they are skipped. */
+    tag: Tag[];
+}
+/** The response indicating a successful removal of tags for the event. */
+export interface RemoveTagsResponse {
+}
+/** The request to retrieve tags of the event. */
+export interface GetTagsRequest {
+    /** The sequence of the event whose tags should be retrieved. */
+    sequence: bigint;
+}
+/** The response containing tags of an event. */
+export interface GetTagsResponse {
+    /** The tags associated to the event. */
+    tag: Tag[];
+}
+/** The snapshot. */
+export interface Snapshot {
+    /** The name of the snapshot. */
+    name: string;
+    /** The version of the snapshot. */
+    version: string;
+    /** The payload of the snapshot. */
+    payload: Uint8Array;
+    /** The timestamp of the snapshot. */
+    timestamp: bigint;
+    /** The metadata of the snapshot. */
+    metadata: {
+        [key: string]: string;
+    };
+}
+export interface Snapshot_MetadataEntry {
+    key: string;
+    value: string;
+}
+/** The request to add the snapshot to the snapshot store. */
+export interface AddSnapshotRequest {
+    /** The key this snapshot is added to. */
+    key: Uint8Array;
+    /**
+     * The sequence of the snapshot. Usually linked to the sequence of the event in the event store up to which
+     * the snapshot is taken.
+     */
+    sequence: bigint;
+    /** If set to true, older snapshots for the same key are pruned. */
+    prune: boolean;
+    /** The snapshot. */
+    snapshot: Snapshot | undefined;
+}
+/** The response indicating the successful addition of the snapshot. */
+export interface AddSnapshotResponse {
+}
+/**
+ * The request to delete the snapshot from the snapshot store.
+ * Deletes from a sequence of `0` to the specified `to_sequence`
+ */
+export interface DeleteSnapshotsRequest {
+    /** The key the snapshot is identified by. */
+    key: Uint8Array;
+    /** The exclusive upper bound sequence of the snapshot to end the deletion. */
+    toSequence: bigint;
+}
+/** The response indicating the successful deletion of the snapshot. */
+export interface DeleteSnapshotsResponse {
+}
+/** The request to retrieve all snapshots from the snapshot store based on the key and sequence bounds. */
+export interface ListSnapshotsRequest {
+    /** The key of the snapshot. */
+    key: Uint8Array;
+    /** The inclusive bottom bound sequence used to filter out snapshots. */
+    fromSequence: bigint;
+    /** The exclusive upper bound sequence used to filter out snapshots. */
+    toSequence: bigint;
+}
+/** The response to the ListSnapshotRequest. */
+export interface ListSnapshotsResponse {
+    /** The key of the snapshot. */
+    key: Uint8Array;
+    /** The sequence of the snapshot. */
+    sequence: bigint;
+    /** The snapshot. */
+    snapshot: Snapshot | undefined;
+}
+/** The request to retrieve the snapshot with the highest sequence from the snapshot store. */
+export interface GetLastSnapshotRequest {
+    /** The key of the snapshot. */
+    key: Uint8Array;
+}
+/** The response to GetLatestSnapshotRequest. */
+export interface GetLastSnapshotResponse {
+    /** The key of the snapshot. */
+    key: Uint8Array;
+    /** The sequence of the snapshot. */
+    sequence: bigint;
+    /** The snapshot. */
+    snapshot: Snapshot | undefined;
+}
+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 Event: MessageFns<Event>;
+export declare const Event_MetadataEntry: MessageFns<Event_MetadataEntry>;
+export declare const Tag: MessageFns<Tag>;
+export declare const TaggedEvent: MessageFns<TaggedEvent>;
+export declare const SequencedEvent: MessageFns<SequencedEvent>;
+export declare const AppendEventsRequest: MessageFns<AppendEventsRequest>;
+export declare const AppendEventsResponse: MessageFns<AppendEventsResponse>;
+export declare const SourceEventsRequest: MessageFns<SourceEventsRequest>;
+export declare const SourceEventsResponse: MessageFns<SourceEventsResponse>;
+export declare const ConsistencyCondition: MessageFns<ConsistencyCondition>;
+export declare const Criterion: MessageFns<Criterion>;
+export declare const TagsAndNamesCriterion: MessageFns<TagsAndNamesCriterion>;
+export declare const StreamEventsRequest: MessageFns<StreamEventsRequest>;
+export declare const StreamEventsResponse: MessageFns<StreamEventsResponse>;
+export declare const GetHeadRequest: MessageFns<GetHeadRequest>;
+export declare const GetHeadResponse: MessageFns<GetHeadResponse>;
+export declare const GetTailRequest: MessageFns<GetTailRequest>;
+export declare const GetTailResponse: MessageFns<GetTailResponse>;
+export declare const GetSequenceAtRequest: MessageFns<GetSequenceAtRequest>;
+export declare const GetSequenceAtResponse: MessageFns<GetSequenceAtResponse>;
+export declare const AddTagsRequest: MessageFns<AddTagsRequest>;
+export declare const AddTagsResponse: MessageFns<AddTagsResponse>;
+export declare const RemoveTagsRequest: MessageFns<RemoveTagsRequest>;
+export declare const RemoveTagsResponse: MessageFns<RemoveTagsResponse>;
+export declare const GetTagsRequest: MessageFns<GetTagsRequest>;
+export declare const GetTagsResponse: MessageFns<GetTagsResponse>;
+export declare const Snapshot: MessageFns<Snapshot>;
+export declare const Snapshot_MetadataEntry: MessageFns<Snapshot_MetadataEntry>;
+export declare const AddSnapshotRequest: MessageFns<AddSnapshotRequest>;
+export declare const AddSnapshotResponse: MessageFns<AddSnapshotResponse>;
+export declare const DeleteSnapshotsRequest: MessageFns<DeleteSnapshotsRequest>;
+export declare const DeleteSnapshotsResponse: MessageFns<DeleteSnapshotsResponse>;
+export declare const ListSnapshotsRequest: MessageFns<ListSnapshotsRequest>;
+export declare const ListSnapshotsResponse: MessageFns<ListSnapshotsResponse>;
+export declare const GetLastSnapshotRequest: MessageFns<GetLastSnapshotRequest>;
+export declare const GetLastSnapshotResponse: MessageFns<GetLastSnapshotResponse>;
+/** Service providing Event Store RPCs supporting DCB. */
+export type DcbEventStoreDefinition = typeof DcbEventStoreDefinition;
+export declare const DcbEventStoreDefinition: {
+    readonly name: "DcbEventStore";
+    readonly fullName: "io.axoniq.axonserver.grpc.event.dcb.DcbEventStore";
+    readonly methods: {
+        /** Appends new events to the store. */
+        readonly append: {
+            readonly name: "Append";
+            readonly requestType: typeof AppendEventsRequest;
+            readonly requestStream: true;
+            readonly responseType: typeof AppendEventsResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Provides a finite stream of events based on the passed SourceEventsRequest. */
+        readonly source: {
+            readonly name: "Source";
+            readonly requestType: typeof SourceEventsRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof SourceEventsResponse;
+            readonly responseStream: true;
+            readonly options: {};
+        };
+        /** Provides an infinite stream of events based on the passed StreamEventsRequest. */
+        readonly stream: {
+            readonly name: "Stream";
+            readonly requestType: typeof StreamEventsRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof StreamEventsResponse;
+            readonly responseStream: true;
+            readonly options: {};
+        };
+        /** Gets the current _head_ of the Event Store. The _head_ points to the sequence of the first event to be appended. */
+        readonly getHead: {
+            readonly name: "GetHead";
+            readonly requestType: typeof GetHeadRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof GetHeadResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Gets the current _tail_ of the Event Store. The _tail_ points to the sequence of the first event stored. */
+        readonly getTail: {
+            readonly name: "GetTail";
+            readonly requestType: typeof GetTailRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof GetTailResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /**
+         * Returns the lowest sequence of an event with a timestamp equal to or higher than the given timestamp. The HEAD is
+         * returned if no events exist with a timestamp equal to or higher than the given timestamp.
+         *
+         * N.B. Axon Server does not assign timestamps to events. The timestamps used for fulfilling this RPC are timestamps
+         * provided by the client. It could happen that there are events after the returned sequence that have an earlier
+         * timestamp. Axon Server does not reject appends if timestamps of events are not monotonically increasing.
+         */
+        readonly getSequenceAt: {
+            readonly name: "GetSequenceAt";
+            readonly requestType: typeof GetSequenceAtRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof GetSequenceAtResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Assigns tags to the event identified by its sequence. */
+        readonly addTags: {
+            readonly name: "AddTags";
+            readonly requestType: typeof AddTagsRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof AddTagsResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Removes tags from the event identified by its sequence. */
+        readonly removeTags: {
+            readonly name: "RemoveTags";
+            readonly requestType: typeof RemoveTagsRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof RemoveTagsResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Gets tags for the event identified by its sequence. */
+        readonly getTags: {
+            readonly name: "GetTags";
+            readonly requestType: typeof GetTagsRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof GetTagsResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
+export interface DcbEventStoreServiceImplementation<CallContextExt = {}> {
+    /** Appends new events to the store. */
+    append(request: AsyncIterable<AppendEventsRequest>, context: CallContext & CallContextExt): Promise<DeepPartial<AppendEventsResponse>>;
+    /** Provides a finite stream of events based on the passed SourceEventsRequest. */
+    source(request: SourceEventsRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<SourceEventsResponse>>;
+    /** Provides an infinite stream of events based on the passed StreamEventsRequest. */
+    stream(request: StreamEventsRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<StreamEventsResponse>>;
+    /** Gets the current _head_ of the Event Store. The _head_ points to the sequence of the first event to be appended. */
+    getHead(request: GetHeadRequest, context: CallContext & CallContextExt): Promise<DeepPartial<GetHeadResponse>>;
+    /** Gets the current _tail_ of the Event Store. The _tail_ points to the sequence of the first event stored. */
+    getTail(request: GetTailRequest, context: CallContext & CallContextExt): Promise<DeepPartial<GetTailResponse>>;
+    /**
+     * Returns the lowest sequence of an event with a timestamp equal to or higher than the given timestamp. The HEAD is
+     * returned if no events exist with a timestamp equal to or higher than the given timestamp.
+     *
+     * N.B. Axon Server does not assign timestamps to events. The timestamps used for fulfilling this RPC are timestamps
+     * provided by the client. It could happen that there are events after the returned sequence that have an earlier
+     * timestamp. Axon Server does not reject appends if timestamps of events are not monotonically increasing.
+     */
+    getSequenceAt(request: GetSequenceAtRequest, context: CallContext & CallContextExt): Promise<DeepPartial<GetSequenceAtResponse>>;
+    /** Assigns tags to the event identified by its sequence. */
+    addTags(request: AddTagsRequest, context: CallContext & CallContextExt): Promise<DeepPartial<AddTagsResponse>>;
+    /** Removes tags from the event identified by its sequence. */
+    removeTags(request: RemoveTagsRequest, context: CallContext & CallContextExt): Promise<DeepPartial<RemoveTagsResponse>>;
+    /** Gets tags for the event identified by its sequence. */
+    getTags(request: GetTagsRequest, context: CallContext & CallContextExt): Promise<DeepPartial<GetTagsResponse>>;
+}
+export interface DcbEventStoreClient<CallOptionsExt = {}> {
+    /** Appends new events to the store. */
+    append(request: AsyncIterable<DeepPartial<AppendEventsRequest>>, options?: CallOptions & CallOptionsExt): Promise<AppendEventsResponse>;
+    /** Provides a finite stream of events based on the passed SourceEventsRequest. */
+    source(request: DeepPartial<SourceEventsRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<SourceEventsResponse>;
+    /** Provides an infinite stream of events based on the passed StreamEventsRequest. */
+    stream(request: DeepPartial<StreamEventsRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<StreamEventsResponse>;
+    /** Gets the current _head_ of the Event Store. The _head_ points to the sequence of the first event to be appended. */
+    getHead(request: DeepPartial<GetHeadRequest>, options?: CallOptions & CallOptionsExt): Promise<GetHeadResponse>;
+    /** Gets the current _tail_ of the Event Store. The _tail_ points to the sequence of the first event stored. */
+    getTail(request: DeepPartial<GetTailRequest>, options?: CallOptions & CallOptionsExt): Promise<GetTailResponse>;
+    /**
+     * Returns the lowest sequence of an event with a timestamp equal to or higher than the given timestamp. The HEAD is
+     * returned if no events exist with a timestamp equal to or higher than the given timestamp.
+     *
+     * N.B. Axon Server does not assign timestamps to events. The timestamps used for fulfilling this RPC are timestamps
+     * provided by the client. It could happen that there are events after the returned sequence that have an earlier
+     * timestamp. Axon Server does not reject appends if timestamps of events are not monotonically increasing.
+     */
+    getSequenceAt(request: DeepPartial<GetSequenceAtRequest>, options?: CallOptions & CallOptionsExt): Promise<GetSequenceAtResponse>;
+    /** Assigns tags to the event identified by its sequence. */
+    addTags(request: DeepPartial<AddTagsRequest>, options?: CallOptions & CallOptionsExt): Promise<AddTagsResponse>;
+    /** Removes tags from the event identified by its sequence. */
+    removeTags(request: DeepPartial<RemoveTagsRequest>, options?: CallOptions & CallOptionsExt): Promise<RemoveTagsResponse>;
+    /** Gets tags for the event identified by its sequence. */
+    getTags(request: DeepPartial<GetTagsRequest>, options?: CallOptions & CallOptionsExt): Promise<GetTagsResponse>;
+}
+/** Service providing Snapshot Store RPCs. */
+export type DcbSnapshotStoreDefinition = typeof DcbSnapshotStoreDefinition;
+export declare const DcbSnapshotStoreDefinition: {
+    readonly name: "DcbSnapshotStore";
+    readonly fullName: "io.axoniq.axonserver.grpc.event.dcb.DcbSnapshotStore";
+    readonly methods: {
+        /** Adds a snapshot to the snapshot store. */
+        readonly add: {
+            readonly name: "Add";
+            readonly requestType: typeof AddSnapshotRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof AddSnapshotResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Deletes a snapshot from the snapshot store. */
+        readonly delete: {
+            readonly name: "Delete";
+            readonly requestType: typeof DeleteSnapshotsRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof DeleteSnapshotsResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Retrieves snapshots from the snapshot store. */
+        readonly list: {
+            readonly name: "List";
+            readonly requestType: typeof ListSnapshotsRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof ListSnapshotsResponse;
+            readonly responseStream: true;
+            readonly options: {};
+        };
+        /** Gets the latest snapshot based on the request from the snapshot store. */
+        readonly getLast: {
+            readonly name: "GetLast";
+            readonly requestType: typeof GetLastSnapshotRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof GetLastSnapshotResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
+export interface DcbSnapshotStoreServiceImplementation<CallContextExt = {}> {
+    /** Adds a snapshot to the snapshot store. */
+    add(request: AddSnapshotRequest, context: CallContext & CallContextExt): Promise<DeepPartial<AddSnapshotResponse>>;
+    /** Deletes a snapshot from the snapshot store. */
+    delete(request: DeleteSnapshotsRequest, context: CallContext & CallContextExt): Promise<DeepPartial<DeleteSnapshotsResponse>>;
+    /** Retrieves snapshots from the snapshot store. */
+    list(request: ListSnapshotsRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<ListSnapshotsResponse>>;
+    /** Gets the latest snapshot based on the request from the snapshot store. */
+    getLast(request: GetLastSnapshotRequest, context: CallContext & CallContextExt): Promise<DeepPartial<GetLastSnapshotResponse>>;
+}
+export interface DcbSnapshotStoreClient<CallOptionsExt = {}> {
+    /** Adds a snapshot to the snapshot store. */
+    add(request: DeepPartial<AddSnapshotRequest>, options?: CallOptions & CallOptionsExt): Promise<AddSnapshotResponse>;
+    /** Deletes a snapshot from the snapshot store. */
+    delete(request: DeepPartial<DeleteSnapshotsRequest>, options?: CallOptions & CallOptionsExt): Promise<DeleteSnapshotsResponse>;
+    /** Retrieves snapshots from the snapshot store. */
+    list(request: DeepPartial<ListSnapshotsRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<ListSnapshotsResponse>;
+    /** Gets the latest snapshot based on the request from the snapshot store. */
+    getLast(request: DeepPartial<GetLastSnapshotRequest>, options?: CallOptions & CallOptionsExt): Promise<GetLastSnapshotResponse>;
+}
+/** Service to use AxonServer as a provider of an EventScheduler */
+export type DcbEventSchedulerDefinition = typeof DcbEventSchedulerDefinition;
+export declare const DcbEventSchedulerDefinition: {
+    readonly name: "DcbEventScheduler";
+    readonly fullName: "io.axoniq.axonserver.grpc.event.dcb.DcbEventScheduler";
+    readonly methods: {
+        /** Schedule the given event for publication at the given time}. The returned ScheduleToken can be used to reschedule or 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: {};
+        };
+        /** Reschedule a scheduled event and optionally replace it by a new event. */
+        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 DcbEventSchedulerServiceImplementation<CallContextExt = {}> {
+    /** Schedule the given event for publication at the given time}. The returned ScheduleToken can be used to reschedule or cancel the planned publication. */
+    scheduleEvent(request: ScheduleEventRequest, context: CallContext & CallContextExt): Promise<DeepPartial<ScheduleToken>>;
+    /** Reschedule a scheduled event and optionally replace it by a new event. */
+    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 DcbEventSchedulerClient<CallOptionsExt = {}> {
+    /** Schedule the given event for publication at the given time}. The returned ScheduleToken can be used to reschedule or cancel the planned publication. */
+    scheduleEvent(request: DeepPartial<ScheduleEventRequest>, options?: CallOptions & CallOptionsExt): Promise<ScheduleToken>;
+    /** Reschedule a scheduled event and optionally replace it by a new event. */
+    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>;
+}
+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=dcb.d.ts.map