@microsoft/terraform-cdk-constructs 1.10.0 → 2.5.0

package/lib/azure-eventgridsystemtopic/test/event-grid-system-topic.spec.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktn_1 = require("cdktn");
+const cdktn = require("cdktn");
+const api_version_manager_1 = require("../../core-azure/lib/version-manager/api-version-manager");
+const version_interfaces_1 = require("../../core-azure/lib/version-manager/interfaces/version-interfaces");
+const event_grid_system_topic_1 = require("../lib/event-grid-system-topic");
+const event_grid_system_topic_schemas_1 = require("../lib/event-grid-system-topic-schemas");
+describe("EventGridSystemTopic - Unified Implementation", () => {
+    let app;
+    let stack;
+    let manager;
+    const source = "/subscriptions/test-sub/resourceGroups/test-rg/providers/Microsoft.Storage/storageAccounts/teststorage";
+    const topicType = "Microsoft.Storage.StorageAccounts";
+    const resourceGroupId = "/subscriptions/test-sub/resourceGroups/test-rg";
+    beforeEach(() => {
+        app = cdktn_1.Testing.app();
+        stack = new cdktn.TerraformStack(app, "TestStack");
+        manager = api_version_manager_1.ApiVersionManager.instance();
+        try {
+            manager.registerResourceType(event_grid_system_topic_schemas_1.SYSTEM_TOPIC_TYPE, event_grid_system_topic_schemas_1.ALL_SYSTEM_TOPIC_VERSIONS);
+        }
+        catch (error) {
+            // Ignore if already registered
+        }
+    });
+    describe("Constructor and Basic Properties", () => {
+        it("should create system topic with automatic latest version resolution", () => {
+            const props = {
+                name: "test-system-topic",
+                location: "eastus",
+                source,
+                topicType,
+                resourceGroupId,
+            };
+            const systemTopic = new event_grid_system_topic_1.EventGridSystemTopic(stack, "TestSystemTopic", props);
+            expect(systemTopic).toBeInstanceOf(event_grid_system_topic_1.EventGridSystemTopic);
+            expect(systemTopic.resolvedApiVersion).toBe("2025-02-15");
+            expect(systemTopic.props).toBe(props);
+            expect(systemTopic.name).toBe("test-system-topic");
+            expect(systemTopic.location).toBe("eastus");
+        });
+        it("should create system topic with explicit version pinning", () => {
+            const props = {
+                name: "test-system-topic-pinned",
+                location: "westus",
+                source,
+                topicType,
+                resourceGroupId,
+                apiVersion: "2025-02-15",
+            };
+            const systemTopic = new event_grid_system_topic_1.EventGridSystemTopic(stack, "PinnedSystemTopic", props);
+            expect(systemTopic.resolvedApiVersion).toBe("2025-02-15");
+        });
+        it("should create system topic with all optional properties", () => {
+            const props = {
+                name: "test-system-topic-full",
+                location: "centralus",
+                source,
+                topicType,
+                resourceGroupId,
+                identity: {
+                    type: "SystemAssigned",
+                },
+                tags: {
+                    environment: "production",
+                    project: "terraform-cdk-constructs",
+                },
+            };
+            const systemTopic = new event_grid_system_topic_1.EventGridSystemTopic(stack, "FullSystemTopic", props);
+            expect(systemTopic.props.identity).toEqual(props.identity);
+            expect(systemTopic.props.tags).toEqual(props.tags);
+        });
+        it("should require location to be provided", () => {
+            const props = {
+                name: "test-system-topic",
+                source,
+                topicType,
+                resourceGroupId,
+            };
+            expect(() => {
+                new event_grid_system_topic_1.EventGridSystemTopic(stack, "MissingLocation", props);
+            }).toThrow("Location is required for Microsoft.EventGrid/systemTopics");
+        });
+    });
+    describe("Framework Integration", () => {
+        it("should resolve latest API version automatically", () => {
+            const systemTopic = new event_grid_system_topic_1.EventGridSystemTopic(stack, "TestSystemTopic", {
+                name: "test-system-topic",
+                location: "eastus",
+                source,
+                topicType,
+                resourceGroupId,
+            });
+            expect(systemTopic.resolvedApiVersion).toBe("2025-02-15");
+            expect(systemTopic.latestVersion()).toBe("2025-02-15");
+        });
+        it("should support all registered API versions", () => {
+            const systemTopic = new event_grid_system_topic_1.EventGridSystemTopic(stack, "TestSystemTopic", {
+                name: "test-system-topic",
+                location: "eastus",
+                source,
+                topicType,
+                resourceGroupId,
+            });
+            expect(systemTopic.supportedVersions()).toEqual(["2025-02-15"]);
+        });
+        it("should validate version support", () => {
+            expect(() => {
+                new event_grid_system_topic_1.EventGridSystemTopic(stack, "ValidVersion", {
+                    name: "test-system-topic",
+                    location: "eastus",
+                    source,
+                    topicType,
+                    resourceGroupId,
+                    apiVersion: "2025-02-15",
+                });
+            }).not.toThrow();
+            expect(() => {
+                new event_grid_system_topic_1.EventGridSystemTopic(stack, "InvalidVersion", {
+                    name: "test-system-topic",
+                    location: "eastus",
+                    source,
+                    topicType,
+                    resourceGroupId,
+                    apiVersion: "2026-01-01",
+                });
+            }).toThrow("Unsupported API version '2026-01-01'");
+        });
+        it("should load correct schema for resolved version", () => {
+            const systemTopic = new event_grid_system_topic_1.EventGridSystemTopic(stack, "TestSystemTopic", {
+                name: "test-system-topic",
+                location: "eastus",
+                source,
+                topicType,
+                resourceGroupId,
+            });
+            expect(systemTopic.schema).toBeDefined();
+            expect(systemTopic.schema.resourceType).toBe(event_grid_system_topic_schemas_1.SYSTEM_TOPIC_TYPE);
+            expect(systemTopic.schema.version).toBe("2025-02-15");
+            expect(systemTopic.schema.properties).toBeDefined();
+        });
+        it("should load version configuration correctly", () => {
+            const systemTopic = new event_grid_system_topic_1.EventGridSystemTopic(stack, "TestSystemTopic", {
+                name: "test-system-topic",
+                location: "eastus",
+                source,
+                topicType,
+                resourceGroupId,
+            });
+            expect(systemTopic.versionConfig).toBeDefined();
+            expect(systemTopic.versionConfig.version).toBe("2025-02-15");
+            expect(systemTopic.versionConfig.supportLevel).toBe(version_interfaces_1.VersionSupportLevel.ACTIVE);
+        });
+    });
+    describe("Property Validation", () => {
+        it("should validate properties when validation is enabled", () => {
+            const props = {
+                name: "test-system-topic",
+                location: "eastus",
+                source,
+                topicType,
+                resourceGroupId,
+                enableValidation: true,
+            };
+            expect(() => {
+                new event_grid_system_topic_1.EventGridSystemTopic(stack, "ValidatedSystemTopic", props);
+            }).not.toThrow();
+        });
+        it("should have validation results for valid properties", () => {
+            const systemTopic = new event_grid_system_topic_1.EventGridSystemTopic(stack, "ValidatedSystemTopic", {
+                name: "valid-system-topic",
+                location: "eastus",
+                source,
+                topicType,
+                resourceGroupId,
+                enableValidation: true,
+            });
+            expect(systemTopic.validationResult).toBeDefined();
+            expect(systemTopic.validationResult.valid).toBe(true);
+            expect(systemTopic.validationResult.errors).toHaveLength(0);
+        });
+        it("should create Terraform outputs", () => {
+            const systemTopic = new event_grid_system_topic_1.EventGridSystemTopic(stack, "OutputsSystemTopic", {
+                name: "outputs-system-topic",
+                location: "eastus",
+                source,
+                topicType,
+                resourceGroupId,
+            });
+            expect(systemTopic.idOutput).toBeInstanceOf(cdktn.TerraformOutput);
+            expect(systemTopic.locationOutput).toBeInstanceOf(cdktn.TerraformOutput);
+            expect(systemTopic.nameOutput).toBeInstanceOf(cdktn.TerraformOutput);
+            expect(systemTopic.tagsOutput).toBeInstanceOf(cdktn.TerraformOutput);
+        });
+    });
+    describe("Version Compatibility", () => {
+        it("should work with all supported API versions", () => {
+            const versions = ["2025-02-15"];
+            versions.forEach((version) => {
+                const systemTopic = new event_grid_system_topic_1.EventGridSystemTopic(stack, `SystemTopic-${version.replace(/-/g, "")}`, {
+                    name: `test-system-topic-${version}`,
+                    location: "eastus",
+                    source,
+                    topicType,
+                    resourceGroupId,
+                    apiVersion: version,
+                });
+                expect(systemTopic.resolvedApiVersion).toBe(version);
+                expect(systemTopic.schema.version).toBe(version);
+            });
+        });
+        it("should expose required schema properties", () => {
+            const systemTopic = new event_grid_system_topic_1.EventGridSystemTopic(stack, "SchemaSystemTopic", {
+                name: "schema-system-topic",
+                location: "eastus",
+                source,
+                topicType,
+                resourceGroupId,
+            });
+            expect(systemTopic.schema.properties.location).toBeDefined();
+            expect(systemTopic.schema.properties.name).toBeDefined();
+            expect(systemTopic.schema.properties.source).toBeDefined();
+            expect(systemTopic.schema.properties.topicType).toBeDefined();
+            expect(systemTopic.schema.properties.identity).toBeDefined();
+        });
+    });
+    describe("Public Methods and Properties", () => {
+        it("should have resourceId property matching id", () => {
+            const systemTopic = new event_grid_system_topic_1.EventGridSystemTopic(stack, "ResourceIdSystemTopic", {
+                name: "resource-id-system-topic",
+                location: "eastus",
+                source,
+                topicType,
+                resourceGroupId,
+            });
+            expect(systemTopic.resourceId).toBe(systemTopic.id);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event-grid-system-topic.spec.js","sourceRoot":"","sources":["../../../src/azure-eventgridsystemtopic/test/event-grid-system-topic.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { Testing } from \"cdktn\";\nimport * as cdktn from \"cdktn\";\nimport { ApiVersionManager } from \"../../core-azure/lib/version-manager/api-version-manager\";\nimport { VersionSupportLevel } from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\nimport {\n  EventGridSystemTopic,\n  EventGridSystemTopicProps,\n} from \"../lib/event-grid-system-topic\";\nimport {\n  ALL_SYSTEM_TOPIC_VERSIONS,\n  SYSTEM_TOPIC_TYPE,\n} from \"../lib/event-grid-system-topic-schemas\";\n\ndescribe(\"EventGridSystemTopic - Unified Implementation\", () => {\n  let app: cdktn.App;\n  let stack: cdktn.TerraformStack;\n  let manager: ApiVersionManager;\n\n  const source =\n    \"/subscriptions/test-sub/resourceGroups/test-rg/providers/Microsoft.Storage/storageAccounts/teststorage\";\n  const topicType = \"Microsoft.Storage.StorageAccounts\";\n  const resourceGroupId = \"/subscriptions/test-sub/resourceGroups/test-rg\";\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktn.TerraformStack(app, \"TestStack\");\n    manager = ApiVersionManager.instance();\n\n    try {\n      manager.registerResourceType(\n        SYSTEM_TOPIC_TYPE,\n        ALL_SYSTEM_TOPIC_VERSIONS,\n      );\n    } catch (error) {\n      // Ignore if already registered\n    }\n  });\n\n  describe(\"Constructor and Basic Properties\", () => {\n    it(\"should create system topic with automatic latest version resolution\", () => {\n      const props: EventGridSystemTopicProps = {\n        name: \"test-system-topic\",\n        location: \"eastus\",\n        source,\n        topicType,\n        resourceGroupId,\n      };\n\n      const systemTopic = new EventGridSystemTopic(\n        stack,\n        \"TestSystemTopic\",\n        props,\n      );\n\n      expect(systemTopic).toBeInstanceOf(EventGridSystemTopic);\n      expect(systemTopic.resolvedApiVersion).toBe(\"2025-02-15\");\n      expect(systemTopic.props).toBe(props);\n      expect(systemTopic.name).toBe(\"test-system-topic\");\n      expect(systemTopic.location).toBe(\"eastus\");\n    });\n\n    it(\"should create system topic with explicit version pinning\", () => {\n      const props: EventGridSystemTopicProps = {\n        name: \"test-system-topic-pinned\",\n        location: \"westus\",\n        source,\n        topicType,\n        resourceGroupId,\n        apiVersion: \"2025-02-15\",\n      };\n\n      const systemTopic = new EventGridSystemTopic(\n        stack,\n        \"PinnedSystemTopic\",\n        props,\n      );\n\n      expect(systemTopic.resolvedApiVersion).toBe(\"2025-02-15\");\n    });\n\n    it(\"should create system topic with all optional properties\", () => {\n      const props: EventGridSystemTopicProps = {\n        name: \"test-system-topic-full\",\n        location: \"centralus\",\n        source,\n        topicType,\n        resourceGroupId,\n        identity: {\n          type: \"SystemAssigned\",\n        },\n        tags: {\n          environment: \"production\",\n          project: \"terraform-cdk-constructs\",\n        },\n      };\n\n      const systemTopic = new EventGridSystemTopic(\n        stack,\n        \"FullSystemTopic\",\n        props,\n      );\n\n      expect(systemTopic.props.identity).toEqual(props.identity);\n      expect(systemTopic.props.tags).toEqual(props.tags);\n    });\n\n    it(\"should require location to be provided\", () => {\n      const props: EventGridSystemTopicProps = {\n        name: \"test-system-topic\",\n        source,\n        topicType,\n        resourceGroupId,\n      };\n\n      expect(() => {\n        new EventGridSystemTopic(stack, \"MissingLocation\", props);\n      }).toThrow(\"Location is required for Microsoft.EventGrid/systemTopics\");\n    });\n  });\n\n  describe(\"Framework Integration\", () => {\n    it(\"should resolve latest API version automatically\", () => {\n      const systemTopic = new EventGridSystemTopic(stack, \"TestSystemTopic\", {\n        name: \"test-system-topic\",\n        location: \"eastus\",\n        source,\n        topicType,\n        resourceGroupId,\n      });\n\n      expect(systemTopic.resolvedApiVersion).toBe(\"2025-02-15\");\n      expect(systemTopic.latestVersion()).toBe(\"2025-02-15\");\n    });\n\n    it(\"should support all registered API versions\", () => {\n      const systemTopic = new EventGridSystemTopic(stack, \"TestSystemTopic\", {\n        name: \"test-system-topic\",\n        location: \"eastus\",\n        source,\n        topicType,\n        resourceGroupId,\n      });\n\n      expect(systemTopic.supportedVersions()).toEqual([\"2025-02-15\"]);\n    });\n\n    it(\"should validate version support\", () => {\n      expect(() => {\n        new EventGridSystemTopic(stack, \"ValidVersion\", {\n          name: \"test-system-topic\",\n          location: \"eastus\",\n          source,\n          topicType,\n          resourceGroupId,\n          apiVersion: \"2025-02-15\",\n        });\n      }).not.toThrow();\n\n      expect(() => {\n        new EventGridSystemTopic(stack, \"InvalidVersion\", {\n          name: \"test-system-topic\",\n          location: \"eastus\",\n          source,\n          topicType,\n          resourceGroupId,\n          apiVersion: \"2026-01-01\",\n        });\n      }).toThrow(\"Unsupported API version '2026-01-01'\");\n    });\n\n    it(\"should load correct schema for resolved version\", () => {\n      const systemTopic = new EventGridSystemTopic(stack, \"TestSystemTopic\", {\n        name: \"test-system-topic\",\n        location: \"eastus\",\n        source,\n        topicType,\n        resourceGroupId,\n      });\n\n      expect(systemTopic.schema).toBeDefined();\n      expect(systemTopic.schema.resourceType).toBe(SYSTEM_TOPIC_TYPE);\n      expect(systemTopic.schema.version).toBe(\"2025-02-15\");\n      expect(systemTopic.schema.properties).toBeDefined();\n    });\n\n    it(\"should load version configuration correctly\", () => {\n      const systemTopic = new EventGridSystemTopic(stack, \"TestSystemTopic\", {\n        name: \"test-system-topic\",\n        location: \"eastus\",\n        source,\n        topicType,\n        resourceGroupId,\n      });\n\n      expect(systemTopic.versionConfig).toBeDefined();\n      expect(systemTopic.versionConfig.version).toBe(\"2025-02-15\");\n      expect(systemTopic.versionConfig.supportLevel).toBe(\n        VersionSupportLevel.ACTIVE,\n      );\n    });\n  });\n\n  describe(\"Property Validation\", () => {\n    it(\"should validate properties when validation is enabled\", () => {\n      const props: EventGridSystemTopicProps = {\n        name: \"test-system-topic\",\n        location: \"eastus\",\n        source,\n        topicType,\n        resourceGroupId,\n        enableValidation: true,\n      };\n\n      expect(() => {\n        new EventGridSystemTopic(stack, \"ValidatedSystemTopic\", props);\n      }).not.toThrow();\n    });\n\n    it(\"should have validation results for valid properties\", () => {\n      const systemTopic = new EventGridSystemTopic(\n        stack,\n        \"ValidatedSystemTopic\",\n        {\n          name: \"valid-system-topic\",\n          location: \"eastus\",\n          source,\n          topicType,\n          resourceGroupId,\n          enableValidation: true,\n        },\n      );\n\n      expect(systemTopic.validationResult).toBeDefined();\n      expect(systemTopic.validationResult!.valid).toBe(true);\n      expect(systemTopic.validationResult!.errors).toHaveLength(0);\n    });\n\n    it(\"should create Terraform outputs\", () => {\n      const systemTopic = new EventGridSystemTopic(\n        stack,\n        \"OutputsSystemTopic\",\n        {\n          name: \"outputs-system-topic\",\n          location: \"eastus\",\n          source,\n          topicType,\n          resourceGroupId,\n        },\n      );\n\n      expect(systemTopic.idOutput).toBeInstanceOf(cdktn.TerraformOutput);\n      expect(systemTopic.locationOutput).toBeInstanceOf(cdktn.TerraformOutput);\n      expect(systemTopic.nameOutput).toBeInstanceOf(cdktn.TerraformOutput);\n      expect(systemTopic.tagsOutput).toBeInstanceOf(cdktn.TerraformOutput);\n    });\n  });\n\n  describe(\"Version Compatibility\", () => {\n    it(\"should work with all supported API versions\", () => {\n      const versions = [\"2025-02-15\"];\n\n      versions.forEach((version) => {\n        const systemTopic = new EventGridSystemTopic(\n          stack,\n          `SystemTopic-${version.replace(/-/g, \"\")}`,\n          {\n            name: `test-system-topic-${version}`,\n            location: \"eastus\",\n            source,\n            topicType,\n            resourceGroupId,\n            apiVersion: version,\n          },\n        );\n\n        expect(systemTopic.resolvedApiVersion).toBe(version);\n        expect(systemTopic.schema.version).toBe(version);\n      });\n    });\n\n    it(\"should expose required schema properties\", () => {\n      const systemTopic = new EventGridSystemTopic(stack, \"SchemaSystemTopic\", {\n        name: \"schema-system-topic\",\n        location: \"eastus\",\n        source,\n        topicType,\n        resourceGroupId,\n      });\n\n      expect(systemTopic.schema.properties.location).toBeDefined();\n      expect(systemTopic.schema.properties.name).toBeDefined();\n      expect(systemTopic.schema.properties.source).toBeDefined();\n      expect(systemTopic.schema.properties.topicType).toBeDefined();\n      expect(systemTopic.schema.properties.identity).toBeDefined();\n    });\n  });\n\n  describe(\"Public Methods and Properties\", () => {\n    it(\"should have resourceId property matching id\", () => {\n      const systemTopic = new EventGridSystemTopic(\n        stack,\n        \"ResourceIdSystemTopic\",\n        {\n          name: \"resource-id-system-topic\",\n          location: \"eastus\",\n          source,\n          topicType,\n          resourceGroupId,\n        },\n      );\n\n      expect(systemTopic.resourceId).toBe(systemTopic.id);\n    });\n  });\n});\n"]}

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

@@ -0,0 +1,7 @@
+/**
+ * Azure Event Hubs module
+ *
+ * This module provides constructs for creating and managing Azure Event Hubs
+ * Namespaces and Event Hubs (entities).
+ */
+export * from "./lib";

package/lib/azure-eventhub/index.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Azure Event Hubs module
+ *
+ * This module provides constructs for creating and managing Azure Event Hubs
+ * Namespaces and Event Hubs (entities).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXp1cmUtZXZlbnRodWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7OztHQUtHOzs7Ozs7Ozs7Ozs7Ozs7O0FBRUgsd0NBQXNCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBBenVyZSBFdmVudCBIdWJzIG1vZHVsZVxuICpcbiAqIFRoaXMgbW9kdWxlIHByb3ZpZGVzIGNvbnN0cnVjdHMgZm9yIGNyZWF0aW5nIGFuZCBtYW5hZ2luZyBBenVyZSBFdmVudCBIdWJzXG4gKiBOYW1lc3BhY2VzIGFuZCBFdmVudCBIdWJzIChlbnRpdGllcykuXG4gKi9cblxuZXhwb3J0ICogZnJvbSBcIi4vbGliXCI7XG4iXX0=

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

@@ -0,0 +1,204 @@
+/**
+ * Azure Event Hubs Namespace implementation using the AzapiResource framework
+ *
+ * This class provides a version-aware implementation for Azure Event Hubs
+ * Namespaces (Microsoft.EventHub/namespaces) that automatically handles version
+ * management, schema validation, and property transformation across all
+ * supported API versions.
+ *
+ * Supported API Versions:
+ * - 2024-01-01 (Active, Latest)
+ * - 2021-11-01 (Active, Backward Compatibility)
+ *
+ * Features:
+ * - Automatic latest version resolution when no version is specified
+ * - Explicit version pinning for stability requirements
+ * - Schema-driven validation and transformation
+ * - Full JSII compliance for multi-language support
+ * - SKU management (Basic, Standard, Premium)
+ * - Auto-inflate throughput configuration
+ * - Public network access and minimum TLS controls
+ * - Managed identity support
+ */
+import * as cdktn from "cdktn";
+import { Construct } from "constructs";
+import { AzapiResource, AzapiResourceProps } from "../../core-azure/lib/azapi/azapi-resource";
+import { ApiSchema } from "../../core-azure/lib/version-manager/interfaces/version-interfaces";
+/**
+ * SKU configuration for an Event Hubs Namespace
+ */
+export interface EventhubNamespaceSku {
+    /**
+     * The SKU name for the namespace
+     *
+     * Available options:
+     * - "Basic" - Basic tier (1 consumer group, 100 brokered connections)
+     * - "Standard" - Standard tier (20 consumer groups, auto-inflate support)
+     * - "Premium" - Premium tier (dedicated capacity, higher limits)
+     *
+     * @defaultValue "Standard"
+     */
+    readonly name: "Basic" | "Standard" | "Premium";
+    /**
+     * The billing tier of the namespace
+     *
+     * If not provided, defaults to the same value as `name`.
+     */
+    readonly tier?: "Basic" | "Standard" | "Premium";
+    /**
+     * The number of throughput units (Standard) or capacity units (Premium)
+     *
+     * Only applicable to Standard and Premium tiers.
+     */
+    readonly capacity?: number;
+}
+/**
+ * Managed identity configuration for the namespace
+ */
+export interface EventhubNamespaceIdentity {
+    /**
+     * Type of managed identity
+     */
+    readonly type: "SystemAssigned" | "UserAssigned" | "SystemAssigned,UserAssigned" | "None";
+    /**
+     * User-assigned identity resource IDs
+     * Required when type includes UserAssigned
+     */
+    readonly userAssignedIdentities?: {
+        [key: string]: any;
+    };
+}
+/**
+ * Properties for the Azure Event Hubs Namespace
+ *
+ * Extends AzapiResourceProps with Event Hubs Namespace specific properties
+ */
+export interface EventhubNamespaceProps extends AzapiResourceProps {
+    /**
+     * Resource Group ID where the namespace will be created
+     */
+    readonly resourceGroupId: string;
+    /**
+     * SKU configuration for the namespace
+     *
+     * @defaultValue { name: "Standard" }
+     */
+    readonly sku?: EventhubNamespaceSku;
+    /**
+     * Whether to enable zone redundancy for the namespace
+     */
+    readonly zoneRedundant?: boolean;
+    /**
+     * Whether auto-inflate is enabled for the namespace (Standard tier)
+     *
+     * When enabled, throughput units automatically scale up to
+     * `maximumThroughputUnits` based on load.
+     */
+    readonly isAutoInflateEnabled?: boolean;
+    /**
+     * The upper limit of throughput units when auto-inflate is enabled
+     *
+     * Valid values are between 0 and 40.
+     */
+    readonly maximumThroughputUnits?: number;
+    /**
+     * The minimum TLS version supported by the namespace
+     *
+     * @defaultValue "1.2"
+     */
+    readonly minimumTlsVersion?: "1.0" | "1.1" | "1.2";
+    /**
+     * Whether public network access is allowed for the namespace
+     *
+     * @defaultValue "Enabled"
+     */
+    readonly publicNetworkAccess?: "Enabled" | "Disabled";
+    /**
+     * Whether to disable SAS (local) authentication
+     *
+     * When enabled, only Azure AD authentication is allowed.
+     */
+    readonly disableLocalAuth?: boolean;
+    /**
+     * Managed identity configuration for the namespace
+     */
+    readonly identity?: EventhubNamespaceIdentity;
+}
+/**
+ * Azure Event Hubs Namespace implementation
+ *
+ * This class provides a single, version-aware implementation that automatically
+ * handles version resolution, schema validation, and property transformation
+ * while maintaining full JSII compliance.
+ *
+ * An Event Hubs Namespace is a management container for Event Hubs. It provides
+ * DNS-integrated network endpoints and a range of access control and network
+ * integration management features.
+ *
+ * @example
+ * // Basic Event Hubs Namespace with default settings:
+ * const namespace = new EventhubNamespace(this, "my-namespace", {
+ *   name: "my-eventhub-ns",
+ *   location: "eastus",
+ *   resourceGroupId: resourceGroup.id,
+ * });
+ *
+ * @example
+ * // Standard namespace with auto-inflate:
+ * const namespace = new EventhubNamespace(this, "production-namespace", {
+ *   name: "prod-eventhub-ns",
+ *   location: "eastus",
+ *   resourceGroupId: resourceGroup.id,
+ *   sku: { name: "Standard", capacity: 2 },
+ *   isAutoInflateEnabled: true,
+ *   maximumThroughputUnits: 10,
+ * });
+ *
+ * @stability stable
+ */
+export declare class EventhubNamespace extends AzapiResource {
+    /**
+     * The input properties for this Event Hubs Namespace instance
+     */
+    readonly props: EventhubNamespaceProps;
+    readonly idOutput: cdktn.TerraformOutput;
+    readonly nameOutput: cdktn.TerraformOutput;
+    /**
+     * Creates a new Azure Event Hubs Namespace using the AzapiResource framework
+     *
+     * @param scope - The scope in which to define this construct
+     * @param id - The unique identifier for this instance
+     * @param props - Configuration properties for the Event Hubs Namespace
+     */
+    constructor(scope: Construct, id: string, props: EventhubNamespaceProps);
+    /**
+     * Gets the default API version to use when no explicit version is specified
+     * Returns the latest stable version as the default
+     */
+    protected defaultVersion(): string;
+    /**
+     * Gets the Azure resource type for Event Hubs Namespaces
+     */
+    protected resourceType(): string;
+    /**
+     * Gets the API schema for the resolved version
+     */
+    protected apiSchema(): ApiSchema;
+    /**
+     * Indicates that this resource type requires a location
+     */
+    protected requiresLocation(): boolean;
+    /**
+     * Creates the resource body for the Azure API call
+     * Transforms the input properties into the JSON format expected by Azure REST API
+     */
+    protected createResourceBody(props: any): any;
+    /**
+     * Resolves the parent resource ID for the Event Hubs Namespace
+     * Event Hubs Namespaces are top-level resources within a resource group
+     *
+     * @param props - The resource properties
+     * @returns The parent resource ID (the resource group)
+     */
+    protected resolveParentId(props: any): string;
+}