@microsoft/terraform-cdk-constructs 0.0.3-pre.6 → 0.0.3-pre.7

package/lib/azure-eventhub/lib/instance.js

@@ -10,6 +10,35 @@ const authorization_1 = require("./authorization");
 const consumer_1 = require("./consumer");
 const kusto_connection_1 = require("./kusto-connection");
 class Instance extends constructs_1.Construct {
+    /**
+     * Constructs a new Event Hub instance.
+     *
+     * This class creates an Azure Event Hub instance within a specified namespace. Event Hubs is a highly scalable
+     * data streaming platform and event ingestion service, capable of receiving and processing millions of events per second.
+     * Event Hubs can process and store events, data, or telemetry produced by distributed software and devices.
+     *
+     * @param scope - The scope in which to define this construct, typically used for managing lifecycles and creation order.
+     * @param name - The unique name for this instance of the Event Hub.
+     * @param ehInstanceProps - The properties for configuring the Event Hub instance. The properties include:
+     *                - `name`: Required. The name of the Event Hub instance.
+     *                - `partitionCount`: Optional. The number of partitions for the Event Hub. Defaults to 2. Max value is 32 for shared namespaces.
+     *                - `messageRetention`: Optional. The number of days to retain the messages. Defaults to 1.
+     *                - `status`: Optional. Specifies the operational status of the Event Hub (Active, Disabled, SendDisabled). Defaults to "Active".
+     *                - `resourceGroup`: Required. The name of the resource group in which the Event Hub's parent namespace exists.
+     *                - `namespaceName`: Required. The name of the Event Hub Namespace where this instance will be created.
+     *
+     * Example usage:
+     * ```typescript
+     * const eventHubInstance = new Instance(this, 'myEventHubInstance', {
+     *   name: 'exampleEventHub',
+     *   namespaceName: 'exampleNamespace',
+     *   resourceGroup: resourceGroup,
+     *   partitionCount: 4,
+     *   messageRetention: 7,
+     *   status: 'Active'
+     * });
+     * ```
+     */
     constructor(scope, name, ehInstanceProps) {
         super(scope, name);
         this.ehInstanceProps = ehInstanceProps;
@@ -36,6 +65,33 @@ class Instance extends constructs_1.Construct {
         cdktfTerraformOutputEventhubInstanceId.overrideLogicalId("id");
         cdktfTerraformOutputEventhubInstancePartitionIds.overrideLogicalId("partition_ids");
     }
+    /**
+     * Adds an Authorization Rule to an Event Hub instance.
+     *
+     * This method creates a new Authorization Rule associated with the specified Event Hub,
+     * granting specified permissions such as 'listen', 'send', and 'manage' based on the properties provided.
+     * The rule determines the access level granted to users and applications for the Event Hub.
+     *
+     * @param props - The properties for the Authorization Rule, which include:
+     *                - `name`: Required. A unique identifier for the Authorization Rule within the Event Hub.
+     *                - `listen`: Optional. Specifies if the rule allows listening to the Event Hub. Defaults to false.
+     *                - `send`: Optional. Specifies if the rule allows sending events to the Event Hub. Defaults to false.
+     *                - `manage`: Optional. Specifies if the rule allows managing the Event Hub. When set to true,
+     *                            both 'listen' and 'send' are implicitly enabled. Defaults to false.
+     *
+     * @returns An instance of the AuthorizationRule class, configured with the specified permissions and associated
+     *          with the Event Hub specified in the enclosing construct's properties.
+     *
+     * Example usage:
+     * ```typescript
+     * const eventHubAuthRule = eventHubInstance.addAuthorizationRule({
+     *   name: 'myCustomAuthRule',
+     *   listen: true,
+     *   send: true,
+     *   manage: false // Only listening and sending permissions are granted.
+     * });
+     * ```
+     */
     addAuthorizationRule(props) {
         return new authorization_1.AuthorizationRule(this, `ehauthrule-${props.name}`, {
             resourceGroupName: this.ehInstanceProps.resourceGroup.name,
@@ -44,6 +100,30 @@ class Instance extends constructs_1.Construct {
             ...props,
         });
     }
+    /**
+     * Adds a Consumer Group to an existing Event Hub instance.
+     *
+     * This method creates a new Consumer Group for the specified Event Hub. Consumer groups represent a view of the entire Event Hub,
+     * allowing consumer applications to have separate, independent views of the event stream. They read the stream at their own pace
+     * and maintain their own sequence point or offset. This enables a single Event Hub to support multiple consumer applications.
+     *
+     * @param name - The name of the Consumer Group to be added. This name must be unique within the Event Hub namespace.
+     * @param userMetadata - Optional. User-defined metadata for the Consumer Group. This metadata is useful for storing additional
+     *                       information about the consumer group, such as its purpose or operational details.
+     *
+     * @returns An instance of the ConsumerGroup class, configured with the specified properties and associated with the Event Hub
+     *          specified in the enclosing construct's properties.
+     *
+     * Example usage:
+     * ```typescript
+     * const myConsumerGroup = eventHubInstance.addConsumerGroup('myConsumerGroupName', 'Metadata about this consumer group');
+     * ```
+     *
+     * @remarks
+     * Each consumer group can have multiple concurrent readers, but each partition in the Event Hub can only have one active consumer
+     * from a specific consumer group at a time. Multiple consumer groups enable multiple consuming applications to each have a separate
+     * view of the event stream, and to read the stream independently at their own pace and with their own offsets.
+     */
     addConsumerGroup(name, userMetadata) {
         return new consumer_1.ConsumerGroup(this, `ehconsumergroup-${name}`, {
             resourceGroup: this.ehInstanceProps.resourceGroup,
@@ -53,6 +133,44 @@ class Instance extends constructs_1.Construct {
             userMetadata: userMetadata,
         });
     }
+    /**
+     * Adds a Kusto Data Connection to an existing Kusto Cluster and Database for ingesting data from an EventHub.
+     *
+     * This method configures a new Kusto Data Connection linked to the specified EventHub. It facilitates the ingestion of streaming data
+     * into the Kusto database, allowing for real-time analytics on streamed data. This connection specifies how data from EventHub
+     * is to be ingested into tables within the Kusto Database.
+     *
+     * @param props - The properties for the Kusto Data Connection, derived from BaseKustoDataConnectionProps, which include:
+     *                - `name`: Required. The name of the data connection to create.
+     *                - `location`: Required. The Azure region where the data connection will be created.
+     *                - `kustoResourceGroup`: Required. The Resource Group where the Kusto database exists.
+     *                - `kustoClusterName`: Required. The name of the Kusto Cluster to which this data connection will be added.
+     *                - `kustoDatabaseName`: Required. The name of the Kusto Database to which this data connection will be added.
+     *                - `consumerGroup`: Optional. The EventHub consumer group used for ingestion. Defaults to "$Default".
+     *                - `tableName`: Optional. The target table name in the Kusto database used for data ingestion.
+     *                - `identityId`: Optional. The resource ID of a managed identity used for authentication with EventHub.
+     *                - `mappingRuleName`: Optional. The mapping rule name used for data ingestion.
+     *                - `dataFormat`: Optional. Specifies the data format of EventHub messages. Defaults to "JSON".
+     *                - `databaseRoutingType`: Optional. Indicates the routing type for the database. Defaults to "Single".
+     *                - `compression`: Optional. Specifies the compression type for the data connection. Defaults to "None".
+     *
+     * @returns An instance of the KustoDataConnection class, configured with the specified properties and linked to the EventHub
+     *          specified in the enclosing construct's properties.
+     *
+     * Example usage:
+     * ```typescript
+     * const kustoConnection = kustoInstance.addKustoDataConnection({
+     *   name: 'myKustoDataConnection',
+     *   location: 'West US',
+     *   kustoResourceGroup: resourceGroup,
+     *   kustoClusterName: 'myCluster',
+     *   kustoDatabaseName: 'myDatabase',
+     *   tableName: 'IngestionTable',
+     *   consumerGroup: '$Default',
+     *   dataFormat: 'JSON'
+     * });
+     * ```
+     */
     addKustoDataConnection(props) {
         return new kusto_connection_1.KustoDataConnection(this, `ehkustodataconnection-${this.ehInstanceProps.name}-${props.name}`, {
             eventhubId: this.id,
@@ -62,5 +180,5 @@ class Instance extends constructs_1.Construct {
 }
 exports.Instance = Instance;
 _a = JSII_RTTI_SYMBOL_1;
-Instance[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_eventhub.Instance", version: "0.0.3-pre.6" };
-//# sourceMappingURL=data:application/json;base64,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
+Instance[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_eventhub.Instance", version: "0.0.3-pre.7" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"instance.js","sourceRoot":"","sources":["../../../src/azure-eventhub/lib/instance.ts"],"names":[],"mappings":";;;;;AAAA,mEAAgE;AAEhE,+BAA+B;AAC/B,2CAAuC;AACvC,mDAA4E;AAC5E,yCAA2C;AAC3C,yDAG4B;AAyC5B,MAAa,QAAS,SAAQ,sBAAS;IAKrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,YAAY,KAAgB,EAAE,IAAY,EAAE,eAA8B;QACxE,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAEnB,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;QAEvC,MAAM,QAAQ,GAAG;YACf,cAAc,EAAE,eAAe,CAAC,cAAc,IAAI,CAAC;YACnD,gBAAgB,EAAE,eAAe,CAAC,gBAAgB,IAAI,CAAC;YACvD,MAAM,EAAE,eAAe,CAAC,MAAM,IAAI,QAAQ;SAC3C,CAAC;QAEF,MAAM,gBAAgB,GAAG,IAAI,mBAAQ,CACnC,IAAI,EACJ,cAAc,eAAe,CAAC,IAAI,EAAE,EACpC;YACE,IAAI,EAAE,eAAe,CAAC,IAAI;YAC1B,iBAAiB,EAAE,eAAe,CAAC,aAAa,CAAC,IAAI;YACrD,aAAa,EAAE,eAAe,CAAC,aAAa;YAC5C,GAAG,QAAQ;SACZ,CACF,CAAC;QAEF,UAAU;QACV,IAAI,CAAC,EAAE,GAAG,gBAAgB,CAAC,EAAE,CAAC;QAC9B,IAAI,CAAC,YAAY,GAAG,gBAAgB,CAAC,YAAY,CAAC;QAElD,MAAM,sCAAsC,GAAG,IAAI,KAAK,CAAC,eAAe,CACtE,IAAI,EACJ,IAAI,EACJ;YACE,KAAK,EAAE,gBAAgB,CAAC,EAAE;SAC3B,CACF,CAAC;QACF,MAAM,gDAAgD,GACpD,IAAI,KAAK,CAAC,eAAe,CAAC,IAAI,EAAE,eAAe,EAAE;YAC/C,KAAK,EAAE,gBAAgB,CAAC,YAAY;SACrC,CAAC,CAAC;QAEL,sCAAsC,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QAC/D,gDAAgD,CAAC,iBAAiB,CAChE,eAAe,CAChB,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACI,oBAAoB,CAAC,KAA6B;QACvD,OAAO,IAAI,iCAAiB,CAAC,IAAI,EAAE,cAAc,KAAK,CAAC,IAAI,EAAE,EAAE;YAC7D,iBAAiB,EAAE,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,IAAI;YAC1D,aAAa,EAAE,IAAI,CAAC,eAAe,CAAC,aAAa;YACjD,YAAY,EAAE,IAAI,CAAC,eAAe,CAAC,IAAI;YACvC,GAAG,KAAK;SACT,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACI,gBAAgB,CAAC,IAAY,EAAE,YAAqB;QACzD,OAAO,IAAI,wBAAa,CAAC,IAAI,EAAE,mBAAmB,IAAI,EAAE,EAAE;YACxD,aAAa,EAAE,IAAI,CAAC,eAAe,CAAC,aAAa;YACjD,aAAa,EAAE,IAAI,CAAC,eAAe,CAAC,aAAa;YACjD,YAAY,EAAE,IAAI,CAAC,eAAe,CAAC,IAAI;YACvC,IAAI,EAAE,IAAI;YACV,YAAY,EAAE,YAAY;SAC3B,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACI,sBAAsB,CAAC,KAAmC;QAC/D,OAAO,IAAI,sCAAmB,CAC5B,IAAI,EACJ,yBAAyB,IAAI,CAAC,eAAe,CAAC,IAAI,IAAI,KAAK,CAAC,IAAI,EAAE,EAClE;YACE,UAAU,EAAE,IAAI,CAAC,EAAE;YACnB,GAAG,KAAK;SACT,CACF,CAAC;IACJ,CAAC;;AAnMH,4BAoMC","sourcesContent":["import { Eventhub } from \"@cdktf/provider-azurerm/lib/eventhub\";\nimport { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { AuthorizationRule, AuthorizationRuleProps } from \"./authorization\";\nimport { ConsumerGroup } from \"./consumer\";\nimport {\n  KustoDataConnection,\n  BaseKustoDataConnectionProps,\n} from \"./kusto-connection\";\n\nexport interface BaseInstanceProps {\n  /**\n   * Specifies the name of the EventHub resource.\n   */\n  readonly name: string;\n  /**\n   * Specifies the current number of shards on the Event Hub.\n   * When using a shared parent EventHub Namespace, maximum value is 32.\n   * @default 2\n   */\n  readonly partitionCount?: number;\n  /**\n   * Specifies the number of days to retain the events for this Event Hub.\n   * @default 1\n   */\n  readonly messageRetention?: number;\n  /**\n   * Specifies the status of the Event Hub resource. Possible values are Active, Disabled and SendDisabled.\n   * @default \"Active\"\n   */\n  readonly status?: string;\n\n  /**\n   * TODO: capture_description\n   * TOOD: destination\n   */\n}\n\nexport interface InstanceProps extends BaseInstanceProps {\n  /**\n   * The name of the resource group in which the EventHub's parent Namespace exists.\n   */\n  readonly resourceGroup: ResourceGroup;\n  /**\n   * Specifies the name of the EventHub Namespace.\n   */\n  readonly namespaceName: string;\n}\n\nexport class Instance extends Construct {\n  readonly ehInstanceProps: InstanceProps;\n  readonly id: string;\n  readonly partitionIds: string[];\n\n  /**\n   * Constructs a new Event Hub instance.\n   *\n   * This class creates an Azure Event Hub instance within a specified namespace. Event Hubs is a highly scalable\n   * data streaming platform and event ingestion service, capable of receiving and processing millions of events per second.\n   * Event Hubs can process and store events, data, or telemetry produced by distributed software and devices.\n   *\n   * @param scope - The scope in which to define this construct, typically used for managing lifecycles and creation order.\n   * @param name - The unique name for this instance of the Event Hub.\n   * @param ehInstanceProps - The properties for configuring the Event Hub instance. The properties include:\n   *                - `name`: Required. The name of the Event Hub instance.\n   *                - `partitionCount`: Optional. The number of partitions for the Event Hub. Defaults to 2. Max value is 32 for shared namespaces.\n   *                - `messageRetention`: Optional. The number of days to retain the messages. Defaults to 1.\n   *                - `status`: Optional. Specifies the operational status of the Event Hub (Active, Disabled, SendDisabled). Defaults to \"Active\".\n   *                - `resourceGroup`: Required. The name of the resource group in which the Event Hub's parent namespace exists.\n   *                - `namespaceName`: Required. The name of the Event Hub Namespace where this instance will be created.\n   *\n   * Example usage:\n   * ```typescript\n   * const eventHubInstance = new Instance(this, 'myEventHubInstance', {\n   *   name: 'exampleEventHub',\n   *   namespaceName: 'exampleNamespace',\n   *   resourceGroup: resourceGroup,\n   *   partitionCount: 4,\n   *   messageRetention: 7,\n   *   status: 'Active'\n   * });\n   * ```\n   */\n  constructor(scope: Construct, name: string, ehInstanceProps: InstanceProps) {\n    super(scope, name);\n\n    this.ehInstanceProps = ehInstanceProps;\n\n    const defaults = {\n      partitionCount: ehInstanceProps.partitionCount || 2,\n      messageRetention: ehInstanceProps.messageRetention || 1,\n      status: ehInstanceProps.status || \"Active\",\n    };\n\n    const eventhubInstance = new Eventhub(\n      this,\n      `ehinstance-${ehInstanceProps.name}`,\n      {\n        name: ehInstanceProps.name,\n        resourceGroupName: ehInstanceProps.resourceGroup.name,\n        namespaceName: ehInstanceProps.namespaceName,\n        ...defaults,\n      },\n    );\n\n    // Outputs\n    this.id = eventhubInstance.id;\n    this.partitionIds = eventhubInstance.partitionIds;\n\n    const cdktfTerraformOutputEventhubInstanceId = new cdktf.TerraformOutput(\n      this,\n      \"id\",\n      {\n        value: eventhubInstance.id,\n      },\n    );\n    const cdktfTerraformOutputEventhubInstancePartitionIds =\n      new cdktf.TerraformOutput(this, \"partition_ids\", {\n        value: eventhubInstance.partitionIds,\n      });\n\n    cdktfTerraformOutputEventhubInstanceId.overrideLogicalId(\"id\");\n    cdktfTerraformOutputEventhubInstancePartitionIds.overrideLogicalId(\n      \"partition_ids\",\n    );\n  }\n\n  /**\n   * Adds an Authorization Rule to an Event Hub instance.\n   *\n   * This method creates a new Authorization Rule associated with the specified Event Hub,\n   * granting specified permissions such as 'listen', 'send', and 'manage' based on the properties provided.\n   * The rule determines the access level granted to users and applications for the Event Hub.\n   *\n   * @param props - The properties for the Authorization Rule, which include:\n   *                - `name`: Required. A unique identifier for the Authorization Rule within the Event Hub.\n   *                - `listen`: Optional. Specifies if the rule allows listening to the Event Hub. Defaults to false.\n   *                - `send`: Optional. Specifies if the rule allows sending events to the Event Hub. Defaults to false.\n   *                - `manage`: Optional. Specifies if the rule allows managing the Event Hub. When set to true,\n   *                            both 'listen' and 'send' are implicitly enabled. Defaults to false.\n   *\n   * @returns An instance of the AuthorizationRule class, configured with the specified permissions and associated\n   *          with the Event Hub specified in the enclosing construct's properties.\n   *\n   * Example usage:\n   * ```typescript\n   * const eventHubAuthRule = eventHubInstance.addAuthorizationRule({\n   *   name: 'myCustomAuthRule',\n   *   listen: true,\n   *   send: true,\n   *   manage: false // Only listening and sending permissions are granted.\n   * });\n   * ```\n   */\n  public addAuthorizationRule(props: AuthorizationRuleProps) {\n    return new AuthorizationRule(this, `ehauthrule-${props.name}`, {\n      resourceGroupName: this.ehInstanceProps.resourceGroup.name,\n      namespaceName: this.ehInstanceProps.namespaceName,\n      eventhubName: this.ehInstanceProps.name,\n      ...props,\n    });\n  }\n\n  /**\n   * Adds a Consumer Group to an existing Event Hub instance.\n   *\n   * This method creates a new Consumer Group for the specified Event Hub. Consumer groups represent a view of the entire Event Hub,\n   * allowing consumer applications to have separate, independent views of the event stream. They read the stream at their own pace\n   * and maintain their own sequence point or offset. This enables a single Event Hub to support multiple consumer applications.\n   *\n   * @param name - The name of the Consumer Group to be added. This name must be unique within the Event Hub namespace.\n   * @param userMetadata - Optional. User-defined metadata for the Consumer Group. This metadata is useful for storing additional\n   *                       information about the consumer group, such as its purpose or operational details.\n   *\n   * @returns An instance of the ConsumerGroup class, configured with the specified properties and associated with the Event Hub\n   *          specified in the enclosing construct's properties.\n   *\n   * Example usage:\n   * ```typescript\n   * const myConsumerGroup = eventHubInstance.addConsumerGroup('myConsumerGroupName', 'Metadata about this consumer group');\n   * ```\n   *\n   * @remarks\n   * Each consumer group can have multiple concurrent readers, but each partition in the Event Hub can only have one active consumer\n   * from a specific consumer group at a time. Multiple consumer groups enable multiple consuming applications to each have a separate\n   * view of the event stream, and to read the stream independently at their own pace and with their own offsets.\n   */\n  public addConsumerGroup(name: string, userMetadata?: string) {\n    return new ConsumerGroup(this, `ehconsumergroup-${name}`, {\n      resourceGroup: this.ehInstanceProps.resourceGroup,\n      namespaceName: this.ehInstanceProps.namespaceName,\n      eventhubName: this.ehInstanceProps.name,\n      name: name,\n      userMetadata: userMetadata,\n    });\n  }\n\n  /**\n   * Adds a Kusto Data Connection to an existing Kusto Cluster and Database for ingesting data from an EventHub.\n   *\n   * This method configures a new Kusto Data Connection linked to the specified EventHub. It facilitates the ingestion of streaming data\n   * into the Kusto database, allowing for real-time analytics on streamed data. This connection specifies how data from EventHub\n   * is to be ingested into tables within the Kusto Database.\n   *\n   * @param props - The properties for the Kusto Data Connection, derived from BaseKustoDataConnectionProps, which include:\n   *                - `name`: Required. The name of the data connection to create.\n   *                - `location`: Required. The Azure region where the data connection will be created.\n   *                - `kustoResourceGroup`: Required. The Resource Group where the Kusto database exists.\n   *                - `kustoClusterName`: Required. The name of the Kusto Cluster to which this data connection will be added.\n   *                - `kustoDatabaseName`: Required. The name of the Kusto Database to which this data connection will be added.\n   *                - `consumerGroup`: Optional. The EventHub consumer group used for ingestion. Defaults to \"$Default\".\n   *                - `tableName`: Optional. The target table name in the Kusto database used for data ingestion.\n   *                - `identityId`: Optional. The resource ID of a managed identity used for authentication with EventHub.\n   *                - `mappingRuleName`: Optional. The mapping rule name used for data ingestion.\n   *                - `dataFormat`: Optional. Specifies the data format of EventHub messages. Defaults to \"JSON\".\n   *                - `databaseRoutingType`: Optional. Indicates the routing type for the database. Defaults to \"Single\".\n   *                - `compression`: Optional. Specifies the compression type for the data connection. Defaults to \"None\".\n   *\n   * @returns An instance of the KustoDataConnection class, configured with the specified properties and linked to the EventHub\n   *          specified in the enclosing construct's properties.\n   *\n   * Example usage:\n   * ```typescript\n   * const kustoConnection = kustoInstance.addKustoDataConnection({\n   *   name: 'myKustoDataConnection',\n   *   location: 'West US',\n   *   kustoResourceGroup: resourceGroup,\n   *   kustoClusterName: 'myCluster',\n   *   kustoDatabaseName: 'myDatabase',\n   *   tableName: 'IngestionTable',\n   *   consumerGroup: '$Default',\n   *   dataFormat: 'JSON'\n   * });\n   * ```\n   */\n  public addKustoDataConnection(props: BaseKustoDataConnectionProps) {\n    return new KustoDataConnection(\n      this,\n      `ehkustodataconnection-${this.ehInstanceProps.name}-${props.name}`,\n      {\n        eventhubId: this.id,\n        ...props,\n      },\n    );\n  }\n}\n"]}

package/lib/azure-eventhub/lib/kusto-connection.d.ts

@@ -64,5 +64,46 @@ export interface KustoDataConnectionProps extends BaseKustoDataConnectionProps {
 }
 export declare class KustoDataConnection extends Construct {
     readonly eventhubKustoDataConnectionProps: KustoDataConnectionProps;
+    /**
+     * Constructs a new Azure Kusto Data Connection for ingesting data from an EventHub.
+     *
+     * This class creates a data connection within a specified Kusto (Azure Data Explorer) database that connects
+     * to an Azure EventHub. This setup enables seamless data ingestion from EventHub into the Kusto database,
+     * allowing for real-time analytics on streamed data.
+     *
+     * @param scope - The scope in which to define this construct, typically representing the Cloud Development Kit (CDK) stack.
+     * @param id - The unique identifier for this instance of the data connection.
+     * @param kustoDataConnectionProps - The properties for configuring the Kusto EventHub Data Connection. These properties include:
+     *                - `name`: Required. The name of the data connection.
+     *                - `location`: Required. The Azure region where the data connection will be created.
+     *                - `kustoResourceGroup`: Required. The Resource Group where the Kusto database exists.
+     *                - `kustoClusterName`: Required. The name of the Kusto Cluster to which this data connection will be added.
+     *                - `kustoDatabaseName`: Required. The name of the Kusto Database to which this data connection will be added.
+     *                - `eventhubId`: Required. The resource ID of the EventHub used for data ingestion.
+     *                - `consumerGroup`: Optional. The EventHub consumer group used for ingestion. Defaults to "$Default".
+     *                - `tableName`: Optional. The target table name in the Kusto database used for data ingestion.
+     *                - `identityId`: Optional. The resource ID of a managed identity used for authentication with EventHub.
+     *                - `mappingRuleName`: Optional. The mapping rule name used for data ingestion.
+     *                - `dataFormat`: Optional. Specifies the data format of EventHub messages. Defaults to "JSON".
+     *                - `databaseRoutingType`: Optional. Indicates the routing type for the database. Defaults to "Single".
+     *                - `compression`: Optional. Specifies the compression type for the data connection. Defaults to "None".
+     *
+     * Example usage:
+     * ```typescript
+     * const kustoDataConnection = new KustoDataConnection(this, 'myDataConnection', {
+     *   name: 'exampleDataConnection',
+     *   location: 'East US',
+     *   kustoResourceGroup: resourceGroup,
+     *   kustoClusterName: 'exampleCluster',
+     *   kustoDatabaseName: 'exampleDatabase',
+     *   eventhubId: '/subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.EventHub/namespaces/{namespace}/eventhubs/{eventhub}',
+     *   consumerGroup: '$Default',
+     *   tableName: 'destinationTable',
+     *   dataFormat: 'JSON',
+     *   databaseRoutingType: 'Single',
+     *   compression: 'None'
+     * });
+     * ```
+     */
     constructor(scope: Construct, id: string, kustoDataConnectionProps: KustoDataConnectionProps);
 }

package/lib/azure-eventhub/lib/kusto-connection.js

@@ -6,6 +6,47 @@ const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const kusto_eventhub_data_connection_1 = require("@cdktf/provider-azurerm/lib/kusto-eventhub-data-connection");
 const constructs_1 = require("constructs");
 class KustoDataConnection extends constructs_1.Construct {
+    /**
+     * Constructs a new Azure Kusto Data Connection for ingesting data from an EventHub.
+     *
+     * This class creates a data connection within a specified Kusto (Azure Data Explorer) database that connects
+     * to an Azure EventHub. This setup enables seamless data ingestion from EventHub into the Kusto database,
+     * allowing for real-time analytics on streamed data.
+     *
+     * @param scope - The scope in which to define this construct, typically representing the Cloud Development Kit (CDK) stack.
+     * @param id - The unique identifier for this instance of the data connection.
+     * @param kustoDataConnectionProps - The properties for configuring the Kusto EventHub Data Connection. These properties include:
+     *                - `name`: Required. The name of the data connection.
+     *                - `location`: Required. The Azure region where the data connection will be created.
+     *                - `kustoResourceGroup`: Required. The Resource Group where the Kusto database exists.
+     *                - `kustoClusterName`: Required. The name of the Kusto Cluster to which this data connection will be added.
+     *                - `kustoDatabaseName`: Required. The name of the Kusto Database to which this data connection will be added.
+     *                - `eventhubId`: Required. The resource ID of the EventHub used for data ingestion.
+     *                - `consumerGroup`: Optional. The EventHub consumer group used for ingestion. Defaults to "$Default".
+     *                - `tableName`: Optional. The target table name in the Kusto database used for data ingestion.
+     *                - `identityId`: Optional. The resource ID of a managed identity used for authentication with EventHub.
+     *                - `mappingRuleName`: Optional. The mapping rule name used for data ingestion.
+     *                - `dataFormat`: Optional. Specifies the data format of EventHub messages. Defaults to "JSON".
+     *                - `databaseRoutingType`: Optional. Indicates the routing type for the database. Defaults to "Single".
+     *                - `compression`: Optional. Specifies the compression type for the data connection. Defaults to "None".
+     *
+     * Example usage:
+     * ```typescript
+     * const kustoDataConnection = new KustoDataConnection(this, 'myDataConnection', {
+     *   name: 'exampleDataConnection',
+     *   location: 'East US',
+     *   kustoResourceGroup: resourceGroup,
+     *   kustoClusterName: 'exampleCluster',
+     *   kustoDatabaseName: 'exampleDatabase',
+     *   eventhubId: '/subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.EventHub/namespaces/{namespace}/eventhubs/{eventhub}',
+     *   consumerGroup: '$Default',
+     *   tableName: 'destinationTable',
+     *   dataFormat: 'JSON',
+     *   databaseRoutingType: 'Single',
+     *   compression: 'None'
+     * });
+     * ```
+     */
     constructor(scope, id, kustoDataConnectionProps) {
         super(scope, id);
         this.eventhubKustoDataConnectionProps = kustoDataConnectionProps;
@@ -31,5 +72,5 @@ class KustoDataConnection extends constructs_1.Construct {
 }
 exports.KustoDataConnection = KustoDataConnection;
 _a = JSII_RTTI_SYMBOL_1;
-KustoDataConnection[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_eventhub.KustoDataConnection", version: "0.0.3-pre.6" };
-//# sourceMappingURL=data:application/json;base64,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
+KustoDataConnection[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_eventhub.KustoDataConnection", version: "0.0.3-pre.7" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"kusto-connection.js","sourceRoot":"","sources":["../../../src/azure-eventhub/lib/kusto-connection.ts"],"names":[],"mappings":";;;;;AAAA,+GAAyG;AAEzG,2CAAuC;AA6EvC,MAAa,mBAAoB,SAAQ,sBAAS;IAGhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACH,YACE,KAAgB,EAChB,EAAU,EACV,wBAAkD;QAElD,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,IAAI,CAAC,gCAAgC,GAAG,wBAAwB,CAAC;QAEjE,MAAM,QAAQ,GAAG;YACf,SAAS,EAAE,wBAAwB,CAAC,SAAS,IAAI,SAAS;YAC1D,UAAU,EAAE,wBAAwB,CAAC,UAAU,IAAI,SAAS;YAC5D,eAAe,EAAE,wBAAwB,CAAC,eAAe,IAAI,SAAS;YACtE,aAAa,EAAE,wBAAwB,CAAC,aAAa,IAAI,UAAU;YACnE,UAAU,EAAE,wBAAwB,CAAC,UAAU,IAAI,MAAM;YACzD,mBAAmB,EACjB,wBAAwB,CAAC,mBAAmB,IAAI,QAAQ;YAC1D,WAAW,EAAE,wBAAwB,CAAC,WAAW,IAAI,MAAM;SAC5D,CAAC;QAEF,IAAI,4DAA2B,CAC7B,IAAI,EACJ,yBAAyB,IAAI,CAAC,gCAAgC,CAAC,IAAI,EAAE,EACrE;YACE,IAAI,EAAE,IAAI,CAAC,gCAAgC,CAAC,IAAI;YAChD,QAAQ,EAAE,IAAI,CAAC,gCAAgC,CAAC,QAAQ;YACxD,iBAAiB,EACf,IAAI,CAAC,gCAAgC,CAAC,kBAAkB,CAAC,IAAI;YAC/D,WAAW,EAAE,IAAI,CAAC,gCAAgC,CAAC,gBAAgB;YACnE,YAAY,EAAE,IAAI,CAAC,gCAAgC,CAAC,iBAAiB;YACrE,UAAU,EAAE,IAAI,CAAC,gCAAgC,CAAC,UAAU;YAC5D,GAAG,QAAQ;SACZ,CACF,CAAC;IACJ,CAAC;;AA9EH,kDA+EC","sourcesContent":["import { KustoEventhubDataConnection } from \"@cdktf/provider-azurerm/lib/kusto-eventhub-data-connection\";\nimport { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\nimport { Construct } from \"constructs\";\n\nexport interface BaseKustoDataConnectionProps {\n  /**\n   * The name of the Kusto EventHub Data Connection to create.\n   */\n  readonly name: string;\n\n  /**\n   * The location where the Kusto EventHub Data Connection should be created.\n   */\n  readonly location: string;\n\n  /**\n   * Specifies the Resource Group where the Kusto Database should exist.\n   */\n  readonly kustoResourceGroup: ResourceGroup;\n\n  /**\n   * Specifies the name of the Kusto Cluster this data connection will be added to.\n   */\n  readonly kustoClusterName: string;\n\n  /**\n   * Specifies the name of the Kusto Database this data connection will be added to.\n   */\n  readonly kustoDatabaseName: string;\n\n  /**\n   * Specifies the EventHub consumer group this data connection will use for ingestion.\n   * @default \"$Default\"\n   */\n  readonly consumerGroup?: string;\n\n  /**\n   * Specifies the target table name used for the message ingestion. Table must exist before resource is created.\n   */\n  readonly tableName?: string | undefined;\n\n  /**\n   * The resource ID of a managed identity (system or user assigned) to be used to authenticate with event hub.\n   */\n  readonly identityId?: string | undefined;\n\n  /**\n   * Specifies the mapping rule used for the message ingestion. Mapping rule must exist before resource is created.\n   */\n  readonly mappingRuleName?: string | undefined;\n\n  /**\n   * Specifies the data format of the EventHub messages.\n   * Allowed values: APACHEAVRO, AVRO, CSV, JSON, MULTIJSON, ORC, PARQUET, PSV, RAW, SCSV, SINGLEJSON, SOHSV, TSVE, TSV, TXT, and W3CLOGFILE.\n   * @default \"JSON\"\n   */\n  readonly dataFormat?: string;\n\n  /**\n   * Indication for database routing information from the data connection, by default only database routing information is allowed.\n   * Allowed values: Single, Multi.\n   * @default \"Single\"\n   */\n  readonly databaseRoutingType?: string;\n\n  /**\n   * Specifies compression type for the connection. Allowed values: GZip and None.\n   * @default \"None\"\n   */\n  readonly compression?: string;\n}\n\nexport interface KustoDataConnectionProps extends BaseKustoDataConnectionProps {\n  /**\n   * Specifies the resource id of the EventHub this data connection will use for ingestion.\n   */\n  readonly eventhubId: string;\n}\n\nexport class KustoDataConnection extends Construct {\n  public readonly eventhubKustoDataConnectionProps: KustoDataConnectionProps;\n\n  /**\n   * Constructs a new Azure Kusto Data Connection for ingesting data from an EventHub.\n   *\n   * This class creates a data connection within a specified Kusto (Azure Data Explorer) database that connects\n   * to an Azure EventHub. This setup enables seamless data ingestion from EventHub into the Kusto database,\n   * allowing for real-time analytics on streamed data.\n   *\n   * @param scope - The scope in which to define this construct, typically representing the Cloud Development Kit (CDK) stack.\n   * @param id - The unique identifier for this instance of the data connection.\n   * @param kustoDataConnectionProps - The properties for configuring the Kusto EventHub Data Connection. These properties include:\n   *                - `name`: Required. The name of the data connection.\n   *                - `location`: Required. The Azure region where the data connection will be created.\n   *                - `kustoResourceGroup`: Required. The Resource Group where the Kusto database exists.\n   *                - `kustoClusterName`: Required. The name of the Kusto Cluster to which this data connection will be added.\n   *                - `kustoDatabaseName`: Required. The name of the Kusto Database to which this data connection will be added.\n   *                - `eventhubId`: Required. The resource ID of the EventHub used for data ingestion.\n   *                - `consumerGroup`: Optional. The EventHub consumer group used for ingestion. Defaults to \"$Default\".\n   *                - `tableName`: Optional. The target table name in the Kusto database used for data ingestion.\n   *                - `identityId`: Optional. The resource ID of a managed identity used for authentication with EventHub.\n   *                - `mappingRuleName`: Optional. The mapping rule name used for data ingestion.\n   *                - `dataFormat`: Optional. Specifies the data format of EventHub messages. Defaults to \"JSON\".\n   *                - `databaseRoutingType`: Optional. Indicates the routing type for the database. Defaults to \"Single\".\n   *                - `compression`: Optional. Specifies the compression type for the data connection. Defaults to \"None\".\n   *\n   * Example usage:\n   * ```typescript\n   * const kustoDataConnection = new KustoDataConnection(this, 'myDataConnection', {\n   *   name: 'exampleDataConnection',\n   *   location: 'East US',\n   *   kustoResourceGroup: resourceGroup,\n   *   kustoClusterName: 'exampleCluster',\n   *   kustoDatabaseName: 'exampleDatabase',\n   *   eventhubId: '/subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.EventHub/namespaces/{namespace}/eventhubs/{eventhub}',\n   *   consumerGroup: '$Default',\n   *   tableName: 'destinationTable',\n   *   dataFormat: 'JSON',\n   *   databaseRoutingType: 'Single',\n   *   compression: 'None'\n   * });\n   * ```\n   */\n  constructor(\n    scope: Construct,\n    id: string,\n    kustoDataConnectionProps: KustoDataConnectionProps,\n  ) {\n    super(scope, id);\n\n    this.eventhubKustoDataConnectionProps = kustoDataConnectionProps;\n\n    const defaults = {\n      tableName: kustoDataConnectionProps.tableName || undefined,\n      identityId: kustoDataConnectionProps.identityId || undefined,\n      mappingRuleName: kustoDataConnectionProps.mappingRuleName || undefined,\n      consumerGroup: kustoDataConnectionProps.consumerGroup || \"$Default\",\n      dataFormat: kustoDataConnectionProps.dataFormat || \"JSON\",\n      databaseRoutingType:\n        kustoDataConnectionProps.databaseRoutingType || \"Single\",\n      compression: kustoDataConnectionProps.compression || \"None\",\n    };\n\n    new KustoEventhubDataConnection(\n      this,\n      `kusto-data-connection-${this.eventhubKustoDataConnectionProps.name}`,\n      {\n        name: this.eventhubKustoDataConnectionProps.name,\n        location: this.eventhubKustoDataConnectionProps.location,\n        resourceGroupName:\n          this.eventhubKustoDataConnectionProps.kustoResourceGroup.name,\n        clusterName: this.eventhubKustoDataConnectionProps.kustoClusterName,\n        databaseName: this.eventhubKustoDataConnectionProps.kustoDatabaseName,\n        eventhubId: this.eventhubKustoDataConnectionProps.eventhubId,\n        ...defaults,\n      },\n    );\n  }\n}\n"]}

package/lib/azure-eventhub/lib/namespace.d.ts

@@ -72,6 +72,80 @@ export declare class Namespace extends AzureResourceWithAlert {
     resourceGroup: ResourceGroup;
     id: string;
     readonly namespaceName: string;
+    /**
+     * Constructs a new Event Hub Namespace.
+     *
+     * This class creates an Azure Event Hub Namespace, which serves as a container for all messaging components.
+     * Namespaces provide a scoping container for Event Hub resources within a specific region, which can be further
+     * controlled and managed using the provided settings.
+     *
+     * @param scope - The scope in which to define this construct, typically representing the Cloud Development Kit (CDK) stack.
+     * @param name - The unique name for this instance of the Event Hub Namespace.
+     * @param ehNamespaceProps - The properties for configuring the Event Hub Namespace. These properties include:
+     *                - `resourceGroup`: Required. The Azure Resource Group in which the namespace will be created.
+     *                - `name`: Required. The name of the Event Hub Namespace to create.
+     *                - `sku`: Optional. The SKU tier of the namespace (Basic, Standard, Premium). Defaults to "Basic".
+     *                - `capacity`: Optional. Specifies the throughput units for a Standard SKU namespace. Defaults to 2.
+     *                - `autoInflateEnabled`: Optional. Enables or disables Auto Inflate. Defaults to false.
+     *                - `maximumThroughputUnits`: Optional. The maximum number of throughput units when Auto Inflate is enabled. Defaults to 2.
+     *                - `zoneRedundant`: Optional. Specifies if the namespace should be zone redundant. Defaults to true.
+     *                - `tags`: Optional. Tags for resource management and categorization.
+     *                - `minimumTlsVersion`: Optional. Specifies the minimum supported TLS version. Defaults to "1.2".
+     *                - `publicNetworkAccessEnabled`: Optional. Specifies if public network access is enabled. Defaults to true.
+     *                - `localAuthenticationEnabled`: Optional. Specifies if SAS authentication is enabled. Defaults to false.
+     *                - `identityType`: Optional. The type of Managed Service Identity. Defaults to "SystemAssigned".
+     *                - `identityIds`: Optional. A list of User Assigned Managed Identity IDs.
+     *
+     * Example usage:
+     * ```typescript
+     * const eventHubNamespace = new Namespace(this, 'myNamespace', {
+     *   resourceGroup: resourceGroup,
+     *   name: 'myEventHubNamespace',
+     *   sku: 'Standard',
+     *   capacity: 4,
+     *   autoInflateEnabled: true,
+     *   maximumThroughputUnits: 10,
+     *   zoneRedundant: false,
+     *   tags: {
+     *     department: 'IT'
+     *   },
+     *   minimumTlsVersion: '1.2',
+     *   publicNetworkAccessEnabled: false,
+     *   localAuthenticationEnabled: true,
+     *   identityType: 'SystemAssigned'
+     * });
+     * ```
+     */
     constructor(scope: Construct, name: string, ehNamespaceProps: NamespaceProps);
+    /**
+     * Creates and adds an Event Hub instance to the current namespace.
+     *
+     * This method sets up a new Event Hub instance within the namespace defined by this class. An Event Hub instance
+     * serves as a container that processes and stores events. This method facilitates the setup of multiple Event Hubs
+     * within a single namespace, each configured according to the specified properties.
+     *
+     * @param props - The properties for configuring the new Event Hub instance. These properties extend `BaseInstanceProps`, which include:
+     *                - `name`: Required. The name of the Event Hub instance.
+     *                - `partitionCount`: Optional. The number of partitions in the Event Hub. Default is 2.
+     *                - `messageRetention`: Optional. The number of days to retain messages in the Event Hub. Default is 1.
+     *                - `status`: Optional. The operational status of the Event Hub (Active, Disabled, SendDisabled). Default is "Active".
+     *                Other properties from `BaseInstanceProps` can also be passed and will be used in the creation of the Event Hub.
+     *
+     * @returns An instance of the Event Hub (`Instance` class), configured with the specified properties.
+     *
+     * Example usage:
+     * ```typescript
+     * const eventHub = namespace.addEventhubInstance({
+     *   name: 'myEventHub',
+     *   partitionCount: 4,
+     *   messageRetention: 7,
+     *   status: 'Active'
+     * });
+     * ```
+     *
+     * @remarks
+     * Ensure that the namespace has sufficient capacity and configuration to support the properties of the Event Hub being created,
+     * especially in terms of partition count and throughput units if applicable.
+     */
     addEventhubInstance(props: BaseInstanceProps): Instance;
 }

package/lib/azure-eventhub/lib/namespace.js

@@ -8,6 +8,50 @@ const cdktf = require("cdktf");
 const instance_1 = require("./instance");
 const lib_1 = require("../../core-azure/lib");
 class Namespace extends lib_1.AzureResourceWithAlert {
+    /**
+     * Constructs a new Event Hub Namespace.
+     *
+     * This class creates an Azure Event Hub Namespace, which serves as a container for all messaging components.
+     * Namespaces provide a scoping container for Event Hub resources within a specific region, which can be further
+     * controlled and managed using the provided settings.
+     *
+     * @param scope - The scope in which to define this construct, typically representing the Cloud Development Kit (CDK) stack.
+     * @param name - The unique name for this instance of the Event Hub Namespace.
+     * @param ehNamespaceProps - The properties for configuring the Event Hub Namespace. These properties include:
+     *                - `resourceGroup`: Required. The Azure Resource Group in which the namespace will be created.
+     *                - `name`: Required. The name of the Event Hub Namespace to create.
+     *                - `sku`: Optional. The SKU tier of the namespace (Basic, Standard, Premium). Defaults to "Basic".
+     *                - `capacity`: Optional. Specifies the throughput units for a Standard SKU namespace. Defaults to 2.
+     *                - `autoInflateEnabled`: Optional. Enables or disables Auto Inflate. Defaults to false.
+     *                - `maximumThroughputUnits`: Optional. The maximum number of throughput units when Auto Inflate is enabled. Defaults to 2.
+     *                - `zoneRedundant`: Optional. Specifies if the namespace should be zone redundant. Defaults to true.
+     *                - `tags`: Optional. Tags for resource management and categorization.
+     *                - `minimumTlsVersion`: Optional. Specifies the minimum supported TLS version. Defaults to "1.2".
+     *                - `publicNetworkAccessEnabled`: Optional. Specifies if public network access is enabled. Defaults to true.
+     *                - `localAuthenticationEnabled`: Optional. Specifies if SAS authentication is enabled. Defaults to false.
+     *                - `identityType`: Optional. The type of Managed Service Identity. Defaults to "SystemAssigned".
+     *                - `identityIds`: Optional. A list of User Assigned Managed Identity IDs.
+     *
+     * Example usage:
+     * ```typescript
+     * const eventHubNamespace = new Namespace(this, 'myNamespace', {
+     *   resourceGroup: resourceGroup,
+     *   name: 'myEventHubNamespace',
+     *   sku: 'Standard',
+     *   capacity: 4,
+     *   autoInflateEnabled: true,
+     *   maximumThroughputUnits: 10,
+     *   zoneRedundant: false,
+     *   tags: {
+     *     department: 'IT'
+     *   },
+     *   minimumTlsVersion: '1.2',
+     *   publicNetworkAccessEnabled: false,
+     *   localAuthenticationEnabled: true,
+     *   identityType: 'SystemAssigned'
+     * });
+     * ```
+     */
     constructor(scope, name, ehNamespaceProps) {
         super(scope, name);
         this.ehNamespaceProps = ehNamespaceProps;
@@ -43,7 +87,36 @@ class Namespace extends lib_1.AzureResourceWithAlert {
         });
         cdktfTerraformOutputEventhubNamespceId.overrideLogicalId("id");
     }
-    // Create an EventHub Instance Method
+    /**
+     * Creates and adds an Event Hub instance to the current namespace.
+     *
+     * This method sets up a new Event Hub instance within the namespace defined by this class. An Event Hub instance
+     * serves as a container that processes and stores events. This method facilitates the setup of multiple Event Hubs
+     * within a single namespace, each configured according to the specified properties.
+     *
+     * @param props - The properties for configuring the new Event Hub instance. These properties extend `BaseInstanceProps`, which include:
+     *                - `name`: Required. The name of the Event Hub instance.
+     *                - `partitionCount`: Optional. The number of partitions in the Event Hub. Default is 2.
+     *                - `messageRetention`: Optional. The number of days to retain messages in the Event Hub. Default is 1.
+     *                - `status`: Optional. The operational status of the Event Hub (Active, Disabled, SendDisabled). Default is "Active".
+     *                Other properties from `BaseInstanceProps` can also be passed and will be used in the creation of the Event Hub.
+     *
+     * @returns An instance of the Event Hub (`Instance` class), configured with the specified properties.
+     *
+     * Example usage:
+     * ```typescript
+     * const eventHub = namespace.addEventhubInstance({
+     *   name: 'myEventHub',
+     *   partitionCount: 4,
+     *   messageRetention: 7,
+     *   status: 'Active'
+     * });
+     * ```
+     *
+     * @remarks
+     * Ensure that the namespace has sufficient capacity and configuration to support the properties of the Event Hub being created,
+     * especially in terms of partition count and throughput units if applicable.
+     */
     addEventhubInstance(props) {
         return new instance_1.Instance(this, "ehinstance", {
             resourceGroup: this.resourceGroup,
@@ -54,5 +127,5 @@ class Namespace extends lib_1.AzureResourceWithAlert {
 }
 exports.Namespace = Namespace;
 _a = JSII_RTTI_SYMBOL_1;
-Namespace[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_eventhub.Namespace", version: "0.0.3-pre.6" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"namespace.js","sourceRoot":"","sources":["../../../src/azure-eventhub/lib/namespace.ts"],"names":[],"mappings":";;;;;AAAA,uFAAmF;AAEnF,+BAA+B;AAE/B,yCAAyD;AACzD,8CAA8D;AAsE9D,MAAa,SAAU,SAAQ,4BAAsB;IAMnD,YACE,KAAgB,EAChB,IAAY,EACZ,gBAAgC;QAEhC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAEnB,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAC;QACzC,IAAI,CAAC,aAAa,GAAG,gBAAgB,CAAC,aAAa,CAAC;QACpD,IAAI,CAAC,aAAa,GAAG,gBAAgB,CAAC,IAAI,CAAC;QAE3C,MAAM,QAAQ,GAAG;YACf,GAAG,EAAE,gBAAgB,CAAC,GAAG,IAAI,OAAO;YACpC,QAAQ,EAAE,gBAAgB,CAAC,QAAQ,IAAI,CAAC;YACxC,kBAAkB,EAAE,gBAAgB,CAAC,kBAAkB,IAAI,KAAK;YAChE,sBAAsB,EAAE,gBAAgB,CAAC,sBAAsB,IAAI,CAAC;YACpE,aAAa,EAAE,gBAAgB,CAAC,aAAa,IAAI,KAAK;YACtD,IAAI,EAAE,gBAAgB,CAAC,IAAI,IAAI,EAAE;YACjC,iBAAiB,EAAE,gBAAgB,CAAC,iBAAiB,IAAI,KAAK;YAC9D,0BAA0B,EACxB,gBAAgB,CAAC,0BAA0B,IAAI,IAAI;YACrD,0BAA0B,EACxB,gBAAgB,CAAC,0BAA0B,IAAI,IAAI;YACrD,QAAQ,EAAE;gBACR,IAAI,EAAE,gBAAgB,CAAC,YAAY,IAAI,gBAAgB;gBACvD,WAAW,EACT,gBAAgB,CAAC,YAAY,IAAI,cAAc;oBAC7C,CAAC,CAAC,gBAAgB,CAAC,WAAW;oBAC9B,CAAC,CAAC,SAAS;aAChB;SACF,CAAC;QAEF,MAAM,gBAAgB,GAAG,IAAI,sCAAiB,CAAC,IAAI,EAAE,aAAa,EAAE;YAClE,IAAI,EAAE,gBAAgB,CAAC,IAAI;YAC3B,iBAAiB,EAAE,IAAI,CAAC,aAAa,CAAC,IAAI;YAC1C,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,QAAQ;YACrC,GAAG,QAAQ;SACZ,CAAC,CAAC;QAEH,UAAU;QACV,IAAI,CAAC,EAAE,GAAG,gBAAgB,CAAC,EAAE,CAAC;QAC9B,MAAM,sCAAsC,GAAG,IAAI,KAAK,CAAC,eAAe,CACtE,IAAI,EACJ,IAAI,EACJ;YACE,KAAK,EAAE,gBAAgB,CAAC,EAAE;SAC3B,CACF,CAAC;QACF,sCAAsC,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;IACjE,CAAC;IAED,qCAAqC;IACrC,mBAAmB,CAAC,KAAwB;QAC1C,OAAO,IAAI,mBAAQ,CAAC,IAAI,EAAE,YAAY,EAAE;YACtC,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,GAAG,KAAK;SACT,CAAC,CAAC;IACL,CAAC;;AAhEH,8BAiEC","sourcesContent":["import { EventhubNamespace } from \"@cdktf/provider-azurerm/lib/eventhub-namespace\";\nimport { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { Instance, BaseInstanceProps } from \"./instance\";\nimport { AzureResourceWithAlert } from \"../../core-azure/lib\";\n\nexport interface NamespaceProps {\n  /**\n   * The Azure Resource Group in which to create the EventHub Namespace.\n   */\n  readonly resourceGroup: ResourceGroup;\n  /**\n   * The name of the EventHub Namespace to create.\n   */\n  readonly name: string;\n  /**\n   * Defines which tier to use. Valid options are Basic, Standard, and Premium.\n   * @default \"Basic\"\n   */\n  readonly sku?: string;\n  /**\n   * Specifies the Capacity / Throughput Units for a Standard SKU namespace.\n   * @default 2\n   */\n  readonly capacity?: number;\n  /**\n   * Specifies if the EventHub Namespace should be Auto Inflate enabled.\n   * @default false\n   */\n  readonly autoInflateEnabled?: boolean;\n  /**\n   * Specifies the maximum number of throughput units when Auto Inflate is Enabled. Valid values range from 1 - 20.\n   * @default 2\n   */\n  readonly maximumThroughputUnits?: number;\n  /**\n   * Specifies if the EventHub Namespace should be Zone Redundant (created across Availability Zones).\n   * @default true\n   */\n  readonly zoneRedundant?: boolean;\n  /**\n   * The tags to assign to the Key Vault.\n   */\n  readonly tags?: { [key: string]: string };\n  /**\n   * The minimum supported TLS version for this EventHub Namespace. Valid values are: 1.0, 1.1 and 1.2.\n   * @default \"1.2\"\n   */\n  readonly minimumTlsVersion?: string;\n  /**\n   * Is public network access enabled for the EventHub Namespace?\n   * @default true\n   */\n  readonly publicNetworkAccessEnabled?: boolean;\n  /**\n   * Is SAS authentication enabled for the EventHub Namespace? North Central US Not supported.\n   * @default false\n   */\n  readonly localAuthenticationEnabled?: boolean;\n  /**\n   * Specifies the type of Managed Service Identity that should be configured on this Event Hub Namespace. Possible values are SystemAssigned or UserAssigned.\n   * @default \"SystemAssigned\"\n   */\n  readonly identityType?: string;\n  /**\n   * Specifies a list of User Assigned Managed Identity IDs to be assigned to this EventHub namespace.\n   */\n  readonly identityIds?: string[] | undefined;\n\n  /**\n   * TODO: network_rulesets\n   */\n}\n\nexport class Namespace extends AzureResourceWithAlert {\n  readonly ehNamespaceProps: NamespaceProps;\n  public resourceGroup: ResourceGroup;\n  public id: string;\n  readonly namespaceName: string;\n\n  constructor(\n    scope: Construct,\n    name: string,\n    ehNamespaceProps: NamespaceProps,\n  ) {\n    super(scope, name);\n\n    this.ehNamespaceProps = ehNamespaceProps;\n    this.resourceGroup = ehNamespaceProps.resourceGroup;\n    this.namespaceName = ehNamespaceProps.name;\n\n    const defaults = {\n      sku: ehNamespaceProps.sku || \"Basic\",\n      capacity: ehNamespaceProps.capacity || 2,\n      autoInflateEnabled: ehNamespaceProps.autoInflateEnabled || false,\n      maximumThroughputUnits: ehNamespaceProps.maximumThroughputUnits || 2,\n      zoneRedundant: ehNamespaceProps.zoneRedundant || false,\n      tags: ehNamespaceProps.tags || {},\n      minimumTlsVersion: ehNamespaceProps.minimumTlsVersion || \"1.2\",\n      publicNetworkAccessEnabled:\n        ehNamespaceProps.publicNetworkAccessEnabled || true,\n      localAuthenticationEnabled:\n        ehNamespaceProps.localAuthenticationEnabled || true,\n      identity: {\n        type: ehNamespaceProps.identityType || \"SystemAssigned\",\n        identityIds:\n          ehNamespaceProps.identityType == \"UserAssigned\"\n            ? ehNamespaceProps.identityIds\n            : undefined,\n      },\n    };\n\n    const eventhubNamespce = new EventhubNamespace(this, \"ehnamespace\", {\n      name: ehNamespaceProps.name,\n      resourceGroupName: this.resourceGroup.name,\n      location: this.resourceGroup.location,\n      ...defaults,\n    });\n\n    // Outputs\n    this.id = eventhubNamespce.id;\n    const cdktfTerraformOutputEventhubNamespceId = new cdktf.TerraformOutput(\n      this,\n      \"id\",\n      {\n        value: eventhubNamespce.id,\n      },\n    );\n    cdktfTerraformOutputEventhubNamespceId.overrideLogicalId(\"id\");\n  }\n\n  // Create an EventHub Instance Method\n  addEventhubInstance(props: BaseInstanceProps) {\n    return new Instance(this, \"ehinstance\", {\n      resourceGroup: this.resourceGroup,\n      namespaceName: this.namespaceName,\n      ...props,\n    });\n  }\n}\n"]}
+Namespace[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_eventhub.Namespace", version: "0.0.3-pre.7" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"namespace.js","sourceRoot":"","sources":["../../../src/azure-eventhub/lib/namespace.ts"],"names":[],"mappings":";;;;;AAAA,uFAAmF;AAEnF,+BAA+B;AAE/B,yCAAyD;AACzD,8CAA8D;AAsE9D,MAAa,SAAU,SAAQ,4BAAsB;IAMnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,YACE,KAAgB,EAChB,IAAY,EACZ,gBAAgC;QAEhC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAEnB,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAC;QACzC,IAAI,CAAC,aAAa,GAAG,gBAAgB,CAAC,aAAa,CAAC;QACpD,IAAI,CAAC,aAAa,GAAG,gBAAgB,CAAC,IAAI,CAAC;QAE3C,MAAM,QAAQ,GAAG;YACf,GAAG,EAAE,gBAAgB,CAAC,GAAG,IAAI,OAAO;YACpC,QAAQ,EAAE,gBAAgB,CAAC,QAAQ,IAAI,CAAC;YACxC,kBAAkB,EAAE,gBAAgB,CAAC,kBAAkB,IAAI,KAAK;YAChE,sBAAsB,EAAE,gBAAgB,CAAC,sBAAsB,IAAI,CAAC;YACpE,aAAa,EAAE,gBAAgB,CAAC,aAAa,IAAI,KAAK;YACtD,IAAI,EAAE,gBAAgB,CAAC,IAAI,IAAI,EAAE;YACjC,iBAAiB,EAAE,gBAAgB,CAAC,iBAAiB,IAAI,KAAK;YAC9D,0BAA0B,EACxB,gBAAgB,CAAC,0BAA0B,IAAI,IAAI;YACrD,0BAA0B,EACxB,gBAAgB,CAAC,0BAA0B,IAAI,IAAI;YACrD,QAAQ,EAAE;gBACR,IAAI,EAAE,gBAAgB,CAAC,YAAY,IAAI,gBAAgB;gBACvD,WAAW,EACT,gBAAgB,CAAC,YAAY,IAAI,cAAc;oBAC7C,CAAC,CAAC,gBAAgB,CAAC,WAAW;oBAC9B,CAAC,CAAC,SAAS;aAChB;SACF,CAAC;QAEF,MAAM,gBAAgB,GAAG,IAAI,sCAAiB,CAAC,IAAI,EAAE,aAAa,EAAE;YAClE,IAAI,EAAE,gBAAgB,CAAC,IAAI;YAC3B,iBAAiB,EAAE,IAAI,CAAC,aAAa,CAAC,IAAI;YAC1C,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,QAAQ;YACrC,GAAG,QAAQ;SACZ,CAAC,CAAC;QAEH,UAAU;QACV,IAAI,CAAC,EAAE,GAAG,gBAAgB,CAAC,EAAE,CAAC;QAC9B,MAAM,sCAAsC,GAAG,IAAI,KAAK,CAAC,eAAe,CACtE,IAAI,EACJ,IAAI,EACJ;YACE,KAAK,EAAE,gBAAgB,CAAC,EAAE;SAC3B,CACF,CAAC;QACF,sCAAsC,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;IACjE,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,mBAAmB,CAAC,KAAwB;QAC1C,OAAO,IAAI,mBAAQ,CAAC,IAAI,EAAE,YAAY,EAAE;YACtC,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,GAAG,KAAK;SACT,CAAC,CAAC;IACL,CAAC;;AAzIH,8BA0IC","sourcesContent":["import { EventhubNamespace } from \"@cdktf/provider-azurerm/lib/eventhub-namespace\";\nimport { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { Instance, BaseInstanceProps } from \"./instance\";\nimport { AzureResourceWithAlert } from \"../../core-azure/lib\";\n\nexport interface NamespaceProps {\n  /**\n   * The Azure Resource Group in which to create the EventHub Namespace.\n   */\n  readonly resourceGroup: ResourceGroup;\n  /**\n   * The name of the EventHub Namespace to create.\n   */\n  readonly name: string;\n  /**\n   * Defines which tier to use. Valid options are Basic, Standard, and Premium.\n   * @default \"Basic\"\n   */\n  readonly sku?: string;\n  /**\n   * Specifies the Capacity / Throughput Units for a Standard SKU namespace.\n   * @default 2\n   */\n  readonly capacity?: number;\n  /**\n   * Specifies if the EventHub Namespace should be Auto Inflate enabled.\n   * @default false\n   */\n  readonly autoInflateEnabled?: boolean;\n  /**\n   * Specifies the maximum number of throughput units when Auto Inflate is Enabled. Valid values range from 1 - 20.\n   * @default 2\n   */\n  readonly maximumThroughputUnits?: number;\n  /**\n   * Specifies if the EventHub Namespace should be Zone Redundant (created across Availability Zones).\n   * @default true\n   */\n  readonly zoneRedundant?: boolean;\n  /**\n   * The tags to assign to the Key Vault.\n   */\n  readonly tags?: { [key: string]: string };\n  /**\n   * The minimum supported TLS version for this EventHub Namespace. Valid values are: 1.0, 1.1 and 1.2.\n   * @default \"1.2\"\n   */\n  readonly minimumTlsVersion?: string;\n  /**\n   * Is public network access enabled for the EventHub Namespace?\n   * @default true\n   */\n  readonly publicNetworkAccessEnabled?: boolean;\n  /**\n   * Is SAS authentication enabled for the EventHub Namespace? North Central US Not supported.\n   * @default false\n   */\n  readonly localAuthenticationEnabled?: boolean;\n  /**\n   * Specifies the type of Managed Service Identity that should be configured on this Event Hub Namespace. Possible values are SystemAssigned or UserAssigned.\n   * @default \"SystemAssigned\"\n   */\n  readonly identityType?: string;\n  /**\n   * Specifies a list of User Assigned Managed Identity IDs to be assigned to this EventHub namespace.\n   */\n  readonly identityIds?: string[] | undefined;\n\n  /**\n   * TODO: network_rulesets\n   */\n}\n\nexport class Namespace extends AzureResourceWithAlert {\n  readonly ehNamespaceProps: NamespaceProps;\n  public resourceGroup: ResourceGroup;\n  public id: string;\n  readonly namespaceName: string;\n\n  /**\n   * Constructs a new Event Hub Namespace.\n   *\n   * This class creates an Azure Event Hub Namespace, which serves as a container for all messaging components.\n   * Namespaces provide a scoping container for Event Hub resources within a specific region, which can be further\n   * controlled and managed using the provided settings.\n   *\n   * @param scope - The scope in which to define this construct, typically representing the Cloud Development Kit (CDK) stack.\n   * @param name - The unique name for this instance of the Event Hub Namespace.\n   * @param ehNamespaceProps - The properties for configuring the Event Hub Namespace. These properties include:\n   *                - `resourceGroup`: Required. The Azure Resource Group in which the namespace will be created.\n   *                - `name`: Required. The name of the Event Hub Namespace to create.\n   *                - `sku`: Optional. The SKU tier of the namespace (Basic, Standard, Premium). Defaults to \"Basic\".\n   *                - `capacity`: Optional. Specifies the throughput units for a Standard SKU namespace. Defaults to 2.\n   *                - `autoInflateEnabled`: Optional. Enables or disables Auto Inflate. Defaults to false.\n   *                - `maximumThroughputUnits`: Optional. The maximum number of throughput units when Auto Inflate is enabled. Defaults to 2.\n   *                - `zoneRedundant`: Optional. Specifies if the namespace should be zone redundant. Defaults to true.\n   *                - `tags`: Optional. Tags for resource management and categorization.\n   *                - `minimumTlsVersion`: Optional. Specifies the minimum supported TLS version. Defaults to \"1.2\".\n   *                - `publicNetworkAccessEnabled`: Optional. Specifies if public network access is enabled. Defaults to true.\n   *                - `localAuthenticationEnabled`: Optional. Specifies if SAS authentication is enabled. Defaults to false.\n   *                - `identityType`: Optional. The type of Managed Service Identity. Defaults to \"SystemAssigned\".\n   *                - `identityIds`: Optional. A list of User Assigned Managed Identity IDs.\n   *\n   * Example usage:\n   * ```typescript\n   * const eventHubNamespace = new Namespace(this, 'myNamespace', {\n   *   resourceGroup: resourceGroup,\n   *   name: 'myEventHubNamespace',\n   *   sku: 'Standard',\n   *   capacity: 4,\n   *   autoInflateEnabled: true,\n   *   maximumThroughputUnits: 10,\n   *   zoneRedundant: false,\n   *   tags: {\n   *     department: 'IT'\n   *   },\n   *   minimumTlsVersion: '1.2',\n   *   publicNetworkAccessEnabled: false,\n   *   localAuthenticationEnabled: true,\n   *   identityType: 'SystemAssigned'\n   * });\n   * ```\n   */\n  constructor(\n    scope: Construct,\n    name: string,\n    ehNamespaceProps: NamespaceProps,\n  ) {\n    super(scope, name);\n\n    this.ehNamespaceProps = ehNamespaceProps;\n    this.resourceGroup = ehNamespaceProps.resourceGroup;\n    this.namespaceName = ehNamespaceProps.name;\n\n    const defaults = {\n      sku: ehNamespaceProps.sku || \"Basic\",\n      capacity: ehNamespaceProps.capacity || 2,\n      autoInflateEnabled: ehNamespaceProps.autoInflateEnabled || false,\n      maximumThroughputUnits: ehNamespaceProps.maximumThroughputUnits || 2,\n      zoneRedundant: ehNamespaceProps.zoneRedundant || false,\n      tags: ehNamespaceProps.tags || {},\n      minimumTlsVersion: ehNamespaceProps.minimumTlsVersion || \"1.2\",\n      publicNetworkAccessEnabled:\n        ehNamespaceProps.publicNetworkAccessEnabled || true,\n      localAuthenticationEnabled:\n        ehNamespaceProps.localAuthenticationEnabled || true,\n      identity: {\n        type: ehNamespaceProps.identityType || \"SystemAssigned\",\n        identityIds:\n          ehNamespaceProps.identityType == \"UserAssigned\"\n            ? ehNamespaceProps.identityIds\n            : undefined,\n      },\n    };\n\n    const eventhubNamespce = new EventhubNamespace(this, \"ehnamespace\", {\n      name: ehNamespaceProps.name,\n      resourceGroupName: this.resourceGroup.name,\n      location: this.resourceGroup.location,\n      ...defaults,\n    });\n\n    // Outputs\n    this.id = eventhubNamespce.id;\n    const cdktfTerraformOutputEventhubNamespceId = new cdktf.TerraformOutput(\n      this,\n      \"id\",\n      {\n        value: eventhubNamespce.id,\n      },\n    );\n    cdktfTerraformOutputEventhubNamespceId.overrideLogicalId(\"id\");\n  }\n\n  /**\n   * Creates and adds an Event Hub instance to the current namespace.\n   *\n   * This method sets up a new Event Hub instance within the namespace defined by this class. An Event Hub instance\n   * serves as a container that processes and stores events. This method facilitates the setup of multiple Event Hubs\n   * within a single namespace, each configured according to the specified properties.\n   *\n   * @param props - The properties for configuring the new Event Hub instance. These properties extend `BaseInstanceProps`, which include:\n   *                - `name`: Required. The name of the Event Hub instance.\n   *                - `partitionCount`: Optional. The number of partitions in the Event Hub. Default is 2.\n   *                - `messageRetention`: Optional. The number of days to retain messages in the Event Hub. Default is 1.\n   *                - `status`: Optional. The operational status of the Event Hub (Active, Disabled, SendDisabled). Default is \"Active\".\n   *                Other properties from `BaseInstanceProps` can also be passed and will be used in the creation of the Event Hub.\n   *\n   * @returns An instance of the Event Hub (`Instance` class), configured with the specified properties.\n   *\n   * Example usage:\n   * ```typescript\n   * const eventHub = namespace.addEventhubInstance({\n   *   name: 'myEventHub',\n   *   partitionCount: 4,\n   *   messageRetention: 7,\n   *   status: 'Active'\n   * });\n   * ```\n   *\n   * @remarks\n   * Ensure that the namespace has sufficient capacity and configuration to support the properties of the Event Hub being created,\n   * especially in terms of partition count and throughput units if applicable.\n   */\n  addEventhubInstance(props: BaseInstanceProps) {\n    return new Instance(this, \"ehinstance\", {\n      resourceGroup: this.resourceGroup,\n      namespaceName: this.namespaceName,\n      ...props,\n    });\n  }\n}\n"]}