@microsoft/terraform-cdk-constructs 0.0.3-pre.10

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

@@ -0,0 +1,164 @@
+import { ResourceGroup } from "@cdktf/provider-azurerm/lib/resource-group";
+import { Construct } from "constructs";
+import { AuthorizationRule, AuthorizationRuleProps } from "./authorization";
+import { ConsumerGroup } from "./consumer";
+import { KustoDataConnection, BaseKustoDataConnectionProps } from "./kusto-connection";
+export interface BaseInstanceProps {
+    /**
+     * Specifies the name of the EventHub resource.
+     */
+    readonly name: string;
+    /**
+     * Specifies the current number of shards on the Event Hub.
+     * When using a shared parent EventHub Namespace, maximum value is 32.
+     * @default 2
+     */
+    readonly partitionCount?: number;
+    /**
+     * Specifies the number of days to retain the events for this Event Hub.
+     * @default 1
+     */
+    readonly messageRetention?: number;
+    /**
+     * Specifies the status of the Event Hub resource. Possible values are Active, Disabled and SendDisabled.
+     * @default "Active"
+     */
+    readonly status?: string;
+}
+export interface InstanceProps extends BaseInstanceProps {
+    /**
+     * The name of the resource group in which the EventHub's parent Namespace exists.
+     */
+    readonly resourceGroup: ResourceGroup;
+    /**
+     * Specifies the name of the EventHub Namespace.
+     */
+    readonly namespaceName: string;
+}
+export declare class Instance extends Construct {
+    readonly ehInstanceProps: InstanceProps;
+    readonly id: string;
+    readonly partitionIds: string[];
+    /**
+     * 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: Construct, name: string, ehInstanceProps: InstanceProps);
+    /**
+     * 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: AuthorizationRuleProps): AuthorizationRule;
+    /**
+     * 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: string, userMetadata?: string): ConsumerGroup;
+    /**
+     * 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: BaseKustoDataConnectionProps): KustoDataConnection;
+}

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

@@ -0,0 +1,184 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Instance = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const eventhub_1 = require("@cdktf/provider-azurerm/lib/eventhub");
+const cdktf = require("cdktf");
+const constructs_1 = require("constructs");
+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;
+        const defaults = {
+            partitionCount: ehInstanceProps.partitionCount || 2,
+            messageRetention: ehInstanceProps.messageRetention || 1,
+            status: ehInstanceProps.status || "Active",
+        };
+        const eventhubInstance = new eventhub_1.Eventhub(this, `ehinstance-${ehInstanceProps.name}`, {
+            name: ehInstanceProps.name,
+            resourceGroupName: ehInstanceProps.resourceGroup.name,
+            namespaceName: ehInstanceProps.namespaceName,
+            ...defaults,
+        });
+        // Outputs
+        this.id = eventhubInstance.id;
+        this.partitionIds = eventhubInstance.partitionIds;
+        const cdktfTerraformOutputEventhubInstanceId = new cdktf.TerraformOutput(this, "id", {
+            value: eventhubInstance.id,
+        });
+        const cdktfTerraformOutputEventhubInstancePartitionIds = new cdktf.TerraformOutput(this, "partition_ids", {
+            value: eventhubInstance.partitionIds,
+        });
+        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,
+            namespaceName: this.ehInstanceProps.namespaceName,
+            eventhubName: this.ehInstanceProps.name,
+            ...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,
+            namespaceName: this.ehInstanceProps.namespaceName,
+            eventhubName: this.ehInstanceProps.name,
+            name: name,
+            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,
+            ...props,
+        });
+    }
+}
+exports.Instance = Instance;
+_a = JSII_RTTI_SYMBOL_1;
+Instance[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_eventhub.Instance", version: "0.0.3-pre.10" };
+//# 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

@@ -0,0 +1,109 @@
+import { ResourceGroup } from "@cdktf/provider-azurerm/lib/resource-group";
+import { Construct } from "constructs";
+export interface BaseKustoDataConnectionProps {
+    /**
+     * The name of the Kusto EventHub Data Connection to create.
+     */
+    readonly name: string;
+    /**
+     * The location where the Kusto EventHub Data Connection should be created.
+     */
+    readonly location: string;
+    /**
+     * Specifies the Resource Group where the Kusto Database should exist.
+     */
+    readonly kustoResourceGroup: ResourceGroup;
+    /**
+     * Specifies the name of the Kusto Cluster this data connection will be added to.
+     */
+    readonly kustoClusterName: string;
+    /**
+     * Specifies the name of the Kusto Database this data connection will be added to.
+     */
+    readonly kustoDatabaseName: string;
+    /**
+     * Specifies the EventHub consumer group this data connection will use for ingestion.
+     * @default "$Default"
+     */
+    readonly consumerGroup?: string;
+    /**
+     * Specifies the target table name used for the message ingestion. Table must exist before resource is created.
+     */
+    readonly tableName?: string | undefined;
+    /**
+     * The resource ID of a managed identity (system or user assigned) to be used to authenticate with event hub.
+     */
+    readonly identityId?: string | undefined;
+    /**
+     * Specifies the mapping rule used for the message ingestion. Mapping rule must exist before resource is created.
+     */
+    readonly mappingRuleName?: string | undefined;
+    /**
+     * Specifies the data format of the EventHub messages.
+     * Allowed values: APACHEAVRO, AVRO, CSV, JSON, MULTIJSON, ORC, PARQUET, PSV, RAW, SCSV, SINGLEJSON, SOHSV, TSVE, TSV, TXT, and W3CLOGFILE.
+     * @default "JSON"
+     */
+    readonly dataFormat?: string;
+    /**
+     * Indication for database routing information from the data connection, by default only database routing information is allowed.
+     * Allowed values: Single, Multi.
+     * @default "Single"
+     */
+    readonly databaseRoutingType?: string;
+    /**
+     * Specifies compression type for the connection. Allowed values: GZip and None.
+     * @default "None"
+     */
+    readonly compression?: string;
+}
+export interface KustoDataConnectionProps extends BaseKustoDataConnectionProps {
+    /**
+     * Specifies the resource id of the EventHub this data connection will use for ingestion.
+     */
+    readonly eventhubId: string;
+}
+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

@@ -0,0 +1,76 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KustoDataConnection = void 0;
+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;
+        const defaults = {
+            tableName: kustoDataConnectionProps.tableName || undefined,
+            identityId: kustoDataConnectionProps.identityId || undefined,
+            mappingRuleName: kustoDataConnectionProps.mappingRuleName || undefined,
+            consumerGroup: kustoDataConnectionProps.consumerGroup || "$Default",
+            dataFormat: kustoDataConnectionProps.dataFormat || "JSON",
+            databaseRoutingType: kustoDataConnectionProps.databaseRoutingType || "Single",
+            compression: kustoDataConnectionProps.compression || "None",
+        };
+        new kusto_eventhub_data_connection_1.KustoEventhubDataConnection(this, `kusto-data-connection-${this.eventhubKustoDataConnectionProps.name}`, {
+            name: this.eventhubKustoDataConnectionProps.name,
+            location: this.eventhubKustoDataConnectionProps.location,
+            resourceGroupName: this.eventhubKustoDataConnectionProps.kustoResourceGroup.name,
+            clusterName: this.eventhubKustoDataConnectionProps.kustoClusterName,
+            databaseName: this.eventhubKustoDataConnectionProps.kustoDatabaseName,
+            eventhubId: this.eventhubKustoDataConnectionProps.eventhubId,
+            ...defaults,
+        });
+    }
+}
+exports.KustoDataConnection = KustoDataConnection;
+_a = JSII_RTTI_SYMBOL_1;
+KustoDataConnection[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_eventhub.KustoDataConnection", version: "0.0.3-pre.10" };
+//# 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"]}