@azure/provisioning-core 1.0.0-beta.1

package/dist/commonjs/constructs/stack.d.ts

@@ -0,0 +1,110 @@
+import { ProvisioningComponent } from "./provisioning-component.js";
+import type { ExpressionOrValue } from "../expression/expressions.js";
+import type { NamingPolicy } from "../naming/naming-policy.js";
+import { OutputCollection } from "./output.js";
+import { ParameterCollection } from "./parameter.js";
+import { VariableCollection } from "./variable.js";
+import { type QueryOptions } from "./resource/resource-query.js";
+import { type Loop, type LoopedResource, type Resource, type ResourceOptions } from "./resource/resource.js";
+import type { ResourceCtor } from "./resource/resource-registry.js";
+import type { TargetScope } from "../serialization/contract/index.js";
+export interface StackOptions {
+    readonly targetScope?: TargetScope | undefined;
+    readonly location?: ExpressionOrValue<string> | undefined;
+    readonly tags?: Record<string, ExpressionOrValue<string>> | undefined;
+    readonly namingPolicy?: NamingPolicy | undefined;
+}
+/**
+ * A Stack defines a deployment unit.
+ *
+ * @remarks
+ * Each stack produces one or more Bicep files — resources at different
+ * scopes (subscription vs. resource group) are split into separate files
+ * linked by module references.
+ *
+ * Resources register themselves by passing the stack (or a child component)
+ * as their first constructor argument. `Stack.add()` is available as a
+ * convenience for creating child components with the stack as parent.
+ *
+ * The `targetScope` option controls the Bicep target scope. Default is
+ * `"subscription"`, which requires explicit `ResourceGroup` instances.
+ * Set `"resourceGroup"` to deploy resources directly into an existing
+ * resource group.
+ *
+ * Every stack registers itself in `Stack.roots` for collection by tools
+ * like the playground and CLI.
+ *
+ * @example
+ * ```typescript snippet:ignore
+ * import { Stack, ResourceGroup } from "@azure/provisioning-core";
+ * import { KeyVault } from "@azure/provisioning-keyvault";
+ *
+ * const stack = new Stack("my-app");
+ * const rg = new ResourceGroup(stack, { name: "rg-my-app", location: "eastus" });
+ * const vault = new KeyVault(rg, {
+ *   name: "kv-my-app",
+ *   properties: {
+ *     tenantId: "11111111-1111-1111-1111-111111111111",
+ *     sku: { family: "A", name: "standard" },
+ *   },
+ * });
+ * ```
+ */
+export declare class Stack extends ProvisioningComponent {
+    #private;
+    readonly name: string;
+    readonly targetScope: TargetScope;
+    readonly parameters: ParameterCollection;
+    readonly variables: VariableCollection;
+    readonly outputs: OutputCollection;
+    /** All root stacks created since the last call to `Stack.clearRoots()`. */
+    static get roots(): readonly Stack[];
+    /**
+     * Returns all root stacks and clears the registry. Useful for collecting
+     * all stacks after executing user code (e.g. in the playground or CLI).
+     */
+    static clearRoots(): Stack[];
+    /** Create a root stack. */
+    constructor(name: string, options?: StackOptions);
+    /**
+     * The scalar resources in this stack. With no `type`, returns
+     * every scalar resource; pass a resource class to filter and narrow to
+     * that subclass. Returns a plain array — use native `.filter` / `.find` /
+     * `.map` for anything further.
+     *
+     * By default walks the whole tree; pass `{ recursive: false }` to consider
+     * only the stack's direct children.
+     */
+    getResources(options?: QueryOptions): Resource[];
+    getResources<T extends Resource>(type: ResourceCtor<T>, options?: QueryOptions): T[];
+    /**
+     * Find the **first** scalar resource of `type` whose literal name equals
+     * `name`, or `undefined` if none matches.
+     *
+     * @remarks
+     * Returns the first match in tree order. ARM names are unique only *per
+     * resource type within a scope*, so a stack MAY legitimately contain more
+     * than one resource of the same `type` and `name` (e.g. across different
+     * resource groups) — this returns whichever is found first. Use
+     * `getResources(type)` and filter yourself if you need all matches.
+     *
+     * Only scalar resources are searched, and names that do not resolve to a
+     * string literal are never matched. Pass `{ recursive: false }` to search
+     * only the stack's direct children.
+     */
+    getResource<T extends Resource>(type: ResourceCtor<T>, name: string, options?: QueryOptions): T | undefined;
+    /**
+     * Create a child under this stack (with the stack as its parent context),
+     * as a convenience for `new Ctor(stack, ...args)`.
+     *
+     * Constructs a single child instance and returns it.
+     */
+    add<T extends new (context: ProvisioningComponent, ...args: any[]) => ProvisioningComponent>(ctor: T, ...args: ConstructorParameters<T> extends [any, ...infer Rest] ? Rest : never): InstanceType<T>;
+}
+/** @internal */
+export declare function getLoopedResources(stack: Stack, options?: QueryOptions): LoopedResource<Resource>[];
+/** @internal */
+export declare function getLoopedResources<T extends Resource>(stack: Stack, type: ResourceCtor<T>, options?: QueryOptions): LoopedResource<T>[];
+/** @internal */
+export declare function addLoopedResource<T extends Resource, P>(stack: Stack, ctor: new (context: Stack, props: P, options?: ResourceOptions) => T, loop: Loop<unknown>, ...rest: undefined extends P ? [props?: P, options?: ResourceOptions] : [props: P, options?: ResourceOptions]): LoopedResource<T>;
+//# sourceMappingURL=stack.d.ts.map

package/dist/commonjs/constructs/stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack.d.ts","sourceRoot":"","sources":["../../../src/constructs/stack.ts"],"names":[],"mappings":"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"}

package/dist/commonjs/constructs/stack.js

@@ -0,0 +1,101 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stack_exports = {};
+__export(stack_exports, {
+  Stack: () => Stack,
+  addLoopedResource: () => addLoopedResource,
+  getLoopedResources: () => getLoopedResources
+});
+module.exports = __toCommonJS(stack_exports);
+var import_provisioning_component = require("./provisioning-component.js");
+var import_naming_policy = require("../naming/naming-policy.js");
+var import_output = require("./output.js");
+var import_parameter = require("./parameter.js");
+var import_variable = require("./variable.js");
+var import_resource_query = require("./resource/resource-query.js");
+var import_resource = require("./resource/resource.js");
+class Stack extends import_provisioning_component.ProvisioningComponent {
+  name;
+  targetScope;
+  parameters = new import_parameter.ParameterCollection();
+  variables = new import_variable.VariableCollection();
+  outputs = new import_output.OutputCollection();
+  // --- Static root stack registry ---
+  static #roots = [];
+  /** All root stacks created since the last call to `Stack.clearRoots()`. */
+  static get roots() {
+    return Stack.#roots;
+  }
+  /**
+   * Returns all root stacks and clears the registry. Useful for collecting
+   * all stacks after executing user code (e.g. in the playground or CLI).
+   */
+  static clearRoots() {
+    return Stack.#roots.splice(0, Stack.#roots.length);
+  }
+  /** Create a root stack. */
+  constructor(name, options) {
+    super();
+    const opts = options ?? {};
+    this.name = name;
+    this.targetScope = opts.targetScope ?? "subscription";
+    Stack.#roots.push(this);
+    this._localDeploymentContext = {
+      location: opts.location,
+      tags: opts.tags,
+      namingPolicy: opts.namingPolicy ?? new import_naming_policy.DefaultNamingPolicy({ workload: name })
+    };
+  }
+  getResources(typeOrOptions, maybeOptions) {
+    return (0, import_resource_query.getResources)(this, typeOrOptions, maybeOptions);
+  }
+  /**
+   * Find the **first** scalar resource of `type` whose literal name equals
+   * `name`, or `undefined` if none matches.
+   *
+   * @remarks
+   * Returns the first match in tree order. ARM names are unique only *per
+   * resource type within a scope*, so a stack MAY legitimately contain more
+   * than one resource of the same `type` and `name` (e.g. across different
+   * resource groups) — this returns whichever is found first. Use
+   * `getResources(type)` and filter yourself if you need all matches.
+   *
+   * Only scalar resources are searched, and names that do not resolve to a
+   * string literal are never matched. Pass `{ recursive: false }` to search
+   * only the stack's direct children.
+   */
+  getResource(type, name, options) {
+    return (0, import_resource_query.getResource)(this, type, name, options);
+  }
+  add(ctor, ...rest) {
+    return new ctor(this.self, ...rest);
+  }
+}
+function getLoopedResources(stack, typeOrOptions, maybeOptions) {
+  return (0, import_resource_query.getLoopedResources)(stack, typeOrOptions, maybeOptions);
+}
+function addLoopedResource(stack, ctor, loop, ...rest) {
+  return (0, import_resource.createLoopedResource)(ctor, loop, stack.self, ...rest);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Stack,
+  addLoopedResource,
+  getLoopedResources
+});
+//# sourceMappingURL=stack.js.map

package/dist/commonjs/constructs/stack.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/constructs/stack.ts"],
+  "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport { ProvisioningComponent } from \"./provisioning-component.js\";\nimport type { ExpressionOrValue } from \"../expression/expressions.js\";\nimport type { NamingPolicy } from \"../naming/naming-policy.js\";\nimport { DefaultNamingPolicy } from \"../naming/naming-policy.js\";\nimport { OutputCollection } from \"./output.js\";\nimport { ParameterCollection } from \"./parameter.js\";\nimport { VariableCollection } from \"./variable.js\";\nimport {\n  getLoopedResources as runGetLoopedResources,\n  getResources as runGetResources,\n  getResource as runGetResource,\n  type QueryOptions,\n} from \"./resource/resource-query.js\";\nimport {\n  createLoopedResource,\n  type Loop,\n  type LoopedResource,\n  type Resource,\n  type ResourceOptions,\n} from \"./resource/resource.js\";\nimport type { ResourceCtor } from \"./resource/resource-registry.js\";\nimport type { TargetScope } from \"../serialization/contract/index.js\";\n\n// ---------------------------------------------------------------------------\n// Stack \u2014 class-based API for creating stacks\n// ---------------------------------------------------------------------------\n\nexport interface StackOptions {\n  readonly targetScope?: TargetScope | undefined;\n  readonly location?: ExpressionOrValue<string> | undefined;\n  readonly tags?: Record<string, ExpressionOrValue<string>> | undefined;\n  readonly namingPolicy?: NamingPolicy | undefined;\n}\n\n/**\n * A Stack defines a deployment unit.\n *\n * @remarks\n * Each stack produces one or more Bicep files \u2014 resources at different\n * scopes (subscription vs. resource group) are split into separate files\n * linked by module references.\n *\n * Resources register themselves by passing the stack (or a child component)\n * as their first constructor argument. `Stack.add()` is available as a\n * convenience for creating child components with the stack as parent.\n *\n * The `targetScope` option controls the Bicep target scope. Default is\n * `\"subscription\"`, which requires explicit `ResourceGroup` instances.\n * Set `\"resourceGroup\"` to deploy resources directly into an existing\n * resource group.\n *\n * Every stack registers itself in `Stack.roots` for collection by tools\n * like the playground and CLI.\n *\n * @example\n * ```typescript snippet:ignore\n * import { Stack, ResourceGroup } from \"@azure/provisioning-core\";\n * import { KeyVault } from \"@azure/provisioning-keyvault\";\n *\n * const stack = new Stack(\"my-app\");\n * const rg = new ResourceGroup(stack, { name: \"rg-my-app\", location: \"eastus\" });\n * const vault = new KeyVault(rg, {\n *   name: \"kv-my-app\",\n *   properties: {\n *     tenantId: \"11111111-1111-1111-1111-111111111111\",\n *     sku: { family: \"A\", name: \"standard\" },\n *   },\n * });\n * ```\n */\nexport class Stack extends ProvisioningComponent {\n  readonly name: string;\n  readonly targetScope: TargetScope;\n  readonly parameters: ParameterCollection = new ParameterCollection();\n  readonly variables: VariableCollection = new VariableCollection();\n  readonly outputs: OutputCollection = new OutputCollection();\n\n  // --- Static root stack registry ---\n\n  static #roots: Stack[] = [];\n\n  /** All root stacks created since the last call to `Stack.clearRoots()`. */\n  static get roots(): readonly Stack[] {\n    return Stack.#roots;\n  }\n\n  /**\n   * Returns all root stacks and clears the registry. Useful for collecting\n   * all stacks after executing user code (e.g. in the playground or CLI).\n   */\n  static clearRoots(): Stack[] {\n    return Stack.#roots.splice(0, Stack.#roots.length);\n  }\n\n  /** Create a root stack. */\n  constructor(name: string, options?: StackOptions) {\n    super();\n    const opts = options ?? {};\n    this.name = name;\n    this.targetScope = opts.targetScope ?? \"subscription\";\n    Stack.#roots.push(this);\n    this._localDeploymentContext = {\n      location: opts.location,\n      tags: opts.tags,\n      namingPolicy: opts.namingPolicy ?? new DefaultNamingPolicy({ workload: name }),\n    };\n  }\n\n  // --- Query ---\n  // Query the resources in this stack. Exposed on `Stack` (not `ProvisioningComponent`)\n  // because \"all resources in the stack\" is unambiguous, whereas\n  // `resource.getResources()` \u2014 which excludes the resource itself \u2014\n  // would be confusing. For multiple stacks, use\n  // `stacks.flatMap(s => s.getResources(...))`.\n\n  /**\n   * The scalar resources in this stack. With no `type`, returns\n   * every scalar resource; pass a resource class to filter and narrow to\n   * that subclass. Returns a plain array \u2014 use native `.filter` / `.find` /\n   * `.map` for anything further.\n   *\n   * By default walks the whole tree; pass `{ recursive: false }` to consider\n   * only the stack's direct children.\n   */\n  getResources(options?: QueryOptions): Resource[];\n  getResources<T extends Resource>(type: ResourceCtor<T>, options?: QueryOptions): T[];\n  getResources(\n    typeOrOptions?: ResourceCtor<Resource> | QueryOptions,\n    maybeOptions?: QueryOptions,\n  ): Resource[] {\n    return runGetResources(this, typeOrOptions as never, maybeOptions);\n  }\n\n  /**\n   * Find the **first** scalar resource of `type` whose literal name equals\n   * `name`, or `undefined` if none matches.\n   *\n   * @remarks\n   * Returns the first match in tree order. ARM names are unique only *per\n   * resource type within a scope*, so a stack MAY legitimately contain more\n   * than one resource of the same `type` and `name` (e.g. across different\n   * resource groups) \u2014 this returns whichever is found first. Use\n   * `getResources(type)` and filter yourself if you need all matches.\n   *\n   * Only scalar resources are searched, and names that do not resolve to a\n   * string literal are never matched. Pass `{ recursive: false }` to search\n   * only the stack's direct children.\n   */\n  getResource<T extends Resource>(\n    type: ResourceCtor<T>,\n    name: string,\n    options?: QueryOptions,\n  ): T | undefined {\n    return runGetResource(this, type, name, options);\n  }\n\n  /**\n   * Create a child under this stack (with the stack as its parent context),\n   * as a convenience for `new Ctor(stack, ...args)`.\n   *\n   * Constructs a single child instance and returns it.\n   */\n  add<T extends new (context: ProvisioningComponent, ...args: any[]) => ProvisioningComponent>(\n    ctor: T,\n    ...args: ConstructorParameters<T> extends [any, ...infer Rest] ? Rest : never\n  ): InstanceType<T>;\n  add(\n    ctor: new (context: ProvisioningComponent, ...args: any[]) => ProvisioningComponent,\n    ...rest: any[]\n  ): ProvisioningComponent {\n    return new ctor(this.self, ...rest);\n  }\n}\n\n/** @internal */\nexport function getLoopedResources(\n  stack: Stack,\n  options?: QueryOptions,\n): LoopedResource<Resource>[];\n/** @internal */\nexport function getLoopedResources<T extends Resource>(\n  stack: Stack,\n  type: ResourceCtor<T>,\n  options?: QueryOptions,\n): LoopedResource<T>[];\nexport function getLoopedResources(\n  stack: Stack,\n  typeOrOptions?: ResourceCtor<Resource> | QueryOptions,\n  maybeOptions?: QueryOptions,\n): LoopedResource<Resource>[] {\n  return runGetLoopedResources(stack, typeOrOptions as never, maybeOptions);\n}\n\n/** @internal */\nexport function addLoopedResource<T extends Resource, P>(\n  stack: Stack,\n  ctor: new (context: Stack, props: P, options?: ResourceOptions) => T,\n  loop: Loop<unknown>,\n  ...rest: undefined extends P\n    ? [props?: P, options?: ResourceOptions]\n    : [props: P, options?: ResourceOptions]\n): LoopedResource<T> {\n  return createLoopedResource(ctor, loop, stack.self, ...rest);\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,oCAAsC;AAGtC,2BAAoC;AACpC,oBAAiC;AACjC,uBAAoC;AACpC,sBAAmC;AACnC,4BAKO;AACP,sBAMO;AAmDA,MAAM,cAAc,oDAAsB;AAAA,EACtC;AAAA,EACA;AAAA,EACA,aAAkC,IAAI,qCAAoB;AAAA,EAC1D,YAAgC,IAAI,mCAAmB;AAAA,EACvD,UAA4B,IAAI,+BAAiB;AAAA;AAAA,EAI1D,OAAO,SAAkB,CAAC;AAAA;AAAA,EAG1B,WAAW,QAA0B;AACnC,WAAO,MAAM;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAO,aAAsB;AAC3B,WAAO,MAAM,OAAO,OAAO,GAAG,MAAM,OAAO,MAAM;AAAA,EACnD;AAAA;AAAA,EAGA,YAAY,MAAc,SAAwB;AAChD,UAAM;AACN,UAAM,OAAO,WAAW,CAAC;AACzB,SAAK,OAAO;AACZ,SAAK,cAAc,KAAK,eAAe;AACvC,UAAM,OAAO,KAAK,IAAI;AACtB,SAAK,0BAA0B;AAAA,MAC7B,UAAU,KAAK;AAAA,MACf,MAAM,KAAK;AAAA,MACX,cAAc,KAAK,gBAAgB,IAAI,yCAAoB,EAAE,UAAU,KAAK,CAAC;AAAA,IAC/E;AAAA,EACF;AAAA,EAoBA,aACE,eACA,cACY;AACZ,eAAO,sBAAAA,cAAgB,MAAM,eAAwB,YAAY;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBA,YACE,MACA,MACA,SACe;AACf,eAAO,sBAAAC,aAAe,MAAM,MAAM,MAAM,OAAO;AAAA,EACjD;AAAA,EAYA,IACE,SACG,MACoB;AACvB,WAAO,IAAI,KAAK,KAAK,MAAM,GAAG,IAAI;AAAA,EACpC;AACF;AAaO,SAAS,mBACd,OACA,eACA,cAC4B;AAC5B,aAAO,sBAAAC,oBAAsB,OAAO,eAAwB,YAAY;AAC1E;AAGO,SAAS,kBACd,OACA,MACA,SACG,MAGgB;AACnB,aAAO,sCAAqB,MAAM,MAAM,MAAM,MAAM,GAAG,IAAI;AAC7D;",
+  "names": ["runGetResources", "runGetResource", "runGetLoopedResources"]
+}

package/dist/commonjs/constructs/variable.d.ts

@@ -0,0 +1,63 @@
+import type { Expression, InputOf } from "../expression/expressions.js";
+import type { Stack } from "./stack.js";
+export type ExpressionValue<T> = T extends Expression<infer U> ? U : T;
+/**
+ * A value accepted as a deployment variable's value: any JSON literal
+ * (scalar, `null`, array, object — recursively), an `Expression`, or a
+ * resource view (`InputOf<unknown>`). The literal members are required so
+ * plain object/array literals are accepted (a bare `InputOf<unknown>` is a
+ * weak type and would reject them).
+ */
+export type VariableValue = string | number | boolean | null | readonly VariableValue[] | {
+    readonly [key: string]: VariableValue;
+} | InputOf<unknown>;
+export type VariableOptions = {
+    readonly description?: string | undefined;
+    readonly export?: boolean | undefined;
+};
+/**
+ * Pure declaration data for a deployment variable. Stored on the stack
+ * (paired with the returned expression handle in {@link VariableEntry});
+ * read by the serializer at emit time. Not part of the value-level handle.
+ */
+export interface VariableMetadata extends VariableOptions {
+    readonly name: string;
+    readonly value: VariableValue;
+}
+export type Variable<TValue extends VariableValue = VariableValue> = Expression<ExpressionValue<TValue>>;
+/**
+ * Authoring-time collection of a stack's deployment variables. Backed by an
+ * ordered private array; supports add/get/delete/iteration. Look variables up
+ * by name via {@link VariableCollection.get}.
+ */
+export declare class VariableCollection {
+    #private;
+    /** Add a variable; returns its expression handle. Throws on duplicate name. */
+    add<TValue extends VariableValue = VariableValue>(name: string, value: TValue, options?: VariableOptions): Variable<TValue>;
+    /** The expression handle for a variable, or `undefined`. */
+    get(name: string): Variable | undefined;
+    /** The declaration metadata for a variable, or `undefined`. */
+    getMetadata(name: string): VariableMetadata | undefined;
+    /** All variable handles, in insertion order. */
+    list(): readonly Variable[];
+    /** All declaration metadata, in insertion order. */
+    listMetadata(): readonly VariableMetadata[];
+    has(name: string): boolean;
+    /** Remove a variable by name. Returns whether one was removed. */
+    delete(name: string): boolean;
+    get size(): number;
+    [Symbol.iterator](): IterableIterator<Variable>;
+}
+/**
+ * A computed value evaluated at deploy time, compiled to a Bicep `var` declaration.
+ *
+ * @example
+ * ```typescript snippet:ignore
+ * import { Stack, createVariable } from "@azure/provisioning-core";
+ *
+ * const stack = new Stack("my-app");
+ * const suffix = createVariable(stack, "suffix", "prod");
+ * ```
+ */
+export declare function createVariable<TValue extends VariableValue = VariableValue>(stack: Stack, name: string, value: TValue, options?: VariableOptions): Variable<TValue>;
+//# sourceMappingURL=variable.d.ts.map

package/dist/commonjs/constructs/variable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variable.d.ts","sourceRoot":"","sources":["../../../src/constructs/variable.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAC;AAGxE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGxC,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEvE;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GACrB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,aAAa,EAAE,GACxB;IAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa,CAAA;CAAE,GACzC,OAAO,CAAC,OAAO,CAAC,CAAC;AAErB,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACvC,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,gBAAiB,SAAQ,eAAe;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;CAC/B;AAOD,MAAM,MAAM,QAAQ,CAAC,MAAM,SAAS,aAAa,GAAG,aAAa,IAAI,UAAU,CAC7E,eAAe,CAAC,MAAM,CAAC,CACxB,CAAC;AAEF;;;;GAIG;AACH,qBAAa,kBAAkB;;IAG7B,+EAA+E;IAC/E,GAAG,CAAC,MAAM,SAAS,aAAa,GAAG,aAAa,EAC9C,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,eAAe,GACxB,QAAQ,CAAC,MAAM,CAAC;IAYnB,4DAA4D;IAC5D,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAIvC,+DAA+D;IAC/D,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAIvD,gDAAgD;IAChD,IAAI,IAAI,SAAS,QAAQ,EAAE;IAI3B,oDAAoD;IACpD,YAAY,IAAI,SAAS,gBAAgB,EAAE;IAI3C,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B,kEAAkE;IAClE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAO7B,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,QAAQ,CAAC;CAOhD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,MAAM,SAAS,aAAa,GAAG,aAAa,EACzE,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,eAAe,GACxB,QAAQ,CAAC,MAAM,CAAC,CAElB"}

package/dist/commonjs/constructs/variable.js

@@ -0,0 +1,85 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var variable_exports = {};
+__export(variable_exports, {
+  VariableCollection: () => VariableCollection,
+  createVariable: () => createVariable
+});
+module.exports = __toCommonJS(variable_exports);
+var import_expressions = require("../expression/expressions.js");
+var import_ast_nodes = require("../expression/ast-nodes.js");
+var import_util = require("../util.js");
+class VariableCollection {
+  #entries = [];
+  /** Add a variable; returns its expression handle. Throws on duplicate name. */
+  add(name, value, options) {
+    (0, import_util.assertBicepIdentifier)(name, "Deployment variable");
+    if (this.has(name)) {
+      throw new Error(`Duplicate deployment variable name: ${name}`);
+    }
+    const variable = (0, import_expressions.wrapExpression)(
+      (0, import_ast_nodes.symbolicValueExpressionNode)(name)
+    );
+    this.#entries.push({ metadata: { name, value, ...options }, variable });
+    return variable;
+  }
+  /** The expression handle for a variable, or `undefined`. */
+  get(name) {
+    return this.#find(name)?.variable;
+  }
+  /** The declaration metadata for a variable, or `undefined`. */
+  getMetadata(name) {
+    return this.#find(name)?.metadata;
+  }
+  /** All variable handles, in insertion order. */
+  list() {
+    return this.#entries.map((e) => e.variable);
+  }
+  /** All declaration metadata, in insertion order. */
+  listMetadata() {
+    return this.#entries.map((e) => e.metadata);
+  }
+  has(name) {
+    return this.#find(name) !== void 0;
+  }
+  /** Remove a variable by name. Returns whether one was removed. */
+  delete(name) {
+    const i = this.#entries.findIndex((e) => e.metadata.name === name);
+    if (i === -1) return false;
+    this.#entries.splice(i, 1);
+    return true;
+  }
+  get size() {
+    return this.#entries.length;
+  }
+  [Symbol.iterator]() {
+    return this.#entries.map((e) => e.variable)[Symbol.iterator]();
+  }
+  #find(name) {
+    return this.#entries.find((e) => e.metadata.name === name);
+  }
+}
+function createVariable(stack, name, value, options) {
+  return stack.variables.add(name, value, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VariableCollection,
+  createVariable
+});
+//# sourceMappingURL=variable.js.map

package/dist/commonjs/constructs/variable.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/constructs/variable.ts"],
+  "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { Expression, InputOf } from \"../expression/expressions.js\";\nimport { wrapExpression } from \"../expression/expressions.js\";\nimport { symbolicValueExpressionNode } from \"../expression/ast-nodes.js\";\nimport type { Stack } from \"./stack.js\";\nimport { assertBicepIdentifier } from \"../util.js\";\n\nexport type ExpressionValue<T> = T extends Expression<infer U> ? U : T;\n\n/**\n * A value accepted as a deployment variable's value: any JSON literal\n * (scalar, `null`, array, object \u2014 recursively), an `Expression`, or a\n * resource view (`InputOf<unknown>`). The literal members are required so\n * plain object/array literals are accepted (a bare `InputOf<unknown>` is a\n * weak type and would reject them).\n */\nexport type VariableValue =\n  | string\n  | number\n  | boolean\n  | null\n  | readonly VariableValue[]\n  | { readonly [key: string]: VariableValue }\n  | InputOf<unknown>;\n\nexport type VariableOptions = {\n  readonly description?: string | undefined;\n  readonly export?: boolean | undefined;\n};\n\n/**\n * Pure declaration data for a deployment variable. Stored on the stack\n * (paired with the returned expression handle in {@link VariableEntry});\n * read by the serializer at emit time. Not part of the value-level handle.\n */\nexport interface VariableMetadata extends VariableOptions {\n  readonly name: string;\n  readonly value: VariableValue;\n}\n\ninterface VariableEntry {\n  readonly metadata: VariableMetadata;\n  readonly variable: Expression<unknown>;\n}\n\nexport type Variable<TValue extends VariableValue = VariableValue> = Expression<\n  ExpressionValue<TValue>\n>;\n\n/**\n * Authoring-time collection of a stack's deployment variables. Backed by an\n * ordered private array; supports add/get/delete/iteration. Look variables up\n * by name via {@link VariableCollection.get}.\n */\nexport class VariableCollection {\n  #entries: VariableEntry[] = [];\n\n  /** Add a variable; returns its expression handle. Throws on duplicate name. */\n  add<TValue extends VariableValue = VariableValue>(\n    name: string,\n    value: TValue,\n    options?: VariableOptions,\n  ): Variable<TValue> {\n    assertBicepIdentifier(name, \"Deployment variable\");\n    if (this.has(name)) {\n      throw new Error(`Duplicate deployment variable name: ${name}`);\n    }\n    const variable = wrapExpression<ExpressionValue<TValue>>(\n      symbolicValueExpressionNode<ExpressionValue<TValue>, string>(name),\n    );\n    this.#entries.push({ metadata: { name, value, ...options }, variable });\n    return variable;\n  }\n\n  /** The expression handle for a variable, or `undefined`. */\n  get(name: string): Variable | undefined {\n    return this.#find(name)?.variable;\n  }\n\n  /** The declaration metadata for a variable, or `undefined`. */\n  getMetadata(name: string): VariableMetadata | undefined {\n    return this.#find(name)?.metadata;\n  }\n\n  /** All variable handles, in insertion order. */\n  list(): readonly Variable[] {\n    return this.#entries.map((e) => e.variable);\n  }\n\n  /** All declaration metadata, in insertion order. */\n  listMetadata(): readonly VariableMetadata[] {\n    return this.#entries.map((e) => e.metadata);\n  }\n\n  has(name: string): boolean {\n    return this.#find(name) !== undefined;\n  }\n\n  /** Remove a variable by name. Returns whether one was removed. */\n  delete(name: string): boolean {\n    const i = this.#entries.findIndex((e) => e.metadata.name === name);\n    if (i === -1) return false;\n    this.#entries.splice(i, 1);\n    return true;\n  }\n\n  get size(): number {\n    return this.#entries.length;\n  }\n\n  [Symbol.iterator](): IterableIterator<Variable> {\n    return this.#entries.map((e) => e.variable)[Symbol.iterator]();\n  }\n\n  #find(name: string): VariableEntry | undefined {\n    return this.#entries.find((e) => e.metadata.name === name);\n  }\n}\n\n/**\n * A computed value evaluated at deploy time, compiled to a Bicep `var` declaration.\n *\n * @example\n * ```typescript snippet:ignore\n * import { Stack, createVariable } from \"@azure/provisioning-core\";\n *\n * const stack = new Stack(\"my-app\");\n * const suffix = createVariable(stack, \"suffix\", \"prod\");\n * ```\n */\nexport function createVariable<TValue extends VariableValue = VariableValue>(\n  stack: Stack,\n  name: string,\n  value: TValue,\n  options?: VariableOptions,\n): Variable<TValue> {\n  return stack.variables.add(name, value, options);\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,yBAA+B;AAC/B,uBAA4C;AAE5C,kBAAsC;AAiD/B,MAAM,mBAAmB;AAAA,EAC9B,WAA4B,CAAC;AAAA;AAAA,EAG7B,IACE,MACA,OACA,SACkB;AAClB,2CAAsB,MAAM,qBAAqB;AACjD,QAAI,KAAK,IAAI,IAAI,GAAG;AAClB,YAAM,IAAI,MAAM,uCAAuC,IAAI,EAAE;AAAA,IAC/D;AACA,UAAM,eAAW;AAAA,UACf,8CAA6D,IAAI;AAAA,IACnE;AACA,SAAK,SAAS,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;AACtE,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,IAAI,MAAoC;AACtC,WAAO,KAAK,MAAM,IAAI,GAAG;AAAA,EAC3B;AAAA;AAAA,EAGA,YAAY,MAA4C;AACtD,WAAO,KAAK,MAAM,IAAI,GAAG;AAAA,EAC3B;AAAA;AAAA,EAGA,OAA4B;AAC1B,WAAO,KAAK,SAAS,IAAI,CAAC,MAAM,EAAE,QAAQ;AAAA,EAC5C;AAAA;AAAA,EAGA,eAA4C;AAC1C,WAAO,KAAK,SAAS,IAAI,CAAC,MAAM,EAAE,QAAQ;AAAA,EAC5C;AAAA,EAEA,IAAI,MAAuB;AACzB,WAAO,KAAK,MAAM,IAAI,MAAM;AAAA,EAC9B;AAAA;AAAA,EAGA,OAAO,MAAuB;AAC5B,UAAM,IAAI,KAAK,SAAS,UAAU,CAAC,MAAM,EAAE,SAAS,SAAS,IAAI;AACjE,QAAI,MAAM,GAAI,QAAO;AACrB,SAAK,SAAS,OAAO,GAAG,CAAC;AACzB,WAAO;AAAA,EACT;AAAA,EAEA,IAAI,OAAe;AACjB,WAAO,KAAK,SAAS;AAAA,EACvB;AAAA,EAEA,CAAC,OAAO,QAAQ,IAAgC;AAC9C,WAAO,KAAK,SAAS,IAAI,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,QAAQ,EAAE;AAAA,EAC/D;AAAA,EAEA,MAAM,MAAyC;AAC7C,WAAO,KAAK,SAAS,KAAK,CAAC,MAAM,EAAE,SAAS,SAAS,IAAI;AAAA,EAC3D;AACF;AAaO,SAAS,eACd,OACA,MACA,OACA,SACkB;AAClB,SAAO,MAAM,UAAU,IAAI,MAAM,OAAO,OAAO;AACjD;",
+  "names": []
+}

package/dist/commonjs/deployment-context/deployment-context.d.ts

@@ -0,0 +1,27 @@
+import type { ExpressionOrValue } from "../expression/expressions.js";
+import type { NamingPolicy } from "../naming/naming-policy.js";
+/**
+ * Inherited environment that flows down the component tree.
+ *
+ * @remarks
+ * Each node may attach a local contribution via `ProvisioningComponent._localDeploymentContext`
+ * (today, only `Stack` and `ResourceGroup` do). When a `Resource` reads the
+ * effective context, the framework walks ancestors and resolves each field:
+ *
+ * - `location`: nearest ancestor with a value wins.
+ * - `namingPolicy`: nearest ancestor with a value wins.
+ * - `tags`: flat-merged across **all** ancestors; innermost wins on key conflict.
+ *
+ * Per-resource Bicep `scope:` is not part of this — a resource's deployment
+ * scope is determined by which file or module it lands in, which in turn is
+ * determined by the ProvisioningComponent tree (the nearest `ResourceGroup`/`Stack` ancestor).
+ *
+ * The same interface describes both a node's local contribution and the
+ * fully-resolved view returned by `ProvisioningComponent.deploymentContext`.
+ */
+export interface DeploymentContext {
+    readonly location?: ExpressionOrValue<string> | undefined;
+    readonly tags?: Record<string, ExpressionOrValue<string>> | undefined;
+    readonly namingPolicy?: NamingPolicy | undefined;
+}
+//# sourceMappingURL=deployment-context.d.ts.map

package/dist/commonjs/deployment-context/deployment-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployment-context.d.ts","sourceRoot":"","sources":["../../../src/deployment-context/deployment-context.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACtE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,CAAC,EAAE,iBAAiB,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;IAC1D,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC;IACtE,QAAQ,CAAC,YAAY,CAAC,EAAE,YAAY,GAAG,SAAS,CAAC;CAClD"}

package/dist/commonjs/deployment-context/deployment-context.js

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var deployment_context_exports = {};
+module.exports = __toCommonJS(deployment_context_exports);
+//# sourceMappingURL=deployment-context.js.map

package/dist/commonjs/deployment-context/deployment-context.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/deployment-context/deployment-context.ts"],
+  "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { ExpressionOrValue } from \"../expression/expressions.js\";\nimport type { NamingPolicy } from \"../naming/naming-policy.js\";\n\n/**\n * Inherited environment that flows down the component tree.\n *\n * @remarks\n * Each node may attach a local contribution via `ProvisioningComponent._localDeploymentContext`\n * (today, only `Stack` and `ResourceGroup` do). When a `Resource` reads the\n * effective context, the framework walks ancestors and resolves each field:\n *\n * - `location`: nearest ancestor with a value wins.\n * - `namingPolicy`: nearest ancestor with a value wins.\n * - `tags`: flat-merged across **all** ancestors; innermost wins on key conflict.\n *\n * Per-resource Bicep `scope:` is not part of this \u2014 a resource's deployment\n * scope is determined by which file or module it lands in, which in turn is\n * determined by the ProvisioningComponent tree (the nearest `ResourceGroup`/`Stack` ancestor).\n *\n * The same interface describes both a node's local contribution and the\n * fully-resolved view returned by `ProvisioningComponent.deploymentContext`.\n */\nexport interface DeploymentContext {\n  readonly location?: ExpressionOrValue<string> | undefined;\n  readonly tags?: Record<string, ExpressionOrValue<string>> | undefined;\n  readonly namingPolicy?: NamingPolicy | undefined;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;AAAA;AAAA;",
+  "names": []
+}

package/dist/commonjs/expression/ast-nodes.d.ts

@@ -0,0 +1,100 @@
+import type { Resource } from "../constructs/resource/resource.js";
+import type { BinaryOperator, UnaryOperator } from "../serialization/contract/index.js";
+import type { PropertySegment } from "../types.js";
+export type { BinaryOperator, UnaryOperator };
+export interface FunctionCallExpressionNode<_TValue = unknown, TOperator extends string = string> {
+    readonly kind: "fn-call";
+    readonly operator: TOperator;
+    readonly args: readonly unknown[];
+}
+export interface SymbolicValueExpressionNode<_TValue = unknown, TPath extends string = string> {
+    readonly kind: "symbolic-value";
+    readonly path: TPath;
+}
+export interface IdentifierExpressionNode<_TValue = unknown> {
+    readonly kind: "identifier";
+    readonly id: string | Resource;
+}
+export interface PropertyAccessExpressionNode<_TValue = unknown> {
+    readonly kind: "property-access";
+    readonly base: ExpressionNode;
+    readonly property: string;
+    readonly nullish: boolean;
+    /**
+     * Optional ARM wire-path segments. When present, the serialization
+     * lowering pass rewrites this single access into a chain that walks
+     * these segments (handling renames + `@flattenProperty` hoisting).
+     * Untyped / hand-built expressions leave this `undefined` and pass
+     * through unchanged.
+     */
+    readonly armPath?: readonly string[] | undefined;
+}
+export interface ArrayAccessExpressionNode<_TValue = unknown> {
+    readonly kind: "array-access";
+    readonly base: ExpressionNode;
+    /**
+     * The index into the array. A literal `number`/`string` lowers to an
+     * integer/string array-access (or a property-access for identifier-like
+     * strings) at serialize time. Any {@link ExpressionNode} is serialized
+     * recursively into the wire array-access's `index` slot — e.g. a looped
+     * `.at(loop.index)` stores the unwrapped `symbolic-value` node (emitting
+     * `sym[i]`), and a computed offset stores a `binary` / `fn-call` node
+     * (`sym[i + 1]`). `Expression<T>` proxies are always unwrapped to their
+     * raw node before landing here, per the "state holds normalized raw
+     * nodes" invariant — so a proxy is never stored directly.
+     */
+    readonly index: ArrayAccessIndex;
+    readonly nullish: boolean;
+    readonly fromEnd: boolean;
+}
+export interface BinaryExpressionNode<_TValue = unknown> {
+    readonly kind: "binary";
+    readonly operator: BinaryOperator;
+    readonly left: unknown;
+    readonly right: unknown;
+}
+export interface UnaryExpressionNode<_TValue = unknown> {
+    readonly kind: "unary";
+    readonly operator: UnaryOperator;
+    readonly argument: unknown;
+}
+export interface TernaryExpressionNode<_TValue = unknown> {
+    readonly kind: "ternary";
+    readonly condition: unknown;
+    readonly trueValue: unknown;
+    readonly falseValue: unknown;
+}
+export interface InstanceFunctionCallExpressionNode<_TValue = unknown> {
+    readonly kind: "instance-function-call";
+    readonly base: ExpressionNode;
+    readonly name: string;
+    readonly args: readonly unknown[];
+}
+export interface InterpolatedStringExpressionNode<_TValue = unknown> {
+    readonly kind: "interpolated-string";
+    readonly segments: readonly unknown[];
+}
+export type ExpressionNode<T = unknown> = FunctionCallExpressionNode<T> | SymbolicValueExpressionNode<T> | IdentifierExpressionNode<T> | PropertyAccessExpressionNode<T> | ArrayAccessExpressionNode<T> | BinaryExpressionNode<T> | UnaryExpressionNode<T> | TernaryExpressionNode<T> | InstanceFunctionCallExpressionNode<T> | InterpolatedStringExpressionNode<T>;
+/**
+ * The index stored on an {@link ArrayAccessExpressionNode}: a literal
+ * `number` or `string`, or a raw {@link ExpressionNode} evaluated at
+ * serialize time (e.g. a loop's `symbolic-value` index, or a `binary` /
+ * `fn-call` node for a computed offset). `Expression<T>` proxies are
+ * unwrapped to their raw node before being stored, so the proxy type is
+ * intentionally absent here.
+ */
+export type ArrayAccessIndex = number | string | ExpressionNode;
+/** Tests whether a value structurally matches a raw expression AST node. */
+export declare function isExpressionNode(value: unknown): value is ExpressionNode;
+export declare function functionCallExpressionNode<TValue = unknown, TOperator extends string = string>(operator: TOperator, args: readonly unknown[]): FunctionCallExpressionNode<TValue, TOperator>;
+export declare function symbolicValueExpressionNode<TValue = unknown, TPath extends string = string>(path: TPath): SymbolicValueExpressionNode<TValue, TPath>;
+export declare function identifierExpressionNode<TValue = unknown>(identifier: string | Resource): IdentifierExpressionNode<TValue>;
+export declare function propertyAccessExpressionNode<TValue = unknown>(base: ExpressionNode, property: string, options?: Partial<Pick<PropertyAccessExpressionNode, "armPath" | "nullish">>): PropertyAccessExpressionNode<TValue>;
+export declare function arrayAccessExpressionNode<TValue = unknown>(base: ExpressionNode, index: ArrayAccessIndex, options?: Partial<Pick<ArrayAccessExpressionNode, "nullish" | "fromEnd">>): ArrayAccessExpressionNode<TValue>;
+export declare function binaryExpressionNode<TValue = unknown>(operator: BinaryOperator, left: unknown, right: unknown): BinaryExpressionNode<TValue>;
+export declare function unaryExpressionNode<TValue = unknown>(operator: UnaryOperator, argument: unknown): UnaryExpressionNode<TValue>;
+export declare function ternaryExpressionNode<TValue = unknown>(condition: unknown, trueValue: unknown, falseValue: unknown): TernaryExpressionNode<TValue>;
+export declare function instanceFunctionCallExpressionNode<TValue = unknown>(base: ExpressionNode, name: string, args: readonly unknown[]): InstanceFunctionCallExpressionNode<TValue>;
+export declare function interpolatedStringExpressionNode<TValue = unknown>(segments: readonly unknown[]): InterpolatedStringExpressionNode<TValue>;
+export declare function accessExpressionNode(base: ExpressionNode, member: PropertySegment, options?: Partial<Pick<PropertyAccessExpressionNode, "armPath" | "nullish">>): PropertyAccessExpressionNode | ArrayAccessExpressionNode;
+//# sourceMappingURL=ast-nodes.d.ts.map

package/dist/commonjs/expression/ast-nodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-nodes.d.ts","sourceRoot":"","sources":["../../../src/expression/ast-nodes.ts"],"names":[],"mappings":"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"}