@azure/event-hubs 5.13.0-beta.2 → 6.0.0-alpha.20250129.1

package/dist/esm/models/private.d.ts

@@ -0,0 +1,185 @@
+import type { LoadBalancingStrategy } from "../loadBalancerStrategies/loadBalancingStrategy.js";
+import type { RetryOptions } from "@azure/core-amqp";
+import type { Typed } from "rhea-promise";
+import type { SubscribeOptions } from "../eventHubConsumerClientModels.js";
+import type { idempotentProducerAmqpPropertyNames } from "../util/constants.js";
+/**
+ * The set of options to configure the behavior of an `EventHubProducer`.
+ * These can be specified when creating the producer via the `createProducer` method.
+ * - `partitionId`  : The string identifier of the partition that the producer can be bound to.
+ * - `retryOptions` : The retry options used to govern retry attempts when an issue is encountered while sending events.
+ * A simple usage can be `{ "maxRetries": 4 }`.
+ * @internal
+ */
+export interface EventHubProducerOptions {
+    /**
+     * The identifier of the partition that the producer will be bound to.
+     * If a value is provided, all events sent using the producer will reach the same partition.
+     * If no value is provided, the service will determine the partition to which the event will be sent.
+     */
+    partitionId?: string;
+    /**
+     * The retry options used to govern retry attempts when an issue is encountered while sending events.
+     * If no value is provided here, the retry options set when creating the `EventHubClient` is used.
+     */
+    retryOptions?: RetryOptions;
+}
+/**
+ * @internal
+ */
+export type OperationNames = "getEventHubProperties" | "getPartitionIds" | "getPartitionProperties";
+/**
+ * @internal
+ */
+export interface CommonEventProcessorOptions extends Required<Pick<SubscribeOptions, "maxBatchSize" | "maxWaitTimeInSeconds">>, Pick<SubscribeOptions, Exclude<keyof SubscribeOptions, "maxBatchSize" | "maxWaitTimeInSeconds">> {
+    /**
+     * A load balancing strategy that determines how to claim partitions.
+     */
+    loadBalancingStrategy: LoadBalancingStrategy;
+    /**
+     * An optional ownerId to use rather than using an internally generated ID
+     * This allows you to logically group a series of processors together (for instance
+     * like we do with EventHubConsumerClient)
+     */
+    ownerId?: string;
+    /**
+     * The maximum amount of time since a PartitionOwnership was updated
+     * to use to determine if a partition is no longer claimed.
+     * Setting this value to 0 will cause the default value to be used.
+     */
+    inactiveTimeLimitInMs?: number;
+    /**
+     * Retry Options to be used when receiving events
+     */
+    retryOptions?: RetryOptions;
+}
+/**
+ * The set of options to configure the behavior of an `EventHubConsumer`.
+ * These can be specified when creating the consumer using the `createConsumer` method.
+ * - `ownerLevel`  : A number indicating that the consumer intends to be an exclusive consumer of events resulting in other
+ * consumers to fail if their `ownerLevel` is lower or doesn't exist.
+ * - `retryOptions`: The retry options used to govern retry attempts when an issue is encountered while receiving events.
+ * A simple usage can be `{ "maxRetries": 4 }`.
+ * - `skipParsingBodyAsJson` : Option to disable the client from running JSON.parse() on the message body when receiving the message.
+ * Not applicable if the message was sent with AMQP body type value or sequence. Use this option when you prefer to work directly with
+ * the bytes present in the message body than have the client attempt to parse it.
+ *
+ * Example usage:
+ * ```js
+ * {
+ *     retryOptions: {
+ *         maxRetries: 4
+ *     },
+ *     trackLastEnqueuedEventProperties: false,
+ *     skipParsingBodyAsJson: true
+ * }
+ * ```
+ * @internal
+ */
+export interface PartitionReceiverOptions {
+    /**
+     * The owner level associated with an exclusive consumer.
+     *
+     * When provided, the owner level indicates that a consumer is intended to be the exclusive receiver of events for the
+     * requested partition and the associated consumer group.
+     * When multiple consumers exist for the same partition/consumer group pair, then the ones with lower or no
+     * `ownerLevel` will get a `ReceiverDisconnectedError` during the next attempted receive operation.
+     */
+    ownerLevel?: number;
+    /**
+     * The retry options used to govern retry attempts when an issue is encountered while receiving events.
+     * If no value is provided here, the retry options set when creating the `EventHubClient` is used.
+     */
+    retryOptions?: RetryOptions;
+    /**
+     * Indicates whether or not the consumer should request information on the last enqueued event on its
+     * associated partition, and track that information as events are received.
+  
+     * When information about the partition's last enqueued event is being tracked, each event received
+     * from the Event Hubs service will carry metadata about the partition that it otherwise would not. This results in a small amount of
+     * additional network bandwidth consumption that is generally a favorable trade-off when considered
+     * against periodically making requests for partition properties using the Event Hub client.
+     */
+    trackLastEnqueuedEventProperties?: boolean;
+    /**
+     * Option to disable the client from running JSON.parse() on the message body when receiving the message.
+     * Not applicable if the message was sent with AMQP body type value or sequence. Use this option when you
+     * prefer to work directly with the bytes present in the message body than have the client attempt to parse it.
+     */
+    skipParsingBodyAsJson?: boolean;
+    /**
+     * The count of events requested eagerly and queued without regard to whether a read was requested.
+     */
+    prefetchCount?: number;
+}
+/**
+ * @internal
+ */
+export interface IdempotentLinkProperties {
+    [idempotentProducerAmqpPropertyNames.epoch]: Typed | null;
+    [idempotentProducerAmqpPropertyNames.producerId]: Typed | null;
+    [idempotentProducerAmqpPropertyNames.producerSequenceNumber]: Typed | null;
+}
+/**
+ * The set of options that can be specified for an `EventHubProducerClient`
+ * to influence its behavior when publishing directly to an Event Hub partition.
+ *
+ * These options are ignored when publishing to the Event Hubs gateway for automatic
+ * routing or when using a partition key.
+ */
+export interface PartitionPublishingOptions {
+    /**
+     * The owner level indicates that a publishing is intended to be performed exclusively for events in the
+     * requested partition in the context of the associated producer group.
+     *
+     * To do so, publishing will attempt to assert ownership over the partition;
+     * in the case where more than one publisher in the producer group attempts to assert ownership for the same partition,
+     * the one having a larger `ownerLevel` value will "win".
+     */
+    ownerLevel?: number;
+    /**
+     * The identifier of the producer group that this producer is associated with when publishing to the associated partition.
+     * Events will be published in the context of this group.
+     *
+     * If `undefined`, the Event Hubs service will control the value.
+     *
+     * The producer group is only recognized and relevant when certain features of the producer are enabled.
+     * For example, it is used by idempotent publishing.
+     */
+    producerGroupId?: number;
+    /**
+     * The starting number that should be used for the automatic sequencing of events for the associated partition, when published by this producer.
+     *
+     * If `undefined`, the Event Hubs service will control the value.
+     *
+     * The producer group is only recognized and relevant when certain features of the producer are enabled.
+     * For example, it is used by idempotent publishing.
+     */
+    startingSequenceNumber?: number;
+}
+/**
+ * Describes the information about the state of publishing for a partition.
+ */
+export interface PartitionPublishingProperties {
+    /**
+     * Indicates whether or not idempotent publishing is enabled for the producer and, by extension, the associated partition.
+     */
+    isIdempotentPublishingEnabled: boolean;
+    /**
+     * The owner level of the producer publishing to the associated partition.
+     */
+    ownerLevel?: number;
+    /**
+     * The partition id the properties are associated with.
+     */
+    partitionId: string;
+    /**
+     * The identifier of the producer group for which this producer is publishing to the associated partition.
+     */
+    producerGroupId?: number;
+    /**
+     * The sequence number assigned to the event that was most recently published to the associated partition successfully.
+     */
+    lastPublishedSequenceNumber?: number;
+}
+//# sourceMappingURL=private.d.ts.map

package/dist/esm/models/private.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"private.d.ts","sourceRoot":"","sources":["../../../src/models/private.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oDAAoD,CAAC;AAChG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,sBAAsB,CAAC;AAEhF;;;;;;;GAOG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,uBAAuB,GAAG,iBAAiB,GAAG,wBAAwB,CAAC;AAEpG;;GAEG;AACH,MAAM,WAAW,2BACf,SAAQ,QAAQ,CAAC,IAAI,CAAC,gBAAgB,EAAE,cAAc,GAAG,sBAAsB,CAAC,CAAC,EAC/E,IAAI,CACF,gBAAgB,EAChB,OAAO,CACL,MAAM,gBAAgB,EAEtB,cAAc,GAAG,sBAAsB,CACxC,CACF;IACH;;OAEG;IACH,qBAAqB,EAAE,qBAAqB,CAAC;IAE7C;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B;;OAEG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B;;;;;;;;OAQG;IACH,gCAAgC,CAAC,EAAE,OAAO,CAAC;IAC3C;;;;OAIG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,CAAC,mCAAmC,CAAC,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IAC1D,CAAC,mCAAmC,CAAC,UAAU,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IAC/D,CAAC,mCAAmC,CAAC,sBAAsB,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;CAC5E;AAED;;;;;;GAMG;AACH,MAAM,WAAW,0BAA0B;IACzC;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;;;;OAQG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;OAOG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;OAEG;IACH,6BAA6B,EAAE,OAAO,CAAC;IACvC;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;OAEG;IACH,2BAA2B,CAAC,EAAE,MAAM,CAAC;CACtC"}

package/dist/esm/models/private.js

@@ -0,0 +1,4 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export {};
+//# sourceMappingURL=private.js.map

package/dist/esm/models/private.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"private.js","sourceRoot":"","sources":["../../../src/models/private.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { LoadBalancingStrategy } from \"../loadBalancerStrategies/loadBalancingStrategy.js\";\nimport type { RetryOptions } from \"@azure/core-amqp\";\nimport type { Typed } from \"rhea-promise\";\nimport type { SubscribeOptions } from \"../eventHubConsumerClientModels.js\";\nimport type { idempotentProducerAmqpPropertyNames } from \"../util/constants.js\";\n\n/**\n * The set of options to configure the behavior of an `EventHubProducer`.\n * These can be specified when creating the producer via the `createProducer` method.\n * - `partitionId`  : The string identifier of the partition that the producer can be bound to.\n * - `retryOptions` : The retry options used to govern retry attempts when an issue is encountered while sending events.\n * A simple usage can be `{ \"maxRetries\": 4 }`.\n * @internal\n */\nexport interface EventHubProducerOptions {\n  /**\n   * The identifier of the partition that the producer will be bound to.\n   * If a value is provided, all events sent using the producer will reach the same partition.\n   * If no value is provided, the service will determine the partition to which the event will be sent.\n   */\n  partitionId?: string;\n  /**\n   * The retry options used to govern retry attempts when an issue is encountered while sending events.\n   * If no value is provided here, the retry options set when creating the `EventHubClient` is used.\n   */\n  retryOptions?: RetryOptions;\n}\n\n/**\n * @internal\n */\nexport type OperationNames = \"getEventHubProperties\" | \"getPartitionIds\" | \"getPartitionProperties\";\n\n/**\n * @internal\n */\nexport interface CommonEventProcessorOptions\n  extends Required<Pick<SubscribeOptions, \"maxBatchSize\" | \"maxWaitTimeInSeconds\">>,\n    Pick<\n      SubscribeOptions,\n      Exclude<\n        keyof SubscribeOptions,\n        // (made required above)\n        \"maxBatchSize\" | \"maxWaitTimeInSeconds\"\n      >\n    > {\n  /**\n   * A load balancing strategy that determines how to claim partitions.\n   */\n  loadBalancingStrategy: LoadBalancingStrategy;\n\n  /**\n   * An optional ownerId to use rather than using an internally generated ID\n   * This allows you to logically group a series of processors together (for instance\n   * like we do with EventHubConsumerClient)\n   */\n  ownerId?: string;\n\n  /**\n   * The maximum amount of time since a PartitionOwnership was updated\n   * to use to determine if a partition is no longer claimed.\n   * Setting this value to 0 will cause the default value to be used.\n   */\n  inactiveTimeLimitInMs?: number;\n  /**\n   * Retry Options to be used when receiving events\n   */\n  retryOptions?: RetryOptions;\n}\n\n/**\n * The set of options to configure the behavior of an `EventHubConsumer`.\n * These can be specified when creating the consumer using the `createConsumer` method.\n * - `ownerLevel`  : A number indicating that the consumer intends to be an exclusive consumer of events resulting in other\n * consumers to fail if their `ownerLevel` is lower or doesn't exist.\n * - `retryOptions`: The retry options used to govern retry attempts when an issue is encountered while receiving events.\n * A simple usage can be `{ \"maxRetries\": 4 }`.\n * - `skipParsingBodyAsJson` : Option to disable the client from running JSON.parse() on the message body when receiving the message.\n * Not applicable if the message was sent with AMQP body type value or sequence. Use this option when you prefer to work directly with\n * the bytes present in the message body than have the client attempt to parse it.\n *\n * Example usage:\n * ```js\n * {\n *     retryOptions: {\n *         maxRetries: 4\n *     },\n *     trackLastEnqueuedEventProperties: false,\n *     skipParsingBodyAsJson: true\n * }\n * ```\n * @internal\n */\nexport interface PartitionReceiverOptions {\n  /**\n   * The owner level associated with an exclusive consumer.\n   *\n   * When provided, the owner level indicates that a consumer is intended to be the exclusive receiver of events for the\n   * requested partition and the associated consumer group.\n   * When multiple consumers exist for the same partition/consumer group pair, then the ones with lower or no\n   * `ownerLevel` will get a `ReceiverDisconnectedError` during the next attempted receive operation.\n   */\n  ownerLevel?: number;\n  /**\n   * The retry options used to govern retry attempts when an issue is encountered while receiving events.\n   * If no value is provided here, the retry options set when creating the `EventHubClient` is used.\n   */\n  retryOptions?: RetryOptions;\n  /**\n   * Indicates whether or not the consumer should request information on the last enqueued event on its\n   * associated partition, and track that information as events are received.\n\n   * When information about the partition's last enqueued event is being tracked, each event received\n   * from the Event Hubs service will carry metadata about the partition that it otherwise would not. This results in a small amount of\n   * additional network bandwidth consumption that is generally a favorable trade-off when considered\n   * against periodically making requests for partition properties using the Event Hub client.\n   */\n  trackLastEnqueuedEventProperties?: boolean;\n  /**\n   * Option to disable the client from running JSON.parse() on the message body when receiving the message.\n   * Not applicable if the message was sent with AMQP body type value or sequence. Use this option when you\n   * prefer to work directly with the bytes present in the message body than have the client attempt to parse it.\n   */\n  skipParsingBodyAsJson?: boolean;\n  /**\n   * The count of events requested eagerly and queued without regard to whether a read was requested.\n   */\n  prefetchCount?: number;\n}\n\n/**\n * @internal\n */\nexport interface IdempotentLinkProperties {\n  [idempotentProducerAmqpPropertyNames.epoch]: Typed | null;\n  [idempotentProducerAmqpPropertyNames.producerId]: Typed | null;\n  [idempotentProducerAmqpPropertyNames.producerSequenceNumber]: Typed | null;\n}\n\n/**\n * The set of options that can be specified for an `EventHubProducerClient`\n * to influence its behavior when publishing directly to an Event Hub partition.\n *\n * These options are ignored when publishing to the Event Hubs gateway for automatic\n * routing or when using a partition key.\n */\nexport interface PartitionPublishingOptions {\n  /**\n   * The owner level indicates that a publishing is intended to be performed exclusively for events in the\n   * requested partition in the context of the associated producer group.\n   *\n   * To do so, publishing will attempt to assert ownership over the partition;\n   * in the case where more than one publisher in the producer group attempts to assert ownership for the same partition,\n   * the one having a larger `ownerLevel` value will \"win\".\n   */\n  ownerLevel?: number;\n  /**\n   * The identifier of the producer group that this producer is associated with when publishing to the associated partition.\n   * Events will be published in the context of this group.\n   *\n   * If `undefined`, the Event Hubs service will control the value.\n   *\n   * The producer group is only recognized and relevant when certain features of the producer are enabled.\n   * For example, it is used by idempotent publishing.\n   */\n  producerGroupId?: number;\n  /**\n   * The starting number that should be used for the automatic sequencing of events for the associated partition, when published by this producer.\n   *\n   * If `undefined`, the Event Hubs service will control the value.\n   *\n   * The producer group is only recognized and relevant when certain features of the producer are enabled.\n   * For example, it is used by idempotent publishing.\n   */\n  startingSequenceNumber?: number;\n}\n\n/**\n * Describes the information about the state of publishing for a partition.\n */\nexport interface PartitionPublishingProperties {\n  /**\n   * Indicates whether or not idempotent publishing is enabled for the producer and, by extension, the associated partition.\n   */\n  isIdempotentPublishingEnabled: boolean;\n  /**\n   * The owner level of the producer publishing to the associated partition.\n   */\n  ownerLevel?: number;\n  /**\n   * The partition id the properties are associated with.\n   */\n  partitionId: string;\n  /**\n   * The identifier of the producer group for which this producer is publishing to the associated partition.\n   */\n  producerGroupId?: number;\n  /**\n   * The sequence number assigned to the event that was most recently published to the associated partition successfully.\n   */\n  lastPublishedSequenceNumber?: number;\n}\n"]}

package/dist/esm/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:
+ * ```js
+ * {
+ *     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:
+ * ```js
+ * {
+ *     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:
+ * ```js
+ * {
+ *     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:
+ * ```js
+ * {
+ *     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/esm/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/esm/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/esm/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 * ```js\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 * ```js\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 * ```js\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 * ```js\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/esm/package.json

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

package/dist/esm/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/esm/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"}