@azure/provisioning-core 1.0.0-beta.1

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

@@ -0,0 +1,77 @@
+import type { PrimitiveTypeMap } from "../serialization/contract/index.js";
+import type { Expression, ExpressionOrValue } from "../expression/expressions.js";
+import type { Stack } from "./stack.js";
+export type InferParamType<T extends keyof PrimitiveTypeMap, A> = A extends readonly (infer E)[] ? E : PrimitiveTypeMap[T];
+/**
+ * A value accepted as a parameter's `defaultValue`: a literal of the declared
+ * type or an `Expression` of it. Resource views are intentionally excluded —
+ * a Bicep `param` default cannot reference resources.
+ */
+export type ParameterValue<T extends keyof PrimitiveTypeMap = keyof PrimitiveTypeMap> = ExpressionOrValue<PrimitiveTypeMap[T]>;
+export type ParameterOptions<T extends keyof PrimitiveTypeMap = keyof PrimitiveTypeMap, A extends readonly PrimitiveTypeMap[T][] | undefined = undefined> = {
+    readonly defaultValue?: ExpressionOrValue<InferParamType<T, A>> | undefined;
+    readonly description?: string | undefined;
+    readonly secure?: boolean | undefined;
+    readonly minValue?: number | undefined;
+    readonly maxValue?: number | undefined;
+    readonly minLength?: number | undefined;
+    readonly maxLength?: number | undefined;
+    readonly metadata?: Record<string, unknown> | undefined;
+    readonly allowed?: A;
+    readonly discriminator?: string | undefined;
+    readonly sealed?: boolean | undefined;
+};
+/**
+ * Pure declaration data for a deployment parameter. Stored on the stack
+ * (paired with the returned expression handle in {@link ParameterEntry});
+ * read by the serializer at emit time. Not part of the value-level handle.
+ */
+export interface ParameterMetadata extends ParameterOptions<keyof PrimitiveTypeMap, readonly PrimitiveTypeMap[keyof PrimitiveTypeMap][] | undefined> {
+    readonly name: string;
+    readonly type: keyof PrimitiveTypeMap;
+}
+export type Parameter<T extends keyof PrimitiveTypeMap = keyof PrimitiveTypeMap, A extends readonly PrimitiveTypeMap[T][] | undefined = undefined> = Expression<InferParamType<T, A>>;
+/**
+ * Authoring-time collection of a stack's deployment parameters. Backed by an
+ * ordered private array; supports add/get/delete/iteration. Look parameters up
+ * by name via {@link ParameterCollection.get}.
+ */
+export declare class ParameterCollection {
+    #private;
+    /** Add a parameter; returns its expression handle. Throws on duplicate name. */
+    add<T extends keyof PrimitiveTypeMap = keyof PrimitiveTypeMap, const A extends readonly PrimitiveTypeMap[T][] | undefined = undefined>(name: string, type: T, options?: ParameterOptions<T, A>): Parameter<T, A>;
+    /** The expression handle for a parameter, or `undefined`. */
+    get(name: string): Parameter | undefined;
+    /** The declaration metadata for a parameter, or `undefined`. */
+    getMetadata(name: string): ParameterMetadata | undefined;
+    /** All parameter handles, in insertion order. */
+    list(): readonly Parameter[];
+    /** All declaration metadata, in insertion order. */
+    listMetadata(): readonly ParameterMetadata[];
+    has(name: string): boolean;
+    /** Remove a parameter by name. Returns whether one was removed. */
+    delete(name: string): boolean;
+    get size(): number;
+    [Symbol.iterator](): IterableIterator<Parameter>;
+}
+/**
+ * A deploy-time input to a stack, compiled to a Bicep `param` declaration.
+ *
+ * @remarks
+ * The returned value is an `Expression` that can be passed to resource
+ * properties. At deploy time, the user supplies the actual value. The
+ * declaration metadata is stored separately on the stack, keyed by name.
+ *
+ * @example
+ * ```typescript snippet:ignore
+ * import { Stack, createParameter } from "@azure/provisioning-core";
+ *
+ * const stack = new Stack("my-app", { targetScope: "resourceGroup" });
+ * const env = createParameter(stack, "env", "string", {
+ *   allowed: ["dev", "staging", "prod"] as const,
+ *   defaultValue: "dev",
+ * });
+ * ```
+ */
+export declare function createParameter<T extends keyof PrimitiveTypeMap = keyof PrimitiveTypeMap, const A extends readonly PrimitiveTypeMap[T][] | undefined = undefined>(stack: Stack, name: string, type: T, options?: ParameterOptions<T, A>): Parameter<T, A>;
+//# sourceMappingURL=parameter.d.ts.map

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

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

package/dist/commonjs/constructs/parameter.js

@@ -0,0 +1,95 @@
+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 parameter_exports = {};
+__export(parameter_exports, {
+  ParameterCollection: () => ParameterCollection,
+  createParameter: () => createParameter
+});
+module.exports = __toCommonJS(parameter_exports);
+var import_expressions = require("../expression/expressions.js");
+var import_expressions2 = require("../expression/expressions.js");
+var import_ast_nodes = require("../expression/ast-nodes.js");
+var import_util = require("../util.js");
+class ParameterCollection {
+  #entries = [];
+  /** Add a parameter; returns its expression handle. Throws on duplicate name. */
+  add(name, type, options) {
+    (0, import_util.assertBicepIdentifier)(name, "Deployment parameter");
+    if (this.has(name)) {
+      throw new Error(`Duplicate deployment parameter name: ${name}`);
+    }
+    (0, import_util.assertValueAssignableToType)(options?.defaultValue, type, `Deployment parameter "${name}"`);
+    if (options?.defaultValue !== void 0 && !(0, import_expressions2.isExpression)(options.defaultValue) && options.allowed !== void 0 && !options.allowed.includes(options.defaultValue)) {
+      throw new Error(
+        `Deployment parameter "${name}" default value must be one of its allowed values.`
+      );
+    }
+    const param = (0, import_expressions.wrapExpression)(
+      (0, import_ast_nodes.symbolicValueExpressionNode)(name)
+    );
+    this.#entries.push({
+      metadata: { name, type, ...options },
+      parameter: param
+    });
+    return param;
+  }
+  /** The expression handle for a parameter, or `undefined`. */
+  get(name) {
+    return this.#find(name)?.parameter;
+  }
+  /** The declaration metadata for a parameter, or `undefined`. */
+  getMetadata(name) {
+    return this.#find(name)?.metadata;
+  }
+  /** All parameter handles, in insertion order. */
+  list() {
+    return this.#entries.map((e) => e.parameter);
+  }
+  /** All declaration metadata, in insertion order. */
+  listMetadata() {
+    return this.#entries.map((e) => e.metadata);
+  }
+  has(name) {
+    return this.#find(name) !== void 0;
+  }
+  /** Remove a parameter 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.parameter)[Symbol.iterator]();
+  }
+  #find(name) {
+    return this.#entries.find((e) => e.metadata.name === name);
+  }
+}
+function createParameter(stack, name, type, options) {
+  return stack.parameters.add(name, type, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ParameterCollection,
+  createParameter
+});
+//# sourceMappingURL=parameter.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/constructs/parameter.ts"],
+  "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { PrimitiveTypeMap } from \"../serialization/contract/index.js\";\nimport type { Expression, ExpressionOrValue } from \"../expression/expressions.js\";\nimport { wrapExpression } from \"../expression/expressions.js\";\nimport { isExpression } from \"../expression/expressions.js\";\nimport { symbolicValueExpressionNode } from \"../expression/ast-nodes.js\";\nimport type { Stack } from \"./stack.js\";\nimport { assertBicepIdentifier, assertValueAssignableToType } from \"../util.js\";\n\nexport type InferParamType<T extends keyof PrimitiveTypeMap, A> = A extends readonly (infer E)[]\n  ? E\n  : PrimitiveTypeMap[T];\n\n/**\n * A value accepted as a parameter's `defaultValue`: a literal of the declared\n * type or an `Expression` of it. Resource views are intentionally excluded \u2014\n * a Bicep `param` default cannot reference resources.\n */\nexport type ParameterValue<T extends keyof PrimitiveTypeMap = keyof PrimitiveTypeMap> =\n  ExpressionOrValue<PrimitiveTypeMap[T]>;\n\nexport type ParameterOptions<\n  T extends keyof PrimitiveTypeMap = keyof PrimitiveTypeMap,\n  A extends readonly PrimitiveTypeMap[T][] | undefined = undefined,\n> = {\n  readonly defaultValue?: ExpressionOrValue<InferParamType<T, A>> | undefined;\n  readonly description?: string | undefined;\n  readonly secure?: boolean | undefined;\n  readonly minValue?: number | undefined;\n  readonly maxValue?: number | undefined;\n  readonly minLength?: number | undefined;\n  readonly maxLength?: number | undefined;\n  readonly metadata?: Record<string, unknown> | undefined;\n  readonly allowed?: A;\n  readonly discriminator?: string | undefined;\n  readonly sealed?: boolean | undefined;\n};\n\n/**\n * Pure declaration data for a deployment parameter. Stored on the stack\n * (paired with the returned expression handle in {@link ParameterEntry});\n * read by the serializer at emit time. Not part of the value-level handle.\n */\nexport interface ParameterMetadata extends ParameterOptions<\n  keyof PrimitiveTypeMap,\n  readonly PrimitiveTypeMap[keyof PrimitiveTypeMap][] | undefined\n> {\n  readonly name: string;\n  readonly type: keyof PrimitiveTypeMap;\n}\n\n/**\n * A stack entry pairing a parameter's declaration metadata with the\n * expression handle returned to the user. Internal; metadata is exposed via\n * {@link ParameterCollection.getMetadata} / {@link ParameterCollection.listMetadata}.\n */\ninterface ParameterEntry {\n  readonly metadata: ParameterMetadata;\n  readonly parameter: Expression<unknown>;\n}\n\nexport type Parameter<\n  T extends keyof PrimitiveTypeMap = keyof PrimitiveTypeMap,\n  A extends readonly PrimitiveTypeMap[T][] | undefined = undefined,\n> = Expression<InferParamType<T, A>>;\n\n/**\n * Authoring-time collection of a stack's deployment parameters. Backed by an\n * ordered private array; supports add/get/delete/iteration. Look parameters up\n * by name via {@link ParameterCollection.get}.\n */\nexport class ParameterCollection {\n  #entries: ParameterEntry[] = [];\n\n  /** Add a parameter; returns its expression handle. Throws on duplicate name. */\n  add<\n    T extends keyof PrimitiveTypeMap = keyof PrimitiveTypeMap,\n    const A extends readonly PrimitiveTypeMap[T][] | undefined = undefined,\n  >(name: string, type: T, options?: ParameterOptions<T, A>): Parameter<T, A> {\n    assertBicepIdentifier(name, \"Deployment parameter\");\n    if (this.has(name)) {\n      throw new Error(`Duplicate deployment parameter name: ${name}`);\n    }\n    assertValueAssignableToType(options?.defaultValue, type, `Deployment parameter \"${name}\"`);\n    if (\n      options?.defaultValue !== undefined &&\n      !isExpression(options.defaultValue) &&\n      options.allowed !== undefined &&\n      !options.allowed.includes(options.defaultValue as PrimitiveTypeMap[T])\n    ) {\n      throw new Error(\n        `Deployment parameter \"${name}\" default value must be one of its allowed values.`,\n      );\n    }\n    const param = wrapExpression<InferParamType<T, A>>(\n      symbolicValueExpressionNode<InferParamType<T, A>, string>(name),\n    );\n    this.#entries.push({\n      metadata: { name, type, ...options },\n      parameter: param,\n    });\n    return param;\n  }\n\n  /** The expression handle for a parameter, or `undefined`. */\n  get(name: string): Parameter | undefined {\n    return this.#find(name)?.parameter;\n  }\n\n  /** The declaration metadata for a parameter, or `undefined`. */\n  getMetadata(name: string): ParameterMetadata | undefined {\n    return this.#find(name)?.metadata;\n  }\n\n  /** All parameter handles, in insertion order. */\n  list(): readonly Parameter[] {\n    return this.#entries.map((e) => e.parameter);\n  }\n\n  /** All declaration metadata, in insertion order. */\n  listMetadata(): readonly ParameterMetadata[] {\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 parameter 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<Parameter> {\n    return this.#entries.map((e) => e.parameter)[Symbol.iterator]();\n  }\n\n  #find(name: string): ParameterEntry | undefined {\n    return this.#entries.find((e) => e.metadata.name === name);\n  }\n}\n\n/**\n * A deploy-time input to a stack, compiled to a Bicep `param` declaration.\n *\n * @remarks\n * The returned value is an `Expression` that can be passed to resource\n * properties. At deploy time, the user supplies the actual value. The\n * declaration metadata is stored separately on the stack, keyed by name.\n *\n * @example\n * ```typescript snippet:ignore\n * import { Stack, createParameter } from \"@azure/provisioning-core\";\n *\n * const stack = new Stack(\"my-app\", { targetScope: \"resourceGroup\" });\n * const env = createParameter(stack, \"env\", \"string\", {\n *   allowed: [\"dev\", \"staging\", \"prod\"] as const,\n *   defaultValue: \"dev\",\n * });\n * ```\n */\nexport function createParameter<\n  T extends keyof PrimitiveTypeMap = keyof PrimitiveTypeMap,\n  const A extends readonly PrimitiveTypeMap[T][] | undefined = undefined,\n>(stack: Stack, name: string, type: T, options?: ParameterOptions<T, A>): Parameter<T, A> {\n  return stack.parameters.add(name, type, options);\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,yBAA+B;AAC/B,IAAAA,sBAA6B;AAC7B,uBAA4C;AAE5C,kBAAmE;AAgE5D,MAAM,oBAAoB;AAAA,EAC/B,WAA6B,CAAC;AAAA;AAAA,EAG9B,IAGE,MAAc,MAAS,SAAmD;AAC1E,2CAAsB,MAAM,sBAAsB;AAClD,QAAI,KAAK,IAAI,IAAI,GAAG;AAClB,YAAM,IAAI,MAAM,wCAAwC,IAAI,EAAE;AAAA,IAChE;AACA,iDAA4B,SAAS,cAAc,MAAM,yBAAyB,IAAI,GAAG;AACzF,QACE,SAAS,iBAAiB,UAC1B,KAAC,kCAAa,QAAQ,YAAY,KAClC,QAAQ,YAAY,UACpB,CAAC,QAAQ,QAAQ,SAAS,QAAQ,YAAmC,GACrE;AACA,YAAM,IAAI;AAAA,QACR,yBAAyB,IAAI;AAAA,MAC/B;AAAA,IACF;AACA,UAAM,YAAQ;AAAA,UACZ,8CAA0D,IAAI;AAAA,IAChE;AACA,SAAK,SAAS,KAAK;AAAA,MACjB,UAAU,EAAE,MAAM,MAAM,GAAG,QAAQ;AAAA,MACnC,WAAW;AAAA,IACb,CAAC;AACD,WAAO;AAAA,EACT;AAAA;AAAA,EAGA,IAAI,MAAqC;AACvC,WAAO,KAAK,MAAM,IAAI,GAAG;AAAA,EAC3B;AAAA;AAAA,EAGA,YAAY,MAA6C;AACvD,WAAO,KAAK,MAAM,IAAI,GAAG;AAAA,EAC3B;AAAA;AAAA,EAGA,OAA6B;AAC3B,WAAO,KAAK,SAAS,IAAI,CAAC,MAAM,EAAE,SAAS;AAAA,EAC7C;AAAA;AAAA,EAGA,eAA6C;AAC3C,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,IAAiC;AAC/C,WAAO,KAAK,SAAS,IAAI,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,QAAQ,EAAE;AAAA,EAChE;AAAA,EAEA,MAAM,MAA0C;AAC9C,WAAO,KAAK,SAAS,KAAK,CAAC,MAAM,EAAE,SAAS,SAAS,IAAI;AAAA,EAC3D;AACF;AAqBO,SAAS,gBAGd,OAAc,MAAc,MAAS,SAAmD;AACxF,SAAO,MAAM,WAAW,IAAI,MAAM,MAAM,OAAO;AACjD;",
+  "names": ["import_expressions"]
+}

package/dist/commonjs/constructs/provisioning-component.d.ts

@@ -0,0 +1,91 @@
+import type { DeploymentContext } from "../deployment-context/deployment-context.js";
+export type ProvisioningComponentConstructor<TComponent extends ProvisioningComponent = ProvisioningComponent> = abstract new (...args: any[]) => TComponent;
+/**
+ * Base class for all tree nodes in the library object model.
+ *
+ * @remarks
+ * Both `Stack` and `Resource` extend `ProvisioningComponent`. It provides parent-child
+ * tree tracking and deployment context lookup — walking up the tree to find
+ * the nearest context set by a `Stack` or `ResourceGroup`.
+ *
+ * Subclass `ProvisioningComponent` directly to create reusable groupings of resources
+ * that don't correspond to an ARM resource. For ARM resources, extend
+ * `Resource` instead.
+ *
+ * @example
+ * ```typescript snippet:ignore
+ * import { ProvisioningComponent } from "@azure/provisioning-core";
+ * import { KeyVault, Secret } from "@azure/provisioning-keyvault";
+ *
+ * class DataTier extends ProvisioningComponent {
+ *   readonly vault: KeyVault;
+ *   readonly secret: Secret;
+ *
+ *   constructor(parent: ProvisioningComponent, tenantId: string, secretValue: string) {
+ *     super(parent);
+ *     this.vault = new KeyVault(this, {
+ *       name: "kv-my-app",
+ *       location: "eastus",
+ *       properties: { tenantId, sku: { family: "A", name: "standard" } },
+ *     });
+ *     this.secret = new Secret(this.vault, {
+ *       name: "database-password",
+ *       properties: { value: secretValue },
+ *     });
+ *   }
+ * }
+ * ```
+ */
+export declare class ProvisioningComponent {
+    readonly parent: ProvisioningComponent | undefined;
+    readonly children: ProvisioningComponent[];
+    /**
+     * The contribution this node makes to the inherited deployment context.
+     * Resolved field-by-field by walking ancestors in `deploymentContext`.
+     */
+    protected _localDeploymentContext: DeploymentContext | undefined;
+    constructor(parent?: ProvisioningComponent);
+    /**
+     * The effective deployment context **inherited from ancestors**, resolved
+     * by walking up the parent chain (this node's own local contribution is
+     * intentionally excluded — a node's contribution flows to its descendants,
+     * not to itself). Each field is resolved per its own rule:
+     *
+     * - `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.
+     *
+     * Returns an object whose fields may all be `undefined` if no ancestor
+     * contributed anything.
+     */
+    get deploymentContext(): DeploymentContext;
+    /**
+     * Returns `true` if any ancestor has attached a local deployment context
+     * contribution. Used by `Resource` to enforce that resources sit inside
+     * a `Stack` tree. (This node's own contribution is intentionally not
+     * considered — a node inherits context from ancestors, not from itself.)
+     */
+    protected hasDeploymentContext(): boolean;
+    /**
+     * Public identity for this node.
+     *
+     * @remarks
+     * Plain components return themselves. Resources override this to return
+     * their proxy-backed handle so APIs can get the right instance to use to
+     * reference to the resource and so on.
+     */
+    get self(): this;
+    /**
+     * Applies a callback to every descendant component/resource that matches the
+     * given constructor, including `this` when it matches.
+     */
+    transform(callback: (component: ProvisioningComponent) => void): this;
+    transform<TComponent extends ProvisioningComponent>(ctor: ProvisioningComponentConstructor<TComponent>, callback: (component: TComponent) => void): this;
+    /**
+     * Depth-first visit of this node and all descendants.
+     * Return `false` from the callback to skip visiting that node's children.
+     */
+    visit(callback: (component: ProvisioningComponent) => boolean | void): void;
+    isChildOf(component: ProvisioningComponent): boolean;
+}
+//# sourceMappingURL=provisioning-component.d.ts.map

package/dist/commonjs/constructs/provisioning-component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provisioning-component.d.ts","sourceRoot":"","sources":["../../../src/constructs/provisioning-component.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6CAA6C,CAAC;AAGrF,MAAM,MAAM,gCAAgC,CAC1C,UAAU,SAAS,qBAAqB,GAAG,qBAAqB,IAC9D,QAAQ,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,UAAU,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,qBAAa,qBAAqB;IAChC,QAAQ,CAAC,MAAM,EAAE,qBAAqB,GAAG,SAAS,CAAC;IACnD,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,EAAE,CAAM;IAChD;;;OAGG;IACH,SAAS,CAAC,uBAAuB,EAAE,iBAAiB,GAAG,SAAS,CAAC;gBAErD,MAAM,CAAC,EAAE,qBAAqB;IAK1C;;;;;;;;;;;;OAYG;IACH,IAAI,iBAAiB,IAAI,iBAAiB,CAgCzC;IAED;;;;;OAKG;IACH,SAAS,CAAC,oBAAoB,IAAI,OAAO;IAWzC;;;;;;;OAOG;IACH,IAAI,IAAI,IAAI,IAAI,CAEf;IAED;;;OAGG;IACH,SAAS,CAAC,QAAQ,EAAE,CAAC,SAAS,EAAE,qBAAqB,KAAK,IAAI,GAAG,IAAI;IACrE,SAAS,CAAC,UAAU,SAAS,qBAAqB,EAChD,IAAI,EAAE,gCAAgC,CAAC,UAAU,CAAC,EAClD,QAAQ,EAAE,CAAC,SAAS,EAAE,UAAU,KAAK,IAAI,GACxC,IAAI;IAqBP;;;OAGG;IACH,KAAK,CAAC,QAAQ,EAAE,CAAC,SAAS,EAAE,qBAAqB,KAAK,OAAO,GAAG,IAAI,GAAG,IAAI;IAO3E,SAAS,CAAC,SAAS,EAAE,qBAAqB,GAAG,OAAO;CAQrD"}

package/dist/commonjs/constructs/provisioning-component.js

@@ -0,0 +1,130 @@
+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 provisioning_component_exports = {};
+__export(provisioning_component_exports, {
+  ProvisioningComponent: () => ProvisioningComponent
+});
+module.exports = __toCommonJS(provisioning_component_exports);
+class ProvisioningComponent {
+  parent;
+  children = [];
+  /**
+   * The contribution this node makes to the inherited deployment context.
+   * Resolved field-by-field by walking ancestors in `deploymentContext`.
+   */
+  _localDeploymentContext;
+  constructor(parent) {
+    this.parent = parent;
+    parent?.children.push(this);
+  }
+  /**
+   * The effective deployment context **inherited from ancestors**, resolved
+   * by walking up the parent chain (this node's own local contribution is
+   * intentionally excluded — a node's contribution flows to its descendants,
+   * not to itself). Each field is resolved per its own rule:
+   *
+   * - `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.
+   *
+   * Returns an object whose fields may all be `undefined` if no ancestor
+   * contributed anything.
+   */
+  get deploymentContext() {
+    let location;
+    let namingPolicy;
+    let locationSet = false;
+    let namingSet = false;
+    const tagFrames = [];
+    for (let current = this.parent; current; current = current.parent) {
+      const local = current._localDeploymentContext;
+      if (local === void 0) continue;
+      if (!locationSet && local.location !== void 0) {
+        location = local.location;
+        locationSet = true;
+      }
+      if (!namingSet && local.namingPolicy !== void 0) {
+        namingPolicy = local.namingPolicy;
+        namingSet = true;
+      }
+      if (local.tags !== void 0) tagFrames.push(local.tags);
+    }
+    let tags;
+    for (let i = tagFrames.length - 1; i >= 0; i--) {
+      tags = { ...tags, ...tagFrames[i] };
+    }
+    return { location, tags, namingPolicy };
+  }
+  /**
+   * Returns `true` if any ancestor has attached a local deployment context
+   * contribution. Used by `Resource` to enforce that resources sit inside
+   * a `Stack` tree. (This node's own contribution is intentionally not
+   * considered — a node inherits context from ancestors, not from itself.)
+   */
+  hasDeploymentContext() {
+    for (let current = this.parent; current; current = current.parent) {
+      if (current._localDeploymentContext !== void 0) return true;
+    }
+    return false;
+  }
+  /**
+   * Public identity for this node.
+   *
+   * @remarks
+   * Plain components return themselves. Resources override this to return
+   * their proxy-backed handle so APIs can get the right instance to use to
+   * reference to the resource and so on.
+   */
+  get self() {
+    return this;
+  }
+  transform(ctorOrCallback, callback) {
+    const ctor = callback ? ctorOrCallback : void 0;
+    const cb = callback ?? ctorOrCallback;
+    this.visit((component) => {
+      const target = component.self;
+      if (!ctor || target instanceof ctor) {
+        cb(target);
+      }
+    });
+    return this;
+  }
+  /**
+   * Depth-first visit of this node and all descendants.
+   * Return `false` from the callback to skip visiting that node's children.
+   */
+  visit(callback) {
+    if (callback(this) === false) return;
+    for (const child of this.children) {
+      child.visit(callback);
+    }
+  }
+  isChildOf(component) {
+    let current = this.parent;
+    while (current) {
+      if (current === component) return true;
+      current = current.parent;
+    }
+    return false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ProvisioningComponent
+});
+//# sourceMappingURL=provisioning-component.js.map

package/dist/commonjs/constructs/provisioning-component.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/constructs/provisioning-component.ts"],
+  "sourcesContent": ["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { DeploymentContext } from \"../deployment-context/deployment-context.js\";\nimport type { ExpressionOrValue } from \"../expression/expressions.js\";\n\nexport type ProvisioningComponentConstructor<\n  TComponent extends ProvisioningComponent = ProvisioningComponent,\n> = abstract new (...args: any[]) => TComponent;\n\n/**\n * Base class for all tree nodes in the library object model.\n *\n * @remarks\n * Both `Stack` and `Resource` extend `ProvisioningComponent`. It provides parent-child\n * tree tracking and deployment context lookup \u2014 walking up the tree to find\n * the nearest context set by a `Stack` or `ResourceGroup`.\n *\n * Subclass `ProvisioningComponent` directly to create reusable groupings of resources\n * that don't correspond to an ARM resource. For ARM resources, extend\n * `Resource` instead.\n *\n * @example\n * ```typescript snippet:ignore\n * import { ProvisioningComponent } from \"@azure/provisioning-core\";\n * import { KeyVault, Secret } from \"@azure/provisioning-keyvault\";\n *\n * class DataTier extends ProvisioningComponent {\n *   readonly vault: KeyVault;\n *   readonly secret: Secret;\n *\n *   constructor(parent: ProvisioningComponent, tenantId: string, secretValue: string) {\n *     super(parent);\n *     this.vault = new KeyVault(this, {\n *       name: \"kv-my-app\",\n *       location: \"eastus\",\n *       properties: { tenantId, sku: { family: \"A\", name: \"standard\" } },\n *     });\n *     this.secret = new Secret(this.vault, {\n *       name: \"database-password\",\n *       properties: { value: secretValue },\n *     });\n *   }\n * }\n * ```\n */\nexport class ProvisioningComponent {\n  readonly parent: ProvisioningComponent | undefined;\n  readonly children: ProvisioningComponent[] = [];\n  /**\n   * The contribution this node makes to the inherited deployment context.\n   * Resolved field-by-field by walking ancestors in `deploymentContext`.\n   */\n  protected _localDeploymentContext: DeploymentContext | undefined;\n\n  constructor(parent?: ProvisioningComponent) {\n    this.parent = parent;\n    parent?.children.push(this);\n  }\n\n  /**\n   * The effective deployment context **inherited from ancestors**, resolved\n   * by walking up the parent chain (this node's own local contribution is\n   * intentionally excluded \u2014 a node's contribution flows to its descendants,\n   * not to itself). Each field is resolved per its own rule:\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   * Returns an object whose fields may all be `undefined` if no ancestor\n   * contributed anything.\n   */\n  get deploymentContext(): DeploymentContext {\n    let location: DeploymentContext[\"location\"];\n    let namingPolicy: DeploymentContext[\"namingPolicy\"];\n    let locationSet = false;\n    let namingSet = false;\n    const tagFrames: Array<Record<string, ExpressionOrValue<string>>> = [];\n\n    for (\n      let current: ProvisioningComponent | undefined = this.parent;\n      current;\n      current = current.parent\n    ) {\n      const local = current._localDeploymentContext;\n      if (local === undefined) continue;\n      if (!locationSet && local.location !== undefined) {\n        location = local.location;\n        locationSet = true;\n      }\n      if (!namingSet && local.namingPolicy !== undefined) {\n        namingPolicy = local.namingPolicy;\n        namingSet = true;\n      }\n      if (local.tags !== undefined) tagFrames.push(local.tags);\n    }\n\n    let tags: DeploymentContext[\"tags\"];\n    // Merge root \u2192 leaf so the nearest ancestor (frame 0) wins on conflict.\n    for (let i = tagFrames.length - 1; i >= 0; i--) {\n      tags = { ...tags, ...tagFrames[i] };\n    }\n\n    return { location, tags, namingPolicy };\n  }\n\n  /**\n   * Returns `true` if any ancestor has attached a local deployment context\n   * contribution. Used by `Resource` to enforce that resources sit inside\n   * a `Stack` tree. (This node's own contribution is intentionally not\n   * considered \u2014 a node inherits context from ancestors, not from itself.)\n   */\n  protected hasDeploymentContext(): boolean {\n    for (\n      let current: ProvisioningComponent | undefined = this.parent;\n      current;\n      current = current.parent\n    ) {\n      if (current._localDeploymentContext !== undefined) return true;\n    }\n    return false;\n  }\n\n  /**\n   * Public identity for this node.\n   *\n   * @remarks\n   * Plain components return themselves. Resources override this to return\n   * their proxy-backed handle so APIs can get the right instance to use to\n   * reference to the resource and so on.\n   */\n  get self(): this {\n    return this;\n  }\n\n  /**\n   * Applies a callback to every descendant component/resource that matches the\n   * given constructor, including `this` when it matches.\n   */\n  transform(callback: (component: ProvisioningComponent) => void): this;\n  transform<TComponent extends ProvisioningComponent>(\n    ctor: ProvisioningComponentConstructor<TComponent>,\n    callback: (component: TComponent) => void,\n  ): this;\n  transform<TComponent extends ProvisioningComponent>(\n    ctorOrCallback:\n      ProvisioningComponentConstructor<TComponent> | ((component: ProvisioningComponent) => void),\n    callback?: (component: TComponent) => void,\n  ): this {\n    const ctor = callback\n      ? (ctorOrCallback as ProvisioningComponentConstructor<TComponent>)\n      : undefined;\n    const cb = (callback ?? ctorOrCallback) as (c: ProvisioningComponent) => void;\n\n    this.visit((component) => {\n      const target = component.self;\n      if (!ctor || target instanceof ctor) {\n        cb(target);\n      }\n    });\n\n    return this;\n  }\n\n  /**\n   * Depth-first visit of this node and all descendants.\n   * Return `false` from the callback to skip visiting that node's children.\n   */\n  visit(callback: (component: ProvisioningComponent) => boolean | void): void {\n    if (callback(this) === false) return;\n    for (const child of this.children) {\n      child.visit(callback);\n    }\n  }\n\n  isChildOf(component: ProvisioningComponent): boolean {\n    let current = this.parent;\n    while (current) {\n      if (current === component) return true;\n      current = current.parent;\n    }\n    return false;\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA8CO,MAAM,sBAAsB;AAAA,EACxB;AAAA,EACA,WAAoC,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA,EAKpC;AAAA,EAEV,YAAY,QAAgC;AAC1C,SAAK,SAAS;AACd,YAAQ,SAAS,KAAK,IAAI;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeA,IAAI,oBAAuC;AACzC,QAAI;AACJ,QAAI;AACJ,QAAI,cAAc;AAClB,QAAI,YAAY;AAChB,UAAM,YAA8D,CAAC;AAErE,aACM,UAA6C,KAAK,QACtD,SACA,UAAU,QAAQ,QAClB;AACA,YAAM,QAAQ,QAAQ;AACtB,UAAI,UAAU,OAAW;AACzB,UAAI,CAAC,eAAe,MAAM,aAAa,QAAW;AAChD,mBAAW,MAAM;AACjB,sBAAc;AAAA,MAChB;AACA,UAAI,CAAC,aAAa,MAAM,iBAAiB,QAAW;AAClD,uBAAe,MAAM;AACrB,oBAAY;AAAA,MACd;AACA,UAAI,MAAM,SAAS,OAAW,WAAU,KAAK,MAAM,IAAI;AAAA,IACzD;AAEA,QAAI;AAEJ,aAAS,IAAI,UAAU,SAAS,GAAG,KAAK,GAAG,KAAK;AAC9C,aAAO,EAAE,GAAG,MAAM,GAAG,UAAU,CAAC,EAAE;AAAA,IACpC;AAEA,WAAO,EAAE,UAAU,MAAM,aAAa;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQU,uBAAgC;AACxC,aACM,UAA6C,KAAK,QACtD,SACA,UAAU,QAAQ,QAClB;AACA,UAAI,QAAQ,4BAA4B,OAAW,QAAO;AAAA,IAC5D;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,IAAI,OAAa;AACf,WAAO;AAAA,EACT;AAAA,EAWA,UACE,gBAEA,UACM;AACN,UAAM,OAAO,WACR,iBACD;AACJ,UAAM,KAAM,YAAY;AAExB,SAAK,MAAM,CAAC,cAAc;AACxB,YAAM,SAAS,UAAU;AACzB,UAAI,CAAC,QAAQ,kBAAkB,MAAM;AACnC,WAAG,MAAM;AAAA,MACX;AAAA,IACF,CAAC;AAED,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,UAAsE;AAC1E,QAAI,SAAS,IAAI,MAAM,MAAO;AAC9B,eAAW,SAAS,KAAK,UAAU;AACjC,YAAM,MAAM,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,UAAU,WAA2C;AACnD,QAAI,UAAU,KAAK;AACnB,WAAO,SAAS;AACd,UAAI,YAAY,UAAW,QAAO;AAClC,gBAAU,QAAQ;AAAA,IACpB;AACA,WAAO;AAAA,EACT;AACF;",
+  "names": []
+}

package/dist/commonjs/constructs/resource/resource-proxy.d.ts

@@ -0,0 +1,134 @@
+import { type Expression, type ExpressionOrValue } from "../../expression/expressions.js";
+import { type ArrayAccessIndex } from "../../expression/ast-nodes.js";
+import type { PropertySegment } from "../../types.js";
+import type { LoopedResource, Resource, ResourceDeclaration } from "./resource.js";
+export declare const RAW_RESOURCE_HANDLE: unique symbol;
+export declare const RESOURCE_BRAND: unique symbol;
+/**
+ * Brand present on every `LoopedResource` instance. Lives here (rather than
+ * on the `LoopedResource` class) so tree-walking utilities can brand-check
+ * for looped declarations without a runtime import of `resource.ts` — which
+ * would create an eval-time import cycle (`resource.ts` extends `ProvisioningComponent`).
+ * Use {@link isLoopedResource} in normal code.
+ */
+export declare const LOOPED_RESOURCE_BRAND: unique symbol;
+/**
+ * Brand present on every `ResourceDeclaration` instance (both scalar
+ * `Resource` and looped `LoopedResource`). Use
+ * {@link isResourceDeclaration} instead of a direct
+ * brand check.
+ */
+export declare const RESOURCE_DECLARATION_BRAND: unique symbol;
+/**
+ * Present on indexed resource proxies (see {@link createIndexedResourceProxy}).
+ * Reading it off any resource-like value returns the stored index expression
+ * for indexed proxies, and `undefined` for plain outer proxies. The base
+ * `Resource` constructor probes for it on the `context` argument to detect
+ * `parents.at(i)` / `parents.current()` being passed as a child parent
+ * context; other consumers may probe it for their own purposes (the proxy
+ * itself doesn't imply any parent-child relationship — the index is simply
+ * what identifies which element of a looped declaration this proxy refers
+ * to).
+ */
+export declare const PROXY_INDEX_REF: unique symbol;
+/**
+ * Present on indexed resource proxies. Reading it returns the underlying
+ * outer-proxy resource that the indexed proxy wraps. Used by the base
+ * `Resource` constructor to normalize `this.parent` back to the raw parent
+ * (so tree walks and symbol-map lookups continue to work) while
+ * `PROXY_INDEX_REF` carries the "which index" information onto `state`.
+ */
+export declare const INDEXED_PROXY_TARGET: unique symbol;
+/**
+ * State-object key under which the base `Resource` constructor records the
+ * index expression when the `context` argument is an indexed proxy (i.e.,
+ * `parent.at(i)` / `parent.current()`). The serializer reads this key
+ * from the child's raw state to emit `parent: parentSym[<index>]` instead
+ * of the bare `parent: parentSym` form. Kept as a shared const so writer
+ * (`resource.ts`) and reader (`serialize.ts`) never drift.
+ *
+ * Lives on the **child**, not the parent: siblings under the same parent
+ * can be created via different indexed proxies (e.g. `new Child(p.at(0), …)`
+ * and `new Child(p.at(1), …)` both resolve `.parent` to the same raw parent,
+ * so the index that distinguishes them must be recorded per-child).
+ */
+export declare const STATE_PARENT_INDEX: "parentIndex";
+/**
+ * The identity a member-proxy needs to lower into a Bicep expression and to
+ * back reads/writes. Bundles the three roles that were previously passed
+ * positionally to {@link createResourceMemberProxy}:
+ *
+ * - `resource` — the tree-registered declaration that supplies BOTH the
+ *   symbol root (`identifierExpressionNode(resource)`) and the ARM shape
+ *   source (`getResourceShape`). For a scalar resource this is the outer
+ *   resource proxy; for an indexed looped element it is the raw
+ *   `LoopedResource` declaration (the tree citizen), NOT the ephemeral
+ *   `.at(i)` handle — that handle isn't in the component tree, so it can't
+ *   resolve to a Bicep symbol.
+ * - `root` — the raw backing object that stores assigned values, used by
+ *   `deref(...)` and nested writes.
+ * - `index` — optional array index. When set, the emitted expression roots
+ *   at `resource[index]` instead of `resource`, so `many.at(i).prop.blob`
+ *   serializes as `sym[i].prop.blob`. Populated for `.at(i)` / `.current()`
+ *   handles by {@link createIndexedResourceProxy}.
+ */
+export interface ResourceProxySource {
+    readonly resource: Resource;
+    readonly root: Record<string, unknown>;
+    readonly index?: ArrayAccessIndex;
+}
+export type Deref<T> = T extends Expression<infer U> ? U : T;
+export declare function deref<T>(value: T): Deref<T>;
+export declare function normalizeAssignedValue(value: unknown, currentResource?: Resource): unknown;
+export declare function createResourceMemberProxy<TValue>(source: ResourceProxySource, path: readonly PropertySegment[]): Expression<TValue> & TValue;
+export declare function createResourceProxy<TType extends string, TResource extends Resource<TType> & object>(resource: TResource): TResource;
+export declare function unwrapResourceHandle<T extends ResourceDeclaration>(resource: T): T;
+/**
+ * Returns a passthrough proxy over `resource` that carries an "index"
+ * expression alongside the wrapped resource. Two purposes:
+ *
+ * 1. **Property reads** — ARM getters on the underlying `Resource` funnel
+ *    through `this.expr(...)`. The indexed proxy intercepts `expr` and
+ *    threads `resourceIndexExpression` into the member proxy so that reads
+ *    render as `sym[index].<path>` on the wire. Direct data-property reads
+ *    like `.type` / `.apiVersion` / `.condition` / `.existing` fall through
+ *    unchanged (they are authoring/type metadata, not ARM reads).
+ *
+ * 2. **Child parent context** — passing `parents.at(0)` as the first
+ *    argument to a child constructor must (a) let the child register into
+ *    the raw parent's tree, and (b) record the index so the serializer can
+ *    emit `parent: parentSym[i]`.
+ *    This proxy passes framework members (`children`, `deploymentContext`,
+ *    `_localDeploymentContext`, `hasDeploymentContext`, `.parent`, `.self`,
+ *    ...) through unchanged so the base `Resource` constructor's
+ *    interaction with `context` works exactly as it would with the raw
+ *    parent. `PROXY_INDEX_REF` and `INDEXED_PROXY_TARGET` expose the
+ *    index and the raw target to the base `Resource` constructor.
+ *
+ * The `index` can be a literal number, a literal string, or any expression
+ * (typically a loop's `.index` symbolic value). It is unwrapped from any
+ * `Expression<T>` proxy at construction time so downstream code stores a
+ * primitive or an `ExpressionNode`, never an `Expression` proxy.
+ *
+ * **The indexed proxy is an ephemeral wrapper, not a tree node.** A fresh
+ * proxy is minted per `.at(i)` call and is not stored in
+ * any `parent.children` array; only the raw outer resource proxy
+ * participates in the ProvisioningComponent tree. When a child is created with an
+ * indexed proxy as `context`, `ProvisioningComponent`'s ctor writes
+ * `this.parent = indexedProxy` briefly, but the base `Resource` ctor then overwrites
+ * `this.parent` back to the raw parent (via `INDEXED_PROXY_TARGET`) so the
+ * tree only ever references raw resource proxies. The indexed wrapper is
+ * garbage-collectable once the child ctor returns; its sole job is to
+ * carry the index through construction into `state.parentIndex`.
+ */
+/**
+ * Static type an indexed proxy exposes, derived from the declaration it
+ * wraps. A `LoopedResource<T>` narrows to `T` — the concrete resource
+ * type — so `parent.at(i)` exposes the full ARM and child-accessor
+ * surface, resolved element-scoped at runtime. Any scalar {@link Resource}
+ * yields itself.
+ */
+type IndexedProxyOf<D extends ResourceDeclaration> = D extends LoopedResource<infer T> ? T : D;
+export declare function createIndexedResourceProxy<D extends ResourceDeclaration>(resource: D, index: ExpressionOrValue<number>): IndexedProxyOf<D>;
+export {};
+//# sourceMappingURL=resource-proxy.d.ts.map

package/dist/commonjs/constructs/resource/resource-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-proxy.d.ts","sourceRoot":"","sources":["../../../../src/constructs/resource/resource-proxy.ts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,UAAU,EACf,KAAK,iBAAiB,EACvB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAKL,KAAK,gBAAgB,EAEtB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAInF,eAAO,MAAM,mBAAmB,eAAgC,CAAC;AACjE,eAAO,MAAM,cAAc,eAAkD,CAAC;AAE9E;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,eAAwD,CAAC;AAE3F;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,eAEtC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,eAAyD,CAAC;AAEtF;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,eAA8D,CAAC;AAEhG;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,EAAG,aAAsB,CAAC;AAkBzD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvC,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC;CACnC;AAqCD,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAE7D,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAW3C;AA+FD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,EAAE,eAAe,CAAC,EAAE,QAAQ,GAAG,OAAO,CA+B1F;AA8KD,wBAAgB,yBAAyB,CAAC,MAAM,EAC9C,MAAM,EAAE,mBAAmB,EAC3B,IAAI,EAAE,SAAS,eAAe,EAAE,GAC/B,UAAU,CAAC,MAAM,CAAC,GAAG,MAAM,CAmB7B;AAgBD,wBAAgB,mBAAmB,CACjC,KAAK,SAAS,MAAM,EACpB,SAAS,SAAS,QAAQ,CAAC,KAAK,CAAC,GAAG,MAAM,EAC1C,QAAQ,EAAE,SAAS,GAAG,SAAS,CAoFhC;AAcD,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,mBAAmB,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC,CAQlF;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH;;;;;;GAMG;AACH,KAAK,cAAc,CAAC,CAAC,SAAS,mBAAmB,IAAI,CAAC,SAAS,cAAc,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAQ/F,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,mBAAmB,EACtE,QAAQ,EAAE,CAAC,EACX,KAAK,EAAE,iBAAiB,CAAC,MAAM,CAAC,GAC/B,cAAc,CAAC,CAAC,CAAC,CAwHnB"}