=       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     "(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone Pure ! generator."Gets the next fresh !.# Builds 2 new   s out of one.$Creates a new  . %"#$ "#$ %"#$(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone "Classifies info-like log messages.Indicates current attempt.Indicates connection !.Indicates connection !.Indicates connection !"Indicates a package has been sent.:Indicates the client's received a package from the server.#Classifies error-like log messages. Logging main data structure.      (C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableSafe *.NET TimeSpan: Represents a time interval.YInitializes a new instance of the TimeSpan structure to the specified number of ticks.mInitializes a new instance of the TimeSpan structure to a specified number of hours, minutes, and seconds.sInitializes a new instance of the TimeSpan structure to a specified number of days, hours, minutes, and seconds.Initializes a new instance of the TimeSpan structure to a specified number of days, hours, minutes, seconds, and milliseconds.AGets the number of ticks that represent the value of the current   structure.KGets the days component of the time interval represented by the current   structure.LGets the hours component of the time interval represented by the current   structure.NGets the minutes component of the time interval represented by the current   structure.NGets the seconds component of the time interval represented by the current   structure.SGets the milliseconds component of the time interval represented by the current   structure. Returns a  r that represents a specified number of seconds, where the specification is accurate to the nearest millisecond. Returns a  r that represents a specified number of minutes, where the specification is accurate to the nearest millisecond. Returns a  p that represents a specified number of hours, where the specification is accurate to the nearest millisecond. Returns a  o that represents a specified number of days, where the specification is accurate to the nearest millisecond.Gets the value of the current  5 structure expressed in whole and fractional days.Gets the value of the current  6 structure expressed in whole and fractional hours.Gets the value of the current  8 structure expressed in whole and fractional minutes.Gets the value of the current  8 structure expressed in whole and fractional seconds. Gets the value of the current  = structure expressed in whole and fractional milliseconds.,&'( )*+,-./0123456789 :;<=  )&'( )*+,-./0123456789 :;<=(C) 2014 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone(+0N!/Gathers every persistent subscription property.#bWhether or not the persistent subscription should resolve linkTo events to their linked events.$4Where the subscription should start from (position).%UWhether or not in depth latency statistics should be tracked on this subscription.&[The amount of time after which a message should be considered to be timeout and retried.'_The maximum number of retries (due to timeout) before a message get considered to be parked.(AThe size of the buffer listening to live messages as they happen.);The number of events read at a time when paging in history.*;The number of events to cache when paging through history.++The amount of time to try checkpoint after.,-The minimum number of messages to checkpoint.-gThe maximum number of message to checkpoint. If this number is reached, a checkpoint will be forced..*The maximum number of subscribers allowed./@The strategy to use for distributing events to client consumers.0KSystem supported consumer strategies for use with persistent subscriptions.1_Distributes events to a single client until it is full. Then round robin to the next client.2;Distributes events to each client in a round robin fashion.3NRepresents stream metadata as a series of properties for system data and a = object for user metadata.5The name of the stream.6#The version of the metadata format.7A =$ containing user-specified metadata.83When the stream is either not found or 'no stream'.9 When the stream is soft-deleted.:A < applies to =.;A < applies to E.<"Allows to build a structure using > functions.=Represents stream metadata with strongly typed properties for system values and a dictionary-like interface for custom values.?3The maximum number of events allowed in the stream.@0The maximum age of events allowed in the stream.AtThe event number from which previous events can be scavenged. This is used to implement soft-deletion of streams.B9The amount of time for which the stream head is cachable.C'The access control list for the stream.DTAn enumerable of key-value pairs of keys to JSON text for user-provider metadata.E/Represents an access control list for a stream.G-Roles and users permitted to read the stream.H1Roles and users permitted to write to the stream.I2Roles and users permitted to delete to the stream.J2Roles and users permitted to read stream metadata.K3Roles and users permitted to write stream metadata.LGlobal  Connection settingsS In secondsU!Represents reconnection strategy.?ARepresents a package exchanged between the client and the server.V%Holds login and password information.@Indicates either a ? contains V data or not.WPRepresents the direction of read operation (both from $all an usual streams).XFrom beginning to endYFrom end to beginningZBA structure representing a single event or an resolved link event.\.The event, or the resolved link event if this Z is a link event.]The link event if this Z is a link event.^ Possible i of that event._&Represents a previously written event.a-The event stream that this event belongs to.b*Unique identifier representing this event.c#Number of this event in the stream.dType of this event.e$Representing the data of this event.f5Representing the metadada associated with this event.g;Indicates whether the content is internally marked as json.h7Representing when this event was created in the system.icA structure referring to a potential logical record position in the EventStore transaction file.kCommit position of the recordlPrepare position of the recordAKRepresents a serialized event sent by the server in a subscription context.BORepresents a serialized event representiong either an event or a link event.C5Represents a serialized event coming from the server.DSerializes form of an o.m,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.QThe EventStore will assure idempotency for all operations using any value in m except for  anyStream . When using  anyStream` the EventStore will do its best to assure idempotency but will not guarantee idempotency.nHolds event data.oRContains event information like its type and data. Only used for write queries.EjRepresent a class of error where the user is not at fault. It could be either the client or the server.FHappens when the server deliberately close the connection. This probably happens if the client didn't respect EventStore communication error. For instance, the client takes too much time to respond to a heartbeat request.p Create an o meant to be persisted.GMaps o inner data type to an H understandable by the server.IMaps o inner metadata type to an H! understandable by the server.q"Creates an event using JSON formatr'Creates an event using a binary format.s1Creates an event with metadata using JSON format.t3Creates an event with metadata using binary format.J Serializes  EventData's data to a raw K.L Serializes n metadata to a raw K.MMaps a m to an H understandable by the server.uGThis write should not conflict with anything and should always succeed.vjThe stream being written to should not yet exist. If it does exist treat that as a concurrency problem.wzThe stream should exist and should be empty. If it does not exist or is not empty, treat that as a concurrency problem.xoStates that the last event written to the stream should have a sequence number matching your expected value.ND smart constructor.y/Representing the start of the transaction file.z-Representing the end of the transaction file.{*Tries to parse JSON object from the given _.OConverts a raw P into an QR Constructs a _ from an C.S Constructs a Z from a B.T Constructs a Z from a A.|DReturns the event that was read or which triggered the subscription.If this Za represents a link event, the link will be the original event, otherwise it will be the event.}Tries to desarialize | data as JSON.~Indicates whether this Z is a resolved link event.&The stream name of the original event.The ID of the original event.UMaps a @ into a V understandable by the server. Creates a V given a login and a password.uIndicates how many times we should try to reconnect to the server. A value less than or equal to 0 means no retry.TIndicates we should try to reconnect to the server until the end of the Universe.Default global settings.W0Triggers the logger callback if it has been set.XMillisecond timespanE" with no role or users whatsoever.+Gets a custom property value from metadata.*Get a custom property value from metadata.= with everything set to Y, using  and an empty Z.[Maps an Z to a list of \ to ease the =.] Serialized a E to ^ for serialization purpose._ Serialized a = to ^ for serialization purpose.`Read ACL property.aWrite ACL property.bDelete ACL property.cMetadata read ACL property.dMetadata write ACL property.eMax age metadata property.fMax count metadata property.g#truncated before metadata property.h Cache control metadata property.iACL metadata property.j2Gathers every internal metadata properties into a Set. It used to safely = in JSON.k,Only keeps the properties the users has set.l Parses a m from an Z given a JSON property.nParses E.oParses =.pBuild a structure given a < and an initial value.4Sets role names with read permission for the stream.<Sets a single role name with read permission for the stream.5Sets role names with write permission for the stream.=Sets a single role name with write permission for the stream.6Sets 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.ESets a single role name with metadata read permission for the stream.>Sets role names with metadata write permission for the stream.FSets a single role name with metadata write permission for the stream. Builds a E from a ;. Modifies a E using a ;.8Sets the maximum number of events allowed in the stream.5Sets the maximum age of events allowed in the stream.BSets 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 E by the given one in a :. Updates a StreamMetadata's E given a ;. Sets a custom metadata property. Builds a = from a :. Modifies a = using a :qMaps a 0 to a r understandable by the server.sTries to parse a 0 given a raw r.0System default persistent subscription settings.!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUtu?vwxyzV{|}@~WXYZ[\]^_`abcdefghijklABCDmnoEFp Event typeEvent ID, generated if Y Event dataGIqrstJLMuvwxN Event typeEvent IDData content typeMetadata content type Event dataMetadatayz{ORST|}~ULoginPasswordWX[]_`abcdefghijklnopqs!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUtu?vwxyzV{|}@~WXYZ[\]^_`abcdefghijklABCDmnoEFpGIqrstJLMuvwxNyz{ORST|}~UWX[]_`abcdefghijklnopqsu!"#$%&'()*+,-./012348956755:;<=>?@ABCDEFGHIJKLMNOPQRSTUtu?vwxyzV{|}@~WXYZ[\]^_ `abcdefghijklABC DmnoEFpGIqrstJLMuvwxNyz{ORST|}~UWX[]_`abcdefghijklnopqs(C) 2014 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone*Constructs a heartbeat response given the ! of heartbeat request. Serializes a ? into raw bytes.The minimun size a ?C should have. It's basically a command byte, correlation bytes (!) and a @ byte.(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone!"IN&bSubscription operations state machine. Keeps every information related to subscription updated. Subscription model internal state.Holds all pending  Subscriptions Holds all  Subscriptions that are currently running.%Holds all pending persistent actions.!Subscription action confirmation. Confirms a  Subscription% connection has handled successfully.8Confirms a persist action has been handled successfully.#Information related to a confirmed  Subscription.$Subscription connection information.Set of actions handled by the  Subscription model.Subscription connection.!Subscription action confirmation.Subscription no longer exist.Add a new persist action.4Set of a piece of information we can query from the  Subscription model.&Type of requests handled by the model.>Represents a running subscription. Gathers useful information.5Related regular subscription. In order of appearance:Subscription id. Stream name.Resolve Link TOS.Last commit position.Last event number.;Related to persistent subscription. In order of appearance:Subscription id. Group name. Stream name. Buffer size.Persistence subscription id.Last commit position.Last event number. Represents a  Subscription which is about to be confirmed.8Related to regular subscription. In order of appearance: Stream name.Resolve Link TOS.;Related to persistent subscription. In order of appearance: Group name. Stream name. Buffer size.?Represents an persistent action that hasn't been completed yet.Type of persistent action.0Gets the event number of a running subscription.3Gets the commit position of a running subscription. Gets the ! of a running subscription.Retrieves a running  Subscription.'Retrieves an ongoing persistent action.Registers a regular  Subscription request.Registers a persistent  Subscription request.Registers a persistent action.Confirms a subscription.HConfirms a persistent action. It doesn't assume if the action went well. Remove a  Subscription.Creates a new  Subscription model.Main model handler.9(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone(0#Batch read on $all stream response.QEnumeration detailing the possible outcomes of reading a slice of $all stream."Batch read on $all stream request. smart constructor. (C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone(0(Read event on a regular stream response.EEnumeration representing the status of a single event read operation.'Read event on a regular stream request. smart constructor.                (C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone(0&Batch read on regular stream response.JEnumeration detailing the possible outcomes of reading a slice of a stream%Batch read on regular stream request. smart constructor. !"#$%&'()*+,-./ !"#$%&'()*+,- !"#$%&'()*+,-./ (C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableSafe!"(>0Represents a regular stream name or $all stream.3A stream can either point to $all or a regular one.00 (C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone!"(>L &Represents a slice of the $all stream.Regular stream slice. Gathers common slice operations. Gets slice's Zs.Gets slice's reading direction.+If the slice reaches the end of the stream.)Gets the starting location of this slice.%Gets the next location of this slice.@Enumeration detailing the possible outcomes of reading a stream.%123456789:;<=>?@ABCDE123456789:;<=> 123456789:;<=>?@ABCDE (C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone!"(+>INFAn operation is just a G tree.G)Main operation state machine instruction.HZLifts a pure value into the intruction tree. Also marks the end of an instruction tree.I Emits an operation return value.JAsks for an unused !.KSend a request message given a command and an expected command. response. It also carries a callback to call when response comes in.LEnds the instruction interpretation. If holds Nothing, the interpretation should resume from the beginning. Otherwise it ends by indicating what went wrong.=Operation exception that can occurs on an operation response.Stream and Expected VersionStreamStreamExpected, FoundReason7Invalid operation state. If happens, it's a driver bug.cOccurs when the user asked to close the connection or if the connection can't reconnect anymore.M$Operation result sent by the server.NAsks for a unused !.O Raises an .P5Asks to resume the interpretation from the beginning.QtSends a request to the server given a command request and response. It returns the expected deserialized message.REmits operation return value.S"Replaces every emitted value, via R+ function by calling the given callback.TMaps every emitted value, via R, using given function.URaises  exception.VRaises  exception.WRaises  exception.XRaises  exception.YRaises  exception.ZRaises  exception.[Raises  exception.,FGHIJKLM\]^_`abcNOPQRSTUVWXYZ[defg(FGHIJKLM\]^_`abcNOPQRSTUVWXYZ[FGHIJKL M\]^_`abcNOPQRSTUVWXYZ[defg(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone#Returned after writing to a stream.$Next expected version of the stream.i of the write.h Constructs a D from an o.hhh(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone;NiMain F bookkeeping state machine.j,Output produces by the interpretation of an F.kProduces an intermediary value.lAsks for sending the given ?.mwaits for more input.n&Type of requests handled by the model.oRegister a new F.pSubmit a package.qAborts every pending operation.rOperation internal state.s! generator.tContains all running Fs.uEntry of a running F.v Pushes a new F to model. The given F0 state-machine is initialized and produces a ?.w Submits a ?6 to the model. If the model isn't concerned by the ?, it will returns Y . Because FC can implement complex logic (retry for instance), it returns a Step.xAborts every pending operation.yCreates a new F model state-machine.izjklmnopqr{stu|}~vwxy ijklmvwxyizjklmnopqr{stu|}~vwxy(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone$Batch read on $all stream operation.(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone(JRepresents the result of looking up a specific event number from a stream.3Read a specific event given event number operation.(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone(+Batch read from a regular stream operation.(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone(0Delete stream response.Delete stream request. smart constructor. (C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone!"(IN"Returned after deleting a stream. i of the write."Delete a regular stream operation.(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone(0 Commit transaction response.Commit transaction request.$Write transactional events response.#Write transactional events request.Start transaction response.Start transaction request. smart constructor. smart constructor. smart constructor.*$(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone !"(>LStart transaction operation.Transactional write operation.Transactional commit operation.(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone(0Write events response.Write events request. smart constructor.StreamExpected versionEventsRequire master(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNoneWrite events operation.(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone !"(INRead stream metadata operation.Set stream metadata operation.(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone(0SAvalaible event sent by the server in the context of a persistent subscription../Connection to persistent subscription response.Nak processed events request.#Gathers every possible Nak actions.Ack processed events request.-Connect to a persistent subscription request.(Update persistent subscription response.'Update persistent subscription outcome.'Update persistent subscription request.(Delete persistent subscription response.'Delete persistent subscription outcome.'Delete persistent subscription request.(Create persistent subscription response.'Create persistent subscription outcome.'Create persistent subscription request.QA message sent to the server to indicate the user asked to end a subscription.BA message sent by the server when a subscription has been dropped.1Represents the reason subscription drop happened.VSerialized event sent by the server when a new event has been appended to a stream.(Stream subscription connection response.'Stream subscription connection request. smart constructor. smart constructor. smart construction. smart constructor. smart constructor. smart constructor. smart constructor.      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^|      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMN,      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone_*Creates a regular subscription connection ?.`-Creates a persistent subscription connection ?.a"Creates a persistent subscription ?.b Creates Ack ?.c Create Nak ?.dCreate an unsubscribe ?._`abcd_`abcd_`abcd(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone !"+IN-e"Subscription driver state machine.fDriver internal state.gSubscription model.h! generator.iUHolds ongoing commands. When stored, it means an action hasn't been confirmed yet.j&Set of commands handled by the driver.kCreates a regular  Subscription connection. When a l has arrived, the driver will use the provided callback and emit a final value. It holds a stream name and `Resolve Link TOS` setting.mCreates a persistent  Subscription connection. When a l has arrived, the driver will use the provided callback and emit a final value. It holds a group name, stream name and a buffer size.n Unsubscribe from a subscription.oCreates a persistent action. Depending of the failure or the success of that action, the driver will use the provided callback to emit a final value. It hols a group name, a stream name and a persistent action.pAcks a set of Event !C to notify those events have been correctly handled. It holds a  subscription and a set of !n representing event id. When the ack would be confirmed the driver will return the supplied final value.qNaks a set of Event !F to notify those events haven't been handled correctly. it holds a  subscription, a , an optional reason and a set of event ids. When the nak would be confirmed, the driver will return the provided final value.rType of inputs handled by the  Subscription driver.sCEmitted when a persistent action has been carried out successfully.t Action id.uSubscription group name.v Stream name.wPersistent action type.,Enumerates all persistent action exceptions.The action failed._Happens when creating a persistent subscription on a stream with a group name already taken.`An operation tried to do something on a persistent subscription or a stream that don't exist.`The current user is not allowed to operate on the supplied stream or persistent subscription.That action has been aborted because the user shutdown the connection to the server or the connection to the server is no longer possible..Indicates why a subscription has been dropped.4Subscription connection has been closed by the user.BThe current user is not allowed to operate on the supplied stream. Given stream name doesn't exist.Given stream is deleted.wOccurs when the user shutdown the connection from the server or if the connection to the server is no longer possible.l=Set of events that can occurs during a subscription lifetime.xA wild event appeared !y$The subscription connection dropped.zgSubscription connection is confirmed. It means that subscription can receive events from the server.{ Submits a ?" to a subscription driver. If the ?~ was processed by the driver, it will return a final value and a new driver with its internal state updated accordingly.|GStarts a regular subscription connection. It returns the associated ?# and updates driver internal state.}JStarts a persistent subscription connection. It returns the associated ?# and updates driver internal state.~=Creates a persistent subscription. It returns the associated ?& and updates driver internal state.=Updates a persistent subscription. It returns the associated ?& and updates driver internal state.=Deletes a persistent subscription. It returns the associated ?$ and updates driver internal state.}Given a persistent subscription, acknowledges a set of events have been successfully processed. It returns the associated ?& and updates driver internal state.yGiven a persistent subscription, indicates a set of event haven't been processed correctly. It returns the associated ?& and updates driver internal state. Unsubscribe from a subscription.Aborts every pending action.Creates a new subscription e state machine.:efghijkmnopqrstuvwlxyz{| Stream name.Resolve Link TOS} Group name. Stream name. Buffer size.~ Group name. Stream name. Group name. Stream name. Group name. Stream name. Event ids.Reason. Event ids.(estuvwlxyz{|}~efghijkmnopqrstuvwlxyz{|}~(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone!"INRepresents the next checkpoint to reach on a catchup subscription. Wheither it's a regular stream or the $all stream, it either point to an H or a i. Main subscription state machine.SRepresents the different type of inputs a subscription state-machine can handle.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).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.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.~Submit a new event to the subscription state machine. Internally, that event should be stored into the subscription buffer.(Reads the next available event. Returns Y^ it there is any. When returning an event, it will be removed from the subscription buffer.ASubmits a list of events read from a stream. It's only used by a  subscription.zIndicates if the subscription caught up the end of the stream, meaning the subscription is actually live. Only used by  subscription.Main  subscription state machine.Main  subscription state machine.kDepending either if the subscription concerns a regular stream or $all, indicates if an event number (or i)) is lesser that the current the given  CheckPoint.-That subscription state machine accumulates events coming from batch read and any real time change made on a stream. That state machine will not served any recent change made on the stream until it reaches the end of the stream. On every batch read, it makes sure events contained in that batch are deleted from the subscription buffer in order to avoid duplicates. That implemention has been chosen to avoid potential message lost between the moment with reach the end of the stream and the delay required by asking for a subscription.Base subscription used for  or  subscription.$If it reaches the end of the stream.Aestuvwlxyz{|}~(C) 2014 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone(;N$Processor state-machine.#Represents the state transition of  state machine.Produces a final value.Indicates to send the given ?.Waits for more input. internal state.Subscription driver.Operation model.Supported subscription command.*Creates a regular subscription connection.-Creates a persistent subscription connection."Creates a persistent subscription.Unsubscribes a subscription."Updates a persistent subscription."Deletes a persistent subscription.;Acknowledges a set of events has been successfully handled.>Acknowledges a set of events hasn't been handled successfully.Type of commmand a  can handle.Subcription related commands.Register a new F.Aborts every pending operation.Type of inputs handled by the  driver.A command can be an F or a  Subscription actions. Handle a ? coming from the server.*Creates a regular subscription connection.-Creates a persistent subscription connection."Creates a persistent subscription."Updates a persistent subscription."Deletes a persistent subscription.;Acknowledges a set of events has been successfully handled.>Acknowledges a set of events hasn't been handled successfully.Registers a new F. Submits a ?.Unsubscribes a subscription.Aborts every pending operation.Creates a new  state-machine.* Stream name.Resolve Link TOS. Group name. Stream name. Buffer size. Group name. Stream name. Group name. Stream name. Group name. Stream name.(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone!"(Catchup operation state.BIndicates the stream name and the next event number to start from.YIndicates the commit and prepare position. Used when catching up from the $all stream.Stream catching up operation. (C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone!(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone!"+N 8Internal representation of a connection with the server.TType of connection issue that can arise during the communication with the server.DThe max reconnection attempt threshold has been reached. Holds a (, the port used and the given threshold.Use of a close .Creates a new . Gets current  !. Closes the D. It will not retry to reconnect after that call. it means a new  has to be created. ) exception will be raised if the same  object is used after a  call.Writes  ByteString into the buffer.,Asks the requested amount of bytes from the .2Returns True if the connection is in closed state.kMain connection logic. It will automatically reconnect to the server when a exception occured while the  is accessed. "(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone(+;N*<Main execution environment used among different transitions.Global settings reference.That queue ties the user, the reader thread and the manager thread. The user and the reader push new messages onto the queue while the manager dequeue and handles one message at the time.That queue ties the writer thread with the manager thread. The writer dequeue packages from that queue and sends those to the server. While the manager pushes new packages on every new submitted operation.That queue ties the runner thread with the manager thread. The runner dequeues IO action from it while the manager pushes new command finalizers as those arrived.Holds manager thread state.;Indicates the action to call in order to push new commands.Connection to the server.gIndicates when the production execution model has been shutdown and disposed any ongoing operations. Holds the execution model state.,The action to call when pushing new command.Action that attests the execution model has been closed successfully. It doesn't mean the execution model hasn't been shutdown because of some random exception.A  that can be cycled.1Used to determine if we hit the end of the queue.6Raised when the server responded in an unexpected way.3TCP package sent by the server had a wrong framing.$Server sent a malformed TCP package. Creates an empty . Gets an element from the . Writes an element to the .  Empties a .  Updates a .Indicates if a  is empty.=Asks to shutdown the connection to the server asynchronously. Pushes a new F asynchronously.Subscribes to a regular stream.(Subscribes to a persistent subscription."Creates a persistent subscription."Updates a persistent subscription."Deletes a persistent subscription.;Acknowledges a set of events has been successfully handled.>Acknowledges a set of events hasn't been handled successfully. Unsubscribe from a subscription.,Waits the execution model to close properly.Reader thread. Keeps reading ? from the connection.Writer thread, writes incoming ?sSpawns a new thread worker. Loops over a  Processor's ( state machine, returning an updated  model at the end.bFirst execution mode. It spawns initial reader, runner and writer threads. Then it switches to  mode.'Crusing execution mode. Reads and handle message coming from the channel as those are arrived. That mode is used when the connection to the server is still live. We might have deconnection once in a while but at the end, if we managed to reconnect to it, we consider everything is fine. That mode is triggered either because the user asks to shutdown the connection or because the connection to server has been dropped and we can't reconnect.!,Main Production execution model entry point.U"#$%&'()*+,-./0123456789:;<=>?     @ABCDEFGHIJ K!L!/"#$%&'()* +,-./0123456 789:;<=>?     @ABCDEFGHIJ K!L(C) 2014 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone(+3 The id of a .;Represents a multi-request transaction with the EventStore.MThis exception is raised when the user tries to get the next event from a  that is already closed.It's possible to subscribe to a stream and be notified when new events are written to that stream. There are three types of subscription which are available, all of which can be useful in different situations.M Tracks a  Subcription lifecycle. It holds a  state machine and  SubDropReason if any.Represents a subscription id.4Represents a connection to a single EventStore node.Creates a new ] to a single node. It maintains a full duplex connection to the EventStore. An EventStore  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.0Another difference is that with the EventStore  all operations are handled in a full async manner (even if you call the synchronous behaviors). Many threads can use an EvenStore  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. Waits the  to be closed.Asynchronously closes the .Sends a single o to given stream.WDetermines whether or not any link events encontered in the stream will be resolved.Non blocking version of . Waits until CatchupSubscription" subscription catch-up its stream. Gets the ID of the subscription."Gets the subscription stream name./Asynchronously unsubscribe from the the stream.*If the subscription is on the $all stream.]The last commit position seen on the subscription (if this a subscription to $all stream).aThe last event number seen on the subscription (if this is a subscription to a single stream).Awaits for the next event.Non blocking version of .>Acknowledges those event ids have been successfully processed.Acknowledges that Z! has been successfully processed.Acknowledges those Z#s have been successfully processed.jMark a message that has failed processing. The server will take action based upon the action parameter.jMark messages that have failed processing. The server will take action based upon the action parameter. FAcknowledges those event ids have failed to be processed successfully.N Modifies M% internal state machine, letting any  SubDropReason untouched. Sends a list of o to given stream. Deletes given stream. Gets the id of a . %Starts a transaction on given stream.9Asynchronously writes to a transaction in the EventStore.(Asynchronously commits this transaction.nThere isn't such of thing in EventStore parlance. Basically, if you want to rollback, you just have to not  a .'Reads a single event from given stream.)Reads events from a given stream forward.*Reads events from a given stream backward.*Reads events from the $all stream forward.*Reads events from the $all stream backwardSubcribes to given stream.Subcribes to $all stream.HSubscribes to given stream. If last checkpoint is defined, this will  from that event number, otherwise from the beginning. Once last stream event reached up, a subscription request will be sent using .Same as  but applied to $all stream..Asynchronously sets the metadata for a stream.-Asynchronously gets the metadata of a stream.BAsynchronously create a persistent subscription group on a stream.BAsynchronously update a persistent subscription group on a stream.BAsynchronously delete a persistent subscription group on a stream.QAsynchronously connect to a persistent subscription given a group on a stream.NOPQRSTUVWXYZ[M\]^_`HostNamePort Stream nameab N  Stream name  Stream name Hard delete   Stream name Stream name Event numberResolve Link Tos Stream nameFrom event number Batch sizeResolve Link Tos Stream nameFrom event number Batch sizeResolve Link Tosc Batch sizeResolve Link Tos Batch sizeResolve Link Tosd Stream nameResolve Link TosResolve Link Tos Stream nameResolve Link TosLast checkpoint Batch sizeResolve Link TosLast checkpoint Batch sizeefghBijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     VLMNOPQRSTUonpqsrt348956755EFGHIJK=>?@ABCD  <;:    !"#$%&'()*+,-./012 _`abcdefghijklWXYZ[\]^~|}{yzmuvwx;OPQRSTUVWXYZ[M\]^_`ab N    cdefgh#$%&'()*+,-./0123456789:;<=>?@ABCDEFFGHIJKLMNOPQRSTUVWWXYZ[\]^_``abcdefgghijklmmnopqrstuvwxyzz{|}~~                           !!!"""       !"#$%&'()*+,-./0123456789:;<=>8?@A2BCDEFGHIJKLMNOPQRSTU#VWXYZ[\]^_`#abcdefghijk#almnopqrs#tuvw#Vxyz{|yz}~mnXvZ[\]                                     !                "  # $ % & '  ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V WXYZ[\]^_`abcdebfghijklmno)pqrs#tuvwxyz{|t}~uvwxqyr&'qr     `d !"#$%&e'^_()*+j,-. /0123456789 :;<=>?@YZ[\ABCDEFGHICJ_^KLMNO%&PdeQ@jRSnTUVWXY! Z[\!]!^!_!`!a#bn!c!d#ef!!g!h!i! !j!k!l!m!!n!o!p!q!r!s! !t!u"v"m"w"x"y"z"{"|"}"~""""""""""""c"""""""""""""""""""""""""""":"""D"""E"F"G"H"I"v"""""""""""""""""""""  event_8cXvxZMOhqw2sv6yt2HSVaDatabase.EventStoreDatabase.EventStore.Logging&Database.EventStore.Internal.Generator%Database.EventStore.Internal.TimeSpan"Database.EventStore.Internal.Types%Database.EventStore.Internal.Packages7Database.EventStore.Internal.Manager.Subscription.Model InfoMessage ConnectingConnectionClosed Connected Disconnected PackageSentPackageReceived ErrorMessageUnexpectedExceptionLogErrorInfoTimeSpan timeSpanTickstimeSpanHoursMinsSecstimeSpanDaysHoursMinsSecstimeSpanDaysHoursMinsSecsMillistimeSpanGetTickstimeSpanGetDaystimeSpanGetHourstimeSpanGetMinutestimeSpanGetSecondstimeSpanGetMillistimeSpanFromSecondstimeSpanFromMinutestimeSpanFromHourstimeSpanFromDaystimeSpanTotalDaystimeSpanTotalHourstimeSpanTotalMinutestimeSpanTotalSecondstimeSpanTotalMillisPersistentSubscriptionSettingspsSettingsResolveLinkTospsSettingsStartFrompsSettingsExtraStatspsSettingsMsgTimeoutpsSettingsMaxRetryCountpsSettingsLiveBufSizepsSettingsReadBatchSizepsSettingsHistoryBufSizepsSettingsCheckPointAfterpsSettingsMinCheckPointCountpsSettingsMaxCheckPointCountpsSettingsMaxSubsCountpsSettingsNamedConsumerStrategySystemConsumerStrategyDispatchToSingle RoundRobinStreamMetadataResultstreamMetaResultStreamstreamMetaResultVersionstreamMetaResultDataNotFoundStreamMetadataResultDeletedStreamMetadataResultStreamMetadataBuilderStreamACLBuilderBuilderStreamMetadatastreamMetadataMaxCountstreamMetadataMaxAgestreamMetadataTruncateBeforestreamMetadataCacheControlstreamMetadataACLstreamMetadataCustom StreamACLstreamACLReadRolesstreamACLWriteRolesstreamACLDeleteRolesstreamACLMetaReadRolesstreamACLMetaWriteRolesSettingss_heartbeatIntervals_heartbeatTimeouts_requireMaster s_credentialss_retrys_reconnect_delay_secss_loggerRetry Credentials ReadDirectionForwardBackward ResolvedEventresolvedEventRecordresolvedEventLinkresolvedEventPosition RecordedEventrecordedEventStreamIdrecordedEventIdrecordedEventNumberrecordedEventTyperecordedEventDatarecordedEventMetadatarecordedEventIsJsonrecordedEventCreatedPositionpositionCommitpositionPrepareExpectedVersion EventDataEvent createEventwithJson withBinarywithJsonAndMetadatawithBinaryAndMetadata anyVersionnoStreamVersionemptyStreamVersionexactEventVersion positionStart positionEndrecordedEventDataAsJsonresolvedEventOriginalresolvedEventDataAsJsonisEventResolvedLinkresolvedEventOriginalStreamIdresolvedEventOriginalId credentialsatMost keepRetryingdefaultSettingsemptyStreamACLgetCustomPropertyValuegetCustomPropertyemptyStreamMetadata setReadRoles setReadRole setWriteRoles setWriteRolesetDeleteRoles setDeleteRolesetMetaReadRolessetMetaReadRolesetMetaWriteRolessetMetaWriteRolebuildStreamACLmodifyStreamACL setMaxCount setMaxAgesetTruncateBeforesetCacheControlsetACL modifyACLsetCustomPropertybuildStreamMetadatamodifyStreamMetadata%defaultPersistentSubscriptionSettingsRunning RunningRegRunningPersist StreamName AllStream StreamTypeAll RegularStreamAllSlice StreamSliceSliceLoc sliceEventssliceDirectionsliceEOS sliceFrom sliceNext ReadResult ReadSuccess ReadNoStreamReadStreamDeletedReadNotModified ReadErrorReadAccessDeniedOperationErrorWrongExpectedVersion StreamDeletedInvalidTransaction AccessDeniedInvalidServerResponseProtobufDecodingError ServerErrorInvalidOperationAborted WriteResultwriteNextExpectedVersion writePosition ReadEventReadEventNotFoundreadEventStreamreadEventNumberreadEventResolved DeleteResult NakAction NA_UnknownNA_ParkNA_RetryNA_SkipNA_Stop DropReasonD_UnsubscribedD_AccessDenied D_NotFoundD_PersistentSubscriptionDeletedPersistActionExceptionPersistActionFailPersistActionAlreadyExistPersistActionDoesNotExistPersistActionAccessDeniedPersistActionAborted SubDropReasonSubUnsubscribedSubAccessDenied SubNotFoundSubPersistDeleted SubAborted PersistentCatchupRegularConnectionExceptionMaxAttemptConnectionReachedClosedConnectionServerConnectionErrorWrongPackageFramingPackageParsingError TransactionId TransactionSubscriptionClosed SubscriptionSubscriptionId ConnectionconnectwaitTillClosedshutdown sendEventgetSubResolveLinkTos hasCaughtUpwaitTillCatchupgetSubId getSubStream unsubscribeisSubscribedToAllgetSubLastCommitPosgetSubLastEventNumber nextEventnextEventMaybenotifyEventsProcessed acknowledgeacknowledgeEventsfailed eventsFailednotifyEventsFailed sendEvents deleteStream transactionIdstartTransactiontransactionWritetransactionCommittransactionRollback readEventreadStreamEventsForwardreadStreamEventsBackwardreadAllEventsForwardreadAllEventsBackward subscribesubscribeToAll subscribeFromsubscribeToAllFromsetStreamMetadatagetStreamMetadatacreatePersistentSubscriptionupdatePersistentSubscriptiondeletePersistentSubscriptionconnectToPersistentSubscription Generatoruuidt_Kbofz3yQbJYIj1DO4WUJluData.UUID.Types.InternalUUIDnextUUIDsplitGenerator newGenerator FormatLiteralPositiveNegativemillisPerSecondmillisPerMinute millisPerHour millisPerDayticksPerMillisecondticksPerSecondticksPerMinute ticksPerHour ticksPerDay daysPerTick hoursPerTickminutesPerTicksecondsPerTick millisPerTick maxMillis minMillispaddedtimeSpanBuilderinterval$fShowTimeSpanGHC.BaseMonoidPackageFlagResolvedEventBufResolvedIndexedEvent EventRecordNewEventInternalExceptionConnectionClosedByServer eventDataTypeGHC.IntInt32eventMetadataTypeeventDataBytesbytes_6VWy06pWzJq9evDvK2d4w6Data.ByteString.Internal ByteStringeventMetadataBytesexpVersionInt32newEventtoUTCInt64time_FTheb6LSxyX1UABIbBXRfnData.Time.Clock.UTCUTCTimenewRecordedEventnewResolvedEventnewResolvedEventFromBuf flagWord8GHC.WordWord8 _settingsLog msDiffTimeNothingaeson_2t03sZhvmlzHSWzoTbx1vWData.Aeson.Types.InternalObjectcustomMetaToPairsPair streamACLJSONproto_9J7wWHk3S2y5IOpvO2OjUvData.ProtocolBuffers.TypesValuestreamMetadataJSON p_readRoles p_writeRoles p_deleteRolesp_metaReadRolesp_metaWriteRolesp_maxAge p_maxCountp_truncateBeforep_cacheControlp_aclinternalMetaPropertieskeepUserPropertiesparseNominalDiffTimeNominalDiffTimeparseStreamACLparseStreamMetadatabuild strategyTexttext_5c7VCmRXJenGcMPs3kwpkIData.Text.InternalTextstrategyFromTextAtMost KeepRetrying packageCmdpackageCorrelation packageData packageCred credLogin credPasswordNone AuthenticatedresolvedEventBufEventresolvedEventBufLinkresolvedEventBufCommitPositionresolvedEventBufPreparePositionresolvedIndexedRecordresolvedIndexedLinkeventRecordStreamIdeventRecordNumber eventRecordIdeventRecordTypeeventRecordDataTypeeventRecordMetadataTypeeventRecordDataeventRecordMetadataeventRecordCreatedeventRecordCreatedEpoch newEventId newEventTypenewEventDataTypenewEventMetadataType newEventDatanewEventMetadataAnyNoStream EmptyStreamExactJsonBinary eventTypeeventId eventData$fToJSONStreamMetadata$fFromJSONStreamMetadata$fToJSONStreamACL$fFromJSONStreamACL $fOrdPosition $fEqPosition$fDecodeResolvedEventBuf$fDecodeResolvedIndexedEvent$fDecodeEventRecord$fEncodeNewEvent$fExceptionInternalExceptionheartbeatResponsePackage putPackage mandatorySizecredSizeModelState _stPending _stRunning _stAction ConfirmedConfirmedConnectionConfirmedPersistActionMetaConnectAction Unsubscribed PersistActionQueryRequestPending PendingRegPendingPersist PendingActionrunningLastEventNumberrunningLastCommitPosition runningUUIDquerySubscriptionqueryPersistentAction connectRegconnectPersist persistActionconfirmedSubscriptionconfirmedAction unsubscribednewModel modelHandle RegularMeta PersistMeta ConnectRegConnectPersistQuerySub QueryActionExecuteRegister_paGroup _paStream_paTpe PersistCreate PersistUpdate PersistDelete emptyStateResponseResult newRequest_CommitPosition_PreparePosition_Events_NextCommitPosition_NextPreparePosition_Result_ErrorSUCCESS NOT_MODIFIEDERROR ACCESS_DENIED_commitPosition_preparePosition _maxCount_resolveLinkTos_requireMaster$fDecodeResponse$fEncodeRequest_result _indexedEvent_error NOT_FOUND NO_STREAMSTREAM_DELETED _streamId _eventNumber_events _nextNumber _lastNumber _endOfStream_lastCommitPosition$fShowStreamName_saFrom_saNext_saDir _saEvents_saEOS sliceStream sliceLast_ssDir_ssFrom_ssNext _ssEvents_ssEOS$fSliceAllSlice$fSliceStreamSlice$fTraversableReadResult$fFoldableReadResult$fFunctorReadResult$fShowReadResult$fEqReadResult OperationSMReturnYieldFreshIdSendPkgFailureOpResultfreshIdfailureretrysendyieldforeachmapOp wrongVersion streamDeletedinvalidTransaction accessDeniedprotobufDecodingError serverErrorinvalidServerResponse OP_SUCCESSOP_PREPARE_TIMEOUTOP_COMMIT_TIMEOUTOP_FORWARD_TIMEOUTOP_WRONG_EXPECTED_VERSIONOP_STREAM_DELETEDOP_INVALID_TRANSACTIONOP_ACCESS_DENIED $fMonadSM$fApplicativeSM $fFunctorSM$fExceptionOperationErroreventToNewEvent TransitionProduceTransmitAwaitNewPkgAbort_gen_pendingElem pushOperation submitPackageabort_opOp_opCmd_opCont_opCb initState runOperation runPackageabortOperationshandle readAllEventsreadStreamEvents_message_expectedVersion _hardDelete CommittedCommitWrittenWriteStartedStartnewStartnewWrite newCommit _ccTransId _ccResult _ccMessage _firstNumber _cTransId_cRequireMaster _wwTransId _wwResult _wwMessage _wTransId_wRequireMaster_transId$fDecodeCommitted$fEncodeCommit$fDecodeWritten $fEncodeWrite$fDecodeStarted $fEncodeStarttransactionStart writeEventsreadMetaStream setMetaStream metaStream invalidFormatstreamNotFound onReadResult)PersistentSubscriptionStreamEventAppeared"PersistentSubscriptionConfirmationPersistentSubscriptionNakEventsPersistentSubscriptionAckEventsConnectToPersistentSubscription%UpdatePersistentSubscriptionCompleted"UpdatePersistentSubscriptionResultUpdatePersistentSubscription%DeletePersistentSubscriptionCompleted"DeletePersistentSubscriptionResultDeletePersistentSubscription%CreatePersistentSubscriptionCompleted"CreatePersistentSubscriptionResultCreatePersistentSubscriptionUnsubscribeFromStreamSubscriptionDroppedStreamEventAppearedSubscriptionConfirmationSubscribeToStreamsubscribeToStream_createPersistentSubscription_deletePersistentSubscription_updatePersistentSubscription _connectToPersistentSubscriptionpersistentSubscriptionAckEventspersistentSubscriptionNakEventspsseaEvtpscLastCommitPospscIdpscLastEvtNumberpsneIdpsneProcessedEvtIdspsneMsg psneActionpsaeIdpsaeProcessedEvtIdsctsId ctsStreamIdctsAllowedInFlightMsgs upscResult upscReason UPS_SuccessUPS_DoesNotExistUPS_FailUPS_AccessDenied upsGroupName upsStreamIdupsResolveLinkTos upsStartFrom upsMsgTimeoutupsRecordStatsupsLiveBufSizeupsReadBatchSize upsBufSizeupsMaxRetryCountupsPreferRoundRobinupsChkPtAfterTimeupsChkPtMaxCountupsChkPtMinCountupsSubMaxCountupsNamedConsStrategy dpscResult dpscReason DPS_SuccessDPS_DoesNotExistDPS_FailDPS_AccessDenied dpsGroupName dpsStreamId cpscResult cpscReason CPS_SuccessCPS_AlreadyExistsCPS_FailCPS_AccessDenied cpsGroupName cpsStreamIdcpsResolveLinkTos cpsStartFrom cpsMsgTimeoutcpsRecordStatscpsLiveBufSizecpsReadBatchSize cpsBufSizecpsMaxRetryCountcpsPreferRoundRobincpsChkPtAfterTimecpsChkPtMaxCountcpsChkPtMinCountcpsSubMaxCountcpsNamedConsStrategy dropReasonstreamResolvedEventsubscribeLastCommitPossubscribeLastEventNumbersubscribeStreamIdsubscribeResolveLinkTos1$fDecodePersistentSubscriptionStreamEventAppeared*$fDecodePersistentSubscriptionConfirmation'$fEncodePersistentSubscriptionNakEvents'$fEncodePersistentSubscriptionAckEvents'$fEncodeConnectToPersistentSubscription-$fDecodeUpdatePersistentSubscriptionCompleted$$fEncodeUpdatePersistentSubscription-$fDecodeDeletePersistentSubscriptionCompleted$$fEncodeDeletePersistentSubscription-$fDecodeCreatePersistentSubscriptionCompleted$$fEncodeCreatePersistentSubscription$fEncodeUnsubscribeFromStream$fDecodeSubscriptionDropped$fDecodeStreamEventAppeared $fDecodeSubscriptionConfirmation$fEncodeSubscribeToStreamcreateConnectRegularPackagecreateConnectPersistPackagecreatePersistActionPackagecreateAckPackagecreateNakPackagecreateUnsubscribePackageDriver_model_regCmdSubConnectEvent UnsubscribeApplyPersistAction PersistAck PersistNakInConfirmedActioncaIdcaGroupcaStreamcaAction EventAppearedDropped SubConfirmedconnectToStreamconnectToPersist createPersist updatePersist deletePersist ackPersist nakPersist newDrivercreateRExceptiondeleteRExceptionupdateRExceptiontoSubDropReasonmaybeDecodeMessage!$fExceptionPersistActionException CheckpointInput eventArrivedreadNext batchReadregularSubscriptionpersistentSubscription beforeChkcatchupSubscriptionbaseSubscriptionCheckpointNumberCheckpointPositionArrivedReadNext BatchReadCaughtUp _perGroup_subTos Processor _subDriver_opModelSubscriptionCmd ConnectStream CreatePersist UpdatePersist DeletePersist AckPersist NakPersistNewOpconnectRegularStreamconnectPersistentcreatePersistentupdatePersistentdeletePersistent newOperation newProcessorloopOpTransitionabortTransition CatchupStateRegularCatchup AllCatchupcatchupdefaultBatchSizefromReadResultnetwo_A6pE0dLgMEk2GtUa1JtTJQNetwork.SocketHostName newConnectionconnUUID connCloseconnSendconnRecvControl.Exception.Base connIsClosedexecuteGHC.IO.Handle.TypesHandleOfflineOnlineClosed_var_host_port_settsIdCloseSendRecvnewStatesecsregularConnection$fExceptionConnectionExceptionEnv_queue _pkgQueue _jobQueue_state _nextSubmit_connRef _disposed Production_submit _waitClosed CycleQueuestm_EyxFXFfnfY05IrjGaqCxeDControl.Concurrent.STM.TQueueTQueueSlot newCycleQueuereadCycleQueuewriteCycleQueueemptyCycleQueueupdateCycleQueueisEmptyCycleQueueshutdownExecutionModelpushConnectStreampushConnectPersistpushCreatePersistpushUpdatePersistpushDeletePersistpushAckPersistpushNakPersistpushUnsubscribeprodWaitTillClosedreaderwriterspawn runTransition bootstrapcruisingclosingnewExecutionModel_proc_reader_runner_writerJobMsgStoppedShutdown NewOperationProdEndWorkerReaderRunnerWriter wkUpdStatepushCmd updateProcgetLengthPrefix getPackagegetFlaggetCredEntryLengthgetCredentialsgetUUIDrunnerraiseException $fExceptionServerConnectionErrorSubState modifySubSM _unTransId_tStream _tTransId_tExpVer_tConn_subVar_subRun _subStream_subProd _subInnerSubId_prod _settings _hasCaughtUp_nextEventMaybereadStreamEventsCommonreadAllEventsCommonsubscribeFromCommon createOpAsynccreateSubAsync$fExceptionSubscriptionClosedasync_KuqnF1GrhHK5nNp6Zzm3jyControl.Concurrent.AsyncforConcurrentlymapConcurrently concurrentlyrace_racelink2link waitBothSTMwaitBothwaitEitherCancelwaitEitherSTM_ waitEither_ waitEitherSTM waitEitherwaitEitherCatchCancelwaitEitherCatchSTMwaitEitherCatch waitAnyCancel waitAnySTMwaitAnywaitAnyCatchCancelwaitAnyCatchSTM waitAnyCatch cancelWithcancelpollSTM waitCatchSTMwaitSTMpoll waitCatchwaitwithAsyncOnWithUnmaskwithAsyncWithUnmask withAsyncOnwithAsyncBound withAsyncasyncOnWithUnmaskasyncWithUnmaskasyncOn asyncBoundasync asyncThreadIdAsyncrunConcurrently Concurrently