@azure/event-hubs 6.0.2-alpha.20251014.1 → 6.0.2-alpha.20251021.1

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

@@ -0,0 +1,293 @@
+import type { CheckpointStore } from "./eventProcessor.js";
+import type { EventHubConsumerClientOptions, GetEventHubPropertiesOptions, GetPartitionIdsOptions, GetPartitionPropertiesOptions } from "./models/public.js";
+import type { EventHubProperties, PartitionProperties } from "./managementClient.js";
+import type { NamedKeyCredential, SASCredential, TokenCredential } from "@azure/core-auth";
+import type { SubscribeOptions, Subscription, SubscriptionEventHandlers } from "./eventHubConsumerClientModels.js";
+/**
+ * The `EventHubConsumerClient` class is used to consume events from an Event Hub.
+ *
+ * There are multiple ways to create an `EventHubConsumerClient`
+ * - Use the connection string from the SAS policy created for your Event Hub instance.
+ * - Use the connection string from the SAS policy created for your Event Hub namespace,
+ * and the name of the Event Hub instance
+ * - Use the full namespace like `<yournamespace>.servicebus.windows.net`, and a credentials object.
+ *
+ * Optionally, you can also pass:
+ * - An options bag to configure the retry policy or proxy settings.
+ * - A checkpoint store that is used by the client to read checkpoints to determine the position from where it should
+ * resume receiving events when your application gets restarted. The checkpoint store is also used by the client
+ * to load balance multiple instances of your application.
+ */
+export declare class EventHubConsumerClient {
+    private _consumerGroup;
+    /**
+     * Describes the amqp connection context for the client.
+     */
+    private _context;
+    /**
+     * The options passed by the user when creating the EventHubClient instance.
+     */
+    private _clientOptions;
+    private _partitionGate;
+    /**
+     * The Subscriptions that were spawned by calling `subscribe()`.
+     * Subscriptions that have been stopped by the user will not
+     * be present in this set.
+     */
+    private _subscriptions;
+    /**
+     * The name of the default consumer group in the Event Hubs service.
+     */
+    static defaultConsumerGroupName: string;
+    private _checkpointStore;
+    private _userChoseCheckpointStore;
+    /**
+     * Options for configuring load balancing.
+     */
+    private readonly _loadBalancingOptions;
+    /**
+     * @readonly
+     * The name of the Event Hub instance for which this client is created.
+     */
+    get eventHubName(): string;
+    /**
+     * @readonly
+     * The fully qualified namespace of the Event Hub instance for which this client is created.
+     * This is likely to be similar to <yournamespace>.servicebus.windows.net.
+     */
+    get fullyQualifiedNamespace(): string;
+    /**
+     * The name used to identify this EventHubConsumerClient.
+     * If not specified or empty, a random unique one will be generated.
+     */
+    readonly identifier: string;
+    /**
+     * The `EventHubConsumerClient` class is used to consume events from an Event Hub.
+     * Use the `options` parmeter to configure retry policy or proxy settings.
+     * @param consumerGroup - The name of the consumer group from which you want to process events.
+     * @param connectionString - The connection string to use for connecting to the Event Hub instance.
+     * It is expected that the shared key properties and the Event Hub path are contained in this connection string.
+     * e.g. 'Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;EntityPath=my-event-hub-name'.
+     * @param options - A set of options to apply when configuring the client.
+     * - `retryOptions`   : Configures the retry policy for all the operations on the client.
+     * For example, `{ "maxRetries": 4 }` or `{ "maxRetries": 4, "retryDelayInMs": 30000 }`.
+     * - `webSocketOptions`: Configures the channelling of the AMQP connection over Web Sockets.
+     * - `userAgent`      : A string to append to the built in user agent string that is passed to the service.
+     */
+    constructor(consumerGroup: string, connectionString: string, options?: EventHubConsumerClientOptions);
+    /**
+     * The `EventHubConsumerClient` class is used to consume events from an Event Hub.
+     * Use the `options` parmeter to configure retry policy or proxy settings.
+     * @param consumerGroup - The name of the consumer group from which you want to process events.
+     * @param connectionString - The connection string to use for connecting to the Event Hub instance.
+     * It is expected that the shared key properties and the Event Hub path are contained in this connection string.
+     * e.g. 'Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;EntityPath=my-event-hub-name'.
+     * @param checkpointStore - A checkpoint store that is used by the client to read checkpoints to determine
+     * the position from where it should resume receiving events when your application gets restarted.
+     * It is also used by the client to load balance multiple instances of your application.
+     * @param options - A set of options to apply when configuring the client.
+     * - `retryOptions`   : Configures the retry policy for all the operations on the client.
+     * For example, `{ "maxRetries": 4 }` or `{ "maxRetries": 4, "retryDelayInMs": 30000 }`.
+     * - `webSocketOptions`: Configures the channelling of the AMQP connection over Web Sockets.
+     * - `userAgent`      : A string to append to the built in user agent string that is passed to the service.
+     */
+    constructor(consumerGroup: string, connectionString: string, checkpointStore: CheckpointStore, options?: EventHubConsumerClientOptions);
+    /**
+     * The `EventHubConsumerClient` class is used to consume events from an Event Hub.
+     * Use the `options` parmeter to configure retry policy or proxy settings.
+     * @param consumerGroup - The name of the consumer group from which you want to process events.
+     * @param connectionString - The connection string to use for connecting to the Event Hubs namespace.
+     * It is expected that the shared key properties are contained in this connection string, but not the Event Hub path,
+     * e.g. 'Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;'.
+     * @param eventHubName - The name of the specific Event Hub to connect the client to.
+     * @param options - A set of options to apply when configuring the client.
+     * - `retryOptions`   : Configures the retry policy for all the operations on the client.
+     * For example, `{ "maxRetries": 4 }` or `{ "maxRetries": 4, "retryDelayInMs": 30000 }`.
+     * - `webSocketOptions`: Configures the channelling of the AMQP connection over Web Sockets.
+     * - `userAgent`      : A string to append to the built in user agent string that is passed to the service.
+     */
+    constructor(consumerGroup: string, connectionString: string, eventHubName: string, options?: EventHubConsumerClientOptions);
+    /**
+     * The `EventHubConsumerClient` class is used to consume events from an Event Hub.
+     * Use the `options` parmeter to configure retry policy or proxy settings.
+     * @param consumerGroup - The name of the consumer group from which you want to process events.
+     * @param connectionString - The connection string to use for connecting to the Event Hubs namespace.
+     * It is expected that the shared key properties are contained in this connection string, but not the Event Hub path,
+     * e.g. 'Endpoint=sb://my-servicebus-namespace.servicebus.windows.net/;SharedAccessKeyName=my-SA-name;SharedAccessKey=my-SA-key;'.
+     * @param eventHubName - The name of the specific Event Hub to connect the client to.
+     * @param checkpointStore - A checkpoint store that is used by the client to read checkpoints to determine
+     * the position from where it should resume receiving events when your application gets restarted.
+     * It is also used by the client to load balance multiple instances of your application.
+     * @param options - A set of options to apply when configuring the client.
+     * - `retryOptions`   : Configures the retry policy for all the operations on the client.
+     * For example, `{ "maxRetries": 4 }` or `{ "maxRetries": 4, "retryDelayInMs": 30000 }`.
+     * - `webSocketOptions`: Configures the channelling of the AMQP connection over Web Sockets.
+     * - `userAgent`      : A string to append to the built in user agent string that is passed to the service.
+     */
+    constructor(consumerGroup: string, connectionString: string, eventHubName: string, checkpointStore: CheckpointStore, options?: EventHubConsumerClientOptions);
+    /**
+     * The `EventHubConsumerClient` class is used to consume events from an Event Hub.
+     * Use the `options` parmeter to configure retry policy or proxy settings.
+     * @param consumerGroup - The name of the consumer group from which you want to process events.
+     * @param fullyQualifiedNamespace - The full namespace which is likely to be similar to
+     * <yournamespace>.servicebus.windows.net
+     * @param eventHubName - The name of the specific Event Hub to connect the client to.
+     * @param credential - An credential object used by the client to get the token to authenticate the connection
+     * with the Azure Event Hubs service.
+     * See &commat;azure/identity for creating credentials that support AAD auth.
+     * Use the `AzureNamedKeyCredential` from &commat;azure/core-auth if you want to pass in a `SharedAccessKeyName`
+     * and `SharedAccessKey` without using a connection string. These fields map to the `name` and `key` field respectively
+     * in `AzureNamedKeyCredential`.
+     * Use the `AzureSASCredential` from &commat;azure/core-auth if you want to pass in a `SharedAccessSignature`
+     * without using a connection string. This field maps to `signature` in `AzureSASCredential`.
+     * @param options - A set of options to apply when configuring the client.
+     * - `retryOptions`   : Configures the retry policy for all the operations on the client.
+     * For example, `{ "maxRetries": 4 }` or `{ "maxRetries": 4, "retryDelayInMs": 30000 }`.
+     * - `webSocketOptions`: Configures the channelling of the AMQP connection over Web Sockets.
+     * - `userAgent`      : A string to append to the built in user agent string that is passed to the service.
+     */
+    constructor(consumerGroup: string, fullyQualifiedNamespace: string, eventHubName: string, credential: TokenCredential | NamedKeyCredential | SASCredential, options?: EventHubConsumerClientOptions);
+    /**
+     * The `EventHubConsumerClient` class is used to consume events from an Event Hub.
+     * Use the `options` parmeter to configure retry policy or proxy settings.
+     * @param consumerGroup - The name of the consumer group from which you want to process events.
+     * @param fullyQualifiedNamespace - The full namespace which is likely to be similar to
+     * <yournamespace>.servicebus.windows.net
+     * @param eventHubName - The name of the specific Event Hub to connect the client to.
+     * @param credential - An credential object used by the client to get the token to authenticate the connection
+     * with the Azure Event Hubs service.
+     * See &commat;azure/identity for creating credentials that support AAD auth.
+     * Use the `AzureNamedKeyCredential` from &commat;azure/core-auth if you want to pass in a `SharedAccessKeyName`
+     * and `SharedAccessKey` without using a connection string. These fields map to the `name` and `key` field respectively
+     * in `AzureNamedKeyCredential`.
+     * Use the `AzureSASCredential` from &commat;azure/core-auth if you want to pass in a `SharedAccessSignature`
+     * without using a connection string. This field maps to `signature` in `AzureSASCredential`.
+     * @param checkpointStore - A checkpoint store that is used by the client to read checkpoints to determine
+     * the position from where it should resume receiving events when your application gets restarted.
+     * It is also used by the client to load balance multiple instances of your application.
+     * @param options - A set of options to apply when configuring the client.
+     * - `retryOptions`   : Configures the retry policy for all the operations on the client.
+     * For example, `{ "maxRetries": 4 }` or `{ "maxRetries": 4, "retryDelayInMs": 30000 }`.
+     * - `webSocketOptions`: Configures the channelling of the AMQP connection over Web Sockets.
+     * - `userAgent`      : A string to append to the built in user agent string that is passed to the service.
+     */
+    constructor(consumerGroup: string, fullyQualifiedNamespace: string, eventHubName: string, credential: TokenCredential | NamedKeyCredential | SASCredential, checkpointStore: CheckpointStore, options?: EventHubConsumerClientOptions);
+    /**
+     * Closes the AMQP connection to the Event Hub instance,
+     * returning a promise that will be resolved when disconnection is completed.
+     * @returns Promise<void>
+     * @throws Error if the underlying connection encounters an error while closing.
+     */
+    close(): Promise<void>;
+    /**
+     * Provides the id for each partition associated with the Event Hub.
+     * @param options - The set of options to apply to the operation call.
+     * @returns A promise that resolves with an Array of strings representing the id for
+     * each partition associated with the Event Hub.
+     * @throws Error if the underlying connection has been closed, create a new EventHubConsumerClient.
+     * @throws AbortError if the operation is cancelled via the abortSignal.
+     */
+    getPartitionIds(options?: GetPartitionIdsOptions): Promise<Array<string>>;
+    /**
+     * Provides information about the state of the specified partition.
+     * @param partitionId - The id of the partition for which information is required.
+     * @param options - The set of options to apply to the operation call.
+     * @returns A promise that resolves with information about the state of the partition .
+     * @throws Error if the underlying connection has been closed, create a new EventHubConsumerClient.
+     * @throws AbortError if the operation is cancelled via the abortSignal.
+     */
+    getPartitionProperties(partitionId: string, options?: GetPartitionPropertiesOptions): Promise<PartitionProperties>;
+    /**
+     * Provides the Event Hub runtime information.
+     * @param options - The set of options to apply to the operation call.
+     * @returns A promise that resolves with information about the Event Hub instance.
+     * @throws Error if the underlying connection has been closed, create a new EventHubConsumerClient.
+     * @throws AbortError if the operation is cancelled via the abortSignal.
+     */
+    getEventHubProperties(options?: GetEventHubPropertiesOptions): Promise<EventHubProperties>;
+    /**
+     * Subscribe to events from all partitions.
+     *
+     * If checkpoint store is provided to the `EventHubConsumerClient` and there are multiple
+     * instances of your application, then each instance will subscribe to a subset of the
+     * partitions such that the load is balanced amongst them.
+     *
+     * Call close() on the returned object to stop receiving events.
+     *
+     * Example usage:
+     * ```ts snippet:EventHubConsumerClient_Subscribe
+     * import { EventHubConsumerClient, earliestEventPosition } from "@azure/event-hubs";
+     *
+     * const client = new EventHubConsumerClient("my-consumer-group", "connectionString", "eventHubName");
+     *
+     * const subscription = client.subscribe(
+     *   {
+     *     processEvents: async (events, context) => {
+     *       console.log("Received event count: ", events.length);
+     *     },
+     *     processError: async (err, context) => {
+     *       console.log("Error: ", err);
+     *     },
+     *   },
+     *   { startPosition: earliestEventPosition },
+     * );
+     * ```
+     *
+     * @param handlers - Handlers for the lifecycle of the subscription - subscription initialization
+     *                 per partition, receiving events, handling errors and the closing
+     *                 of a subscription per partition.
+     * @param options - Configures the way events are received.
+     * Most common are `maxBatchSize` and `maxWaitTimeInSeconds` that control the flow of
+     * events to the handler provided to receive events as well as the start position. For example,
+     * `{ maxBatchSize: 20, maxWaitTimeInSeconds: 120, startPosition: { sequenceNumber: 123 } }`
+     */
+    subscribe(handlers: SubscriptionEventHandlers, options?: SubscribeOptions): Subscription;
+    /**
+     * Subscribe to events from a single partition.
+     * Call close() on the returned object to stop receiving events.
+     *
+     * Example usage:
+     * ```ts snippet:EventHubConsumerClient_SubscribeSinglePartition
+     * import { EventHubConsumerClient, earliestEventPosition } from "@azure/event-hubs";
+     *
+     * const client = new EventHubConsumerClient("my-consumer-group", "connectionString", "eventHubName");
+     *
+     * const partitionIds = await client.getPartitionIds();
+     *
+     * const subscription = client.subscribe(
+     *   partitionIds[0],
+     *   {
+     *     processEvents: async (events, context) => {
+     *       console.log("Received event count: ", events.length);
+     *     },
+     *     processError: async (err, context) => {
+     *       console.log("Error: ", err);
+     *     },
+     *   },
+     *   { startPosition: earliestEventPosition },
+     * );
+     * ```
+     *
+     * @param partitionId - The id of the partition to subscribe to.
+     * @param handlers - Handlers for the lifecycle of the subscription - subscription initialization
+     *                 of the partition, receiving events, handling errors and the closing
+     *                 of a subscription to the partition.
+     * @param options - Configures the way events are received.
+     * Most common are `maxBatchSize` and `maxWaitTimeInSeconds` that control the flow of
+     * events to the handler provided to receive events as well as the start position. For example,
+     * `{ maxBatchSize: 20, maxWaitTimeInSeconds: 120, startPosition: { sequenceNumber: 123 } }`
+     */
+    subscribe(partitionId: string, handlers: SubscriptionEventHandlers, options?: SubscribeOptions): Subscription;
+    /**
+     * Gets the LoadBalancing strategy that should be used based on what the user provided.
+     */
+    private _getLoadBalancingStrategy;
+    private createEventProcessorForAllPartitions;
+    private createEventProcessorForSinglePartition;
+    private _createEventProcessor;
+}
+/**
+ * @internal
+ */
+export declare function isCheckpointStore(possible: CheckpointStore | any): possible is CheckpointStore;
+//# sourceMappingURL=eventHubConsumerClient.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"eventHubConsumerClient.d.ts","sourceRoot":"","sources":["../../src/eventHubConsumerClient.ts"],"names":[],"mappings":"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"}

package/dist/react-native/eventHubConsumerClient.js

@@ -0,0 +1,336 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { EventProcessor } from "./eventProcessor.js";
+import { createConnectionContext } from "./connectionContext.js";
+import { BalancedLoadBalancingStrategy } from "./loadBalancerStrategies/balancedStrategy.js";
+import { Constants } from "@azure/core-amqp";
+import { GreedyLoadBalancingStrategy } from "./loadBalancerStrategies/greedyStrategy.js";
+import { InMemoryCheckpointStore } from "./inMemoryCheckpointStore.js";
+import { PartitionGate } from "./impl/partitionGate.js";
+import { UnbalancedLoadBalancingStrategy } from "./loadBalancerStrategies/unbalancedStrategy.js";
+import { isCredential } from "./util/typeGuards.js";
+import { logger } from "./logger.js";
+import { validateEventPositions } from "./eventPosition.js";
+import { getRandomName } from "./util/utils.js";
+const defaultConsumerClientOptions = {
+    // to support our current "process single event only" workflow we'll also purposefully
+    // only request a single event at a time.
+    maxBatchSize: 1,
+    maxWaitTimeInSeconds: 60,
+};
+/**
+ * The `EventHubConsumerClient` class is used to consume events from an Event Hub.
+ *
+ * There are multiple ways to create an `EventHubConsumerClient`
+ * - Use the connection string from the SAS policy created for your Event Hub instance.
+ * - Use the connection string from the SAS policy created for your Event Hub namespace,
+ * and the name of the Event Hub instance
+ * - Use the full namespace like `<yournamespace>.servicebus.windows.net`, and a credentials object.
+ *
+ * Optionally, you can also pass:
+ * - An options bag to configure the retry policy or proxy settings.
+ * - A checkpoint store that is used by the client to read checkpoints to determine the position from where it should
+ * resume receiving events when your application gets restarted. The checkpoint store is also used by the client
+ * to load balance multiple instances of your application.
+ */
+export class EventHubConsumerClient {
+    _consumerGroup;
+    /**
+     * Describes the amqp connection context for the client.
+     */
+    _context;
+    /**
+     * The options passed by the user when creating the EventHubClient instance.
+     */
+    _clientOptions;
+    _partitionGate = new PartitionGate();
+    /**
+     * The Subscriptions that were spawned by calling `subscribe()`.
+     * Subscriptions that have been stopped by the user will not
+     * be present in this set.
+     */
+    _subscriptions = new Set();
+    /**
+     * The name of the default consumer group in the Event Hubs service.
+     */
+    static defaultConsumerGroupName = Constants.defaultConsumerGroup;
+    _checkpointStore;
+    _userChoseCheckpointStore;
+    /**
+     * Options for configuring load balancing.
+     */
+    _loadBalancingOptions;
+    /**
+     * @readonly
+     * The name of the Event Hub instance for which this client is created.
+     */
+    get eventHubName() {
+        return this._context.config.entityPath;
+    }
+    /**
+     * @readonly
+     * The fully qualified namespace of the Event Hub instance for which this client is created.
+     * This is likely to be similar to <yournamespace>.servicebus.windows.net.
+     */
+    get fullyQualifiedNamespace() {
+        return this._context.config.host;
+    }
+    /**
+     * The name used to identify this EventHubConsumerClient.
+     * If not specified or empty, a random unique one will be generated.
+     */
+    identifier;
+    constructor(_consumerGroup, connectionStringOrFullyQualifiedNamespace2, checkpointStoreOrEventHubNameOrOptions3, checkpointStoreOrCredentialOrOptions4, checkpointStoreOrOptions5, options6) {
+        this._consumerGroup = _consumerGroup;
+        if (isCredential(checkpointStoreOrCredentialOrOptions4)) {
+            // #3 or 3.1
+            logger.info("Creating EventHubConsumerClient with TokenCredential.");
+            if (isCheckpointStore(checkpointStoreOrOptions5)) {
+                // 3.1
+                this._checkpointStore = checkpointStoreOrOptions5;
+                this._userChoseCheckpointStore = true;
+                this._clientOptions = options6 || {};
+            }
+            else {
+                this._checkpointStore = new InMemoryCheckpointStore();
+                this._userChoseCheckpointStore = false;
+                this._clientOptions = checkpointStoreOrOptions5 || {};
+            }
+            this._context = createConnectionContext(connectionStringOrFullyQualifiedNamespace2, checkpointStoreOrEventHubNameOrOptions3, checkpointStoreOrCredentialOrOptions4, this._clientOptions);
+        }
+        else if (typeof checkpointStoreOrEventHubNameOrOptions3 === "string") {
+            // #2 or 2.1
+            logger.info("Creating EventHubConsumerClient with connection string and event hub name.");
+            if (isCheckpointStore(checkpointStoreOrCredentialOrOptions4)) {
+                // 2.1
+                this._checkpointStore = checkpointStoreOrCredentialOrOptions4;
+                this._userChoseCheckpointStore = true;
+                this._clientOptions = checkpointStoreOrOptions5 || {};
+            }
+            else {
+                // 2
+                this._checkpointStore = new InMemoryCheckpointStore();
+                this._userChoseCheckpointStore = false;
+                this._clientOptions = checkpointStoreOrCredentialOrOptions4 || {};
+            }
+            this._context = createConnectionContext(connectionStringOrFullyQualifiedNamespace2, checkpointStoreOrEventHubNameOrOptions3, this._clientOptions);
+        }
+        else {
+            // #1 or 1.1
+            logger.info("Creating EventHubConsumerClient with connection string.");
+            if (isCheckpointStore(checkpointStoreOrEventHubNameOrOptions3)) {
+                // 1.1
+                this._checkpointStore = checkpointStoreOrEventHubNameOrOptions3;
+                this._userChoseCheckpointStore = true;
+                this._clientOptions =
+                    checkpointStoreOrCredentialOrOptions4 || {};
+            }
+            else {
+                // 1
+                this._checkpointStore = new InMemoryCheckpointStore();
+                this._userChoseCheckpointStore = false;
+                this._clientOptions =
+                    checkpointStoreOrEventHubNameOrOptions3 || {};
+            }
+            this._context = createConnectionContext(connectionStringOrFullyQualifiedNamespace2, this._clientOptions);
+        }
+        this.identifier = this._clientOptions.identifier ?? getRandomName();
+        this._loadBalancingOptions = {
+            // default options
+            strategy: "balanced",
+            updateIntervalInMs: 10000,
+            partitionOwnershipExpirationIntervalInMs: 60000,
+            // options supplied by user
+            ...this._clientOptions?.loadBalancingOptions,
+        };
+    }
+    /**
+     * Closes the AMQP connection to the Event Hub instance,
+     * returning a promise that will be resolved when disconnection is completed.
+     * @returns Promise<void>
+     * @throws Error if the underlying connection encounters an error while closing.
+     */
+    async close() {
+        // Stop all the actively running subscriptions.
+        const activeSubscriptions = Array.from(this._subscriptions);
+        await Promise.all(activeSubscriptions.map((subscription) => {
+            return subscription.close();
+        }));
+        // Close the connection via the connection context.
+        return this._context.close();
+    }
+    /**
+     * Provides the id for each partition associated with the Event Hub.
+     * @param options - The set of options to apply to the operation call.
+     * @returns A promise that resolves with an Array of strings representing the id for
+     * each partition associated with the Event Hub.
+     * @throws Error if the underlying connection has been closed, create a new EventHubConsumerClient.
+     * @throws AbortError if the operation is cancelled via the abortSignal.
+     */
+    async getPartitionIds(options = {}) {
+        const eventHubProperties = await this._context.managementSession.getEventHubProperties({
+            ...options,
+            retryOptions: this._clientOptions.retryOptions,
+        });
+        return eventHubProperties.partitionIds;
+    }
+    /**
+     * Provides information about the state of the specified partition.
+     * @param partitionId - The id of the partition for which information is required.
+     * @param options - The set of options to apply to the operation call.
+     * @returns A promise that resolves with information about the state of the partition .
+     * @throws Error if the underlying connection has been closed, create a new EventHubConsumerClient.
+     * @throws AbortError if the operation is cancelled via the abortSignal.
+     */
+    getPartitionProperties(partitionId, options = {}) {
+        return this._context.managementSession.getPartitionProperties(partitionId, {
+            ...options,
+            retryOptions: this._clientOptions.retryOptions,
+        });
+    }
+    /**
+     * Provides the Event Hub runtime information.
+     * @param options - The set of options to apply to the operation call.
+     * @returns A promise that resolves with information about the Event Hub instance.
+     * @throws Error if the underlying connection has been closed, create a new EventHubConsumerClient.
+     * @throws AbortError if the operation is cancelled via the abortSignal.
+     */
+    getEventHubProperties(options = {}) {
+        return this._context.managementSession.getEventHubProperties({
+            ...options,
+            retryOptions: this._clientOptions.retryOptions,
+        });
+    }
+    subscribe(handlersOrPartitionId1, optionsOrHandlers2, possibleOptions3) {
+        let eventProcessor;
+        let targetedPartitionId;
+        if (isSubscriptionEventHandlers(handlersOrPartitionId1)) {
+            // #1: subscribe overload - read from all partitions
+            const options = optionsOrHandlers2;
+            if (options && options.startPosition) {
+                validateEventPositions(options.startPosition);
+            }
+            ({ targetedPartitionId, eventProcessor } = this.createEventProcessorForAllPartitions(handlersOrPartitionId1, options));
+        }
+        else if (isSubscriptionEventHandlers(optionsOrHandlers2)) {
+            // #2: subscribe overload (read from specific partition IDs), don't coordinate
+            const options = possibleOptions3;
+            if (options && options.startPosition) {
+                validateEventPositions(options.startPosition);
+            }
+            ({ targetedPartitionId, eventProcessor } = this.createEventProcessorForSinglePartition(
+            // cast to string as downstream code expects partitionId to be string, but JS users could have given us anything.
+            // we don't validate the user input and instead rely on service throwing errors if any
+            String(handlersOrPartitionId1), optionsOrHandlers2, possibleOptions3));
+        }
+        else {
+            throw new TypeError("Unhandled subscribe() overload");
+        }
+        eventProcessor.start();
+        const subscription = {
+            get isRunning() {
+                return eventProcessor.isRunning();
+            },
+            close: () => {
+                this._partitionGate.remove(targetedPartitionId);
+                this._subscriptions.delete(subscription);
+                return eventProcessor.stop();
+            },
+        };
+        this._subscriptions.add(subscription);
+        return subscription;
+    }
+    /**
+     * Gets the LoadBalancing strategy that should be used based on what the user provided.
+     */
+    _getLoadBalancingStrategy() {
+        if (!this._userChoseCheckpointStore) {
+            // The default behavior when a checkpointstore isn't provided
+            // is to always grab all the partitions.
+            return new UnbalancedLoadBalancingStrategy();
+        }
+        const partitionOwnershipExpirationIntervalInMs = this._loadBalancingOptions.partitionOwnershipExpirationIntervalInMs;
+        if (this._loadBalancingOptions?.strategy === "greedy") {
+            return new GreedyLoadBalancingStrategy(partitionOwnershipExpirationIntervalInMs);
+        }
+        // The default behavior when a checkpointstore is provided is
+        // to grab one partition at a time.
+        return new BalancedLoadBalancingStrategy(partitionOwnershipExpirationIntervalInMs);
+    }
+    createEventProcessorForAllPartitions(subscriptionEventHandlers, options) {
+        this._partitionGate.add("all");
+        if (this._userChoseCheckpointStore) {
+            logger.verbose("EventHubConsumerClient subscribing to all partitions, using a checkpoint store.");
+        }
+        else {
+            logger.verbose("EventHubConsumerClient subscribing to all partitions, no checkpoint store.");
+        }
+        const loadBalancingStrategy = this._getLoadBalancingStrategy();
+        const eventProcessor = this._createEventProcessor(this._context, subscriptionEventHandlers, this._checkpointStore, {
+            ...defaultConsumerClientOptions,
+            ...options,
+            ownerLevel: getOwnerLevel(options, this._userChoseCheckpointStore),
+            // make it so all the event processors process work with the same overarching owner ID
+            // this allows the EventHubConsumer to unify all the work for any processors that it spawns
+            ownerId: this.identifier,
+            retryOptions: this._clientOptions.retryOptions,
+            loadBalancingStrategy,
+            loopIntervalInMs: this._loadBalancingOptions.updateIntervalInMs,
+        });
+        return { targetedPartitionId: "all", eventProcessor };
+    }
+    createEventProcessorForSinglePartition(partitionId, eventHandlers, options) {
+        this._partitionGate.add(partitionId);
+        const subscribeOptions = options;
+        if (this._userChoseCheckpointStore) {
+            logger.verbose(`EventHubConsumerClient subscribing to specific partition (${partitionId}), using a checkpoint store.`);
+        }
+        else {
+            logger.verbose(`EventHubConsumerClient subscribing to specific partition (${partitionId}), no checkpoint store.`);
+        }
+        const eventProcessor = this._createEventProcessor(this._context, eventHandlers, this._checkpointStore, {
+            ...defaultConsumerClientOptions,
+            ...options,
+            processingTarget: partitionId,
+            ownerLevel: getOwnerLevel(subscribeOptions, this._userChoseCheckpointStore),
+            retryOptions: this._clientOptions.retryOptions,
+            loadBalancingStrategy: new UnbalancedLoadBalancingStrategy(),
+            loopIntervalInMs: this._loadBalancingOptions.updateIntervalInMs ?? 10000,
+        });
+        return { targetedPartitionId: partitionId, eventProcessor };
+    }
+    _createEventProcessor(connectionContext, subscriptionEventHandlers, checkpointStore, options) {
+        return new EventProcessor(this._consumerGroup, connectionContext, subscriptionEventHandlers, checkpointStore, options);
+    }
+}
+/**
+ * @internal
+ */
+export function isCheckpointStore(possible) {
+    if (!possible) {
+        return false;
+    }
+    const checkpointStore = possible;
+    return (typeof checkpointStore.claimOwnership === "function" &&
+        typeof checkpointStore.listCheckpoints === "function" &&
+        typeof checkpointStore.listOwnership === "function" &&
+        typeof checkpointStore.updateCheckpoint === "function");
+}
+/**
+ * @internal
+ */
+function isSubscriptionEventHandlers(possible) {
+    return typeof possible.processEvents === "function";
+}
+function getOwnerLevel(options, userChoseCheckpointStore) {
+    if (options && options.ownerLevel) {
+        return options.ownerLevel;
+    }
+    if (userChoseCheckpointStore) {
+        return 0;
+    }
+    else {
+        return undefined;
+    }
+}
+//# sourceMappingURL=eventHubConsumerClient.js.map