Represents a connection to a single EventStore node.

Gathers every connection type handled by the client.

Holds login and password information.

Global Connection settings

Represents reconnection strategy.

Indicates how many times we should try to reconnect to the server. A value less than or equal to 0 means no retry.

Indicates we should try to reconnect to the server until the end of the Universe.

Creates a Credentials given a login and a password.

Default global settings.

• s_heartbeatInterval = 750 ms
• s_heartbeatTimeout = 1500 ms
• s_requireMaster = True
• s_retry = atMost 3
• s_reconnect_delay = 3 seconds
• s_ssl = Nothing
• s_loggerType = LogNone
• s_loggerFilter = LoggerLevel LevelInfo
• s_loggerDetailed = False
• s_operationTimeout = 10 seconds
• s_operationRetry = atMost 3
• s_monitoring = Nothing
• s_defaultConnectionName = Nothing
• s_defaultUserCredentials = Nothing

Default SSL settings based on defaultSettings.

Creates a new Connection to a single node. It maintains a full duplex connection to the EventStore. An EventStore Connection operates quite differently than say a SQL connection. Normally when you use an EventStore connection you want to keep the connection open for a much longer of time than when you use a SQL connection.

Another difference is that with the EventStore Connection all operations are handled in a full async manner (even if you call the synchronous behaviors). Many threads can use an EvenStore Connection at the same time or a single thread can make many asynchronous requests. To get the most performance out of the connection it is generally recommended to use it in this way.

Asynchronously closes the Connection.

Waits the Connection to be closed.

Returns a Connection 's Settings.

Contains settings related to a connection to a cluster.

Tells how the DNS server should be contacted.

Represents a source of cluster gossip.

Creates a GossipSeed.

Creates a GossipSeed with a specific HTTP header.

Returns GossipSeed host IP address.

The host header to be sent when requesting gossip.

Returns GossipSeed port.

Configures a ClusterSettings for connecting to a cluster using gossip seeds. clusterDns = "" clusterMaxDiscoverAttempts = 10 clusterExternalGossipPort = 0 clusterGossipTimeout = 1s

Configures a ClusterSettings for connecting to a cluster using DNS discovery. clusterMaxDiscoverAttempts = 10 clusterExternalGossipPort = 0 clusterGossipSeeds = Nothing clusterGossipTimeout = 1s

Contains event information like its type and data. Only used for write queries.

Holds event data.

Constants for System event types.

Create an Event meant to be persisted.

Creates an event using JSON format

Creates an event with metadata using JSON format.

Creates an event using a binary format.

Creates an event with metadata using binary format.

Represents an event position within a stream.

The first event in a stream.

The last event in the stream.

the Nth event of a stream.

Returns a 'EventNumber from a raw Int64.

Returns a raw Int64 from an EventNumber.

Occurs when an operation has been retried more than s_operationRetry.

Represents stream metadata as a series of properties for system data and a StreamMetadata object for user metadata.

When batch-reading a stream, this type-level function maps the result you will have whether you read a regular stream or $all stream. When reading a regular stream, some read-error can occur like the stream got deleted. However read-error cannot occur when reading $all stream (because $all cannot get deleted).

Determines whether any link event encountered in the stream will be resolved. See the discussion for more information: https://eventstore.org/docs/dotnet-api/reading-events/index.html#resolvedevent

Reads a single event from given stream.

Reads events from a stream backward.

Reads events from a stream forward.

Asynchronously gets the metadata of a stream.

Represents an access control list for a stream.

Represents stream metadata with strongly typed properties for system values and a dictionary-like interface for custom values.

Gets a custom property value from metadata.

Get a custom property value from metadata.

StreamACL with no role or users whatsoever.

StreamMetadata with everything set to Nothing, using emptyStreamACL and an empty Object.

Deletes given stream.

Sends a single Event to given stream.

Sends a list of Event to given stream.

Asynchronously sets the metadata for a stream.

Allows to build a structure using Monoid functions.

A Builder applies to StreamACL.

Builds a StreamACL from a StreamACLBuilder.

Modifies a StreamACL using a StreamACLBuilder.

Sets role names with read permission for the stream.

Sets a single role name with read permission for the stream.

Sets role names with write permission for the stream.

Sets a single role name with write permission for the stream.

Sets role names with delete permission for the stream.

Sets a single role name with delete permission for the stream.

Sets role names with metadata read permission for the stream.

Sets a single role name with metadata read permission for the stream.

Sets role names with metadata write permission for the stream.

Sets a single role name with metadata write permission for the stream.

A Builder applies to StreamMetadata.

Builds a StreamMetadata from a StreamMetadataBuilder.

Modifies a StreamMetadata using a StreamMetadataBuilder

Sets the maximum number of events allowed in the stream.

Sets the maximum age of events allowed in the stream.

Sets the event number from which previous events can be scavenged.

Sets the amount of time for which the stream head is cachable.

Overwrites any previous StreamACL by the given one in a StreamMetadataBuilder.

Updates a StreamMetadata's StreamACL given a StreamACLBuilder.

Sets a custom metadata property.

Represents a multi-request transaction with the EventStore.

The id of a Transaction.

Starts a transaction on given stream.

Gets the id of a Transaction.

Asynchronously commits this transaction.

There isn't such of thing in EventStore parlance. Basically, if you want to rollback, you just have to not transactionCommit a Transaction.

Asynchronously writes to a transaction in the EventStore.

Represents a subscription id.

Returns the stream of a subscription.

Common operations supported by a subscription.

Indicates why a subscription has been dropped.

Subscription runtime details. Not useful for the user but at least it makes Haddock documentation generation less ugly.

Waits until the Subscription has been confirmed.

Non blocking version of waitUnsubscribeConfirmed.

Like unsubscribeConfirmed but lives in STM monad.

Wait until unsubscription has been confirmed by the server.

Asks for the next incoming event like nextEventMaybe while still being in the the STM.

Returns the runtime details of a subscription.

Asynchronously unsubscribe from the the stream.

Also referred as volatile subscription. For example, if a stream has 100 events in it when a subscriber connects, the subscriber can expect to see event number 101 onwards until the time the subscription is closed or dropped.

Subscribes to a stream.

Gets the ID of the subscription.

Awaits for the next event.

Non blocking version of nextEvent.

This kind of subscription specifies a starting point, in the form of an event number or transaction file position. The given function will be called for events from the starting point until the end of the stream, and then for subsequently written events.

For example, if a starting point of 50 is specified when a stream has 100 events in it, the subscriber can expect to see events 51 through 100, and then any events subsequently written until such time as the subscription is dropped or closed.

Subscribes to a stream. If last checkpoint is defined, this will readStreamEventsForward from that event number, otherwise from the beginning. Once last stream event reached up, a subscription request will be sent using subscribe.

Waits until CatchupSubscription subscription catch-up its stream.

Non blocking version of waitTillCatchup.

Like hasCaughtUp but lives in STM monad.

The server remembers the state of the subscription. This allows for many different modes of operations compared to a regular or catchup subscription where the client holds the subscription state. (Need EventStore >= v3.1.0).

Gathers every persistent subscription property.

System supported consumer strategies for use with persistent subscriptions.

Gathers every possible Nak actions.

Enumerates all persistent action exceptions.

Acknowledges that ResolvedEvent has been successfully processed.

Acknowledges those ResolvedEvents have been successfully processed.

Mark a message that has failed processing. The server will take action based upon the action parameter.

Mark messages that have failed processing. The server will take action based upon the action parameter.

Acknowledges those event ids have been successfully processed.

Acknowledges those event ids have failed to be processed successfully.

System default persistent subscription settings.

Asynchronously create a persistent subscription group on a stream.

Asynchronously update a persistent subscription group on a stream.

Asynchronously delete a persistent subscription group on a stream.

Asynchronously connect to a persistent subscription given a group on a stream.

Gathers common slice operations.

Gets slice's ResolvedEventss.

If the slice has reached the end of the stream.

Gets the next location of this slice.

Empty slice.

Represents a slice of the $all stream.

Returned after deleting a stream. Position of the write.

Returned after writing to a stream.

Enumeration detailing the possible outcomes of reading a stream.

Represents a previously written event.

Represents the result of looking up a specific event number from a stream.

Regular stream slice.

A structure referring to a potential logical record position in the EventStore transaction file.

Represents the direction of read operation (both from $all an usual streams).

A structure representing a single event or an resolved link event.

Operation exception that can occurs on an operation response.

Represents a regular stream name or $all stream.

If the stream is the $all stream.

Indicates whether this ResolvedEvent is a resolved link event.

Returns the event that was read or which triggered the subscription.

If this ResolvedEvent represents a link event, the link will be the original event, otherwise it will be the event.

Tries to desarialize resolvedEventOriginal data as JSON.

The stream name of the original event.

The ID of the original event.

The event number of the original event.

Tries to parse JSON object from the given RecordedEvent.

Representing the start of the transaction file.

Representing the end of the transaction file.

Internal command representation.

Represents the reason subscription drop happened.

Constants used for expected version control.

The use of expected version can be a bit tricky especially when discussing idempotency assurances given by the EventStore.

The EventStore will assure idempotency for all operations using any value in ExpectedVersion except for anyStream. When using anyStream the EventStore will do its best to assure idempotency but will not guarantee idempotency.

This write should not conflict with anything and should always succeed.

The stream being written to should not yet exist. If it does exist treat that as a concurrency problem.

The stream should exist and should be empty. If it does not exist or is not empty, treat that as a concurrency problem.

States that the last event written to the stream should have a sequence number matching your expected value.

The stream should exist. If it or a metadata stream does not exist treat that as a concurrency problem.

Millisecond timespan

An associative operation.

Non-empty (and non-strict) list type.

Since: base-4.9.0.0