@microsoft/terraform-cdk-constructs 1.8.0 → 1.9.0

package/lib/azure-networkwatcher/lib/network-watcher.js

@@ -0,0 +1,187 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkWatcher = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Unified Azure Network Watcher implementation using AzapiResource framework
+ *
+ * This class provides a version-aware implementation for Azure Network Watcher
+ * that automatically handles version management, schema validation, and property
+ * transformation across all supported API versions.
+ *
+ * IMPORTANT: Azure only allows one Network Watcher per subscription per region.
+ * If you attempt to create a Network Watcher in a region where one already exists,
+ * the deployment will fail.
+ *
+ * Supported API Versions:
+ * - 2024-01-01 (Active, Latest)
+ * - 2023-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
+ *
+ * Network Watcher is primarily used as a dependency for other Network Watcher features:
+ * - Flow Logs
+ * - Connection Monitor
+ * - Packet Capture
+ * - Network Diagnostic Tools
+ */
+const cdktf = require("cdktf");
+const network_watcher_schemas_1 = require("./network-watcher-schemas");
+const azapi_resource_1 = require("../../core-azure/lib/azapi/azapi-resource");
+/**
+ * Unified Azure Network Watcher implementation
+ *
+ * This class provides a single, version-aware implementation that automatically handles version
+ * resolution, schema validation, and property transformation while maintaining full JSII compliance.
+ *
+ * Network Watcher is a regional service that provides tools to monitor, diagnose, and gain
+ * insights into your network health and performance in Azure. It serves as the anchor for
+ * Network Watcher features like Flow Logs, Connection Monitor, and Packet Capture.
+ *
+ * IMPORTANT CONSTRAINT: Azure only allows one Network Watcher per subscription per region.
+ * If you need Network Watcher functionality in multiple regions, you must create a separate
+ * Network Watcher for each region.
+ *
+ * @example
+ * // Basic Network Watcher:
+ * const networkWatcher = new NetworkWatcher(this, "network-watcher", {
+ *   name: "nw-eastus",
+ *   location: "eastus",
+ *   resourceGroupId: resourceGroup.id,
+ * });
+ *
+ * @example
+ * // Network Watcher with specific API version:
+ * const networkWatcher = new NetworkWatcher(this, "network-watcher", {
+ *   name: "nw-westus2",
+ *   location: "westus2",
+ *   resourceGroupId: resourceGroup.id,
+ *   apiVersion: "2024-01-01",
+ *   tags: {
+ *     environment: "production",
+ *   },
+ * });
+ *
+ * @example
+ * // Network Watcher for use with Flow Logs:
+ * const networkWatcher = new NetworkWatcher(this, "network-watcher", {
+ *   name: "NetworkWatcher_eastus",
+ *   location: "eastus",
+ *   resourceGroupId: networkWatcherRg.id,
+ * });
+ *
+ * // Then use it with NSG Flow Logs
+ * const flowLog = new NsgFlowLog(this, "flow-log", {
+ *   networkWatcherId: networkWatcher.id,
+ *   // ... other properties
+ * });
+ *
+ * @stability stable
+ */
+class NetworkWatcher extends azapi_resource_1.AzapiResource {
+    /**
+     * Creates a new Azure Network Watcher using the AzapiResource framework
+     *
+     * The constructor automatically handles version resolution, schema registration,
+     * validation, and resource creation.
+     *
+     * IMPORTANT: Azure only allows one Network Watcher per subscription per region.
+     * Attempting to create a Network Watcher in a region where one already exists
+     * will result in a deployment error.
+     *
+     * @param scope - The scope in which to define this construct
+     * @param id - The unique identifier for this instance
+     * @param props - Configuration properties for the Network Watcher
+     */
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.props = props;
+        // Create Terraform outputs for easy access and referencing from other resources
+        this.idOutput = new cdktf.TerraformOutput(this, "id", {
+            value: this.id,
+            description: "The ID of the Network Watcher",
+        });
+        this.nameOutput = new cdktf.TerraformOutput(this, "name", {
+            value: `\${${this.terraformResource.fqn}.name}`,
+            description: "The name of the Network Watcher",
+        });
+        this.locationOutput = new cdktf.TerraformOutput(this, "location", {
+            value: `\${${this.terraformResource.fqn}.output.location}`,
+            description: "The location of the Network Watcher",
+        });
+        this.provisioningStateOutput = new cdktf.TerraformOutput(this, "provisioning_state", {
+            value: `\${${this.terraformResource.fqn}.output.properties.provisioningState}`,
+            description: "The provisioning state of the Network Watcher",
+        });
+        // Override logical IDs
+        this.idOutput.overrideLogicalId("id");
+        this.nameOutput.overrideLogicalId("name");
+        this.locationOutput.overrideLogicalId("location");
+        this.provisioningStateOutput.overrideLogicalId("provisioning_state");
+    }
+    // =============================================================================
+    // REQUIRED ABSTRACT METHODS FROM AzapiResource
+    // =============================================================================
+    /**
+     * Gets the default API version to use when no explicit version is specified
+     * Returns the latest stable version as the default
+     */
+    defaultVersion() {
+        return "2024-01-01";
+    }
+    /**
+     * Gets the Azure resource type for Network Watcher
+     */
+    resourceType() {
+        return network_watcher_schemas_1.NETWORK_WATCHER_TYPE;
+    }
+    /**
+     * Gets the API schema for the resolved version
+     * Uses the framework's schema resolution to get the appropriate schema
+     */
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    /**
+     * Indicates that this resource type requires a location
+     */
+    requiresLocation() {
+        return true;
+    }
+    /**
+     * Creates the resource body for the Azure API call
+     *
+     * Network Watcher is a simple resource with an empty properties block.
+     * All configuration is handled at the resource level (name, location, tags).
+     */
+    createResourceBody(_props) {
+        // Network Watcher has an empty properties block
+        // The resource is configured primarily through name, location, and tags
+        const body = {
+            properties: {},
+        };
+        return body;
+    }
+    /**
+     * Resolves the parent resource ID for Network Watcher
+     * Network Watcher is a top-level resource within a resource group
+     *
+     * @param props - The resource properties
+     * @returns The parent resource ID (the resource group)
+     */
+    resolveParentId(props) {
+        return props.resourceGroupId;
+    }
+}
+exports.NetworkWatcher = NetworkWatcher;
+_a = JSII_RTTI_SYMBOL_1;
+NetworkWatcher[_a] = { fqn: "@microsoft/terraform-cdk-constructs.NetworkWatcher", version: "1.9.0" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(network_watcher_schemas_1.NETWORK_WATCHER_TYPE, network_watcher_schemas_1.ALL_NETWORK_WATCHER_VERSIONS);
+})();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network-watcher.js","sourceRoot":"","sources":["../../../src/azure-networkwatcher/lib/network-watcher.ts"],"names":[],"mappings":";;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,+BAA+B;AAE/B,uEAGmC;AACnC,8EAGmD;AAiCnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,MAAa,cAAe,SAAQ,8BAAa;IAkC/C;;;;;;;;;;;;;OAaG;IACH,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA0B;QAClE,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QAExB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QAEnB,gFAAgF;QAChF,IAAI,CAAC,QAAQ,GAAG,IAAI,KAAK,CAAC,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE;YACpD,KAAK,EAAE,IAAI,CAAC,EAAE;YACd,WAAW,EAAE,+BAA+B;SAC7C,CAAC,CAAC;QAEH,IAAI,CAAC,UAAU,GAAG,IAAI,KAAK,CAAC,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE;YACxD,KAAK,EAAE,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG,QAAQ;YAC/C,WAAW,EAAE,iCAAiC;SAC/C,CAAC,CAAC;QAEH,IAAI,CAAC,cAAc,GAAG,IAAI,KAAK,CAAC,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE;YAChE,KAAK,EAAE,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG,mBAAmB;YAC1D,WAAW,EAAE,qCAAqC;SACnD,CAAC,CAAC;QAEH,IAAI,CAAC,uBAAuB,GAAG,IAAI,KAAK,CAAC,eAAe,CACtD,IAAI,EACJ,oBAAoB,EACpB;YACE,KAAK,EAAE,MAAM,IAAI,CAAC,iBAAiB,CAAC,GAAG,uCAAuC;YAC9E,WAAW,EAAE,+CAA+C;SAC7D,CACF,CAAC;QAEF,uBAAuB;QACvB,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,CAAC,UAAU,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;QAC1C,IAAI,CAAC,cAAc,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;QAClD,IAAI,CAAC,uBAAuB,CAAC,iBAAiB,CAAC,oBAAoB,CAAC,CAAC;IACvE,CAAC;IAED,gFAAgF;IAChF,+CAA+C;IAC/C,gFAAgF;IAEhF;;;OAGG;IACO,cAAc;QACtB,OAAO,YAAY,CAAC;IACtB,CAAC;IAED;;OAEG;IACO,YAAY;QACpB,OAAO,8CAAoB,CAAC;IAC9B,CAAC;IAED;;;OAGG;IACO,SAAS;QACjB,OAAO,IAAI,CAAC,aAAa,EAAE,CAAC;IAC9B,CAAC;IAED;;OAEG;IACO,gBAAgB;QACxB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACO,kBAAkB,CAAC,MAAW;QACtC,gDAAgD;QAChD,wEAAwE;QACxE,MAAM,IAAI,GAAQ;YAChB,UAAU,EAAE,EAAE;SACf,CAAC;QAEF,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACO,eAAe,CAAC,KAAU;QAClC,OAAQ,KAA6B,CAAC,eAAe,CAAC;IACxD,CAAC;;AAhJH,wCAiJC;;;AAhJC;IACE,8BAAa,CAAC,eAAe,CAC3B,8CAAoB,EACpB,sDAA4B,CAC7B,CAAC;AACJ,CAAC,GAAA,CAAA","sourcesContent":["/**\n * Unified Azure Network Watcher implementation using AzapiResource framework\n *\n * This class provides a version-aware implementation for Azure Network Watcher\n * that automatically handles version management, schema validation, and property\n * transformation across all supported API versions.\n *\n * IMPORTANT: Azure only allows one Network Watcher per subscription per region.\n * If you attempt to create a Network Watcher in a region where one already exists,\n * the deployment will fail.\n *\n * Supported API Versions:\n * - 2024-01-01 (Active, Latest)\n * - 2023-11-01 (Active, Backward Compatibility)\n *\n * Features:\n * - Automatic latest version resolution when no version is specified\n * - Explicit version pinning for stability requirements\n * - Schema-driven validation and transformation\n * - Full JSII compliance for multi-language support\n *\n * Network Watcher is primarily used as a dependency for other Network Watcher features:\n * - Flow Logs\n * - Connection Monitor\n * - Packet Capture\n * - Network Diagnostic Tools\n */\n\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  ALL_NETWORK_WATCHER_VERSIONS,\n  NETWORK_WATCHER_TYPE,\n} from \"./network-watcher-schemas\";\nimport {\n  AzapiResource,\n  AzapiResourceProps,\n} from \"../../core-azure/lib/azapi/azapi-resource\";\nimport { ApiSchema } from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\n\n/**\n * Properties for the unified Azure Network Watcher\n *\n * Extends AzapiResourceProps with Network Watcher specific properties.\n *\n * IMPORTANT: Azure only allows one Network Watcher per subscription per region.\n * Attempting to create multiple Network Watchers in the same region will fail.\n */\nexport interface NetworkWatcherProps extends AzapiResourceProps {\n  /**\n   * Resource Group ID where the Network Watcher will be created\n   *\n   * The Network Watcher will be created as a child of this resource group.\n   * It's recommended to use a dedicated resource group for Network Watchers,\n   * as Azure automatically creates one named \"NetworkWatcherRG\" when certain\n   * network features are used.\n   */\n  readonly resourceGroupId: string;\n}\n\n/**\n * The resource body interface for Azure Network Watcher API calls\n *\n * Network Watcher is a simple resource with minimal properties.\n * The properties block is typically empty.\n */\nexport interface NetworkWatcherBody {\n  readonly properties: { [key: string]: any };\n}\n\n/**\n * Unified Azure Network Watcher implementation\n *\n * This class provides a single, version-aware implementation that automatically handles version\n * resolution, schema validation, and property transformation while maintaining full JSII compliance.\n *\n * Network Watcher is a regional service that provides tools to monitor, diagnose, and gain\n * insights into your network health and performance in Azure. It serves as the anchor for\n * Network Watcher features like Flow Logs, Connection Monitor, and Packet Capture.\n *\n * IMPORTANT CONSTRAINT: Azure only allows one Network Watcher per subscription per region.\n * If you need Network Watcher functionality in multiple regions, you must create a separate\n * Network Watcher for each region.\n *\n * @example\n * // Basic Network Watcher:\n * const networkWatcher = new NetworkWatcher(this, \"network-watcher\", {\n *   name: \"nw-eastus\",\n *   location: \"eastus\",\n *   resourceGroupId: resourceGroup.id,\n * });\n *\n * @example\n * // Network Watcher with specific API version:\n * const networkWatcher = new NetworkWatcher(this, \"network-watcher\", {\n *   name: \"nw-westus2\",\n *   location: \"westus2\",\n *   resourceGroupId: resourceGroup.id,\n *   apiVersion: \"2024-01-01\",\n *   tags: {\n *     environment: \"production\",\n *   },\n * });\n *\n * @example\n * // Network Watcher for use with Flow Logs:\n * const networkWatcher = new NetworkWatcher(this, \"network-watcher\", {\n *   name: \"NetworkWatcher_eastus\",\n *   location: \"eastus\",\n *   resourceGroupId: networkWatcherRg.id,\n * });\n *\n * // Then use it with NSG Flow Logs\n * const flowLog = new NsgFlowLog(this, \"flow-log\", {\n *   networkWatcherId: networkWatcher.id,\n *   // ... other properties\n * });\n *\n * @stability stable\n */\nexport class NetworkWatcher extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(\n      NETWORK_WATCHER_TYPE,\n      ALL_NETWORK_WATCHER_VERSIONS,\n    );\n  }\n\n  /**\n   * The input properties for this Network Watcher instance\n   */\n  public readonly props: NetworkWatcherProps;\n\n  // Output properties for easy access and referencing\n  /**\n   * Terraform output for the Network Watcher resource ID\n   */\n  public readonly idOutput: cdktf.TerraformOutput;\n\n  /**\n   * Terraform output for the Network Watcher name\n   */\n  public readonly nameOutput: cdktf.TerraformOutput;\n\n  /**\n   * Terraform output for the Network Watcher location\n   */\n  public readonly locationOutput: cdktf.TerraformOutput;\n\n  /**\n   * Terraform output for the Network Watcher provisioning state\n   */\n  public readonly provisioningStateOutput: cdktf.TerraformOutput;\n\n  /**\n   * Creates a new Azure Network Watcher using the AzapiResource framework\n   *\n   * The constructor automatically handles version resolution, schema registration,\n   * validation, and resource creation.\n   *\n   * IMPORTANT: Azure only allows one Network Watcher per subscription per region.\n   * Attempting to create a Network Watcher in a region where one already exists\n   * will result in a deployment error.\n   *\n   * @param scope - The scope in which to define this construct\n   * @param id - The unique identifier for this instance\n   * @param props - Configuration properties for the Network Watcher\n   */\n  constructor(scope: Construct, id: string, props: NetworkWatcherProps) {\n    super(scope, id, props);\n\n    this.props = props;\n\n    // Create Terraform outputs for easy access and referencing from other resources\n    this.idOutput = new cdktf.TerraformOutput(this, \"id\", {\n      value: this.id,\n      description: \"The ID of the Network Watcher\",\n    });\n\n    this.nameOutput = new cdktf.TerraformOutput(this, \"name\", {\n      value: `\\${${this.terraformResource.fqn}.name}`,\n      description: \"The name of the Network Watcher\",\n    });\n\n    this.locationOutput = new cdktf.TerraformOutput(this, \"location\", {\n      value: `\\${${this.terraformResource.fqn}.output.location}`,\n      description: \"The location of the Network Watcher\",\n    });\n\n    this.provisioningStateOutput = new cdktf.TerraformOutput(\n      this,\n      \"provisioning_state\",\n      {\n        value: `\\${${this.terraformResource.fqn}.output.properties.provisioningState}`,\n        description: \"The provisioning state of the Network Watcher\",\n      },\n    );\n\n    // Override logical IDs\n    this.idOutput.overrideLogicalId(\"id\");\n    this.nameOutput.overrideLogicalId(\"name\");\n    this.locationOutput.overrideLogicalId(\"location\");\n    this.provisioningStateOutput.overrideLogicalId(\"provisioning_state\");\n  }\n\n  // =============================================================================\n  // REQUIRED ABSTRACT METHODS FROM AzapiResource\n  // =============================================================================\n\n  /**\n   * Gets the default API version to use when no explicit version is specified\n   * Returns the latest stable version as the default\n   */\n  protected defaultVersion(): string {\n    return \"2024-01-01\";\n  }\n\n  /**\n   * Gets the Azure resource type for Network Watcher\n   */\n  protected resourceType(): string {\n    return NETWORK_WATCHER_TYPE;\n  }\n\n  /**\n   * Gets the API schema for the resolved version\n   * Uses the framework's schema resolution to get the appropriate schema\n   */\n  protected apiSchema(): ApiSchema {\n    return this.resolveSchema();\n  }\n\n  /**\n   * Indicates that this resource type requires a location\n   */\n  protected requiresLocation(): boolean {\n    return true;\n  }\n\n  /**\n   * Creates the resource body for the Azure API call\n   *\n   * Network Watcher is a simple resource with an empty properties block.\n   * All configuration is handled at the resource level (name, location, tags).\n   */\n  protected createResourceBody(_props: any): any {\n    // Network Watcher has an empty properties block\n    // The resource is configured primarily through name, location, and tags\n    const body: any = {\n      properties: {},\n    };\n\n    return body;\n  }\n\n  /**\n   * Resolves the parent resource ID for Network Watcher\n   * Network Watcher is a top-level resource within a resource group\n   *\n   * @param props - The resource properties\n   * @returns The parent resource ID (the resource group)\n   */\n  protected resolveParentId(props: any): string {\n    return (props as NetworkWatcherProps).resourceGroupId;\n  }\n}\n"]}

package/lib/azure-networkwatcher/test/network-watcher.integ.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Integration test for Azure Network Watcher
+ *
+ * This test demonstrates basic usage of the NetworkWatcher construct
+ * and validates deployment, idempotency, and cleanup.
+ *
+ * IMPORTANT: Azure only allows one Network Watcher per subscription per region.
+ * If a Network Watcher already exists in the test region, this test will fail.
+ *
+ * Run with: npm run integration:nostream
+ */
+import "cdktf/lib/testing/adapters/jest";

package/lib/azure-networkwatcher/test/network-watcher.integ.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * Integration test for Azure Network Watcher
+ *
+ * This test demonstrates basic usage of the NetworkWatcher construct
+ * and validates deployment, idempotency, and cleanup.
+ *
+ * IMPORTANT: Azure only allows one Network Watcher per subscription per region.
+ * If a Network Watcher already exists in the test region, this test will fail.
+ *
+ * Run with: npm run integration:nostream
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+require("cdktf/lib/testing/adapters/jest");
+const azure_resourcegroup_1 = require("../../azure-resourcegroup");
+const provider_1 = require("../../core-azure/lib/azapi/providers-azapi/provider");
+const testing_1 = require("../../testing");
+const network_watcher_1 = require("../lib/network-watcher");
+/**
+ * Example stack demonstrating Network Watcher usage
+ *
+ * Note: This example creates a dedicated resource group for the Network Watcher.
+ * In practice, Azure often uses a resource group named "NetworkWatcherRG" for
+ * automatically provisioned Network Watchers.
+ */
+class NetworkWatcherExampleStack extends cdktf_1.TerraformStack {
+    constructor(scope, id) {
+        super(scope, id);
+        // Configure AZAPI provider
+        new provider_1.AzapiProvider(this, "azapi", {});
+        // Create a resource group for Network Watcher
+        // Note: Azure typically uses NetworkWatcherRG for auto-provisioned Network Watchers
+        // Using northeurope to avoid conflict with existing Network Watchers
+        const resourceGroup = new azure_resourcegroup_1.ResourceGroup(this, "example-rg", {
+            name: "nw-example-rg",
+            location: "northeurope",
+            tags: {
+                environment: "example",
+                purpose: "integration-test",
+            },
+        });
+        // Example 1: Basic Network Watcher
+        // Note: Only one Network Watcher per region per subscription is allowed
+        new network_watcher_1.NetworkWatcher(this, "basic-network-watcher", {
+            name: "nw-basic-example",
+            location: resourceGroup.props.location,
+            resourceGroupId: resourceGroup.id,
+            tags: {
+                example: "basic",
+            },
+        });
+        // Example 2: Network Watcher with specific version
+        // Using a different construct ID but same region (this is for demonstration only -
+        // in practice, you should only have one Network Watcher per region)
+        // This example shows version pinning but would fail if deployed alongside Example 1
+        // since both use the same region.
+        // Uncomment for testing version pinning in a different region:
+        /*
+        new NetworkWatcher(this, "versioned-network-watcher", {
+          name: "nw-versioned-example",
+          location: "westus2",  // Different region
+          resourceGroupId: resourceGroup.id,
+          apiVersion: "2024-01-01",
+          tags: {
+            example: "versioned",
+          },
+        });
+        */
+    }
+}
+describe("Network Watcher Integration Test", () => {
+    it("should deploy, validate idempotency, and cleanup Network Watcher resources", () => {
+        const app = cdktf_1.Testing.app();
+        const stack = new NetworkWatcherExampleStack(app, "test-network-watcher");
+        const synthesized = cdktf_1.Testing.fullSynth(stack);
+        // This will:
+        // 1. Run terraform apply to deploy resources
+        // 2. Run terraform plan to check idempotency (no changes expected)
+        // 3. Run terraform destroy to cleanup resources
+        (0, testing_1.TerraformApplyCheckAndDestroy)(synthesized);
+    }, 600000); // 10 minute timeout for deployment and cleanup
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/azure-networkwatcher/test/network-watcher.spec.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Comprehensive tests for the NetworkWatcher implementation
+ *
+ * This test suite validates the NetworkWatcher class using the AzapiResource framework.
+ * Tests cover automatic version resolution, explicit version pinning, schema validation,
+ * property configurations, and resource creation.
+ */
+export {};