)tD      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABC&(C) 2016 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNoneDEDDE(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone%&,D0Represents a regular stream name or $all stream. 3A stream can either point to $all or a regular one. F   F(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNoneGPure H generator.IGets the next fresh H.J Builds 2 new G s out of one.KCreates a new G.GLIJKGIJKGLIJK(C) 2016 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNoneM Gathers both an IPv4 and a port. NOPQMRSTU NOPQMRSTUNOPQMRSTU(C) 2016 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone!"05I 7Contains settings related to a connection to a cluster..The DNS name to use for discovering endpoints.9The maximum number of attempts for discovering endpoints.>The well-known endpoint on which cluster managers are running..Endpoints for seeding gossip if not using DNS.Timeout for cluster gossip.4Indicates a specific DNS server should be contacted.-Tells how the DNS server should be contacted.V&Procedure used to discover an network M.&Represents a source of cluster gossip.WThe endpoint for the external HTTP endpoint of the gossip seed. The HTTP endpoint is used rather than the TCP endpoint because it is required for the client to exchange gossip with the server. standard port which should be used here in 2113.2The host header to be sent when requesting gossip. Creates a . Creates a  with a specific HTTP header.Returns  host IP address.Returns  port. Configures a   for connecting to a cluster using gossip seeds. clusterDns = "" clusterMaxDiscoverAttempts = 10 clusterExternalGossipPort = 0 clusterGossipTimeout = 1s Configures a   for connecting to a cluster using DNS discovery. clusterMaxDiscoverAttempts = 10 clusterExternalGossipPort = 0 clusterGossipSeeds = Nothing clusterGossipTimeout = 1sYXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ VW!MRST V&XYZ[\]^_`abcdefghijklmnopqrs tuvwxyz{|}~  VW(C) 2016 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNoneI  Internal command representation.   (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 H.$Indicates connection H.%Indicates connection H&"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) 2014 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone!",05T0/Gathers every persistent subscription property.2bWhether or not the persistent subscription should resolve linkTo events to their linked events.34Where the subscription should start from (position).4UWhether or not in depth latency statistics should be tracked on this subscription.5[The amount of time after which a message should be considered to be timeout and retried.6_The maximum number of retries (due to timeout) before a message get considered to be parked.7AThe size of the buffer listening to live messages as they happen.8;The number of events read at a time when paging in history.9;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.?KSystem supported consumer strategies for use with persistent subscriptions.@_Distributes events to a single client until it is full. Then round robin to the next client.A;Distributes events to each client in a round robin fashion.BNRepresents stream metadata as a series of properties for system data and a L object for user metadata.D3When the stream is either not found or 'no stream'.E When the stream is soft-deleted.FThe name of the stream.G#The version of the metadata format.HA L$ containing user-specified metadata.IA K applies to L.JA K applies to T.K"Allows to build a structure using  functions.LRepresents stream metadata with strongly typed properties for system values and a dictionary-like interface for custom values.N3The maximum number of events allowed in the stream.O0The maximum age of events allowed in the stream.PtThe event number from which previous events can be scavenged. This is used to implement soft-deletion of streams.Q9The amount of time for which the stream head is cachable.R'The access control list for the stream.STAn enumerable of key-value pairs of keys to JSON text for user-provider metadata.T/Represents an access control list for a stream.V-Roles and users permitted to read the stream.W1Roles and users permitted to write to the stream.X2Roles and users permitted to delete to the stream.Y2Roles and users permitted to read stream metadata.Z3Roles and users permitted to write stream metadata.[Global  Connection settingsb In secondse!Represents reconnection strategy.ARepresents a package exchanged between the client and the server.f%Holds login and password information.Indicates either a  contains f data or not.gPRepresents the direction of read operation (both from $all an usual streams).hFrom beginning to endiFrom end to beginningjBA structure representing a single event or an resolved link event.l.The event, or the resolved link event if this j is a link event.mThe link event if this j is a link event.n Possible y of that event.o&Represents a previously written event.q-The event stream that this event belongs to.r*Unique identifier representing this event.s#Number of this event in the stream.tType of this event.u$Representing the data of this event.v5Representing the metadada associated with this event.w;Indicates whether the content is internally marked as json.x7Representing when this event was created in the system.ycA structure referring to a potential logical record position in the EventStore transaction file.{Commit position of the record|Prepare position of the recordKRepresents a serialized event sent by the server in a subscription context.ORepresents a serialized event representiong either an event or a link event.5Represents a serialized event coming from the server.Serializes form of an .},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 } except for  anyStream . When using  anyStream` the EventStore will do its best to assure idempotency but will not guarantee idempotency.~Holds event data.RContains event information like its type and data. Only used for write queries.!Constants for System event types.Event type for stream deleted.Event type for statistics.Event type for linkTo.Event type for stream metadata.#Event type for the system settings.Event defined by the user.jRepresent a class of error where the user is not at fault. It could be either the client or the server.Happens 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. Create an  meant to be persisted.Maps  inner data type to an  understandable by the server.Maps  inner metadata type to an ! understandable by the server."Creates an event using JSON format'Creates an event using a binary format.1Creates an event with metadata using JSON format.3Creates an event with metadata using binary format. Serializes  EventData's data to a raw . Serializes ~ metadata to a raw .Maps a } to an  understandable by the server.GThis write should not conflict with anything and should always succeed.jThe stream being written to should not yet exist. If it does exist treat that as a concurrency problem.zThe stream should exist and should be empty. If it does not exist or is not empty, treat that as a concurrency problem.oStates that the last event written to the stream should have a sequence number matching your expected value.jThe stream should exist. If it or a metadata stream does not exist treat that as a concurrency problem. smart constructor./Representing the start of the transaction file.-Representing the end of the transaction file.*Tries to parse JSON object from the given o.Converts a raw  into an r fromIntegral should be a no-op in GHC and allow eventstore to compile w GHCJS GHCJS maps CTime to Int32 (cf PR .https://github.com/YoEight/eventstore/pull/47) Constructs a o from an . Constructs a j from a . Constructs a j from a .DReturns the event that was read or which triggered the subscription.If this ja 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 j is a resolved link event.&The stream name of the original event.The ID of the original event.Maps a  into a  understandable by the server. Creates a f given a login and a password.*Constructs a heartbeat response given the H of heartbeat request.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. s_heartbeatInterval = 750 ms s_heartbeatTimeout = 1500 ms s_requireMaster = True s_credentials = Nothing s_retry = D 3 s_reconnect_delay_secs = 3 s_logger = NothingDefault SSLsettings based on .0Triggers the logger callback if it has been set.Millisecond timespanT" with no role or users whatsoever.+Gets a custom property value from metadata.*Get a custom property value from metadata.L with everything set to , using  and an empty .Maps an  to a list of  to ease the L. Serialized a T to  for serialization purpose. Serialized a L to  for serialization purpose.Read ACL property.Write ACL property.Delete ACL property.Metadata read ACL property.Metadata write ACL property.Max age metadata property.Max count metadata property.#truncated before metadata property. Cache control metadata property.ACL metadata property.2Gathers every internal metadata properties into a . It used to safely L in JSON.,Only keeps the properties the users has set. Parses a  from an  given a JSON property.Parses T.Parses L.Build a structure given a K 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 T from a J. Modifies a T using a J.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 T by the given one in a I. Updates a StreamMetadata's T given a J. Sets a custom metadata property. Builds a L from a I. Modifies a L using a IMaps a ? to a  understandable by the server.Tries to parse a ? given a raw .0System default persistent subscription settings.0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|     }~  Event typeEvent ID, generated if  Event data Event typeEvent IDData content typeMetadata content type Event dataMetadata!"LoginPassword#$%&'()*+,-./0120123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|     }~ !"#0123456789:;<=>?@ABCDEFGHFFIJKLMNOPQRSTUVWXYZ[ \]^_`abcdefghijklmno pqrstuvwxyz{|      }~ !"#$%&'()*+,-./012 (C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone!"%&0T38Internal representation of a connection with the server.40Represents connection logic action to carry out.TType of connection issue that can arise during the communication with the server.8The max reconnection attempt threshold has been reached.Use of a close 5.3TCP package sent by the server had a wrong framing.$Server sent a malformed TCP package.6Creates a new 3.7 Gets current 3 H.8 Closes the 3D. It will not retry to reconnect after that call. it means a new 3 has to be created. ) exception will be raised if the same 3 object is used after a 8 call.9Sends  to the server.:,Asks the requested amount of bytes from the ;.<2Returns True if the connection is in closed state.="Forces reconnection on given node.>kMain connection logic. It will automatically reconnect to the server when a exception occured while the ? is accessed.@ Serializes a  into raw bytes.AThe minimun size a C should have. It's basically a command byte, correlation bytes (H) and a  byte.9BCDE3FGHIJK4LMNOPQRSTU6789:<=VWXYZ>[\]^_`a@bAcdefghi 36789:<=#BCDE3FGHIJK4LMNOPQRSTU6789:<=VWXYZ>[\]^_`a@bAcdefghi (C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone,5jSAvalaible event sent by the server in the context of a persistent subscription..k/Connection to persistent subscription response.lNak processed events request.#Gathers every possible Nak actions.mAck processed events request.n-Connect to a persistent subscription request.o(Update persistent subscription response.p'Update persistent subscription outcome.q'Update persistent subscription request.r(Delete persistent subscription response.s'Delete persistent subscription outcome.t'Delete persistent subscription request.u(Create persistent subscription response.v'Create persistent subscription outcome.w'Create persistent subscription request.xQA message sent to the server to indicate the user asked to end a subscription.yBA message sent by the server when a subscription has been dropped.1Represents the reason subscription drop happened.zVSerialized 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.~w smart constructor.t smart construction.q smart constructor.n smart constructor.m smart constructor.l smart constructor.jklmnopqrstuvwxyz{|}~}jklmnopqrstuvwxyz{|}~,jklmnopqrstuvwxyz{|}~ (C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone!"%&OT&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 H 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!"$*Creates a regular subscription connection .%-Creates a persistent subscription connection .&"Creates a persistent subscription .' Creates Ack .( Create Nak .)Create an unsubscribe .$%&'()$%&'()$%&'()(C) 2016 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone.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.!Unexpected error from the server.  (C) 2016 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone*+,-./0123456789*+,-./0123456789* +,-./0123456789(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone !"%&0IOT):"Subscription driver state machine.;Driver internal state.<Subscription model.=H generator.>UHolds ongoing commands. When stored, it means an action hasn't been confirmed yet.?&Set of commands handled by the driver.@Creates a regular  Subscription connection. When a A has arrived, the driver will use the provided callback and emit a final value. It holds a stream name and `Resolve Link TOS` setting.BCreates a persistent  Subscription connection. When a A 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.C Unsubscribe from a subscription.DCreates 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.EAcks a set of Event HC to notify those events have been correctly handled. It holds a  subscription and a set of Hn representing event id. When the ack would be confirmed the driver will return the supplied final value.FNaks a set of Event HF 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.GType of inputs handled by the  Subscription driver.HCEmitted when a persistent action has been carried out successfully.I Action id.JSubscription group name.K Stream name.LPersistent 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.A=Set of events that can occurs during a subscription lifetime.MA wild event appeared !N$The subscription connection dropped.OgSubscription connection is confirmed. It means that subscription can receive events from the server.P 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.QGStarts a regular subscription connection. It returns the associated # and updates driver internal state.RJStarts a persistent subscription connection. It returns the associated # and updates driver internal state.S=Creates a persistent subscription. It returns the associated & and updates driver internal state.T=Updates a persistent subscription. It returns the associated & and updates driver internal state.U=Deletes a persistent subscription. It returns the associated $ and updates driver internal state.V}Given a persistent subscription, acknowledges a set of events have been successfully processed. It returns the associated & and updates driver internal state.WyGiven a persistent subscription, indicates a set of event haven't been processed correctly. It returns the associated & and updates driver internal state.X Unsubscribe from a subscription.YAborts every pending action.ZHandles s coming from the server.[&Handles commands coming from the user.\Creates a new subscription : state machine.H]^:_;`<=>?@BCDEFGabcHdIJKLAMNOePQ Stream name.Resolve Link TOSR Group name. Stream name. Buffer size.S Group name. Stream name.T Group name. Stream name.U Group name. Stream name.V Event ids.WReason. Event ids.XYfghijklmnopqrstuvwxyZ[\z{.:HdIJKLAeMNOPQRSTUVWXY\+]^:_;`<=>?@BCDEFGabcHdIJKLAMNOePQRSTUVWXYfghijklmnopqrstuvwxyZ[\z{(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone%&,0DOT|An operation is just a } tree.})Main operation state machine instruction.~ZLifts a pure value into the intruction tree. Also marks the end of an instruction tree. Emits an operation return value.Asks for an unused H.Send a request message given a command and an expected command. response. It also carries a callback to call when response comes in.Ends 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.$Operation result sent by the server.Asks for a unused H. Raises an .5Asks to resume the interpretation from the beginning.tSends a request to the server given a command request and response. It returns the expected deserialized message.Emits operation return value."Replaces every emitted value, via + function by calling the given callback.Maps every emitted value, via , using given function.Raises  exception.Raises  exception.Raises  exception.Raises  exception.Raises  exception.Raises  exception.Raises  exception.-|}~)|}~|}~ (C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone!"ATMain | bookkeeping state machine.,Output produces by the interpretation of an |.Produces an intermediary value.Asks for sending the given .waits for more input.&Type of requests handled by the model.Register a new |.Submit a package.Aborts every pending operation.Operation internal state.H generator.Contains all running |s.Entry of a running |. Pushes a new | to model. The given |0 state-machine is initialized and produces a . Submits a 6 to the model. If the model isn't concerned by the , it will returns  . Because |C can implement complex logic (retry for instance), it returns a Step.Aborts every pending operation.Creates a new | model state-machine. (C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone,5Delete stream response.Delete stream request. smart constructor. (C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone!"%&,OT"Returned after deleting a stream. y 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%&,DR &Represents a slice of the $all stream.Regular stream slice. Gathers common slice operations. Gets slice's js.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.% (C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone,5#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!"$Batch read on $all stream operation.(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone,5(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!",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,5&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-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%&,,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./Represents the next checkpoint to reach on a catchup subscription. Wheither it's a regular stream or the $all stream, it either point to an  or a y.0Stream catching up operation.12345,-./6789:0; 12345,-./67:012345,-./6789:0;(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone,5 <Commit transaction response.=Commit transaction request.>$Write transactional events response.?#Write transactional events request.@Start transaction response.AStart transaction request.BA smart constructor.C? smart constructor.D= smart constructor.*<EFGHIJKL=MNO>PQRS?TUVW@XYZ[A\]^_BCD`abcde$<EKLJFGHI=MNO>PQRS?TVUW@XZ[YA\]^_BCD<EFGHIJKL=MNO>PQRS?TUVW@XYZ[A\]^_BCD`abcde(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.y of the write.f Constructs a  from an .fff(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone !"%&,DRgStart transaction operation.hTransactional write operation.iTransactional commit operation.ghighighi (C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone,5jWrite events response.kWrite events request.lk smart constructor.jmnopqrsktuvwxlStreamExpected versionEventsRequire masteryzjmnorsqpktuvxwljmnopqrsktuvwxlyz!(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone!"{Write events operation.{{{"(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone !"%&,OT|Read stream metadata operation.}Set stream metadata operation.~|}|}~|}#(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone+12345,-./67:0ghi{|}$(C) 2014 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone!",AT$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 |.Aborts every pending operation.Type of inputs handled by the  driver.A command can be an | 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 |. 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!",0AT'<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.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 | 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 server.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.Q+  &(C) 2015 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone !"%&0OT8Represents a subscription id.GThis data structure is only used by catchup subscription state machine.MThis sequence is used to pack events coming from reading a stream forward.FThis sequence is used to pack events coming from live subscription.Tracks the last event read.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.%Represents a subscription life cycle.=When the server's confirmed this subscription's been created.'Reads this subscription internal state.*Modifies this subscription internal state.When an error's occured.When the server confirmed the subscription is no longer live. This action is triggered because the user asks to unsubscribe. ERetry the all subscription, this behavior is transparent to the user.  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.  Modifies  % internal state machine, letting any  untouched.Makes sure to not cause deadlock because the subscription already been confirmed but because of a connection drop, need to be recconfirmed again.We want to notify the user that something went wrong in the first phase of a catchup subscription (e.g. reading the stream forward until we catchup to stream's end). This prevents a deadlock on user side in case where the user calls  on a stream that doesn't exist.@Subscription event handler. Used during a subscription lifetime.~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 ^ 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.#Last event number read by the user.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 y)) 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.  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).&Asks for the next incoming event like ! while still being in the the .Awaits for the next event.Non blocking version of .Waits until the  has been confirmed.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.Like  but lives in  monad.Like  but lives in  monad.Non blocking version of .;Wait until unsubscription has been confirmed by the server.>Acknowledges those event ids have been successfully processed.Acknowledges that j! has been successfully processed.Acknowledges those j#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.w !"#$%& '()*+ ,-./0123456789:;<=>? @ ABCDEFGHIJ KLMNOP$If it reaches the end of the stream.QRSTUVW     X@/67'()*+0123456789:;<=FGHIJKMN     D !"#$%& '()*+ ,-./0123456789:;<=>? @ ABCDEFGHIJ KLMNOPQRSTUVW     X(C) 2014 Yorick Laupa(see the file LICENSE)!Yorick Laupa <yo.eight@gmail.com> provisional non-portableNone!",0AT! The id of a  . ;Represents a multi-request transaction with the EventStore.!4Represents a connection to a single EventStore node."4Gathers every connection type handled by the client.#HostName and Port.%*Domain name, optional DNS server and port.&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.( Returns a  Connection's [.)Asynchronously closes the !.*Sends a single  to given stream.+Sends a list of  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.0(Asynchronously commits this transaction.1nThere isn't such of thing in EventStore parlance. Basically, if you want to rollback, you just have to not 0 a  .2'Reads a single event from given stream.3)Reads events from a given stream forward.4*Reads events from a given stream backward.5*Reads events from the $all stream forward.6*Reads events from the $all stream backward7Subcribes to given stream.8Subcribes to $all stream.9HSubscribes to given stream. If last checkpoint is defined, this will 3 from that event number, otherwise from the beginning. Once last stream event reached up, a subscription request will be sent using 7.:Same as 9 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.2YZ [\]^_!`abc"#$%&'()* Stream name+ Stream name, Stream name Hard delete-. Stream name/012 Stream name Event numberResolve Link Tos3 Stream nameFrom event number Batch sizeResolve Link Tos4 Stream nameFrom event number Batch sizeResolve Link Tosd5 Batch sizeResolve Link Tos6 Batch sizeResolve Link Tosef7 Stream nameResolve Link Tos8Resolve Link Tos9 Stream nameResolve Link TosLast checkpoint Batch size:Resolve Link TosLast checkpoint Batch sizeg;<=>?@h2  0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@7!"#$%f[\]^_`abcde&)'( ~BCDEFGHFF26543<TUVWXYZLMNOPQRS,*+;KJI .-01/78     9:0123456789:;<=>?@A=>?@opqrstuvwx yz{|ghijklmn }$YZ [\]^_!`abc"#$%&'()*+,-./01234d56ef789:g;<=>?@hi'()'*+'*,'*-./012344567899:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[ \ \ ] ^ _ ` a b c d e f g h i j k l m m n o p q r s t u v v w x y z { | } } ~                                                !&"&#&#&$&%&&&'&(&)&*&+&,&-&.&/&0&1&2&3&4&5&6&7&8&9&:&;&<&=&>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmgnoopqnrstuvwwxxyzz{|}~uDL'         '      '    '   '                                                                 !  " # $ % & ' ( ) * +  , - . / 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 Q12A R S T U VWXY Z [ \']^ _ ` a b c d P e f g h i j k l m n o p q r s t u v w x y z { | F } ~                                                                                                                                           a                                      a         !  " # $ % & ' ( ) * + , - ./0123456789:;<=>?@ABCDEFGHInJKLMNOPQRSTUVWXY+Z[\]^^?@D_`Jabcdefghijklmnopqrstuvwxyz{|}~~_`aBRZa\>L  R     OP                 !""""""$$$$$$a$$$$$$$F$$$$$D$$$`$n$D$_$$ $!$"$#$X$Y$$$R$+$Z$%$$&$a$$'$($\%)%h%*%+%,%|%-%.%/%0%1%2%3456%7%8%9%:%;%<%=%>%%?%@%A%B%C%D%E%F%G%H%I%J%K%L%M%N%O%P%Q%a%a%R%S%T%U%V%V%W%X%Y%%Z%%%F%%%%%%s%)%[%3%7%\%]%^%_%`%a%b%c%(%d%e%f%g%h&i&j&k&l&m&n&o&p&q&r&s&t&u&v&w&x&y&z&{&|&}&~&&&&&&&'&&i&&%&&&&&&m&&&&&&&&&&&&&&&&&&&&&&&&&&t&Y&&&&&&&&'&(&&&&&&&&&&&&&&&?@A*eventstore-0.14.0.2-9kV4axU03H73wcxXtfjdznDatabase.EventStoreDatabase.EventStore.Logging"Database.EventStore.Internal.Utils#Database.EventStore.Internal.Stream&Database.EventStore.Internal.Generator%Database.EventStore.Internal.EndPoint&Database.EventStore.Internal.Discovery$Database.EventStore.Internal.Command"Database.EventStore.Internal.Types'Database.EventStore.Internal.Connection9Database.EventStore.Internal.Manager.Subscription.Message7Database.EventStore.Internal.Manager.Subscription.Model:Database.EventStore.Internal.Manager.Subscription.Packages7Database.EventStore.Internal.Manager.Subscription.Types9Database.EventStore.Internal.Manager.Subscription.Command8Database.EventStore.Internal.Manager.Subscription.Driver&Database.EventStore.Internal.Operation4Database.EventStore.Internal.Manager.Operation.Model;Database.EventStore.Internal.Operation.DeleteStream.Message3Database.EventStore.Internal.Operation.DeleteStream2Database.EventStore.Internal.Operation.Read.CommonData.List.NonEmptynonEmpty:|NonEmpty,classy-prelude-1.2.0.1-SFtcMU2g9TBsbdvElpaTh ClassyPrelude waitAsync'connection-0.2.8-L0AvqCa0PPA7DtwvlWwU1kNetwork.Connection.Types TLSSettings StreamName AllStream StreamTypeAll RegularStreamClusterSettings clusterDnsclusterMaxDiscoverAttemptsclusterExternalGossipPortclusterGossipSeedsclusterGossipTimeoutclusterDnsServer DnsServer DnsFilePath DnsHostName DnsHostPort GossipSeedgossipSeedHeader gossipSeedgossipSeedWithHeadergossipSeedHostgossipSeedPortgossipSeedClusterSettingsdnsClusterSettingsCommand InfoMessage ConnectingConnectionClosed Connected Disconnected PackageSentPackageReceived ErrorMessageUnexpectedExceptionLogErrorInfo$fShowInfoMessage$fShowErrorMessage $fShowLogPersistentSubscriptionSettingspsSettingsResolveLinkTospsSettingsStartFrompsSettingsExtraStatspsSettingsMsgTimeoutpsSettingsMaxRetryCountpsSettingsLiveBufSizepsSettingsReadBatchSizepsSettingsHistoryBufSizepsSettingsCheckPointAfterpsSettingsMinCheckPointCountpsSettingsMaxCheckPointCountpsSettingsMaxSubsCountpsSettingsNamedConsumerStrategySystemConsumerStrategyDispatchToSingle RoundRobinStreamMetadataResultNotFoundStreamMetadataResultDeletedStreamMetadataResultstreamMetaResultStreamstreamMetaResultVersionstreamMetaResultDataStreamMetadataBuilderStreamACLBuilderBuilderStreamMetadatastreamMetadataMaxCountstreamMetadataMaxAgestreamMetadataTruncateBeforestreamMetadataCacheControlstreamMetadataACLstreamMetadataCustom StreamACLstreamACLReadRolesstreamACLWriteRolesstreamACLDeleteRolesstreamACLMetaReadRolesstreamACLMetaWriteRolesSettingss_heartbeatIntervals_heartbeatTimeouts_requireMaster s_credentialss_retrys_reconnect_delay_secss_loggers_sslRetry Credentials ReadDirectionForwardBackward ResolvedEventresolvedEventRecordresolvedEventLinkresolvedEventPosition RecordedEventrecordedEventStreamIdrecordedEventIdrecordedEventNumberrecordedEventTyperecordedEventDatarecordedEventMetadatarecordedEventIsJsonrecordedEventCreatedPositionpositionCommitpositionPrepareExpectedVersion EventDataEvent EventTypeStreamDeletedTypeStatsCollectionType LinkToTypeStreamMetadataType SettingsType UserDefined createEventwithJson withBinarywithJsonAndMetadatawithBinaryAndMetadata anyVersionnoStreamVersionemptyStreamVersionexactEventVersion streamExists positionStart positionEndrecordedEventDataAsJsonresolvedEventOriginalresolvedEventDataAsJsonisEventResolvedLinkresolvedEventOriginalStreamIdresolvedEventOriginalId credentialsatMost keepRetryingdefaultSettingsdefaultSSLSettingsemptyStreamACLgetCustomPropertyValuegetCustomPropertyemptyStreamMetadata setReadRoles setReadRole setWriteRoles setWriteRolesetDeleteRoles setDeleteRolesetMetaReadRolessetMetaReadRolesetMetaWriteRolessetMetaWriteRolebuildStreamACLmodifyStreamACL setMaxCount setMaxAgesetTruncateBeforesetCacheControlsetACL modifyACLsetCustomPropertybuildStreamMetadatamodifyStreamMetadata%defaultPersistentSubscriptionSettingsConnectionExceptionMaxAttemptConnectionReachedClosedConnectionWrongPackageFramingPackageParsingError NakAction NA_UnknownNA_ParkNA_RetryNA_SkipNA_Stop DropReasonD_UnsubscribedD_AccessDenied D_NotFoundD_PersistentSubscriptionDeletedD_SubscriberMaxCountReached SubDropReasonSubUnsubscribedSubAccessDenied SubNotFoundSubPersistDeleted SubAbortedSubNotAuthenticatedSubServerError SubNotHandledSubClientErrorSubSubscriberMaxCountReachedPersistActionExceptionPersistActionFailPersistActionAlreadyExistPersistActionDoesNotExistPersistActionAccessDeniedPersistActionAbortedOperationErrorWrongExpectedVersion StreamDeletedInvalidTransaction AccessDeniedInvalidServerResponseProtobufDecodingError ServerErrorInvalidOperationNotAuthenticatedOpAborted DeleteResultAllSlice StreamSliceSliceLoc sliceEventssliceDirectionsliceEOS sliceFrom sliceNext ReadResult ReadSuccess ReadNoStreamReadStreamDeletedReadNotModified ReadErrorReadAccessDenied ReadEventReadEventNotFoundreadEventStreamreadEventNumberreadEventResolved WriteResultwriteNextExpectedVersion writePositionSubscriptionIdSubscriptionClosedSubscriptionUnsubscribedByUser Subscription PersistentCatchupRegulargetSubId getSubStream unsubscribeisSubscribedToAllgetSubLastCommitPosgetSubLastEventNumber nextEventnextEventMaybewaitConfirmationgetSubResolveLinkTos hasCaughtUpwaitTillCatchuphasCaughtUpSTMunsubscribeConfirmedSTMunsubscribeConfirmedwaitUnsubscribeConfirmednotifyEventsProcessed acknowledgeacknowledgeEventsfailed eventsFailednotifyEventsFailed TransactionId Transaction ConnectionConnectionTypeStaticClusterDnsconnectwaitTillClosedconnectionSettingsshutdown sendEvent sendEvents deleteStream transactionIdstartTransactiontransactionWritetransactionCommittransactionRollback readEventreadStreamEventsForwardreadStreamEventsBackwardreadAllEventsForwardreadAllEventsBackward subscribesubscribeToAll subscribeFromsubscribeToAllFromsetStreamMetadatagetStreamMetadatacreatePersistentSubscriptionupdatePersistentSubscriptiondeletePersistentSubscriptionconnectToPersistentSubscription$fEqTransactionId$fOrdTransactionId$fShowTransactionId prettyWord8padding$fShowStreamName Generator'uuid-types-1.0.3-KkJukRoC73NBxNhM2Y1VW9Data.UUID.Types.InternalUUIDnextUUIDsplitGenerator newGeneratorEndPoint NodeEndPoints tcpEndPointsecureEndPoint endPointIp endPointPort emptyEndPoint DiscoverygossipEndpointAState ClusterInfomembers MemberInfo _instanceId_state_isAlive_internalTcpIp_internalTcpPort_externalTcpIp_externalTcpPort_internalHttpIp_internalHttpPort_externalHttpIp_externalHttpPort_lastCommitPosition_writerCheckpoint_chaserCheckpoint_epochPosition _epochNumber_epochId _nodePriorityGUUID VNodeState InitializingUnknown PreReplica CatchingUpCloneSlave PreMasterMasterManager ShuttingDownShutdown runDiscoveryDnsDiscoveryExceptionMaxDiscoveryAttemptReachedDNSDiscoveryError httpRequestemptyGossipSeedstaticEndPointDiscoverysimpleDnsEndPointDiscoveryclusterDnsEndPointDiscoverydiscoverEndPointtryGetGossipFromtryDetermineBestNodegossipCandidatesFromOldGossiparrangeGossipCandidatesgossipCandidatesFromDns resolveDns shuffleAllshuffle forRange_ forArrayFirst forRangeFirst$fFromJSONClusterInfo$fFromJSONMemberInfo$fFromJSONGUUID$fFromJSONVNodeState $fExceptionDnsDiscoveryExceptioncmdWord8 $fShowCommandGHC.BaseMonoidPackageFlagResolvedEventBufResolvedIndexedEvent EventRecordNewEventInternalExceptionConnectionClosedByServer eventDataTypeGHC.IntInt32eventMetadataTypeeventDataBytesbytestring-0.10.8.1Data.ByteString.Internal ByteStringeventMetadataBytesexpVersionInt32newEventtoUTCInt64 time-1.6.0.1Data.Time.Clock.UTCUTCTimenewRecordedEventnewResolvedEventnewResolvedEventFromBuf flagWord8GHC.WordWord8heartbeatResponsePackage _settingsLog msDiffTimeNothing$aeson-1.2.0.0-EbPrqFF8uEn6JTr1dCEeDTData.Aeson.Types.InternalObjectcustomMetaToPairsPair streamACLJSON'protobuf-0.2.1.1-B67d5HadBUcCmXNKGsiOf0Data.ProtocolBuffers.TypesValuestreamMetadataJSON p_readRoles p_writeRoles p_deleteRolesp_metaReadRolesp_metaWriteRolesp_maxAge p_maxCountp_truncateBeforep_cacheControlp_aclinternalMetaPropertiescontainers-0.5.7.1 Data.Set.BaseSetkeepUserPropertiesparseNominalDiffTimeNominalDiffTimeparseStreamACLparseStreamMetadatabuild strategyText#text-1.2.2.1-9Yh8rJoh8fO2JMLWffT3QsData.Text.InternalTextstrategyFromTextAtMost KeepRetrying packageCmdpackageCorrelation packageData packageCred credLogin credPasswordNone AuthenticatedresolvedEventBufEventresolvedEventBufLinkresolvedEventBufCommitPositionresolvedEventBufPreparePosition NotHandledBufnotHandledReasonnotHandledAdditionalInfo MasterInfomasterExternalTcpAddrmasterExternalTcpPortmasterExternalHttpAddrmasterExternalHttpPortmasterExternalSecureTcpAddrmasterExternalSecureTcpPort MasterInfoBufbufMasterExternalTcpAddrbufMasterExternalTcpPortbufMasterExternalHttpAddrbufMasterExternalHttpPortbufMasterExternalSecureTcpAddrbufMasterExternalSecureTcpPortNotHandledReason N_NotReady N_TooBusy N_NotMasterresolvedIndexedRecordresolvedIndexedLinkeventRecordStreamIdeventRecordNumber eventRecordIdeventRecordTypeeventRecordDataTypeeventRecordMetadataTypeeventRecordDataeventRecordMetadataeventRecordCreatedeventRecordCreatedEpoch newEventId newEventTypenewEventDataTypenewEventMetadataType newEventDatanewEventMetadataAnyNoStream EmptyStreamExact StreamExistsJsonBinary eventTypeeventId eventData eventTypeTexteventTypeFromStr masterInfomasterInfoNodeEndPointspackageDataAsText$fToJSONStreamMetadata$fFromJSONStreamMetadata$fToJSONStreamACL$fFromJSONStreamACL $fOrdPosition $fEqPosition$fDecodeResolvedEventBuf$fDecodeNotHandledBuf$fDecodeMasterInfoBuf$fDecodeResolvedIndexedEvent$fDecodeEventRecord$fEncodeNewEvent$fShowEventType$fIsStringEventType$fExceptionInternalExceptionInternalConnectionStatus newConnectionconnUUID connCloseconnSendconnRecv.safe-exceptions-0.1.5.0-6HI4Z0GJ9z5EoVlrctRBFzControl.Exception.Safehandle connIsClosedconnForceReconnectexecuteGHC.IO.Handle.TypesHandle putPackage mandatorySizeStateOfflineOnlineClosed_var_last_disc_setts_ctxNoopWithConnectionCreateConnectionErroredInIdCloseSendRecvForceReconnect onlineLogic offlineLogic closedLogicconnectionLogic handleInputreachedMaxAttemptisSslopenConnectionsecsrecvsendcredSizegetLengthPrefix getPackagegetFlaggetCredEntryLengthgetCredentialsgetUUID$fExceptionConnectionException)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$fEncodeSubscribeToStreamModel _stPending _stRunning _stAction ConfirmedConfirmedConnectionConfirmedPersistActionMetaConnectAction Unsubscribed PersistActionQueryRequestRunning RunningRegRunningPersistPending PendingRegPendingPersist PendingActionrunningLastEventNumberrunningLastCommitPosition runningUUIDquerySubscriptionqueryPersistentAction connectRegconnectPersist persistActionconfirmedSubscriptionconfirmedAction unsubscribednewModel modelHandle RegularMeta PersistMeta ConnectRegConnectPersistQuerySub QueryActionExecuteRegister_paGroup _paStream_paTpe PersistCreate PersistUpdate PersistDelete emptyStatecreateConnectRegularPackagecreateConnectPersistPackagecreatePersistActionPackagecreateAckPackagecreateNakPackagecreateUnsubscribePackage ServerMessageEventAppearedMsgPersistentEventAppearedMsgConfirmationMsgPersistentConfirmationMsgPersistentCreatedMsgPersistentUpdatedMsgPersistentDeletedMsg DroppedMsg BadRequestMsg NotHandledMsgNotAuthenticatedMsg UnknownMsgtoSubDropReasondecodeServerMessagemaybeDecodeMessageDriverInternal_model_gen_regCmdSubConnectEvent UnsubscribeApplyPersistAction PersistAck PersistNakConfirmedActioncaIdcaGroupcaStreamcaAction EventAppearedDropped SubConfirmed submitPackageconnectToStreamconnectToPersist createPersist updatePersist deletePersist ackPersist nakPersistabort handleMsg handleCmd newDriverDriverMPkgAbortcreateRExceptiondeleteRExceptionupdateRExceptioncmdSubCallback initInternalnoopmodelSubRunningmodelSubConfirmedmodelActionConfirmedmodelUnsubscribedregisterDelete registerAddmodelPersistentAction freshUUIDmodelConnectRegmodelConnectPersistmodelPersistAction runDriverM runDriver handleDriver$fMonadTransDriverM!$fExceptionPersistActionException OperationSMReturnYieldFreshIdSendPkgFailureOpResultfreshIdfailureretryyieldforeachmapOp wrongVersion streamDeletedinvalidTransaction accessDeniedprotobufDecodingError serverErrorinvalidServerResponse OP_SUCCESSOP_PREPARE_TIMEOUTOP_COMMIT_TIMEOUTOP_FORWARD_TIMEOUTOP_WRONG_EXPECTED_VERSIONOP_STREAM_DELETEDOP_INVALID_TRANSACTIONOP_ACCESS_DENIED $fMonadSM$fApplicativeSM $fFunctorSM$fExceptionOperationError TransitionProduceTransmitAwaitNew_pendingElem pushOperation NotHandled_opOp_opCmd_opCont_opCb initState runOperation runPackageabortOperationsResponse newRequest_result_message_preparePosition_commitPosition _streamId_expectedVersion_requireMaster _hardDelete$fDecodeResponse$fEncodeRequest_saFrom_saNext_saDir _saEvents_saEOS sliceStream sliceLast_ssDir_ssFrom_ssNext _ssEvents_ssEOS$fSliceAllSlice$fSliceStreamSlice$fTraversableReadResult$fFoldableReadResult$fFunctorReadResult$fShowReadResult$fEqReadResultResult_CommitPosition_PreparePosition_Events_NextCommitPosition_NextPreparePosition_Result_ErrorSUCCESS NOT_MODIFIEDERROR ACCESS_DENIED _maxCount_resolveLinkTos readAllEvents _indexedEvent_error NOT_FOUND NO_STREAMSTREAM_DELETED _eventNumber_events _nextNumber _lastNumber _endOfStreamreadStreamEvents CatchupStateRegularCatchup AllCatchup CheckpointcatchupCatchupOpResultcatchupReadEventscatchupEndOfStreamcatchupCheckpointCheckpointNumberCheckpointPositiondefaultBatchSizestreamNotFoundcatchupStreamNamefromReadResult CommittedCommitWrittenWriteStartedStartnewStartnewWrite newCommit _ccTransId _ccResult _ccMessage _firstNumber _cTransId_cRequireMaster _wwTransId _wwResult _wwMessage _wTransId_wRequireMaster_transId$fDecodeCommitted$fEncodeCommit$fDecodeWritten $fEncodeWrite$fDecodeStarted $fEncodeStarteventToNewEventtransactionStart writeEventsreadMetaStream setMetaStream metaStream invalidFormat onReadResult Processor _subDriver_opModelSubscriptionCmd ConnectStream CreatePersist UpdatePersist DeletePersist AckPersist NakPersistNewOpconnectRegularStreamconnectPersistentcreatePersistentupdatePersistentdeletePersistent newOperation newProcessorForceReconnectCmdloopOpTransitionabortTransitionEnv_queue _pkgQueue _jobQueue _nextSubmit_connVar _disposed Production_submit _waitClosed CycleQueue"stm-2.4.4.1-4z2NRWnB0NIIUvSJsHW0kFControl.Concurrent.STM.TQueueTQueueSlot newCycleQueuereadCycleQueuewriteCycleQueueemptyCycleQueueupdateCycleQueueisEmptyCycleQueueshutdownExecutionModelpushConnectStreampushConnectPersistpushCreatePersistpushUpdatePersistpushDeletePersistpushAckPersistpushNakPersistpushUnsubscribeprodWaitTillClosedreaderwriterspawn runTransition bootstrapcruisingclosingnewExecutionModelForceReconnectExceptionForceReconnectionException_proc_reader_runner_writerJobMsgStoppedArrived NewOperationProdEndWorkerReaderRunnerWriter wkUpdStatepushCmdpushForceReconnect updateProcrunnerraiseExceptionhandles"$fExceptionForceReconnectExceptionCatchupSMState csmReadSeq csmLiveSeq csmLastNum SubLifeCycle onConfirm readState writeStateonErroronUserUnsubscribedretrySubSubStateMachineInput modifySubSMSubState confirmSubcatchupOpEventHandlersubEventHandlereventArrivedSM readNextSM batchReadSM hasCaughtUpSMlastEventNumSMregularSubscriptionpersistentSubscription beforeChkcatchupSubscriptionbaseSubStateMachinenextEventMaybeSTM GHC.Conc.SyncSTMSubId csmLastPos subStream subLifeCyclesubEnvsubRunsubType CatchupParamscatchupResLnkTos catchupStatecatchupBatchSize SubOnline SubDropped SubExceptionSubUserUnsubscribedSubEnv subSettings subPushOpsubPushConnect subPushUnsub subAckCmdsubForceReconnectAckCmdNakCmdPushCmd PushRegularPushPersistent PushConnectPushOpReadNext BatchReadCaughtUp LastEventNum _perGroup_subTos catchupSubtryRetryCatcupSubscription regularSub persistentSubsubNotHandledMsgcreateCatchupOperationinitialCatchupSMStateinsertReadEventsinsertLiveEventreadNextFromBatchSeqreadNextFromLiveSeqlastEventNumberisBatchReqEmpty$fExceptionSubscriptionClosed _unTransId_tStream _tTransId_tExpVer_tConn_prod _settings_typereadStreamEventsCommonreadAllEventsCommonmkSubEnvsubscribeFromCommon createOpAsync