@cratis/chronicle 0.0.1 → 0.2.0

package/dist/correlation/ICorrelationIdAccessor.js

@@ -0,0 +1,4 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+export {};
+//# sourceMappingURL=ICorrelationIdAccessor.js.map

package/dist/correlation/ICorrelationIdAccessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ICorrelationIdAccessor.js","sourceRoot":"","sources":["../../correlation/ICorrelationIdAccessor.ts"],"names":[],"mappings":"AAAA,6CAA6C;AAC7C,qGAAqG"}

package/dist/correlation/ICorrelationIdSetter.d.ts

@@ -0,0 +1,17 @@
+import { CorrelationId } from './CorrelationId';
+/**
+ * Defines the write side of a correlation identifier provider scoped to the active call context.
+ */
+export interface ICorrelationIdSetter {
+    /**
+     * Sets the current correlation identifier for the active call context.
+     * @param correlationId - The {@link CorrelationId} to set.
+     */
+    setCurrent(correlationId: CorrelationId): void;
+    /**
+     * Clears the current correlation identifier for the active call context,
+     * causing the next access to generate a new unique identifier.
+     */
+    clear(): void;
+}
+//# sourceMappingURL=ICorrelationIdSetter.d.ts.map

package/dist/correlation/ICorrelationIdSetter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ICorrelationIdSetter.d.ts","sourceRoot":"","sources":["../../correlation/ICorrelationIdSetter.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACjC;;;OAGG;IACH,UAAU,CAAC,aAAa,EAAE,aAAa,GAAG,IAAI,CAAC;IAE/C;;;OAGG;IACH,KAAK,IAAI,IAAI,CAAC;CACjB"}

package/dist/correlation/ICorrelationIdSetter.js

@@ -0,0 +1,4 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+export {};
+//# sourceMappingURL=ICorrelationIdSetter.js.map

package/dist/correlation/ICorrelationIdSetter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ICorrelationIdSetter.js","sourceRoot":"","sources":["../../correlation/ICorrelationIdSetter.ts"],"names":[],"mappings":"AAAA,6CAA6C;AAC7C,qGAAqG"}

package/dist/correlation/index.d.ts

@@ -0,0 +1,11 @@
+export { CorrelationId } from './CorrelationId';
+export type { ICorrelationIdAccessor } from './ICorrelationIdAccessor';
+export type { ICorrelationIdSetter } from './ICorrelationIdSetter';
+export { CorrelationIdManager } from './CorrelationIdManager';
+import { CorrelationIdManager } from './CorrelationIdManager';
+/**
+ * The default singleton {@link CorrelationIdManager} for the process.
+ * Use this to get and set the correlation identifier for the current async call context.
+ */
+export declare const correlationIdManager: CorrelationIdManager;
+//# sourceMappingURL=index.d.ts.map

package/dist/correlation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../correlation/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,YAAY,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AACvE,YAAY,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,oBAAoB,sBAA6B,CAAC"}

package/dist/correlation/index.js

@@ -0,0 +1,11 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+export { CorrelationId } from './CorrelationId';
+export { CorrelationIdManager } from './CorrelationIdManager';
+import { CorrelationIdManager } from './CorrelationIdManager';
+/**
+ * The default singleton {@link CorrelationIdManager} for the process.
+ * Use this to get and set the correlation identifier for the current async call context.
+ */
+export const correlationIdManager = new CorrelationIdManager();
+//# sourceMappingURL=index.js.map

package/dist/correlation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../correlation/index.ts"],"names":[],"mappings":"AAAA,6CAA6C;AAC7C,qGAAqG;AAErG,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE9D;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,oBAAoB,EAAE,CAAC"}

package/dist/eventSequences/AppendError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppendError.d.ts","sourceRoot":"","sources":["../../eventSequences/AppendError.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,WAAW;IACxB,gDAAgD;IAChD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC5B"}

package/dist/eventSequences/AppendError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppendError.js","sourceRoot":"","sources":["../../eventSequences/AppendError.ts"],"names":[],"mappings":"AAAA,6CAA6C;AAC7C,qGAAqG"}

package/dist/eventSequences/AppendOptions.d.ts

@@ -0,0 +1,14 @@
+import { Guid } from '@cratis/fundamentals';
+import type { ConcurrencyScope } from './ConcurrencyScope';
+/**
+ * Options for appending an event to an event sequence.
+ */
+export interface AppendOptions {
+    /** Optional correlation identifier for tracking the append operation. */
+    correlationId?: string | Guid;
+    /** Optional explicit sequence number to use for the event. */
+    eventSourceId?: string;
+    /** Optional concurrency scope to use for append operations. */
+    concurrencyScope?: ConcurrencyScope;
+}
+//# sourceMappingURL=AppendOptions.d.ts.map

package/dist/eventSequences/AppendOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppendOptions.d.ts","sourceRoot":"","sources":["../../eventSequences/AppendOptions.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AAC5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D;;GAEG;AACH,MAAM,WAAW,aAAa;IAC1B,yEAAyE;IACzE,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAE9B,8DAA8D;IAC9D,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,+DAA+D;IAC/D,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACvC"}

package/dist/eventSequences/AppendOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppendOptions.js","sourceRoot":"","sources":["../../eventSequences/AppendOptions.ts"],"names":[],"mappings":"AAAA,6CAA6C;AAC7C,qGAAqG"}

package/dist/eventSequences/AppendResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppendResult.d.ts","sourceRoot":"","sources":["../../eventSequences/AppendResult.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB,0DAA0D;IAC1D,QAAQ,CAAC,cAAc,EAAE,mBAAmB,CAAC;IAE7C,mDAAmD;IACnD,QAAQ,CAAC,oBAAoB,EAAE,aAAa,CAAC,mBAAmB,CAAC,CAAC;IAElE,qDAAqD;IACrD,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IAE5C,mEAAmE;IACnE,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC/B"}

package/dist/eventSequences/AppendResult.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppendResult.js","sourceRoot":"","sources":["../../eventSequences/AppendResult.ts"],"names":[],"mappings":"AAAA,6CAA6C;AAC7C,qGAAqG"}

package/dist/eventSequences/ConcurrencyScope.d.ts

@@ -0,0 +1,19 @@
+import type { EventType } from '../events';
+/**
+ * Represents a concurrency scope for append operations.
+ */
+export interface ConcurrencyScope {
+    /** The expected sequence number used for concurrency validation. */
+    sequenceNumber: bigint;
+    /** Whether to include event source identifier as part of the scope. */
+    eventSourceId?: boolean;
+    /** Optional event stream type to scope to. */
+    eventStreamType?: string;
+    /** Optional event stream identifier to scope to. */
+    eventStreamId?: string;
+    /** Optional event source type to scope to. */
+    eventSourceType?: string;
+    /** Optional event types to scope to. */
+    eventTypes?: EventType[];
+}
+//# sourceMappingURL=ConcurrencyScope.d.ts.map

package/dist/eventSequences/ConcurrencyScope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConcurrencyScope.d.ts","sourceRoot":"","sources":["../../eventSequences/ConcurrencyScope.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,oEAAoE;IACpE,cAAc,EAAE,MAAM,CAAC;IAEvB,uEAAuE;IACvE,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB,8CAA8C;IAC9C,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,oDAAoD;IACpD,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,8CAA8C;IAC9C,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB,wCAAwC;IACxC,UAAU,CAAC,EAAE,SAAS,EAAE,CAAC;CAC5B"}

package/dist/eventSequences/ConcurrencyScope.js

@@ -0,0 +1,4 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+export {};
+//# sourceMappingURL=ConcurrencyScope.js.map

package/dist/eventSequences/ConcurrencyScope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConcurrencyScope.js","sourceRoot":"","sources":["../../eventSequences/ConcurrencyScope.ts"],"names":[],"mappings":"AAAA,6CAA6C;AAC7C,qGAAqG"}

package/dist/eventSequences/ConstraintViolation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConstraintViolation.d.ts","sourceRoot":"","sources":["../../eventSequences/ConstraintViolation.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAChC,mDAAmD;IACnD,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAE9B,6BAA6B;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB,8CAA8C;IAC9C,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACtD"}

package/dist/eventSequences/ConstraintViolation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConstraintViolation.js","sourceRoot":"","sources":["../../eventSequences/ConstraintViolation.ts"],"names":[],"mappings":"AAAA,6CAA6C;AAC7C,qGAAqG"}

package/dist/eventSequences/EventForEventSourceId.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Represents an event paired with the event source identifier it belongs to.
+ */
+export interface EventForEventSourceId {
+    /** The event source identifier for the event. */
+    readonly eventSourceId: string;
+    /** The event payload to append. */
+    readonly event: object;
+}
+//# sourceMappingURL=EventForEventSourceId.d.ts.map

package/dist/eventSequences/EventForEventSourceId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventForEventSourceId.d.ts","sourceRoot":"","sources":["../../eventSequences/EventForEventSourceId.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,qBAAqB;IAClC,iDAAiD;IACjD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAE/B,mCAAmC;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CAC1B"}

package/dist/eventSequences/EventForEventSourceId.js

@@ -0,0 +1,4 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+export {};
+//# sourceMappingURL=EventForEventSourceId.js.map

package/dist/eventSequences/EventForEventSourceId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventForEventSourceId.js","sourceRoot":"","sources":["../../eventSequences/EventForEventSourceId.ts"],"names":[],"mappings":"AAAA,6CAA6C;AAC7C,qGAAqG"}

package/dist/eventSequences/EventLog.d.ts

@@ -0,0 +1,12 @@
+import { ChronicleConnection } from '../connection';
+import { EventSequence } from './EventSequence';
+import { IEventLog } from './IEventLog';
+import { IUnitOfWorkManager } from '../transactions/IUnitOfWorkManager';
+/**
+ * Implements {@link IEventLog} by extending the base {@link EventSequence}.
+ * The event log is the default event sequence used for all domain events.
+ */
+export declare class EventLog extends EventSequence implements IEventLog {
+    constructor(eventStoreName: string, namespace: string, connection: ChronicleConnection, unitOfWorkManager: IUnitOfWorkManager);
+}
+//# sourceMappingURL=EventLog.d.ts.map

package/dist/eventSequences/EventLog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventLog.d.ts","sourceRoot":"","sources":["../../eventSequences/EventLog.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAExE;;;GAGG;AACH,qBAAa,QAAS,SAAQ,aAAc,YAAW,SAAS;gBAExD,cAAc,EAAE,MAAM,EACtB,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,mBAAmB,EAC/B,iBAAiB,EAAE,kBAAkB;CAI5C"}

package/dist/eventSequences/EventLog.js

@@ -0,0 +1,14 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+import { EventSequence } from './EventSequence';
+import { EventSequenceId } from './EventSequenceId';
+/**
+ * Implements {@link IEventLog} by extending the base {@link EventSequence}.
+ * The event log is the default event sequence used for all domain events.
+ */
+export class EventLog extends EventSequence {
+    constructor(eventStoreName, namespace, connection, unitOfWorkManager) {
+        super(EventSequenceId.eventLog, eventStoreName, namespace, connection, unitOfWorkManager);
+    }
+}
+//# sourceMappingURL=EventLog.js.map

package/dist/eventSequences/EventLog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventLog.js","sourceRoot":"","sources":["../../eventSequences/EventLog.ts"],"names":[],"mappings":"AAAA,6CAA6C;AAC7C,qGAAqG;AAGrG,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAIpD;;;GAGG;AACH,MAAM,OAAO,QAAS,SAAQ,aAAa;IACvC,YACI,cAAsB,EACtB,SAAiB,EACjB,UAA+B,EAC/B,iBAAqC;QAErC,KAAK,CAAC,eAAe,CAAC,QAAQ,EAAE,cAAc,EAAE,SAAS,EAAE,UAAU,EAAE,iBAAiB,CAAC,CAAC;IAC9F,CAAC;CACJ"}

package/dist/eventSequences/EventSequence.d.ts

@@ -0,0 +1,34 @@
+import { ChronicleConnection } from '../connection';
+import { AppendOptions } from './AppendOptions';
+import { AppendResult } from './AppendResult';
+import { EventForEventSourceId } from './EventForEventSourceId';
+import { IEventSequence } from './IEventSequence';
+import { ITransactionalEventSequence } from './ITransactionalEventSequence';
+import { EventSequenceId } from './EventSequenceId';
+import { EventSequenceNumber } from './EventSequenceNumber';
+import { IUnitOfWorkManager } from '../transactions/IUnitOfWorkManager';
+/**
+ * Implements {@link IEventSequence} by communicating with the Chronicle Kernel
+ * via gRPC using the {@link ChronicleConnection}.
+ */
+export declare class EventSequence implements IEventSequence {
+    readonly id: EventSequenceId;
+    private readonly _eventStoreName;
+    private readonly _namespace;
+    private readonly _connection;
+    private readonly _unitOfWorkManager;
+    readonly transactional: ITransactionalEventSequence;
+    constructor(id: EventSequenceId, _eventStoreName: string, _namespace: string, _connection: ChronicleConnection, _unitOfWorkManager: IUnitOfWorkManager);
+    /** @inheritdoc */
+    append(eventSourceId: string, event: object, options?: AppendOptions): Promise<AppendResult>;
+    /** @inheritdoc */
+    appendMany(eventSourceId: string, events: object[], options?: AppendOptions): Promise<AppendResult[]>;
+    appendMany(events: EventForEventSourceId[], options?: AppendOptions): Promise<AppendResult[]>;
+    /** @inheritdoc */
+    getTailSequenceNumber(eventSourceId?: string): Promise<EventSequenceNumber>;
+    /** @inheritdoc */
+    hasEventsFor(eventSourceId: string): Promise<boolean>;
+    private mapAppendResponse;
+    private toContractConcurrencyScope;
+}
+//# sourceMappingURL=EventSequence.d.ts.map

package/dist/eventSequences/EventSequence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventSequence.d.ts","sourceRoot":"","sources":["../../eventSequences/EventSequence.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAIpD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAS5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAExE;;;GAGG;AACH,qBAAa,aAAc,YAAW,cAAc;IAI5C,QAAQ,CAAC,EAAE,EAAE,eAAe;IAC5B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IAPvC,QAAQ,CAAC,aAAa,EAAE,2BAA2B,CAAC;gBAGvC,EAAE,EAAE,eAAe,EACX,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,mBAAmB,EAChC,kBAAkB,EAAE,kBAAkB;IAK3D,kBAAkB;IACZ,MAAM,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IA+FlG,kBAAkB;IACZ,UAAU,CAAC,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IACrG,UAAU,CAAC,MAAM,EAAE,qBAAqB,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAmJnG,kBAAkB;IACZ,qBAAqB,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAkCjF,kBAAkB;IACZ,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA4B3D,OAAO,CAAC,iBAAiB;IAuBzB,OAAO,CAAC,0BAA0B;CAcrC"}

package/dist/eventSequences/EventSequence.js

@@ -0,0 +1,365 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+import { SpanStatusCode } from '@opentelemetry/api';
+import { Guid } from '@cratis/fundamentals';
+import { getEventTypeFor } from '../events/eventTypeDecorator';
+import { EventSequenceNumber } from './EventSequenceNumber';
+import { TransactionalEventSequence } from './TransactionalEventSequence';
+import { ChronicleTracer } from '../Tracing';
+import { ChronicleMetrics } from '../Metrics';
+import { identityProvider } from '../identity';
+import { causationManager, CausationType } from '../auditing';
+import { correlationIdManager } from '../correlation';
+import { toContractsGuid } from '../connection/Guid';
+/**
+ * Implements {@link IEventSequence} by communicating with the Chronicle Kernel
+ * via gRPC using the {@link ChronicleConnection}.
+ */
+export class EventSequence {
+    id;
+    _eventStoreName;
+    _namespace;
+    _connection;
+    _unitOfWorkManager;
+    transactional;
+    constructor(id, _eventStoreName, _namespace, _connection, _unitOfWorkManager) {
+        this.id = id;
+        this._eventStoreName = _eventStoreName;
+        this._namespace = _namespace;
+        this._connection = _connection;
+        this._unitOfWorkManager = _unitOfWorkManager;
+        this.transactional = new TransactionalEventSequence(this, this._unitOfWorkManager);
+    }
+    /** @inheritdoc */
+    async append(eventSourceId, event, options) {
+        const eventType = getEventTypeFor(event.constructor);
+        const correlationId = options?.correlationId === undefined
+            ? Guid.as(correlationIdManager.current.value)
+            : Guid.as(options.correlationId);
+        const content = JSON.stringify(event);
+        causationManager.add(CausationType.appendEvent, { eventType: eventType.id.value });
+        const causationChain = causationManager.getCurrentChain();
+        const identity = identityProvider.getCurrent();
+        const metricAttributes = {
+            'chronicle.event_store': this._eventStoreName,
+            'chronicle.namespace': this._namespace,
+            'chronicle.event_sequence_id': this.id.value,
+            'chronicle.event_type_id': eventType.id.value
+        };
+        return ChronicleTracer.startActiveSpan('chronicle.event_sequences.append', async (span) => {
+            span.setAttribute('chronicle.event_store', this._eventStoreName);
+            span.setAttribute('chronicle.namespace', this._namespace);
+            span.setAttribute('chronicle.event_sequence_id', this.id.value);
+            span.setAttribute('chronicle.event_source_id', eventSourceId);
+            span.setAttribute('chronicle.event_type_id', eventType.id.value);
+            span.setAttribute('chronicle.event_type_generation', eventType.generation.value);
+            const startTime = Date.now();
+            try {
+                const response = await this._connection.eventSequences.append({
+                    EventStore: this._eventStoreName,
+                    Namespace: this._namespace,
+                    EventSequenceId: this.id.value,
+                    CorrelationId: toContractsGuid(correlationId),
+                    EventSourceType: 'Default',
+                    EventSourceId: eventSourceId,
+                    EventStreamType: 'Default',
+                    EventStreamId: eventSourceId,
+                    EventType: {
+                        Id: eventType.id.value,
+                        Generation: eventType.generation.value,
+                        Tombstone: eventType.tombstone
+                    },
+                    Content: content,
+                    Causation: causationChain.map(c => ({
+                        Occurred: { Value: c.occurred.toISOString() },
+                        Type: c.type.name,
+                        Properties: { ...c.properties }
+                    })),
+                    CausedBy: toContractsCausedBy(identity),
+                    ConcurrencyScope: this.toContractConcurrencyScope(options?.concurrencyScope),
+                    Tags: [],
+                    Occurred: undefined,
+                    Subject: eventSourceId
+                });
+                const duration = Date.now() - startTime;
+                const result = this.mapAppendResponse(response.SequenceNumber, response.ConstraintViolations ?? [], response.Errors ?? []);
+                span.setAttribute('chronicle.sequence_number', result.sequenceNumber.value.toString());
+                span.setStatus({ code: SpanStatusCode.OK });
+                ChronicleMetrics.eventsAppended.add(1, metricAttributes);
+                ChronicleMetrics.appendDuration.record(duration, metricAttributes);
+                if (result.constraintViolations.length > 0) {
+                    ChronicleMetrics.constraintViolations.add(result.constraintViolations.length, {
+                        'chronicle.event_store': this._eventStoreName,
+                        'chronicle.namespace': this._namespace,
+                        'chronicle.event_sequence_id': this.id.value
+                    });
+                }
+                if (result.errors.length > 0) {
+                    ChronicleMetrics.appendErrors.add(result.errors.length, {
+                        'chronicle.event_store': this._eventStoreName,
+                        'chronicle.namespace': this._namespace,
+                        'chronicle.event_sequence_id': this.id.value
+                    });
+                }
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: String(error) });
+                span.recordException(error);
+                ChronicleMetrics.appendErrors.add(1, {
+                    'chronicle.event_store': this._eventStoreName,
+                    'chronicle.namespace': this._namespace,
+                    'chronicle.event_sequence_id': this.id.value
+                });
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+    async appendMany(eventSourceIdOrEvents, eventsOrOptions, options) {
+        if (typeof eventSourceIdOrEvents !== 'string' && !Array.isArray(eventSourceIdOrEvents)) {
+            throw new Error('Invalid arguments: first parameter must be an eventSourceId string or an array of { eventSourceId, event }.');
+        }
+        if (typeof eventSourceIdOrEvents === 'string' && !Array.isArray(eventsOrOptions)) {
+            throw new Error('Invalid arguments: use appendMany(eventSourceId, events, options?) where the second parameter is an array of events.');
+        }
+        if (typeof eventSourceIdOrEvents !== 'string' && Array.isArray(eventsOrOptions)) {
+            throw new Error('Invalid arguments: use appendMany(eventsForEventSourceId, options?) where the second parameter is append options.');
+        }
+        let eventsForEventSourceIds;
+        if (typeof eventSourceIdOrEvents === 'string') {
+            const eventsArray = eventsOrOptions;
+            eventsForEventSourceIds = eventsArray.map((event) => ({
+                eventSourceId: eventSourceIdOrEvents,
+                event
+            }));
+        }
+        else {
+            eventsForEventSourceIds = eventSourceIdOrEvents;
+        }
+        const appendOptions = typeof eventSourceIdOrEvents === 'string'
+            ? options
+            : eventsOrOptions;
+        const correlationId = appendOptions?.correlationId === undefined
+            ? Guid.as(correlationIdManager.current.value)
+            : Guid.as(appendOptions.correlationId);
+        causationManager.add(CausationType.appendManyEvents, { count: String(eventsForEventSourceIds.length) });
+        const batchCausationChain = causationManager.getCurrentChain();
+        const identity = identityProvider.getCurrent();
+        const concurrencyScope = this.toContractConcurrencyScope(appendOptions?.concurrencyScope);
+        const eventsToAppend = eventsForEventSourceIds.map(({ eventSourceId, event }) => {
+            const eventType = getEventTypeFor(event.constructor);
+            return {
+                EventSourceType: 'Default',
+                EventSourceId: eventSourceId,
+                EventStreamType: 'Default',
+                EventStreamId: eventSourceId,
+                EventType: {
+                    Id: eventType.id.value,
+                    Generation: eventType.generation.value,
+                    Tombstone: eventType.tombstone
+                },
+                Content: JSON.stringify(event),
+                Causation: batchCausationChain.map(c => ({
+                    Occurred: { Value: c.occurred.toISOString() },
+                    Type: c.type.name,
+                    Properties: { ...c.properties }
+                })),
+                CausedBy: toContractsCausedBy(identity),
+                ConcurrencyScope: concurrencyScope,
+                Tags: [],
+                Occurred: undefined,
+                Subject: eventSourceId
+            };
+        });
+        const distinctEventSourceIds = [...new Set(eventsForEventSourceIds.map(_ => _.eventSourceId))];
+        const batchMetricAttributes = {
+            'chronicle.event_store': this._eventStoreName,
+            'chronicle.namespace': this._namespace,
+            'chronicle.event_sequence_id': this.id.value,
+            'chronicle.events_count': eventsForEventSourceIds.length
+        };
+        return ChronicleTracer.startActiveSpan('chronicle.event_sequences.append_many', async (span) => {
+            span.setAttribute('chronicle.event_store', this._eventStoreName);
+            span.setAttribute('chronicle.namespace', this._namespace);
+            span.setAttribute('chronicle.event_sequence_id', this.id.value);
+            if (distinctEventSourceIds.length === 1) {
+                span.setAttribute('chronicle.event_source_id', distinctEventSourceIds[0]);
+            }
+            span.setAttribute('chronicle.events_count', eventsForEventSourceIds.length);
+            const startTime = Date.now();
+            try {
+                const response = await this._connection.eventSequences.appendMany({
+                    EventStore: this._eventStoreName,
+                    Namespace: this._namespace,
+                    EventSequenceId: this.id.value,
+                    CorrelationId: toContractsGuid(correlationId),
+                    Events: eventsToAppend,
+                    Causation: batchCausationChain.map(c => ({
+                        Occurred: { Value: c.occurred.toISOString() },
+                        Type: c.type.name,
+                        Properties: { ...c.properties }
+                    })),
+                    CausedBy: toContractsCausedBy(identity),
+                    ConcurrencyScopes: {
+                        ...Object.fromEntries(distinctEventSourceIds.map(eventSourceId => [eventSourceId, concurrencyScope]))
+                    }
+                });
+                const duration = Date.now() - startTime;
+                const result = (response.SequenceNumbers ?? []).map((sequenceNumber, index) => this.mapAppendResponse(sequenceNumber, response.ConstraintViolations ?? [], (response.Errors ?? []).filter((_, errorIndex) => errorIndex === index)));
+                span.setStatus({ code: SpanStatusCode.OK });
+                ChronicleMetrics.batchAppendsPerformed.add(1, batchMetricAttributes);
+                ChronicleMetrics.eventsAppended.add(eventsForEventSourceIds.length, batchMetricAttributes);
+                ChronicleMetrics.appendManyDuration.record(duration, batchMetricAttributes);
+                const totalViolations = result.reduce((sum, appendResult) => sum + appendResult.constraintViolations.length, 0);
+                if (totalViolations > 0) {
+                    ChronicleMetrics.constraintViolations.add(totalViolations, {
+                        'chronicle.event_store': this._eventStoreName,
+                        'chronicle.namespace': this._namespace,
+                        'chronicle.event_sequence_id': this.id.value
+                    });
+                }
+                const totalErrors = result.reduce((sum, appendResult) => sum + appendResult.errors.length, 0);
+                if (totalErrors > 0) {
+                    ChronicleMetrics.appendErrors.add(totalErrors, {
+                        'chronicle.event_store': this._eventStoreName,
+                        'chronicle.namespace': this._namespace,
+                        'chronicle.event_sequence_id': this.id.value
+                    });
+                }
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: String(error) });
+                span.recordException(error);
+                ChronicleMetrics.appendErrors.add(1, {
+                    'chronicle.event_store': this._eventStoreName,
+                    'chronicle.namespace': this._namespace,
+                    'chronicle.event_sequence_id': this.id.value
+                });
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+    /** @inheritdoc */
+    async getTailSequenceNumber(eventSourceId) {
+        return ChronicleTracer.startActiveSpan('chronicle.event_sequences.get_tail_sequence_number', async (span) => {
+            span.setAttribute('chronicle.event_store', this._eventStoreName);
+            span.setAttribute('chronicle.namespace', this._namespace);
+            span.setAttribute('chronicle.event_sequence_id', this.id.value);
+            if (eventSourceId !== undefined) {
+                span.setAttribute('chronicle.event_source_id', eventSourceId);
+            }
+            try {
+                const response = await this._connection.eventSequences.getTailSequenceNumber({
+                    EventStore: this._eventStoreName,
+                    Namespace: this._namespace,
+                    EventSequenceId: this.id.value,
+                    EventSourceId: eventSourceId ?? '',
+                    EventTypes: [],
+                    EventSourceType: 'Default',
+                    EventStreamId: '',
+                    EventStreamType: 'Default'
+                });
+                const result = new EventSequenceNumber(response.SequenceNumber ?? 0n);
+                span.setAttribute('chronicle.sequence_number', result.value.toString());
+                span.setStatus({ code: SpanStatusCode.OK });
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: String(error) });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+    /** @inheritdoc */
+    async hasEventsFor(eventSourceId) {
+        return ChronicleTracer.startActiveSpan('chronicle.event_sequences.has_events_for', async (span) => {
+            span.setAttribute('chronicle.event_store', this._eventStoreName);
+            span.setAttribute('chronicle.namespace', this._namespace);
+            span.setAttribute('chronicle.event_sequence_id', this.id.value);
+            span.setAttribute('chronicle.event_source_id', eventSourceId);
+            try {
+                const response = await this._connection.eventSequences.hasEventsForEventSourceId({
+                    EventStore: this._eventStoreName,
+                    Namespace: this._namespace,
+                    EventSequenceId: this.id.value,
+                    EventSourceId: eventSourceId
+                });
+                const result = response.HasEvents ?? false;
+                span.setAttribute('chronicle.has_events', result);
+                span.setStatus({ code: SpanStatusCode.OK });
+                return result;
+            }
+            catch (error) {
+                span.setStatus({ code: SpanStatusCode.ERROR, message: String(error) });
+                span.recordException(error);
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+    mapAppendResponse(sequenceNumber, constraintViolations, errors) {
+        const mappedViolations = constraintViolations.map(violation => ({
+            constraintId: violation.ConstraintId ?? '',
+            message: violation.Message ?? '',
+            details: violation.Details ?? {}
+        }));
+        const mappedErrors = errors.map(message => ({ message }));
+        const safeSequenceNumber = sequenceNumber === 18446744073709551615n ? 0n : sequenceNumber;
+        return {
+            sequenceNumber: new EventSequenceNumber(safeSequenceNumber),
+            constraintViolations: mappedViolations,
+            errors: mappedErrors,
+            isSuccess: mappedViolations.length === 0 && mappedErrors.length === 0
+        };
+    }
+    toContractConcurrencyScope(scope) {
+        return {
+            SequenceNumber: scope?.sequenceNumber ?? EventSequenceNumber.unset.value,
+            EventSourceId: scope?.eventSourceId ?? false,
+            EventStreamType: scope?.eventStreamType ?? '',
+            EventStreamId: scope?.eventStreamId ?? '',
+            EventSourceType: scope?.eventSourceType ?? '',
+            EventTypes: (scope?.eventTypes ?? []).map(eventType => ({
+                Id: eventType.id.value,
+                Generation: eventType.generation.value,
+                Tombstone: eventType.tombstone
+            }))
+        };
+    }
+}
+/**
+ * Converts a RFC 4122 Guid string into the protobuf Guid shape used by Chronicle contracts.
+ * @param guid - The Guid to convert.
+ * @returns The converted protobuf Guid with fixed64-safe hi/lo values.
+ */
+/**
+ * Converts an {@link Identity} into the CausedBy shape used by Chronicle contracts.
+ * @param identity - The identity to convert.
+ * @returns The contracts CausedBy object.
+ */
+function toContractsCausedBy(identity) {
+    const result = {
+        Subject: identity.subject,
+        Name: identity.name,
+        UserName: identity.userName,
+        OnBehalfOf: undefined
+    };
+    if (identity.onBehalfOf !== undefined) {
+        result.OnBehalfOf = toContractsCausedBy(identity.onBehalfOf);
+    }
+    return result;
+}
+//# sourceMappingURL=EventSequence.js.map