@intentius/chant-lexicon-azure 0.124.31 → 0.124.32

package/dist/op/builders.js

@@ -0,0 +1,70 @@
+/**
+ * Typed step-builder wrappers for this lexicon's activities (chant #1288
+ * Stage 2). See `lexicons/k8s/src/op/builders.ts`'s module doc for why these
+ * live beside their `*Args` interfaces rather than in core: core cannot
+ * import a lexicon's types, so a wrapper whose `opts` IS the activity's own
+ * `*Args` interface can only sit in the lexicon that declares that
+ * interface. `opts`'s type in each wrapper below IS the activity's own
+ * `*Args` interface (via `Omit`/`WithStepRefs`) — never restated. `core`'s own
+ * `azApply`/`azDelete`/`azGroupEnsure`/`azGroupDelete`/`flociAzUp`/
+ * `flociAzDown` are unchanged and produce byte-identical `ActivityStep`
+ * output; these are purely additive.
+ */
+import { activity, takeProfileAndId, } from "@intentius/chant/op";
+/**
+ * Ensure an Azure resource group exists before an ARM apply — the fully
+ * typed twin of core's `azGroupEnsure`. `opts` is {@link AzGroupEnsureArgs}
+ * itself, minus the positional `resourceGroup`. Defaults to the
+ * `fastIdempotent` profile.
+ */
+export const azGroupEnsure = (resourceGroup, opts) => {
+    const { args, profile, id } = takeProfileAndId(opts);
+    return activity("azGroupEnsure", { resourceGroup, ...args }, { profile: profile ?? "fastIdempotent", ...(id ? { id } : {}) });
+};
+/**
+ * Delete an Azure resource group and its contents — the fully typed twin of
+ * core's `azGroupDelete`. `opts` is {@link AzGroupDeleteArgs} itself, minus
+ * the positional `resourceGroup`. Defaults to the `fastIdempotent` profile.
+ */
+export const azGroupDelete = (resourceGroup, opts) => {
+    const { args, profile, id } = takeProfileAndId(opts);
+    return activity("azGroupDelete", { resourceGroup, ...args }, { profile: profile ?? "fastIdempotent", ...(id ? { id } : {}) });
+};
+/**
+ * Apply a built ARM template directly to the ARM resource API — the fully
+ * typed twin of core's `azApply`. `opts` is {@link AzApplyArgs} itself,
+ * minus the positional `templatePath` (`resourceGroup` remains required).
+ * Defaults to the `longInfra` profile.
+ */
+export const azApply = (templatePath, opts) => {
+    const { args, profile, id } = takeProfileAndId(opts);
+    return activity("azApply", { templatePath, ...args }, { profile: profile ?? "longInfra", ...(id ? { id } : {}) });
+};
+/**
+ * Delete the Azure (ARM) resources in a built template — the inverse of
+ * {@link azApply}, fully typed twin of core's `azDelete`. `opts` is
+ * {@link AzApplyArgs} itself (the activity reuses it), minus the positional
+ * `templatePath`. Defaults to the `longInfra` profile.
+ */
+export const azDelete = (templatePath, opts) => {
+    const { args, profile, id } = takeProfileAndId(opts);
+    return activity("azDelete", { templatePath, ...args }, { profile: profile ?? "longInfra", ...(id ? { id } : {}) });
+};
+/**
+ * Boot a local floci-az (Azure emulator) — the fully typed twin of core's
+ * `flociAzUp`. `opts` is {@link FlociAzUpArgs} itself. Defaults to the
+ * `longInfra` profile.
+ */
+export const flociAzUp = (opts) => {
+    const { args, profile, id } = takeProfileAndId(opts);
+    return activity("flociAzUp", args, { profile: profile ?? "longInfra", ...(id ? { id } : {}) });
+};
+/**
+ * Stop and remove the local floci-az container — the fully typed twin of
+ * core's `flociAzDown`. `opts` is {@link FlociAzDownArgs} itself. Defaults
+ * to the `fastIdempotent` profile.
+ */
+export const flociAzDown = (opts) => {
+    const { args, profile, id } = takeProfileAndId(opts);
+    return activity("flociAzDown", args, { profile: profile ?? "fastIdempotent", ...(id ? { id } : {}) });
+};

package/dist/ownership.js

@@ -0,0 +1,13 @@
+/**
+ * The azure lexicon's ownership tag convention. Azure tag keys forbid `/`, so
+ * chant's markers use a hyphenated `chant-<name>` form (distinct from the
+ * label-based convention core keeps for k8s/gcp, and from AWS's `chant:<name>`).
+ * Core owns the generic stamp/detect logic (@intentius/chant/ownership); this is
+ * the azure-specific key naming it stamps.
+ */
+/** Azure tag keys for chant's ownership markers. */
+export const AZURE_TAG_OWNERSHIP_KEYS = {
+    managedBy: "chant-managed-by",
+    stack: "chant-stack",
+    env: "chant-env",
+};

package/dist/package-cli.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env tsx
+/**
+ * Thin entry point for `npm run bundle` in lexicon-azure.
+ * Generates src/generated/ files and writes dist/ bundle.
+ */
+import { generate, writeGeneratedFiles } from "./codegen/generate.js";
+import { packageLexicon } from "./codegen/package.js";
+import { writeBundleSpec } from "@intentius/chant/codegen/package";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
+// 1. Generate src/generated/ files
+const genResult = await generate({ verbose: true });
+writeGeneratedFiles(genResult, pkgDir);
+console.error(`Generated ${genResult.resources} resources, ${genResult.properties} property types, ${genResult.enums} enums`);
+// 2. Run package pipeline and write dist/
+const { spec, stats } = await packageLexicon({ verbose: true });
+const distDir = join(pkgDir, "dist");
+writeBundleSpec(spec, distDir);
+console.error(`Packaged ${stats.resources} resources, ${stats.ruleCount} rules, ${stats.skillCount} skills`);
+console.error(`dist/ written to ${distDir}`);

package/dist/parameter.js

@@ -0,0 +1,13 @@
+var _a;
+import { DECLARABLE_MARKER } from "@intentius/chant/declarable";
+export class Parameter {
+    constructor(type, options) {
+        this[_a] = true;
+        this.lexicon = "azure";
+        this.entityType = "Microsoft.Resources/deployments/parameter";
+        this.parameterType = type;
+        this.description = options?.description;
+        this.defaultValue = options?.defaultValue;
+    }
+}
+_a = DECLARABLE_MARKER;

package/dist/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,0BAA0B,CAAC;AAyB5E;;;;;GAKG;AACH,eAAO,MAAM,WAAW,EAAE,aAodzB,CAAC"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAgB,MAAM,0BAA0B,CAAC;AA0B5E;;;;;GAKG;AACH,eAAO,MAAM,WAAW,EAAE,aAodzB,CAAC"}

package/dist/plugin.js

@@ -0,0 +1,472 @@
+import { compositeCatalog } from "./composites/catalog.js";
+import { detectTemplate } from "./detect.js";
+import { postSynthChecks as postSynthCheckList } from "./lint/post-synth/index.js";
+import { azureAuditCatalog } from "./lint/audit-catalog.js";
+import { FLOCI_AZ_EMULATOR } from "./op/activities/floci-az.js";
+import { createSkillsLoader } from "@intentius/chant/lexicon-plugin-helpers";
+import { readFileSync, readdirSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { moduleSourceDir } from "@intentius/chant/module-source";
+import { azureSerializer } from "./serializer.js";
+import { hardcodedLocationRule } from "./lint/rules/hardcoded-location.js";
+import { storageHttpsRule } from "./lint/rules/storage-https.js";
+import { nsgWildcardRule } from "./lint/rules/nsg-wildcard.js";
+import { ArmParser } from "./import/parser.js";
+import { ArmGenerator } from "./import/generator.js";
+import { azureCompletions } from "./lsp/completions.js";
+import { azureHover } from "./lsp/hover.js";
+import { azureDeepNormalizationHooks, observeResourcesDeepAzure } from "./deep-observe.js";
+import { AZURE_TAG_OWNERSHIP_KEYS } from "./ownership.js";
+/**
+ * Azure Resource Manager lexicon plugin.
+ *
+ * Provides serializer, lint rules, template detection,
+ * import parsing, and code generation for Azure ARM templates.
+ */
+export const azurePlugin = {
+    name: "azure",
+    ownershipChannel: { keys: AZURE_TAG_OWNERSHIP_KEYS, reads: ["exportResources"] },
+    emulator: FLOCI_AZ_EMULATOR,
+    auditCatalog: () => azureAuditCatalog,
+    serializer: azureSerializer,
+    lintRules() {
+        return [hardcodedLocationRule, storageHttpsRule, nsgWildcardRule];
+    },
+    /**
+     * chant #1044 — azure has no tagged templates at all, so before this every
+     * intrinsic use fell the whole file back to the run path. All nine opt
+     * their call form in.
+     *
+     * Audited against `IntrinsicDef.foldsAsCall` (core's lexicon.ts): each one
+     * stores its arguments and renders an ARM bracket expression at
+     * serialization time (../intrinsics.ts). Nothing is evaluated locally —
+     * `UniqueString(x)` emits `[uniqueString(x)]` for ARM to hash at deployment
+     * (it does not hash anything at build time), and `Reference`/`ListKeys`
+     * name a deployment-time read rather than performing one. Every call is a
+     * pure function of its arguments, so calling it while folding is
+     * indistinguishable from calling it during a real run of the file.
+     */
+    intrinsics() {
+        return [
+            { name: "ResourceId", description: "Generate a resource ID for an Azure resource", isTag: false, foldsAsCall: true },
+            { name: "Reference", description: "Get the runtime state of a deployed resource", isTag: false, foldsAsCall: true },
+            { name: "Concat", description: "Concatenate multiple string values", isTag: false, foldsAsCall: true },
+            { name: "ResourceGroup", description: "Get the current resource group object", isTag: false, foldsAsCall: true },
+            { name: "Subscription", description: "Get the current subscription object", isTag: false, foldsAsCall: true },
+            { name: "UniqueString", description: "Generate a deterministic hash string", isTag: false, foldsAsCall: true },
+            { name: "Format", description: "Format a string with arguments", isTag: false, foldsAsCall: true },
+            { name: "If", description: "Conditional expression", isTag: false, foldsAsCall: true },
+            { name: "ListKeys", description: "List access keys for a resource", isTag: false, foldsAsCall: true },
+        ];
+    },
+    pseudoParameters() {
+        return [
+            "Azure.ResourceGroupName",
+            "Azure.ResourceGroupLocation",
+            "Azure.ResourceGroupId",
+            "Azure.SubscriptionId",
+            "Azure.TenantId",
+            "Azure.DeploymentName",
+        ];
+    },
+    initTemplates(template) {
+        if (template === "web-app") {
+            return {
+                src: {
+                    "main.ts": `/**
+ * Azure infrastructure — App Service web application
+ *
+ * Deploys an App Service Plan + Web App with:
+ * - Managed identity (SystemAssigned)
+ * - HTTPS-only traffic
+ * - Minimum TLS 1.2
+ * - FTPS disabled
+ */
+
+import { AppService } from "@intentius/chant-lexicon-azure";
+import { CoreParameter, StackOutput } from "@intentius/chant";
+
+export const environment = new CoreParameter({
+  name: "environment",
+  type: "string",
+  default: "dev",
+});
+
+const { plan, webApp } = AppService({
+  name: "my-web-app",
+  sku: "B1",
+  runtime: "NODE|18-lts",
+  tags: { environment: "dev" },
+});
+
+export { plan, webApp };
+
+export const appUrl = new StackOutput({
+  name: "appUrl",
+  value: \`https://my-web-app.azurewebsites.net\`,
+});
+`,
+                    "tags.ts": `import { defaultTags } from "@intentius/chant-lexicon-azure";
+
+export const tags = defaultTags([
+  { key: "Project", value: "my-web-app" },
+  { key: "Environment", value: "dev" },
+]);
+`,
+                },
+            };
+        }
+        if (template === "aks-cluster") {
+            return {
+                src: {
+                    "main.ts": `/**
+ * Azure infrastructure — AKS Kubernetes cluster
+ *
+ * Deploys an AKS cluster with:
+ * - Managed identity
+ * - RBAC enabled
+ * - Standard load balancer
+ * - Azure CNI networking
+ */
+
+import { AksCluster, VnetDefault, ContainerRegistrySecure } from "@intentius/chant-lexicon-azure";
+import { CoreParameter, StackOutput } from "@intentius/chant";
+
+export const kubernetesVersion = new CoreParameter({
+  name: "kubernetesVersion",
+  type: "string",
+  default: "1.28",
+});
+
+const { virtualNetwork, subnet1, subnet2, nsg, routeTable } = VnetDefault({
+  name: "aks-vnet",
+});
+
+const { cluster } = AksCluster({
+  name: "my-aks",
+  nodeCount: 3,
+  vmSize: "Standard_D2s_v5",
+  tags: { workload: "kubernetes" },
+});
+
+const { registry } = ContainerRegistrySecure({
+  name: "myaksacr",
+});
+
+export { virtualNetwork, subnet1, subnet2, nsg, routeTable, cluster, registry };
+
+export const clusterName = new StackOutput({
+  name: "clusterName",
+  value: "my-aks",
+});
+`,
+                    "tags.ts": `import { defaultTags } from "@intentius/chant-lexicon-azure";
+
+export const tags = defaultTags([
+  { key: "Project", value: "my-aks-cluster" },
+  { key: "Environment", value: "dev" },
+]);
+`,
+                },
+            };
+        }
+        if (template === "function-app") {
+            return {
+                src: {
+                    "main.ts": `/**
+ * Azure infrastructure — Consumption Function App
+ *
+ * Deploys a Function App with:
+ * - Consumption (Y1) App Service Plan
+ * - Storage Account for function runtime
+ * - Managed identity (SystemAssigned)
+ * - HTTPS-only traffic
+ * - Minimum TLS 1.2
+ * - FTPS disabled
+ */
+
+import { FunctionApp } from "@intentius/chant-lexicon-azure";
+import { CoreParameter, StackOutput } from "@intentius/chant";
+
+export const environment = new CoreParameter({
+  name: "environment",
+  type: "string",
+  default: "dev",
+});
+
+const { plan, functionApp, storageAccount } = FunctionApp({
+  name: "my-function-app",
+  runtime: "node",
+  tags: { environment: "dev" },
+});
+
+export { plan, functionApp, storageAccount };
+
+export const functionAppUrl = new StackOutput({
+  name: "functionAppUrl",
+  value: \`https://my-function-app.azurewebsites.net\`,
+});
+`,
+                    "tags.ts": `import { defaultTags } from "@intentius/chant-lexicon-azure";
+
+export const tags = defaultTags([
+  { key: "Project", value: "my-function-app" },
+  { key: "Environment", value: "dev" },
+]);
+`,
+                },
+            };
+        }
+        // Default template — basic storage account
+        return {
+            src: {
+                "main.ts": `/**
+ * Azure infrastructure — Storage Account with secure defaults
+ */
+
+import { StorageAccount, Azure } from "@intentius/chant-lexicon-azure";
+
+export const storage = new StorageAccount({
+  name: "mystorageaccount",
+  location: Azure.ResourceGroupLocation,
+  kind: "StorageV2",
+  sku: { name: "Standard_LRS" },
+  supportsHttpsTrafficOnly: true,
+  minimumTlsVersion: "TLS1_2",
+  allowBlobPublicAccess: false,
+});
+`,
+                "tags.ts": `import { defaultTags } from "@intentius/chant-lexicon-azure";
+
+export const tags = defaultTags([
+  { key: "Project", value: "my-app" },
+  { key: "Environment", value: "dev" },
+]);
+`,
+            },
+        };
+    },
+    detectTemplate,
+    templateParser() {
+        return new ArmParser();
+    },
+    templateGenerator() {
+        return new ArmGenerator();
+    },
+    postSynthChecks() {
+        return postSynthCheckList;
+    },
+    skills: createSkillsLoader(import.meta.url, [
+        {
+            file: "chant-azure.md",
+            name: "chant-azure",
+            description: "Azure Resource Manager infrastructure generation with chant",
+            triggers: [
+                { type: "file-pattern", value: "*.azure.ts" },
+                { type: "context", value: "azure" },
+            ],
+            parameters: [
+                { name: "resourceType", type: "string", description: "Azure resource type to generate" },
+            ],
+            examples: [
+                {
+                    title: "Storage Account",
+                    input: "Create an Azure storage account with secure defaults",
+                    output: 'import { StorageAccount } from "@intentius/chant-lexicon-azure";\n\nexport const storage = new StorageAccount({ ... });',
+                },
+            ],
+        },
+        {
+            file: "chant-azure-security.md",
+            name: "chant-azure-security",
+            description: "Azure security best practices for infrastructure",
+            triggers: [
+                { type: "context", value: "azure security" },
+                { type: "context", value: "azure identity" },
+            ],
+            parameters: [],
+            examples: [
+                {
+                    title: "Secure Storage Account",
+                    input: "Create a storage account with encryption and no public access",
+                    output: 'import { StorageAccountSecure } from "@intentius/chant-lexicon-azure";\n\nconst { storageAccount } = StorageAccountSecure({ name: "mystorage" });',
+                },
+            ],
+        },
+        {
+            file: "chant-azure-patterns.md",
+            name: "chant-azure-patterns",
+            description: "Advanced Azure ARM template patterns",
+            triggers: [
+                { type: "context", value: "azure patterns" },
+                { type: "context", value: "azure composites" },
+            ],
+            parameters: [],
+            examples: [
+                {
+                    title: "Linked Deployment",
+                    input: "Deploy a child project as a linked template",
+                    output: 'import { ChildProjectInstance } from "@intentius/chant";\n\nexport const deploy = new ChildProjectInstance({ project: "../network" });',
+                },
+            ],
+        },
+        {
+            file: "chant-azure-aks.md",
+            name: "chant-azure-aks",
+            description: "AKS end-to-end workflow — deploy ARM template, configure kubectl, deploy K8s workloads",
+            triggers: [
+                { type: "context", value: "aks" },
+                { type: "context", value: "azure kubernetes" },
+                { type: "context", value: "agic" },
+            ],
+            parameters: [],
+            examples: [
+                {
+                    title: "Deploy AKS microservice",
+                    input: "Deploy an AKS project end-to-end",
+                    output: "npm run deploy",
+                },
+            ],
+        },
+    ]),
+    completionProvider(ctx) {
+        return azureCompletions(ctx);
+    },
+    hoverProvider(ctx) {
+        return azureHover(ctx);
+    },
+    composites() {
+        return compositeCatalog;
+    },
+    mcpTools() {
+        return [{
+                name: "azure:lookup-resource",
+                description: "Look up an Azure resource type by name",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string", description: "Resource name to search for (e.g. 'StorageAccount', 'VirtualMachine')" },
+                    },
+                    required: ["query"],
+                },
+                handler: async (args) => {
+                    const dir = moduleSourceDir(import.meta.url);
+                    try {
+                        const lexicon = JSON.parse(readFileSync(join(dir, "generated", "lexicon-azure.json"), "utf-8"));
+                        const query = args.query.toLowerCase();
+                        const matches = Object.entries(lexicon)
+                            .filter(([name]) => name.toLowerCase().includes(query))
+                            .slice(0, 10);
+                        return JSON.stringify(matches, null, 2);
+                    }
+                    catch {
+                        return "Lexicon not available — run `npm run generate` first.";
+                    }
+                },
+            }];
+    },
+    mcpResources() {
+        return [
+            {
+                uri: "resource-catalog",
+                name: "Azure Resource Catalog",
+                description: "All available Azure resource types",
+                mimeType: "application/json",
+                handler: async () => {
+                    const dir = moduleSourceDir(import.meta.url);
+                    try {
+                        return readFileSync(join(dir, "generated", "lexicon-azure.json"), "utf-8");
+                    }
+                    catch {
+                        return "{}";
+                    }
+                },
+            },
+            {
+                uri: "examples",
+                name: "Azure Example Projects",
+                description: "Example project summaries with code snippets for Azure ARM templates",
+                mimeType: "application/json",
+                handler: async () => {
+                    const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
+                    const examplesDir = join(pkgDir, "examples");
+                    const examples = [];
+                    try {
+                        if (!existsSync(examplesDir))
+                            return "[]";
+                        const dirs = readdirSync(examplesDir, { withFileTypes: true })
+                            .filter((e) => e.isDirectory());
+                        for (const dir of dirs) {
+                            const exDir = join(examplesDir, dir.name);
+                            const srcDir = join(exDir, "src");
+                            const files = {};
+                            const scanDir = existsSync(srcDir) ? srcDir : exDir;
+                            const entries = readdirSync(scanDir).filter((f) => f.endsWith(".ts"));
+                            for (const f of entries) {
+                                try {
+                                    files[f] = readFileSync(join(scanDir, f), "utf-8");
+                                }
+                                catch { /* skip unreadable */ }
+                            }
+                            if (Object.keys(files).length > 0) {
+                                examples.push({ name: dir.name, files });
+                            }
+                        }
+                        return JSON.stringify(examples, null, 2);
+                    }
+                    catch {
+                        return "[]";
+                    }
+                },
+            },
+        ];
+    },
+    async generate(opts) {
+        const { generate: gen, writeGeneratedFiles } = await import("./codegen/generate.js");
+        const result = await gen(opts);
+        writeGeneratedFiles(result, dirname(dirname(fileURLToPath(import.meta.url))));
+    },
+    async validate() {
+        const { validate } = await import("./validate.js");
+        await validate();
+    },
+    async coverage(options) {
+        const { analyzeAzureCoverage } = await import("./coverage.js");
+        await analyzeAzureCoverage({ verbose: options?.verbose, minOverall: options?.minOverall });
+    },
+    async package(opts) {
+        const { packageLexicon } = await import("./codegen/package.js");
+        await packageLexicon(opts);
+    },
+    async describeResources(options) {
+        const { describeResources } = await import("./describe-resources.js");
+        return describeResources(options);
+    },
+    /**
+     * Property-level live read (#1086) — `az resource show` already returns
+     * the full ARM resource; this normalizes it. Implementation in
+     * ./deep-observe.ts.
+     */
+    async observeResourcesDeep(options) {
+        return observeResourcesDeepAzure({
+            environment: options.environment,
+            entityNames: options.entityNames,
+            entities: options.entities,
+        });
+    },
+    /** The noise rules the deep pass applies to both the live and declared trees. */
+    deepNormalizationHooks: azureDeepNormalizationHooks,
+    async exportResources(options) {
+        const { exportResources } = await import("./export-resources.js");
+        return exportResources(options);
+    },
+    /**
+     * The generator has always existed in src/codegen/docs.ts; only the package
+     * script reached it, so `plugin.docs()` was a no-op for azure alone (#1342).
+     */
+    async docs(options) {
+        const { generateDocs } = await import("./codegen/docs.js");
+        await generateDocs(options);
+    },
+};

package/dist/pseudo.js

@@ -0,0 +1,40 @@
+/**
+ * ARM pseudo-parameters — references to deployment-time values.
+ *
+ * These serialize to ARM template expressions:
+ *   Azure.ResourceGroupName → "[resourceGroup().name]"
+ *   Azure.SubscriptionId   → "[subscription().subscriptionId]"
+ */
+var _a;
+import { INTRINSIC_MARKER } from "@intentius/chant/intrinsic";
+class ArmPseudoParameter {
+    constructor(expression, displayName) {
+        this[_a] = true;
+        this.expression = expression;
+        this.displayName = displayName;
+    }
+    toJSON() {
+        return this.expression;
+    }
+    toString() {
+        return this.displayName;
+    }
+}
+_a = INTRINSIC_MARKER;
+export const ResourceGroupName = new ArmPseudoParameter("[resourceGroup().name]", "Azure.ResourceGroupName");
+export const ResourceGroupLocation = new ArmPseudoParameter("[resourceGroup().location]", "Azure.ResourceGroupLocation");
+export const ResourceGroupId = new ArmPseudoParameter("[resourceGroup().id]", "Azure.ResourceGroupId");
+export const SubscriptionId = new ArmPseudoParameter("[subscription().subscriptionId]", "Azure.SubscriptionId");
+export const TenantId = new ArmPseudoParameter("[subscription().tenantId]", "Azure.TenantId");
+export const DeploymentName = new ArmPseudoParameter("[deployment().name]", "Azure.DeploymentName");
+/**
+ * Azure namespace containing all pseudo-parameters.
+ */
+export const Azure = {
+    ResourceGroupName,
+    ResourceGroupLocation,
+    ResourceGroupId,
+    SubscriptionId,
+    TenantId,
+    DeploymentName,
+};