@azure/event-hubs 6.0.2-alpha.20251015.1 → 6.0.2-alpha.20251023.1

package/dist/react-native/models/public.d.ts

@@ -0,0 +1,240 @@
+import type { RetryOptions, WebSocketOptions } from "@azure/core-amqp";
+import type { OperationOptions } from "../util/operationOptions.js";
+/**
+ * The set of options to configure the behavior of `getEventHubProperties`.
+ * - `abortSignal`  : An implementation of the `AbortSignalLike` interface to signal the request to cancel the operation.
+ * - `parentSpan` : The `Span` or `SpanContext` to use as the `parent` of the span created while calling this operation.
+ */
+export interface GetEventHubPropertiesOptions extends OperationOptions {
+}
+/**
+ * The set of options to configure the behavior of `getPartitionProperties`.
+ * - `abortSignal`  : An implementation of the `AbortSignalLike` interface to signal the request to cancel the operation.
+ * - `parentSpan` : The `Span` or `SpanContext` to use as the `parent` of the span created while calling this operation.
+ */
+export interface GetPartitionPropertiesOptions extends OperationOptions {
+}
+/**
+ * The set of options to configure the behavior of `getPartitionIds`.
+ * - `abortSignal`  : An implementation of the `AbortSignalLike` interface to signal the request to cancel the operation.
+ * - `parentSpan` : The `Span` or `SpanContext` to use as the `parent` of the span created while calling this operation.
+ */
+export interface GetPartitionIdsOptions extends OperationOptions {
+}
+/**
+ * Options to configure the `sendBatch` method on the `EventHubProducerClient`
+ * when sending an array of events.
+ * If `partitionId` is set, `partitionKey` must not be set and vice versa.
+ *
+ * - `partitionId`  : The partition this batch will be sent to.
+ * - `partitionKey` : A value that is hashed to produce a partition assignment.
+ * - `abortSignal`  : A signal used to cancel the send operation.
+ */
+export interface SendBatchOptions extends OperationOptions {
+    /**
+     * The partition this batch will be sent to.
+     * If this value is set then partitionKey can not be set.
+     */
+    partitionId?: string;
+    /**
+     * A value that is hashed to produce a partition assignment.
+     * It guarantees that messages with the same partitionKey end up in the same partition.
+     * Specifying this will throw an error if the producer was created using a `partitionId`.
+     */
+    partitionKey?: string;
+}
+/**
+ * The set of options to configure the `send` operation on the `EventHubProducer`.
+ * - `partitionKey` : A value that is hashed to produce a partition assignment.
+ * - `abortSignal`  : A signal used to cancel the send operation.
+ *
+ * Example usage:
+ * ```ts snippet:ignore
+ * {
+ *     partitionKey: 'foo'
+ * }
+ * ```
+ *
+ * @internal
+ */
+export interface SendOptions extends OperationOptions {
+    /**
+     * A value that is hashed to produce a partition assignment.
+     * It guarantees that messages with the same partitionKey end up in the same partition.
+     * Specifying this will throw an error if the producer was created using a `partitionId`.
+     */
+    partitionKey?: string;
+}
+/**
+ * An enum representing the different reasons for an `EventHubConsumerClient` to stop processing
+ * events from a partition in a consumer group of an Event Hub.
+ */
+export declare enum CloseReason {
+    /**
+     * Ownership of the partition was lost or transitioned to a new processor instance.
+     */
+    OwnershipLost = "OwnershipLost",
+    /**
+     * The EventProcessor was shutdown.
+     */
+    Shutdown = "Shutdown"
+}
+/**
+ * Describes the options that can be provided while creating the EventHubClient.
+ * - `userAgent`        : A string to append to the built in user agent string that is passed as a connection property
+ * to the service.
+ * - `webSocketOptions` : Options to configure the channelling of the AMQP connection over Web Sockets.
+ *    - `websocket`     : The WebSocket constructor used to create an AMQP connection if you choose to make the connection
+ * over a WebSocket.
+ *    - `webSocketConstructorOptions` : Options to pass to the Websocket constructor when you choose to make the connection
+ * over a WebSocket.
+ * - `retryOptions`     : The retry options for all the operations on the client/producer/consumer.
+ *    - `maxRetries` : The number of times the operation can be retried in case of a retryable error.
+ *    - `maxRetryDelayInMs`: The maximum delay between retries. Applicable only when performing exponential retries.
+ *    - `mode`: Which retry mode to apply, specified by the `RetryMode` enum. Options are `Exponential` and `Fixed`. Defaults to `Fixed`.
+ *    - `retryDelayInMs`: Amount of time to wait in milliseconds before making the next attempt. When `mode` is set to `Exponential`,
+ *       this is used to compute the exponentially increasing delays between retries. Default: 30000 milliseconds.
+ *    - `timeoutInMs`: Amount of time in milliseconds to wait before the operation times out. This will trigger a retry if there are any
+ *       retry attempts remaining. Default value: 60000 milliseconds.
+ *
+ * A simple usage can be `{ "maxRetries": 4 }`.
+ *
+ * Example usage:
+ * ```ts snippet:ignore
+ * {
+ *     retryOptions: {
+ *         maxRetries: 4
+ *     }
+ * }
+ * ```
+ */
+export interface EventHubClientOptions {
+    /**
+     * A custom endpoint to use when connecting to the Event Hubs service.
+     * This can be useful when your network does not allow connecting to the
+     * standard Azure Event Hubs endpoint address, but does allow connecting
+     * through an intermediary.
+     *
+     * Example: "https://my.custom.endpoint:100/"
+     */
+    customEndpointAddress?: string;
+    /**
+     * Options to configure the retry policy for all the operations on the client.
+     * For example, `{ "maxRetries": 4 }` or `{ "maxRetries": 4, "retryDelayInMs": 30000 }`.
+     *
+     */
+    retryOptions?: RetryOptions;
+    /**
+     * Options to configure the channelling of the AMQP connection over Web Sockets.
+     */
+    webSocketOptions?: WebSocketOptions;
+    /**
+     * Value that is appended to the built in user agent string that is passed to the Event Hubs service.
+     */
+    userAgent?: string;
+    /**
+     * A unique name used to identify the client.  If not provided, a GUID will be used as the identifier
+     */
+    identifier?: string;
+}
+/**
+ * Describes the options that can be provided while creating the EventHubConsumerClient.
+ * - `loadBalancingOptions`: Options to tune how the EventHubConsumerClient claims partitions.
+ * - `userAgent`        : A string to append to the built in user agent string that is passed as a connection property
+ * to the service.
+ * - `webSocketOptions` : Options to configure the channelling of the AMQP connection over Web Sockets.
+ *    - `websocket`     : The WebSocket constructor used to create an AMQP connection if you choose to make the connection
+ * over a WebSocket.
+ *    - `webSocketConstructorOptions` : Options to pass to the Websocket constructor when you choose to make the connection
+ * over a WebSocket.
+ * - `retryOptions`     : The retry options for all the operations on the client/producer/consumer.
+ *    - `maxRetries` : The number of times the operation can be retried in case of a retryable error.
+ *    - `maxRetryDelayInMs`: The maximum delay between retries. Applicable only when performing exponential retries.
+ *    - `mode`: Which retry mode to apply, specified by the `RetryMode` enum. Options are `Exponential` and `Fixed`. Defaults to `Fixed`.
+ *    - `retryDelayInMs`: Amount of time to wait in milliseconds before making the next attempt. When `mode` is set to `Exponential`,
+ *       this is used to compute the exponentially increasing delays between retries. Default: 30000 milliseconds.
+ *    - `timeoutInMs`: Amount of time in milliseconds to wait before the operation times out. This will trigger a retry if there are any
+ *       retry attempts remaining. Default value: 60000 milliseconds.
+ *
+ * A simple usage can be `{ "maxRetries": 4 }`.
+ *
+ * Example usage:
+ * ```ts snippet:ignore
+ * {
+ *     retryOptions: {
+ *         maxRetries: 4
+ *     }
+ * }
+ * ```
+ */
+export interface EventHubConsumerClientOptions extends EventHubClientOptions {
+    /**
+     * Options to tune how the EventHubConsumerClient claims partitions.
+     */
+    loadBalancingOptions?: LoadBalancingOptions;
+}
+/**
+ * An options bag to configure load balancing settings.
+ */
+export interface LoadBalancingOptions {
+    /**
+     * Whether to apply a greedy or a more balanced approach when
+     * claiming partitions.
+     *
+     * - balanced: The `EventHubConsumerClient` will take a measured approach to
+     * requesting partition ownership when balancing work with other clients,
+     * slowly claiming partitions until a stabilized distribution is achieved.
+     *
+     * - greedy: The `EventHubConsumerClient` will attempt to claim ownership
+     * of its fair share of partitions aggressively when balancing work with
+     * other clients.
+     *
+     * This option is ignored when either:
+     *   - `CheckpointStore` is __not__ provided to the `EventHubConsumerClient`.
+     *   - `subscribe()` is called for a single partition.
+     * Default: balanced
+     */
+    strategy?: "balanced" | "greedy";
+    /**
+     * The length of time between attempts to claim partitions.
+     * Default: 10000
+     */
+    updateIntervalInMs?: number;
+    /**
+     * The length of time a partition claim is valid.
+     * Default: 60000
+     */
+    partitionOwnershipExpirationIntervalInMs?: number;
+}
+/**
+ * Options to configure the `createBatch` method on the `EventHubProducerClient`.
+ * - `partitionKey`  : A value that is hashed to produce a partition assignment.
+ * - `maxSizeInBytes`: The upper limit for the size of batch.
+ * - `abortSignal`   : A signal the request to cancel the send operation.
+ *
+ * Example usage:
+ * ```ts snippet:ignore
+ * {
+ *     partitionKey: 'foo',
+ *     maxSizeInBytes: 1024 * 1024 // 1 MB
+ * }
+ * ```
+ */
+export interface CreateBatchOptions extends OperationOptions {
+    /**
+     * A value that is hashed to produce a partition assignment. It guarantees that messages
+     * with the same partitionKey end up in the same partition.
+     * If this value is set then partitionId can not be set.
+     */
+    partitionKey?: string;
+    /**
+     * The partition this batch will be sent to.
+     * If this value is set then partitionKey can not be set.
+     */
+    partitionId?: string;
+    /**
+     * The upper limit for the size of batch. The `tryAdd` function will return `false` after this limit is reached.
+     */
+    maxSizeInBytes?: number;
+}
+//# sourceMappingURL=public.d.ts.map

package/dist/react-native/models/public.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public.d.ts","sourceRoot":"","sources":["../../../src/models/public.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAEpE;;;;GAIG;AACH,MAAM,WAAW,4BAA6B,SAAQ,gBAAgB;CAAG;AAEzE;;;;GAIG;AACH,MAAM,WAAW,6BAA8B,SAAQ,gBAAgB;CAAG;AAE1E;;;;GAIG;AACH,MAAM,WAAW,sBAAuB,SAAQ,gBAAgB;CAAG;AAEnE;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAiB,SAAQ,gBAAgB;IACxD;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,WAAY,SAAQ,gBAAgB;IACnD;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;GAGG;AACH,oBAAY,WAAW;IACrB;;OAEG;IACH,aAAa,kBAAkB;IAC/B;;OAEG;IACH,QAAQ,aAAa;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;;OAOG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;OAIG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B;;OAEG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,WAAW,6BAA8B,SAAQ,qBAAqB;IAC1E;;OAEG;IACH,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC7C;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,EAAE,UAAU,GAAG,QAAQ,CAAC;IACjC;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;OAGG;IACH,wCAAwC,CAAC,EAAE,MAAM,CAAC;CACnD;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,kBAAmB,SAAQ,gBAAgB;IAC1D;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB"}

package/dist/react-native/models/public.js

@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+/**
+ * An enum representing the different reasons for an `EventHubConsumerClient` to stop processing
+ * events from a partition in a consumer group of an Event Hub.
+ */
+export var CloseReason;
+(function (CloseReason) {
+    /**
+     * Ownership of the partition was lost or transitioned to a new processor instance.
+     */
+    CloseReason["OwnershipLost"] = "OwnershipLost";
+    /**
+     * The EventProcessor was shutdown.
+     */
+    CloseReason["Shutdown"] = "Shutdown";
+})(CloseReason || (CloseReason = {}));
+//# sourceMappingURL=public.js.map

package/dist/react-native/models/public.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"public.js","sourceRoot":"","sources":["../../../src/models/public.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAwElC;;;GAGG;AACH,MAAM,CAAN,IAAY,WASX;AATD,WAAY,WAAW;IACrB;;OAEG;IACH,8CAA+B,CAAA;IAC/B;;OAEG;IACH,oCAAqB,CAAA;AACvB,CAAC,EATW,WAAW,KAAX,WAAW,QAStB","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { RetryOptions, WebSocketOptions } from \"@azure/core-amqp\";\nimport type { OperationOptions } from \"../util/operationOptions.js\";\n\n/**\n * The set of options to configure the behavior of `getEventHubProperties`.\n * - `abortSignal`  : An implementation of the `AbortSignalLike` interface to signal the request to cancel the operation.\n * - `parentSpan` : The `Span` or `SpanContext` to use as the `parent` of the span created while calling this operation.\n */\nexport interface GetEventHubPropertiesOptions extends OperationOptions {}\n\n/**\n * The set of options to configure the behavior of `getPartitionProperties`.\n * - `abortSignal`  : An implementation of the `AbortSignalLike` interface to signal the request to cancel the operation.\n * - `parentSpan` : The `Span` or `SpanContext` to use as the `parent` of the span created while calling this operation.\n */\nexport interface GetPartitionPropertiesOptions extends OperationOptions {}\n\n/**\n * The set of options to configure the behavior of `getPartitionIds`.\n * - `abortSignal`  : An implementation of the `AbortSignalLike` interface to signal the request to cancel the operation.\n * - `parentSpan` : The `Span` or `SpanContext` to use as the `parent` of the span created while calling this operation.\n */\nexport interface GetPartitionIdsOptions extends OperationOptions {}\n\n/**\n * Options to configure the `sendBatch` method on the `EventHubProducerClient`\n * when sending an array of events.\n * If `partitionId` is set, `partitionKey` must not be set and vice versa.\n *\n * - `partitionId`  : The partition this batch will be sent to.\n * - `partitionKey` : A value that is hashed to produce a partition assignment.\n * - `abortSignal`  : A signal used to cancel the send operation.\n */\nexport interface SendBatchOptions extends OperationOptions {\n  /**\n   * The partition this batch will be sent to.\n   * If this value is set then partitionKey can not be set.\n   */\n  partitionId?: string;\n  /**\n   * A value that is hashed to produce a partition assignment.\n   * It guarantees that messages with the same partitionKey end up in the same partition.\n   * Specifying this will throw an error if the producer was created using a `partitionId`.\n   */\n  partitionKey?: string;\n}\n\n/**\n * The set of options to configure the `send` operation on the `EventHubProducer`.\n * - `partitionKey` : A value that is hashed to produce a partition assignment.\n * - `abortSignal`  : A signal used to cancel the send operation.\n *\n * Example usage:\n * ```ts snippet:ignore\n * {\n *     partitionKey: 'foo'\n * }\n * ```\n *\n * @internal\n */\nexport interface SendOptions extends OperationOptions {\n  /**\n   * A value that is hashed to produce a partition assignment.\n   * It guarantees that messages with the same partitionKey end up in the same partition.\n   * Specifying this will throw an error if the producer was created using a `partitionId`.\n   */\n  partitionKey?: string;\n}\n\n/**\n * An enum representing the different reasons for an `EventHubConsumerClient` to stop processing\n * events from a partition in a consumer group of an Event Hub.\n */\nexport enum CloseReason {\n  /**\n   * Ownership of the partition was lost or transitioned to a new processor instance.\n   */\n  OwnershipLost = \"OwnershipLost\",\n  /**\n   * The EventProcessor was shutdown.\n   */\n  Shutdown = \"Shutdown\",\n}\n\n/**\n * Describes the options that can be provided while creating the EventHubClient.\n * - `userAgent`        : A string to append to the built in user agent string that is passed as a connection property\n * to the service.\n * - `webSocketOptions` : Options to configure the channelling of the AMQP connection over Web Sockets.\n *    - `websocket`     : The WebSocket constructor used to create an AMQP connection if you choose to make the connection\n * over a WebSocket.\n *    - `webSocketConstructorOptions` : Options to pass to the Websocket constructor when you choose to make the connection\n * over a WebSocket.\n * - `retryOptions`     : The retry options for all the operations on the client/producer/consumer.\n *    - `maxRetries` : The number of times the operation can be retried in case of a retryable error.\n *    - `maxRetryDelayInMs`: The maximum delay between retries. Applicable only when performing exponential retries.\n *    - `mode`: Which retry mode to apply, specified by the `RetryMode` enum. Options are `Exponential` and `Fixed`. Defaults to `Fixed`.\n *    - `retryDelayInMs`: Amount of time to wait in milliseconds before making the next attempt. When `mode` is set to `Exponential`,\n *       this is used to compute the exponentially increasing delays between retries. Default: 30000 milliseconds.\n *    - `timeoutInMs`: Amount of time in milliseconds to wait before the operation times out. This will trigger a retry if there are any\n *       retry attempts remaining. Default value: 60000 milliseconds.\n *\n * A simple usage can be `{ \"maxRetries\": 4 }`.\n *\n * Example usage:\n * ```ts snippet:ignore\n * {\n *     retryOptions: {\n *         maxRetries: 4\n *     }\n * }\n * ```\n */\nexport interface EventHubClientOptions {\n  /**\n   * A custom endpoint to use when connecting to the Event Hubs service.\n   * This can be useful when your network does not allow connecting to the\n   * standard Azure Event Hubs endpoint address, but does allow connecting\n   * through an intermediary.\n   *\n   * Example: \"https://my.custom.endpoint:100/\"\n   */\n  customEndpointAddress?: string;\n  /**\n   * Options to configure the retry policy for all the operations on the client.\n   * For example, `{ \"maxRetries\": 4 }` or `{ \"maxRetries\": 4, \"retryDelayInMs\": 30000 }`.\n   *\n   */\n  retryOptions?: RetryOptions;\n  /**\n   * Options to configure the channelling of the AMQP connection over Web Sockets.\n   */\n  webSocketOptions?: WebSocketOptions;\n  /**\n   * Value that is appended to the built in user agent string that is passed to the Event Hubs service.\n   */\n  userAgent?: string;\n  /**\n   * A unique name used to identify the client.  If not provided, a GUID will be used as the identifier\n   */\n  identifier?: string;\n}\n\n/**\n * Describes the options that can be provided while creating the EventHubConsumerClient.\n * - `loadBalancingOptions`: Options to tune how the EventHubConsumerClient claims partitions.\n * - `userAgent`        : A string to append to the built in user agent string that is passed as a connection property\n * to the service.\n * - `webSocketOptions` : Options to configure the channelling of the AMQP connection over Web Sockets.\n *    - `websocket`     : The WebSocket constructor used to create an AMQP connection if you choose to make the connection\n * over a WebSocket.\n *    - `webSocketConstructorOptions` : Options to pass to the Websocket constructor when you choose to make the connection\n * over a WebSocket.\n * - `retryOptions`     : The retry options for all the operations on the client/producer/consumer.\n *    - `maxRetries` : The number of times the operation can be retried in case of a retryable error.\n *    - `maxRetryDelayInMs`: The maximum delay between retries. Applicable only when performing exponential retries.\n *    - `mode`: Which retry mode to apply, specified by the `RetryMode` enum. Options are `Exponential` and `Fixed`. Defaults to `Fixed`.\n *    - `retryDelayInMs`: Amount of time to wait in milliseconds before making the next attempt. When `mode` is set to `Exponential`,\n *       this is used to compute the exponentially increasing delays between retries. Default: 30000 milliseconds.\n *    - `timeoutInMs`: Amount of time in milliseconds to wait before the operation times out. This will trigger a retry if there are any\n *       retry attempts remaining. Default value: 60000 milliseconds.\n *\n * A simple usage can be `{ \"maxRetries\": 4 }`.\n *\n * Example usage:\n * ```ts snippet:ignore\n * {\n *     retryOptions: {\n *         maxRetries: 4\n *     }\n * }\n * ```\n */\nexport interface EventHubConsumerClientOptions extends EventHubClientOptions {\n  /**\n   * Options to tune how the EventHubConsumerClient claims partitions.\n   */\n  loadBalancingOptions?: LoadBalancingOptions;\n}\n\n/**\n * An options bag to configure load balancing settings.\n */\nexport interface LoadBalancingOptions {\n  /**\n   * Whether to apply a greedy or a more balanced approach when\n   * claiming partitions.\n   *\n   * - balanced: The `EventHubConsumerClient` will take a measured approach to\n   * requesting partition ownership when balancing work with other clients,\n   * slowly claiming partitions until a stabilized distribution is achieved.\n   *\n   * - greedy: The `EventHubConsumerClient` will attempt to claim ownership\n   * of its fair share of partitions aggressively when balancing work with\n   * other clients.\n   *\n   * This option is ignored when either:\n   *   - `CheckpointStore` is __not__ provided to the `EventHubConsumerClient`.\n   *   - `subscribe()` is called for a single partition.\n   * Default: balanced\n   */\n  strategy?: \"balanced\" | \"greedy\";\n  /**\n   * The length of time between attempts to claim partitions.\n   * Default: 10000\n   */\n  updateIntervalInMs?: number;\n  /**\n   * The length of time a partition claim is valid.\n   * Default: 60000\n   */\n  partitionOwnershipExpirationIntervalInMs?: number;\n}\n\n/**\n * Options to configure the `createBatch` method on the `EventHubProducerClient`.\n * - `partitionKey`  : A value that is hashed to produce a partition assignment.\n * - `maxSizeInBytes`: The upper limit for the size of batch.\n * - `abortSignal`   : A signal the request to cancel the send operation.\n *\n * Example usage:\n * ```ts snippet:ignore\n * {\n *     partitionKey: 'foo',\n *     maxSizeInBytes: 1024 * 1024 // 1 MB\n * }\n * ```\n */\nexport interface CreateBatchOptions extends OperationOptions {\n  /**\n   * A value that is hashed to produce a partition assignment. It guarantees that messages\n   * with the same partitionKey end up in the same partition.\n   * If this value is set then partitionId can not be set.\n   */\n  partitionKey?: string;\n  /**\n   * The partition this batch will be sent to.\n   * If this value is set then partitionKey can not be set.\n   */\n  partitionId?: string;\n  /**\n   * The upper limit for the size of batch. The `tryAdd` function will return `false` after this limit is reached.\n   */\n  maxSizeInBytes?: number;\n}\n"]}

package/dist/react-native/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/react-native/partitionProcessor.d.ts

@@ -0,0 +1,134 @@
+import type { BasicPartitionProperties, PartitionContext, SubscriptionEventHandlers } from "./eventHubConsumerClientModels.js";
+import type { CheckpointStore } from "./eventProcessor.js";
+import type { CloseReason } from "./models/public.js";
+import type { LastEnqueuedEventProperties } from "./partitionReceiver.js";
+import type { ReceivedEventData } from "./eventData.js";
+/**
+ * A checkpoint is meant to represent the last successfully processed event by the user from a particular
+ * partition of a consumer group in an Event Hub instance.
+ *
+ * When the `updateCheckpoint()` method on the `PartitionProcessor` class is called by the user, a
+ * `Checkpoint` is created internally. It is then stored in the storage solution implemented by the
+ * `CheckpointManager` chosen by the user when creating an `EventProcessor`.
+ *
+ * Users are never expected to interact with `Checkpoint` directly. This interface exists to support the
+ * internal workings of `EventProcessor` and `CheckpointManager`.
+ **/
+export interface Checkpoint {
+    /**
+     * The fully qualified Event Hubs namespace. This is likely to be similar to
+     * <yournamespace>.servicebus.windows.net
+     */
+    fullyQualifiedNamespace: string;
+    /**
+     * The event hub name
+     */
+    eventHubName: string;
+    /**
+     * The consumer group name
+     */
+    consumerGroup: string;
+    /**
+     * The identifier of the Event Hub partition
+     */
+    partitionId: string;
+    /**
+     * The sequence number of the event
+     */
+    sequenceNumber: number;
+    /**
+     * The offset of the event.
+     */
+    offset: string;
+}
+/**
+ * The `PartitionProcessor` is responsible for processing events received from Event Hubs when using `EventProcessor`
+ *
+ * The EventProcessor creates a new instance of the PartitionProcessor for each partition of the event hub it starts processing. When you extend the `PartitionProcessor` in order to customize it as you see fit,
+ * - Override the `processEvents()` method to add the code to process the received events. This is also a good place to update the checkpoints using the `updateCheckpoint()` method
+ * - Optionally override the `processError()` method to handle any error that might have occurred when processing the events.
+ * - Optionally override the `initialize()` method to implement any set up related tasks you would want to carry out before starting to receive events from the partition
+ * - Optionally override the `close()` method to implement any tear down or clean up tasks you would want to carry out.
+ * @internal
+ */
+export declare class PartitionProcessor implements PartitionContext {
+    private _eventHandlers;
+    private _checkpointStore;
+    private _context;
+    private _lastEnqueuedEventProperties?;
+    constructor(_eventHandlers: SubscriptionEventHandlers, _checkpointStore: CheckpointStore, _context: BasicPartitionProperties & {
+        eventProcessorId: string;
+    });
+    /**
+     * Information on the last enqueued event in the partition that is being processed.
+     * This property is updated by the `EventProcessor` if the `trackLastEnqueuedEventProperties` option is set to true
+     * when creating an instance of EventProcessor
+     * @readonly
+     */
+    get lastEnqueuedEventProperties(): LastEnqueuedEventProperties;
+    /**
+     * Information on the last enqueued event in the partition that is being processed.
+     * This property is updated by the `EventProcessor` if the `trackLastEnqueuedEventProperties` option is set to true
+     * when creating an instance of EventProcessor
+     */
+    set lastEnqueuedEventProperties(properties: LastEnqueuedEventProperties);
+    /**
+     * The fully qualified namespace from where the current partition is being processed. It is set by the `EventProcessor`
+     * @readonly
+     */
+    get fullyQualifiedNamespace(): string;
+    /**
+     * The name of the consumer group from where the current partition is being processed. It is set by the `EventProcessor`
+     * @readonly
+     */
+    get consumerGroup(): string;
+    /**
+     * The name of the event hub to which the current partition belongs. It is set by the `EventProcessor`
+     * @readonly
+     */
+    get eventHubName(): string;
+    /**
+     * The identifier of the Event Hub partition that is being processed. It is set by the `EventProcessor`
+     * @readonly
+     */
+    get partitionId(): string;
+    /**
+     * The unique identifier of the `EventProcessor` that has spawned the current instance of `PartitionProcessor`. This is set by the `EventProcessor`
+     */
+    get eventProcessorId(): string;
+    /**
+     * This method is called when the `EventProcessor` takes ownership of a new partition and before any
+     * events are received.
+     */
+    initialize(): Promise<void>;
+    /**
+     * This method is called before the partition processor is closed by the EventProcessor.
+     *
+     * @param reason - The reason for closing this partition processor.
+     */
+    close(reason: CloseReason): Promise<void>;
+    /**
+     * This method is called when new events are received.
+     *
+     * This is also a good place to update checkpoints as appropriate.
+     *
+     * @param event - The received events to be processed.
+     */
+    processEvents(events: ReceivedEventData[]): Promise<void>;
+    /**
+     * This method is called when an error occurs while receiving events from Event Hubs.
+     *
+     * @param error - The error to be processed.
+     */
+    processError(error: Error): Promise<void>;
+    /**
+     * Updates the checkpoint using the event data.
+     *
+     * A checkpoint is meant to represent the last successfully processed event by the user from a particular
+     * partition of a consumer group in an Event Hub instance.
+     *
+     * @param eventData - The event that you want to update the checkpoint with.
+     */
+    updateCheckpoint(eventData: ReceivedEventData): Promise<void>;
+}
+//# sourceMappingURL=partitionProcessor.d.ts.map

package/dist/react-native/partitionProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partitionProcessor.d.ts","sourceRoot":"","sources":["../../src/partitionProcessor.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,wBAAwB,EACxB,gBAAgB,EAChB,yBAAyB,EAC1B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AAC1E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAGxD;;;;;;;;;;IAUI;AACJ,MAAM,WAAW,UAAU;IACzB;;;OAGG;IACH,uBAAuB,EAAE,MAAM,CAAC;IAChC;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;GASG;AACH,qBAAa,kBAAmB,YAAW,gBAAgB;IAIvD,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,QAAQ;IALlB,OAAO,CAAC,4BAA4B,CAAC,CAA8B;gBAGzD,cAAc,EAAE,yBAAyB,EACzC,gBAAgB,EAAE,eAAe,EACjC,QAAQ,EAAE,wBAAwB,GAAG;QAC3C,gBAAgB,EAAE,MAAM,CAAC;KAC1B;IAGH;;;;;OAKG;IACH,IAAW,2BAA2B,IAAI,2BAA2B,CAEpE;IAED;;;;OAIG;IACH,IAAW,2BAA2B,CAAC,UAAU,EAAE,2BAA2B,EAE7E;IAED;;;OAGG;IACH,IAAW,uBAAuB,IAAI,MAAM,CAE3C;IAED;;;OAGG;IACH,IAAW,aAAa,IAAI,MAAM,CAEjC;IAED;;;OAGG;IACH,IAAW,YAAY,IAAI,MAAM,CAEhC;IAED;;;OAGG;IACH,IAAW,WAAW,IAAI,MAAM,CAE/B;IAED;;OAEG;IACH,IAAW,gBAAgB,IAAI,MAAM,CAEpC;IAED;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjC;;;;OAIG;IACG,KAAK,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAM/C;;;;;;OAMG;IACG,aAAa,CAAC,MAAM,EAAE,iBAAiB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/D;;;;OAIG;IACG,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC;IAU/C;;;;;;;OAOG;IACU,gBAAgB,CAAC,SAAS,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;CAY3E"}

package/dist/react-native/partitionProcessor.js

@@ -0,0 +1,137 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { logger } from "./logger.js";
+/**
+ * The `PartitionProcessor` is responsible for processing events received from Event Hubs when using `EventProcessor`
+ *
+ * The EventProcessor creates a new instance of the PartitionProcessor for each partition of the event hub it starts processing. When you extend the `PartitionProcessor` in order to customize it as you see fit,
+ * - Override the `processEvents()` method to add the code to process the received events. This is also a good place to update the checkpoints using the `updateCheckpoint()` method
+ * - Optionally override the `processError()` method to handle any error that might have occurred when processing the events.
+ * - Optionally override the `initialize()` method to implement any set up related tasks you would want to carry out before starting to receive events from the partition
+ * - Optionally override the `close()` method to implement any tear down or clean up tasks you would want to carry out.
+ * @internal
+ */
+export class PartitionProcessor {
+    _eventHandlers;
+    _checkpointStore;
+    _context;
+    _lastEnqueuedEventProperties;
+    constructor(_eventHandlers, _checkpointStore, _context) {
+        this._eventHandlers = _eventHandlers;
+        this._checkpointStore = _checkpointStore;
+        this._context = _context;
+    }
+    /**
+     * Information on the last enqueued event in the partition that is being processed.
+     * This property is updated by the `EventProcessor` if the `trackLastEnqueuedEventProperties` option is set to true
+     * when creating an instance of EventProcessor
+     * @readonly
+     */
+    get lastEnqueuedEventProperties() {
+        return this._lastEnqueuedEventProperties;
+    }
+    /**
+     * Information on the last enqueued event in the partition that is being processed.
+     * This property is updated by the `EventProcessor` if the `trackLastEnqueuedEventProperties` option is set to true
+     * when creating an instance of EventProcessor
+     */
+    set lastEnqueuedEventProperties(properties) {
+        this._lastEnqueuedEventProperties = properties;
+    }
+    /**
+     * The fully qualified namespace from where the current partition is being processed. It is set by the `EventProcessor`
+     * @readonly
+     */
+    get fullyQualifiedNamespace() {
+        return this._context.fullyQualifiedNamespace;
+    }
+    /**
+     * The name of the consumer group from where the current partition is being processed. It is set by the `EventProcessor`
+     * @readonly
+     */
+    get consumerGroup() {
+        return this._context.consumerGroup;
+    }
+    /**
+     * The name of the event hub to which the current partition belongs. It is set by the `EventProcessor`
+     * @readonly
+     */
+    get eventHubName() {
+        return this._context.eventHubName;
+    }
+    /**
+     * The identifier of the Event Hub partition that is being processed. It is set by the `EventProcessor`
+     * @readonly
+     */
+    get partitionId() {
+        return this._context.partitionId;
+    }
+    /**
+     * The unique identifier of the `EventProcessor` that has spawned the current instance of `PartitionProcessor`. This is set by the `EventProcessor`
+     */
+    get eventProcessorId() {
+        return this._context.eventProcessorId;
+    }
+    /**
+     * This method is called when the `EventProcessor` takes ownership of a new partition and before any
+     * events are received.
+     */
+    async initialize() {
+        return this._eventHandlers.processInitialize?.(this);
+    }
+    /**
+     * This method is called before the partition processor is closed by the EventProcessor.
+     *
+     * @param reason - The reason for closing this partition processor.
+     */
+    async close(reason) {
+        if (this._eventHandlers.processClose) {
+            await this._eventHandlers.processClose(reason, this);
+        }
+    }
+    /**
+     * This method is called when new events are received.
+     *
+     * This is also a good place to update checkpoints as appropriate.
+     *
+     * @param event - The received events to be processed.
+     */
+    async processEvents(events) {
+        await this._eventHandlers.processEvents(events, this);
+    }
+    /**
+     * This method is called when an error occurs while receiving events from Event Hubs.
+     *
+     * @param error - The error to be processed.
+     */
+    async processError(error) {
+        if (this._eventHandlers.processError) {
+            try {
+                await this._eventHandlers.processError(error, this);
+            }
+            catch (err) {
+                logger.verbose(`Error thrown from user's processError handler : ${err}`);
+            }
+        }
+    }
+    /**
+     * Updates the checkpoint using the event data.
+     *
+     * A checkpoint is meant to represent the last successfully processed event by the user from a particular
+     * partition of a consumer group in an Event Hub instance.
+     *
+     * @param eventData - The event that you want to update the checkpoint with.
+     */
+    async updateCheckpoint(eventData) {
+        const checkpoint = {
+            fullyQualifiedNamespace: this._context.fullyQualifiedNamespace,
+            eventHubName: this._context.eventHubName,
+            consumerGroup: this._context.consumerGroup,
+            partitionId: this._context.partitionId,
+            sequenceNumber: eventData.sequenceNumber,
+            offset: eventData.offset,
+        };
+        await this._checkpointStore.updateCheckpoint(checkpoint);
+    }
+}
+//# sourceMappingURL=partitionProcessor.js.map

package/dist/react-native/partitionProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"partitionProcessor.js","sourceRoot":"","sources":["../../src/partitionProcessor.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAWlC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAyCrC;;;;;;;;;GASG;AACH,MAAM,OAAO,kBAAkB;IAInB;IACA;IACA;IALF,4BAA4B,CAA+B;IAEnE,YACU,cAAyC,EACzC,gBAAiC,EACjC,QAEP;QAJO,mBAAc,GAAd,cAAc,CAA2B;QACzC,qBAAgB,GAAhB,gBAAgB,CAAiB;QACjC,aAAQ,GAAR,QAAQ,CAEf;IACA,CAAC;IAEJ;;;;;OAKG;IACH,IAAW,2BAA2B;QACpC,OAAO,IAAI,CAAC,4BAA6B,CAAC;IAC5C,CAAC;IAED;;;;OAIG;IACH,IAAW,2BAA2B,CAAC,UAAuC;QAC5E,IAAI,CAAC,4BAA4B,GAAG,UAAU,CAAC;IACjD,CAAC;IAED;;;OAGG;IACH,IAAW,uBAAuB;QAChC,OAAO,IAAI,CAAC,QAAQ,CAAC,uBAAuB,CAAC;IAC/C,CAAC;IAED;;;OAGG;IACH,IAAW,aAAa;QACtB,OAAO,IAAI,CAAC,QAAQ,CAAC,aAAc,CAAC;IACtC,CAAC;IAED;;;OAGG;IACH,IAAW,YAAY;QACrB,OAAO,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC;IACpC,CAAC;IAED;;;OAGG;IACH,IAAW,WAAW;QACpB,OAAO,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC;IACnC,CAAC;IAED;;OAEG;IACH,IAAW,gBAAgB;QACzB,OAAO,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC;IACxC,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,UAAU;QACd,OAAO,IAAI,CAAC,cAAc,CAAC,iBAAiB,EAAE,CAAC,IAAI,CAAC,CAAC;IACvD,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,KAAK,CAAC,MAAmB;QAC7B,IAAI,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,CAAC;YACrC,MAAM,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACvD,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,aAAa,CAAC,MAA2B;QAC7C,MAAM,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACxD,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,YAAY,CAAC,KAAY;QAC7B,IAAI,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,CAAC;YACrC,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;YACtD,CAAC;YAAC,OAAO,GAAQ,EAAE,CAAC;gBAClB,MAAM,CAAC,OAAO,CAAC,mDAAmD,GAAG,EAAE,CAAC,CAAC;YAC3E,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACI,KAAK,CAAC,gBAAgB,CAAC,SAA4B;QACxD,MAAM,UAAU,GAAe;YAC7B,uBAAuB,EAAE,IAAI,CAAC,QAAQ,CAAC,uBAAuB;YAC9D,YAAY,EAAE,IAAI,CAAC,QAAQ,CAAC,YAAY;YACxC,aAAa,EAAE,IAAI,CAAC,QAAQ,CAAC,aAAa;YAC1C,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC,WAAW;YACtC,cAAc,EAAE,SAAS,CAAC,cAAc;YACxC,MAAM,EAAE,SAAS,CAAC,MAAM;SACzB,CAAC;QAEF,MAAM,IAAI,CAAC,gBAAiB,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;IAC5D,CAAC;CACF","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type {\n  BasicPartitionProperties,\n  PartitionContext,\n  SubscriptionEventHandlers,\n} from \"./eventHubConsumerClientModels.js\";\nimport type { CheckpointStore } from \"./eventProcessor.js\";\nimport type { CloseReason } from \"./models/public.js\";\nimport type { LastEnqueuedEventProperties } from \"./partitionReceiver.js\";\nimport type { ReceivedEventData } from \"./eventData.js\";\nimport { logger } from \"./logger.js\";\n\n/**\n * A checkpoint is meant to represent the last successfully processed event by the user from a particular\n * partition of a consumer group in an Event Hub instance.\n *\n * When the `updateCheckpoint()` method on the `PartitionProcessor` class is called by the user, a\n * `Checkpoint` is created internally. It is then stored in the storage solution implemented by the\n * `CheckpointManager` chosen by the user when creating an `EventProcessor`.\n *\n * Users are never expected to interact with `Checkpoint` directly. This interface exists to support the\n * internal workings of `EventProcessor` and `CheckpointManager`.\n **/\nexport interface Checkpoint {\n  /**\n   * The fully qualified Event Hubs namespace. This is likely to be similar to\n   * <yournamespace>.servicebus.windows.net\n   */\n  fullyQualifiedNamespace: string;\n  /**\n   * The event hub name\n   */\n  eventHubName: string;\n  /**\n   * The consumer group name\n   */\n  consumerGroup: string;\n  /**\n   * The identifier of the Event Hub partition\n   */\n  partitionId: string;\n  /**\n   * The sequence number of the event\n   */\n  sequenceNumber: number;\n  /**\n   * The offset of the event.\n   */\n  offset: string;\n}\n\n/**\n * The `PartitionProcessor` is responsible for processing events received from Event Hubs when using `EventProcessor`\n *\n * The EventProcessor creates a new instance of the PartitionProcessor for each partition of the event hub it starts processing. When you extend the `PartitionProcessor` in order to customize it as you see fit,\n * - Override the `processEvents()` method to add the code to process the received events. This is also a good place to update the checkpoints using the `updateCheckpoint()` method\n * - Optionally override the `processError()` method to handle any error that might have occurred when processing the events.\n * - Optionally override the `initialize()` method to implement any set up related tasks you would want to carry out before starting to receive events from the partition\n * - Optionally override the `close()` method to implement any tear down or clean up tasks you would want to carry out.\n * @internal\n */\nexport class PartitionProcessor implements PartitionContext {\n  private _lastEnqueuedEventProperties?: LastEnqueuedEventProperties;\n\n  constructor(\n    private _eventHandlers: SubscriptionEventHandlers,\n    private _checkpointStore: CheckpointStore,\n    private _context: BasicPartitionProperties & {\n      eventProcessorId: string;\n    },\n  ) {}\n\n  /**\n   * Information on the last enqueued event in the partition that is being processed.\n   * This property is updated by the `EventProcessor` if the `trackLastEnqueuedEventProperties` option is set to true\n   * when creating an instance of EventProcessor\n   * @readonly\n   */\n  public get lastEnqueuedEventProperties(): LastEnqueuedEventProperties {\n    return this._lastEnqueuedEventProperties!;\n  }\n\n  /**\n   * Information on the last enqueued event in the partition that is being processed.\n   * This property is updated by the `EventProcessor` if the `trackLastEnqueuedEventProperties` option is set to true\n   * when creating an instance of EventProcessor\n   */\n  public set lastEnqueuedEventProperties(properties: LastEnqueuedEventProperties) {\n    this._lastEnqueuedEventProperties = properties;\n  }\n\n  /**\n   * The fully qualified namespace from where the current partition is being processed. It is set by the `EventProcessor`\n   * @readonly\n   */\n  public get fullyQualifiedNamespace(): string {\n    return this._context.fullyQualifiedNamespace;\n  }\n\n  /**\n   * The name of the consumer group from where the current partition is being processed. It is set by the `EventProcessor`\n   * @readonly\n   */\n  public get consumerGroup(): string {\n    return this._context.consumerGroup!;\n  }\n\n  /**\n   * The name of the event hub to which the current partition belongs. It is set by the `EventProcessor`\n   * @readonly\n   */\n  public get eventHubName(): string {\n    return this._context.eventHubName;\n  }\n\n  /**\n   * The identifier of the Event Hub partition that is being processed. It is set by the `EventProcessor`\n   * @readonly\n   */\n  public get partitionId(): string {\n    return this._context.partitionId;\n  }\n\n  /**\n   * The unique identifier of the `EventProcessor` that has spawned the current instance of `PartitionProcessor`. This is set by the `EventProcessor`\n   */\n  public get eventProcessorId(): string {\n    return this._context.eventProcessorId;\n  }\n\n  /**\n   * This method is called when the `EventProcessor` takes ownership of a new partition and before any\n   * events are received.\n   */\n  async initialize(): Promise<void> {\n    return this._eventHandlers.processInitialize?.(this);\n  }\n\n  /**\n   * This method is called before the partition processor is closed by the EventProcessor.\n   *\n   * @param reason - The reason for closing this partition processor.\n   */\n  async close(reason: CloseReason): Promise<void> {\n    if (this._eventHandlers.processClose) {\n      await this._eventHandlers.processClose(reason, this);\n    }\n  }\n\n  /**\n   * This method is called when new events are received.\n   *\n   * This is also a good place to update checkpoints as appropriate.\n   *\n   * @param event - The received events to be processed.\n   */\n  async processEvents(events: ReceivedEventData[]): Promise<void> {\n    await this._eventHandlers.processEvents(events, this);\n  }\n\n  /**\n   * This method is called when an error occurs while receiving events from Event Hubs.\n   *\n   * @param error - The error to be processed.\n   */\n  async processError(error: Error): Promise<void> {\n    if (this._eventHandlers.processError) {\n      try {\n        await this._eventHandlers.processError(error, this);\n      } catch (err: any) {\n        logger.verbose(`Error thrown from user's processError handler : ${err}`);\n      }\n    }\n  }\n\n  /**\n   * Updates the checkpoint using the event data.\n   *\n   * A checkpoint is meant to represent the last successfully processed event by the user from a particular\n   * partition of a consumer group in an Event Hub instance.\n   *\n   * @param eventData - The event that you want to update the checkpoint with.\n   */\n  public async updateCheckpoint(eventData: ReceivedEventData): Promise<void> {\n    const checkpoint: Checkpoint = {\n      fullyQualifiedNamespace: this._context.fullyQualifiedNamespace,\n      eventHubName: this._context.eventHubName,\n      consumerGroup: this._context.consumerGroup,\n      partitionId: this._context.partitionId,\n      sequenceNumber: eventData.sequenceNumber,\n      offset: eventData.offset,\n    };\n\n    await this._checkpointStore!.updateCheckpoint(checkpoint);\n  }\n}\n"]}

package/dist/react-native/partitionPump.d.ts

@@ -0,0 +1,38 @@
+import type { TracingSpanOptions } from "@azure/core-tracing";
+import { CloseReason } from "./models/public.js";
+import type { CommonEventProcessorOptions } from "./models/private.js";
+import type { ConnectionContext } from "./connectionContext.js";
+import type { EventHubConnectionConfig } from "./eventhubConnectionConfig.js";
+import type { EventPosition } from "./eventPosition.js";
+import type { PartitionProcessor } from "./partitionProcessor.js";
+import type { ReceivedEventData } from "./eventData.js";
+/**
+ * @internal
+ */
+export declare class PartitionPump {
+    private _context;
+    private readonly _startPosition;
+    private _partitionProcessor;
+    private _processorOptions;
+    private _receiver;
+    private _isReceiving;
+    private _isStopped;
+    private _abortController;
+    constructor(_context: ConnectionContext, partitionProcessor: PartitionProcessor, _startPosition: EventPosition, options: CommonEventProcessorOptions);
+    get isReceiving(): boolean;
+    start(): Promise<void>;
+    /**
+     * Creates a new `PartitionReceiver` and replaces any existing receiver.
+     * @param partitionId - The partition the receiver should read messages from.
+     * @param lastSeenSequenceNumber - The sequence number to begin receiving messages from (exclusive).
+     * If `-1`, then the PartitionPump's startPosition will be used instead.
+     */
+    private _setOrReplaceReceiver;
+    private _receiveEvents;
+    stop(reason: CloseReason): Promise<void>;
+}
+/**
+ * @internal
+ */
+export declare function toProcessingSpanOptions(receivedEvents: ReceivedEventData[], eventHubProperties: Pick<EventHubConnectionConfig, "entityPath" | "host">): TracingSpanOptions;
+//# sourceMappingURL=partitionPump.d.ts.map

package/dist/react-native/partitionPump.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partitionPump.d.ts","sourceRoot":"","sources":["../../src/partitionPump.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAmB,MAAM,qBAAqB,CAAC;AAE/E,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAG9E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAIxD;;GAEG;AACH,qBAAa,aAAa;IAQtB,OAAO,CAAC,QAAQ;IAEhB,OAAO,CAAC,QAAQ,CAAC,cAAc;IATjC,OAAO,CAAC,mBAAmB,CAAqB;IAChD,OAAO,CAAC,iBAAiB,CAA8B;IACvD,OAAO,CAAC,SAAS,CAAgC;IACjD,OAAO,CAAC,YAAY,CAAkB;IACtC,OAAO,CAAC,UAAU,CAAkB;IACpC,OAAO,CAAC,gBAAgB,CAAkB;gBAEhC,QAAQ,EAAE,iBAAiB,EACnC,kBAAkB,EAAE,kBAAkB,EACrB,cAAc,EAAE,aAAa,EAC9C,OAAO,EAAE,2BAA2B;IAOtC,IAAW,WAAW,IAAI,OAAO,CAEhC;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAiB5B;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;YAmCf,cAAc;IAiFtB,IAAI,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;CAoB/C;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,cAAc,EAAE,iBAAiB,EAAE,EACnC,kBAAkB,EAAE,IAAI,CAAC,wBAAwB,EAAE,YAAY,GAAG,MAAM,CAAC,GACxE,kBAAkB,CAkBpB"}