@cdktn/provider-generator 0.24.0-pre.88 → 0.24.0-pre.89

package/build/get/generator/models/provider-function-model.js

@@ -0,0 +1,667 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProviderFunctionsModel = exports.assertNoFunctionsGetterCollision = void 0;
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+const codemaker_1 = require("codemaker");
+// Parameter names that collide with a reserved word/identifier in one of the
+// jsii target languages. This is the sibling table for provider-defined
+// functions: tools/generate-function-bindings/scripts/generate.ts holds the
+// canonical (and separately maintained) table for built-in `Fn.*` functions.
+// The two are intentionally not shared - that script lives outside the
+// packages/ build and generates a different artifact - but any reserved name
+// added there should be considered here too.
+const RESERVED_PARAMETER_NAMES = {
+    default: "defaultValue", // reserved word in TypeScript
+    string: "str", // causes issues in Go
+};
+function sanitizeParameterName(name) {
+    var _a;
+    const camelCased = (0, codemaker_1.toCamelCase)(name);
+    return (_a = RESERVED_PARAMETER_NAMES[camelCased]) !== null && _a !== void 0 ? _a : camelCased;
+}
+function sanitizeMethodName(name) {
+    if (name === "length")
+        return "lengthOf"; // reserved on jsii-generated classes
+    return (0, codemaker_1.toCamelCase)(name);
+}
+// Members that `ProviderFunctionsEmitter` (see `emitter/provider-functions-emitter.ts`)
+// itself puts on every generated `<Provider>ProviderFunctions` wrapper class,
+// regardless of which functions a provider declares:
+//   - "constructor": the class's own constructor, which takes the provider's
+//     `providerLocalName`. A provider-defined function named "constructor"
+//     would sanitize to a *second* `constructor` member on the class, which
+//     is invalid TypeScript.
+//   - "providerLocalName": the `private readonly providerLocalName: string`
+//     field the constructor assigns (see the emitter's `emitClassHeader`/
+//     constructor emission). A provider-defined function sanitizing to this
+//     name would collide with that field.
+// If `ProviderFunctionsEmitter` ever grows more members on the wrapper class,
+// add them here too.
+const RESERVED_WRAPPER_MEMBER_NAMES = new Set([
+    "constructor",
+    "providerLocalName",
+]);
+/**
+ * The bracket-composable ("T[]", no top-level union) TypeScript/docstring
+ * type for an element that can nest inside an array without ITSELF needing
+ * the whole-collection token union at that level: `string`, `number`, or a
+ * list/set of one of those, recursively (e.g. `list(list(string))` bottoms
+ * out at `string`). Returns `undefined` for anything else (`bool`, `map`,
+ * `object`, `dynamic`, or a nested collection that doesn't itself qualify),
+ * so the caller falls back to widening the whole parameter to
+ * `any[] | cdktn.IResolvable` instead.
+ */
+function plainArrayElementType(type) {
+    if (type === "string")
+        return { tsType: "string", docstringType: "string" };
+    if (type === "number")
+        return { tsType: "number", docstringType: "number" };
+    if (Array.isArray(type) && (type[0] === "list" || type[0] === "set")) {
+        const inner = plainArrayElementType(type[1]);
+        if (!inner)
+            return undefined;
+        return {
+            tsType: `${inner.tsType}[]`,
+            docstringType: `${type[0] === "set" ? "Set" : "Array"}<${inner.docstringType}>`,
+        };
+    }
+    return undefined;
+}
+/**
+ * Maps a `list`/`set` parameter to its jsii-safe shape - mirrors
+ * `ListAttributeTypeModel`/`SetAttributeTypeModel.inputTypeDefinition`
+ * (both identical) branch for branch, since jsii parameters, like resource
+ * inputs, are allowed to union in a whole-collection `cdktn.IResolvable`
+ * token. `kind` only affects the documentation: the docstring notation
+ * (`Array<...>` for a Terraform list, `Set<...>` for a Terraform set,
+ * recursively via `plainArrayElementType`/`mapParameterType`) plus, for
+ * sets, a prose note - the jsii type is an array either way, so the note
+ * keeps a reader from literally passing a JS `Set` and flags the
+ * ordering/duplicate-element semantics difference. The type-level handling
+ * is identical for both.
+ */
+function mapListOrSetParameterType(kind, element) {
+    const wrapper = kind === "set" ? "Set" : "Array";
+    const docstringNote = kind === "set"
+        ? "Terraform set; ordering is not guaranteed and duplicate values are removed."
+        : undefined;
+    if (element === "string") {
+        // Mirrors the final `else` branch: encoded list tokens already satisfy
+        // `string[]`, so no union is needed.
+        return {
+            tsType: "string[]",
+            docstringType: `${wrapper}<string>`,
+            docstringNote,
+            acceptsResolvableAlready: false,
+        };
+    }
+    if (element === "number") {
+        // Same reasoning as `string` above.
+        return {
+            tsType: "number[]",
+            docstringType: `${wrapper}<number>`,
+            docstringNote,
+            acceptsResolvableAlready: false,
+        };
+    }
+    if (element === "bool") {
+        // Mirrors the `elementType.storedClassType === "boolean"` branch: bool
+        // has no lossless per-element token, but the WHOLE collection is still
+        // tokenizable, so the union is on the outside.
+        return {
+            tsType: "Array<boolean | cdktn.IResolvable> | cdktn.IResolvable",
+            docstringType: `${wrapper}<boolean | IResolvable>`,
+            docstringNote,
+            acceptsResolvableAlready: true,
+        };
+    }
+    const plainElement = plainArrayElementType(element);
+    if (plainElement) {
+        // Mirrors the `elementType.typeModelType !== "simple"` branch: a nested
+        // list/set that itself bottoms out at string/number composes into a
+        // proper nested array type (e.g. `list(list(string))` -> `string[][]`),
+        // with the whole-collection token additionally accepted alongside it.
+        return {
+            tsType: `${plainElement.tsType}[] | cdktn.IResolvable`,
+            docstringType: `${wrapper}<${plainElement.docstringType}>`,
+            docstringNote,
+            acceptsResolvableAlready: true,
+        };
+    }
+    // map/object/dynamic element, or a nested collection that doesn't itself
+    // reduce to string/number: no jsii-safe array-of-X type exists - widen
+    // the whole parameter to `any[]`. Unlike a bare `any` parameter, plain
+    // `any[]` does NOT structurally accept a whole-collection
+    // `cdktn.IResolvable` token, so the union is required here (this is
+    // stricter than `MapAttributeTypeModel`/`ListAttributeTypeModel` have to
+    // be, since those only ever fall back to `any[] | cdktn.IResolvable` via
+    // the same "not simple" branch above, which already grants it). Keep the
+    // docstring honest about the real element shape rather than just saying
+    // `any`.
+    const elementDescription = mapParameterType(element).docstringType;
+    return {
+        tsType: "any[] | cdktn.IResolvable",
+        docstringType: `${wrapper}<${elementDescription}>`,
+        docstringNote,
+        acceptsResolvableAlready: true,
+    };
+}
+/**
+ * Maps a `map` parameter to its jsii-safe shape - mirrors
+ * `MapAttributeTypeModel.inputTypeDefinition`. Only the `bool`-element case
+ * is reachable from real provider schemas today (`string`/`number` element
+ * maps stay a plain, non-union record; nested/complex map elements aren't
+ * emitted for provider functions - see the `object` fallback in
+ * `mapParameterType`), but the shape is kept branch-for-branch aligned with
+ * the model it mirrors rather than collapsed.
+ */
+function mapMapParameterType(element) {
+    if (element === "string") {
+        return {
+            tsType: "{ [key: string]: string }",
+            docstringType: "{ [key: string]: string }",
+            acceptsResolvableAlready: false,
+        };
+    }
+    if (element === "number") {
+        return {
+            tsType: "{ [key: string]: number }",
+            docstringType: "{ [key: string]: number }",
+            acceptsResolvableAlready: false,
+        };
+    }
+    if (element === "bool") {
+        // Mirrors the `elementType.storedClassType === "boolean"` branch: map
+        // of booleans has PER-ENTRY token support, but the whole map itself is
+        // not additionally unioned with `cdktn.IResolvable` (unlike the list/set
+        // case) - matching `MapAttributeTypeModel.inputTypeDefinition` exactly.
+        return {
+            tsType: "{ [key: string]: (boolean | cdktn.IResolvable) }",
+            docstringType: "{ [key: string]: (boolean | IResolvable) }",
+            acceptsResolvableAlready: false,
+        };
+    }
+    // map/object/dynamic element: no structural input helper exists here -
+    // stays `any`, which (being `any`) already accepts a whole-map
+    // `cdktn.IResolvable` token too.
+    return {
+        tsType: "any",
+        docstringType: "any",
+        acceptsResolvableAlready: true,
+    };
+}
+/**
+ * Maps a provider function parameter's declared Terraform type to a
+ * jsii-safe TypeScript parameter type, recursively for collection types.
+ *
+ * Unlike return types, jsii allows unions in *parameter* position, so
+ * `bool` is typed `boolean | cdktn.IResolvable` (mirroring
+ * `SimpleAttributeTypeModel.inputTypeDefinition`'s input-side convention) -
+ * this both accepts a real boolean and still accepts a token in place of
+ * one. `dynamic` has no structural typing and stays `any` (which already
+ * accepts anything, including a token); `object` (structural input helpers
+ * are deferred to a follow-up issue) stays `any` too.
+ *
+ * `list`/`set` and `map` delegate to `mapListOrSetParameterType`/
+ * `mapMapParameterType`, which mirror `ListAttributeTypeModel`/
+ * `SetAttributeTypeModel`/`MapAttributeTypeModel.inputTypeDefinition`
+ * branch for branch (see `attribute-type-model.ts`) - the same
+ * whole-collection-token conventions already used for resource inputs.
+ */
+function mapParameterType(type) {
+    if (type === "string") {
+        return {
+            tsType: "string",
+            docstringType: "string",
+            acceptsResolvableAlready: false,
+        };
+    }
+    if (type === "number") {
+        return {
+            tsType: "number",
+            docstringType: "number",
+            acceptsResolvableAlready: false,
+        };
+    }
+    if (type === "bool") {
+        return {
+            tsType: "boolean | cdktn.IResolvable",
+            docstringType: "boolean | IResolvable",
+            acceptsResolvableAlready: true,
+        };
+    }
+    if (type === "dynamic") {
+        return {
+            tsType: "any",
+            docstringType: "any",
+            acceptsResolvableAlready: true,
+        };
+    }
+    if (Array.isArray(type) && (type[0] === "list" || type[0] === "set")) {
+        return mapListOrSetParameterType(type[0], type[1]);
+    }
+    if (Array.isArray(type) && type[0] === "map") {
+        return mapMapParameterType(type[1]);
+    }
+    // object: structural input helpers are deferred to a follow-up issue.
+    return {
+        tsType: "any",
+        docstringType: "object",
+        acceptsResolvableAlready: true,
+    };
+}
+function buildParameterModel(parameter, fallbackName) {
+    var _a;
+    const terraformName = (_a = parameter.name) !== null && _a !== void 0 ? _a : fallbackName;
+    const { tsType, docstringType, docstringNote, acceptsResolvableAlready } = mapParameterType(parameter.type);
+    return {
+        terraformName,
+        name: sanitizeParameterName(terraformName),
+        tsType,
+        docstringType,
+        docstringNote,
+        description: parameter.description,
+        acceptsResolvableAlready,
+    };
+}
+/**
+ * Widens a mapped type's `tsType`/`docstringType` to also accept an
+ * explicit `cdktn.Token.nullValue()` in this position - unless
+ * `acceptsResolvableAlready` says it already does (e.g. a `bool` parameter
+ * is already `boolean | cdktn.IResolvable`, so nullability adds nothing to
+ * the type itself, only to the docstring note appended by the caller).
+ */
+function withNullableResolvableUnion(model) {
+    if (model.acceptsResolvableAlready) {
+        return { tsType: model.tsType, docstringType: model.docstringType };
+    }
+    return {
+        tsType: `${model.tsType} | cdktn.IResolvable`,
+        docstringType: `${model.docstringType} | IResolvable`,
+    };
+}
+/**
+ * Applies `is_nullable` trailing-compatibility rules across a function's
+ * fixed (non-variadic) parameter list. This needs the whole list in view
+ * (see `buildFunctionModel`), since whether a nullable parameter can become
+ * jsii-optional depends on every parameter *after* it too:
+ *
+ * - A nullable parameter where it and every later fixed parameter are also
+ *   nullable becomes jsii-optional (`name?: T`): omitting it in TypeScript
+ *   leaves `undefined` in the invoke args array, which `FunctionCall`
+ *   already renders as the Terraform `null` keyword. It additionally gains
+ *   the `| cdktn.IResolvable` union (see `withNullableResolvableUnion`), so
+ *   a caller who does supply the argument can pass
+ *   `cdktn.Token.nullValue()` for an explicit Terraform `null` without
+ *   omitting the parameter.
+ * - A nullable parameter followed by a required one keeps its position
+ *   (jsii can't express "optional but not trailing"), and instead gains the
+ *   same `| cdktn.IResolvable` union so a caller can still pass an explicit
+ *   `cdktn.Token.nullValue()` (an `IResolvable` resolving to `null` - see
+ *   `Token.nullValue()`/`Token.asAny()`) in that fixed position - keeping
+ *   the parameter's real type rather than giving up all type safety by
+ *   widening it to `any`.
+ *
+ * Both cases document the real mechanism in the docstring note rather than
+ * implying the plain TypeScript `null` literal is accepted: the trailing
+ * case can also just be omitted, the mid-position case can't be omitted at
+ * all (jsii can't express "optional but not trailing").
+ */
+function applyNullability(parameters, models) {
+    const trailingCompatible = new Array(parameters.length).fill(false);
+    let allNullableSoFar = true;
+    for (let i = parameters.length - 1; i >= 0; i--) {
+        allNullableSoFar = allNullableSoFar && parameters[i].is_nullable === true;
+        trailingCompatible[i] = allNullableSoFar;
+    }
+    return models.map((model, index) => {
+        const parameter = parameters[index];
+        if (!parameter.is_nullable)
+            return model;
+        const { tsType, docstringType } = withNullableResolvableUnion(model);
+        const nullabilityNote = trailingCompatible[index]
+            ? "Omit or pass cdktn.Token.nullValue() to render the Terraform null keyword."
+            : "Pass cdktn.Token.nullValue() for an explicit Terraform null.";
+        return {
+            ...model,
+            ...(trailingCompatible[index] ? { optional: true } : {}),
+            tsType,
+            docstringType,
+            docstringNote: [model.docstringNote, nullabilityNote]
+                .filter(Boolean)
+                .join(" "),
+        };
+    });
+}
+/**
+ * Maps a provider function's declared return type to the jsii-safe
+ * TypeScript return type, the `@returns` JSDoc type, and the expression
+ * that unwraps the `TerraformProviderFunction.invoke(...)` `IResolvable`
+ * into it.
+ *
+ * jsii return positions can't use the `T | cdktn.IResolvable` union that
+ * parameters can (see `mapParameterType`), so every shape that can't be
+ * losslessly unwrapped through an `asXxx` Token helper falls back to the
+ * plain `cdktn.IResolvable` produced by `invoke()` itself, unwrapped.
+ * Provider functions frequently return objects (e.g. every function in the
+ * `time` provider), so - unlike built-in `Fn.*` functions - the object case
+ * is a primary path, not an error: it is treated the same as
+ * `dynamic`/a `list`/`set` of anything other than `string`/`number` (no
+ * `asAnyList` Token helper exists), and returned as the RAW `invoke()`
+ * result. `map` returns, unlike those, DO have a full set of typed Token
+ * helpers (`asStringMap`/`asNumberMap`/`asBooleanMap`/`asAnyMap`), so every
+ * `map` shape gets an actual typed record return instead of falling back to
+ * `cdktn.IResolvable`.
+ *
+ * Whenever the declared return type IS `cdktn.IResolvable` (not `any`):
+ * unlike `helpers.ts` `asAny`, this must NOT go through
+ * `cdktn.Token.asString(...)` - `Token.asString()` produces an encoded
+ * string token that `Tokenization.isResolvable()` does not recognize, so
+ * generated struct setters (e.g. an `OutputReference` `internalValue`) treat
+ * it as a plain object with no known keys and the attribute silently
+ * vanishes from synth output. The raw `IResolvable` from `invoke()` IS
+ * recognized by `Tokenization.isResolvable()` and resolves correctly.
+ * Declaring it as `cdktn.IResolvable` instead of `any` also gives callers
+ * real type safety: `any` let a caller write `result.hours` on a token with
+ * no compile-time feedback, silently producing `undefined` at runtime;
+ * `IResolvable` has no such property and forces the caller through
+ * `cdktn.Token`/the provider's struct types instead. `invoke()` already
+ * returns `IResolvable`, so no cast is needed to return it as
+ * `cdktn.IResolvable`.
+ */
+function mapReturnType(returnType) {
+    if (returnType === "string") {
+        return {
+            tsType: "string",
+            docstringType: "string",
+            wrapReturn: (expr) => `cdktn.Token.asString(${expr})`,
+        };
+    }
+    if (returnType === "number") {
+        return {
+            tsType: "number",
+            docstringType: "number",
+            wrapReturn: (expr) => `cdktn.Token.asNumber(${expr})`,
+        };
+    }
+    if (returnType === "bool") {
+        // Booleans can't be represented as tokens (see helpers.ts asBoolean):
+        // return the IResolvable produced by invoke() unwrapped. The docstring
+        // still documents the real conceptual shape.
+        return {
+            tsType: "cdktn.IResolvable",
+            docstringType: "boolean | IResolvable",
+            wrapReturn: (expr) => expr,
+        };
+    }
+    if (returnType === "dynamic") {
+        return {
+            tsType: "cdktn.IResolvable",
+            docstringType: "any",
+            wrapReturn: (expr) => expr,
+        };
+    }
+    if (Array.isArray(returnType) &&
+        (returnType[0] === "list" || returnType[0] === "set")) {
+        // Same documentation conventions as `mapListOrSetParameterType`: the
+        // notation (`Array<...>`/`Set<...>`) carries the Terraform collection
+        // structure recursively, and only sets get a prose note.
+        const wrapper = returnType[0] === "set" ? "Set" : "Array";
+        const docstringNote = returnType[0] === "set"
+            ? "Terraform set; ordering is not guaranteed and duplicate values are removed."
+            : undefined;
+        const element = returnType[1];
+        if (element === "string") {
+            return {
+                tsType: "string[]",
+                docstringType: `${wrapper}<string>`,
+                docstringNote,
+                wrapReturn: (expr) => `cdktn.Token.asList(${expr})`,
+            };
+        }
+        if (element === "number") {
+            return {
+                tsType: "number[]",
+                docstringType: `${wrapper}<number>`,
+                docstringNote,
+                wrapReturn: (expr) => `cdktn.Token.asNumberList(${expr})`,
+            };
+        }
+        // list/set of anything else: there is no `asAnyList` Token helper -
+        // fall back to the raw IResolvable, same reasoning as dynamic/object
+        // below, but keep the docstring honest about the real element shape
+        // (reusing mapParameterType purely for its descriptive docstringType -
+        // its tsType/acceptsResolvableAlready are irrelevant here).
+        return {
+            tsType: "cdktn.IResolvable",
+            docstringType: `${wrapper}<${mapParameterType(element).docstringType}>`,
+            docstringNote,
+            wrapReturn: (expr) => expr,
+        };
+    }
+    if (Array.isArray(returnType) && returnType[0] === "map") {
+        // Unlike list/set and object/dynamic, every `map` shape has a matching
+        // typed Token helper (see token.ts), so it gets a real typed record
+        // return instead of falling back to the raw IResolvable.
+        const element = returnType[1];
+        if (element === "string") {
+            return {
+                tsType: "{ [key: string]: string }",
+                docstringType: "{ [key: string]: string }",
+                wrapReturn: (expr) => `cdktn.Token.asStringMap(${expr})`,
+            };
+        }
+        if (element === "number") {
+            return {
+                tsType: "{ [key: string]: number }",
+                docstringType: "{ [key: string]: number }",
+                wrapReturn: (expr) => `cdktn.Token.asNumberMap(${expr})`,
+            };
+        }
+        if (element === "bool") {
+            // Token.asBooleanMap's declared return type is `{ [key: string]:
+            // boolean }` (see token.ts) - used verbatim, not unioned with
+            // IResolvable: the map's individual entries are plain booleans once
+            // unwrapped by the helper.
+            return {
+                tsType: "{ [key: string]: boolean }",
+                docstringType: "{ [key: string]: boolean }",
+                wrapReturn: (expr) => `cdktn.Token.asBooleanMap(${expr})`,
+            };
+        }
+        // map of anything else (object/dynamic/nested collection): asAnyMap
+        // still gives a typed (if loosely-typed) record rather than falling
+        // back to the raw IResolvable.
+        return {
+            tsType: "{ [key: string]: any }",
+            docstringType: "{ [key: string]: any }",
+            wrapReturn: (expr) => `cdktn.Token.asAnyMap(${expr})`,
+        };
+    }
+    // object: no structural typing for arbitrary provider function results -
+    // declared as `cdktn.IResolvable`, and returned as the raw `IResolvable`
+    // from invoke() (NOT wrapped in `cdktn.Token.asString(...)`, which would
+    // make the result unrecognizable to `Tokenization.isResolvable()`
+    // downstream - see the mapReturnType docstring above).
+    return {
+        tsType: "cdktn.IResolvable",
+        docstringType: "object",
+        wrapReturn: (expr) => expr,
+    };
+}
+function buildFunctionModel(terraformName, signature) {
+    var _a;
+    const { tsType: returnTsType, docstringType: returnDocstringType, docstringNote: returnDocstringNote, wrapReturn, } = mapReturnType(signature.return_type);
+    const rawParameters = (_a = signature.parameters) !== null && _a !== void 0 ? _a : [];
+    const parameters = applyNullability(rawParameters, rawParameters.map((parameter, index) => buildParameterModel(parameter, `arg${index}`)));
+    let variadicParameter;
+    if (signature.variadic_parameter) {
+        const elementModel = buildParameterModel(signature.variadic_parameter, "values");
+        if (signature.variadic_parameter.is_nullable) {
+            // A nullable variadic parameter: jsii can't express "each individual
+            // argument may independently be null" on the generated `values:
+            // Array<T>` array parameter (it's an ordinary array parameter, not a
+            // true rest/spread parameter - only the invoke() call site spreads
+            // it), so every element's type instead widens to also accept an
+            // explicit `cdktn.Token.nullValue()`, the same way a fixed nullable
+            // parameter does (see `withNullableResolvableUnion`); the docstring
+            // keeps the honest per-element type plus that guidance in its note.
+            const { tsType, docstringType } = withNullableResolvableUnion(elementModel);
+            variadicParameter = {
+                ...elementModel,
+                tsType,
+                docstringType: `Array<${docstringType}>`,
+                docstringNote: [
+                    elementModel.docstringNote,
+                    "Pass cdktn.Token.nullValue() for an explicit Terraform null.",
+                ]
+                    .filter(Boolean)
+                    .join(" "),
+            };
+        }
+        else {
+            // Non-nullable: the docstring wraps the element's docstring type in
+            // `Array<...>` here (rather than in the emitter), so every parameter
+            // - fixed or variadic - can share one `@param {docstringType}`
+            // emission path.
+            variadicParameter = {
+                ...elementModel,
+                docstringType: `Array<${elementModel.docstringType}>`,
+            };
+        }
+    }
+    return {
+        terraformName,
+        methodName: sanitizeMethodName(terraformName),
+        description: signature.description,
+        summary: signature.summary,
+        deprecationMessage: signature.deprecation_message,
+        returnTsType,
+        returnDocstringType,
+        returnDocstringNote,
+        wrapReturn,
+        parameters,
+        variadicParameter,
+    };
+}
+/**
+ * Throws if two functions in the same provider sanitize to the same
+ * generated method name. Terraform function names are unique, but
+ * `sanitizeMethodName` (camelCasing, `length` -> `lengthOf`) is not
+ * necessarily injective, so a real - if unlikely - provider schema could
+ * still produce a duplicate method. Generation is aborted rather than
+ * silently emitting one method that shadows the other.
+ */
+function assertNoMethodNameCollisions(providerName, functions) {
+    const seenBy = new Map(); // methodName -> terraformName
+    for (const fn of functions) {
+        const existingTerraformName = seenBy.get(fn.methodName);
+        if (existingTerraformName !== undefined) {
+            throw new Error(`Provider "${providerName}" declares two provider-defined functions, ` +
+                `"${existingTerraformName}" and "${fn.terraformName}", that both ` +
+                `sanitize to the generated method name "${fn.methodName}". ` +
+                `Generation aborted to avoid silently overwriting one method with ` +
+                `the other - please report this as an issue.`);
+        }
+        seenBy.set(fn.methodName, fn.terraformName);
+    }
+}
+/**
+ * Throws if a function's sanitized `methodName` lands on a member name
+ * `ProviderFunctionsEmitter` already puts on every wrapper class (see
+ * `RESERVED_WRAPPER_MEMBER_NAMES`). Unlike `assertNoMethodNameCollisions`,
+ * which only catches two *functions* colliding with each other, this catches
+ * a single function colliding with the wrapper class itself - e.g. a
+ * Terraform function literally named "constructor", or "provider_local_name"
+ * camelCasing to "providerLocalName".
+ *
+ * This intentionally does NOT also check sanitized *parameter* names against
+ * "providerLocalName": parameters are declared in the generated method's own
+ * scope, not the class's, so a parameter named `providerLocalName` shadows
+ * the class field within that method body without colliding with it (valid,
+ * if confusing, TypeScript) - there is nothing to abort generation over.
+ */
+function assertNoReservedWrapperMemberCollisions(providerName, functions) {
+    for (const fn of functions) {
+        if (RESERVED_WRAPPER_MEMBER_NAMES.has(fn.methodName)) {
+            throw new Error(`Provider "${providerName}" declares a provider-defined function ` +
+                `"${fn.terraformName}" that sanitizes to the generated method name ` +
+                `"${fn.methodName}", which collides with a member that ` +
+                `ProviderFunctionsEmitter already puts on every ` +
+                `"<Provider>ProviderFunctions" wrapper class (the class ` +
+                `constructor, or its "providerLocalName" field). Generation ` +
+                `aborted to avoid emitting invalid TypeScript or silently ` +
+                `shadowing that member - please report this as an issue.`);
+        }
+    }
+}
+/**
+ * Throws if two parameters of the same function (including the variadic
+ * parameter) sanitize to the same generated parameter name, for the same
+ * reason as `assertNoMethodNameCollisions` above but at the parameter level.
+ */
+function assertNoParameterNameCollisions(providerName, fn) {
+    const seenBy = new Map(); // sanitized name -> terraformName
+    const allParameters = fn.variadicParameter
+        ? [...fn.parameters, fn.variadicParameter]
+        : fn.parameters;
+    for (const param of allParameters) {
+        const existingTerraformName = seenBy.get(param.name);
+        if (existingTerraformName !== undefined) {
+            throw new Error(`Provider "${providerName}" function "${fn.terraformName}" declares ` +
+                `two parameters, "${existingTerraformName}" and ` +
+                `"${param.terraformName}", that both sanitize to the generated ` +
+                `parameter name "${param.name}". Generation aborted to avoid ` +
+                `silently dropping one parameter - please report this as an issue.`);
+        }
+        seenBy.set(param.name, param.terraformName);
+    }
+}
+/**
+ * Throws if the provider's own config schema declares an attribute whose
+ * generated property name (see `AttributeModel.name` /
+ * `escapeAttributeName`) is exactly "functions", while the provider also
+ * declares provider-defined functions. That combination would collide with
+ * the memoized `functions` getter `ResourceEmitter` emits on the provider
+ * class (see `resource-emitter.ts`'s `emitFunctionsGetter`) - one would
+ * silently shadow the other. Same loud-failure convention as
+ * `assertNoMethodNameCollisions`/`assertNoParameterNameCollisions` above:
+ * generation is aborted rather than silently picking a winner.
+ */
+function assertNoFunctionsGetterCollision(providerName, attributeNames) {
+    if (attributeNames.includes("functions")) {
+        throw new Error(`Provider "${providerName}" declares provider-defined functions and its ` +
+            `own config schema also has an attribute that generates the property ` +
+            `name "functions" on the provider class. This collides with the ` +
+            `generated "functions" getter used to invoke provider-defined ` +
+            `functions. Generation aborted to avoid silently shadowing one with ` +
+            `the other - please report this as an issue.`);
+    }
+}
+exports.assertNoFunctionsGetterCollision = assertNoFunctionsGetterCollision;
+/**
+ * Builds the model for a provider's `provider-functions/index.ts` file from
+ * its provider schema `functions` map. Returns `undefined` when the provider
+ * declares no functions - callers should skip emitting the file entirely.
+ */
+function buildProviderFunctionsModel(providerName, functions) {
+    const entries = Object.entries(functions !== null && functions !== void 0 ? functions : {});
+    if (entries.length === 0)
+        return undefined;
+    const mappedFunctions = entries
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([name, signature]) => buildFunctionModel(name, signature));
+    assertNoMethodNameCollisions(providerName, mappedFunctions);
+    assertNoReservedWrapperMemberCollisions(providerName, mappedFunctions);
+    for (const fn of mappedFunctions) {
+        assertNoParameterNameCollisions(providerName, fn);
+    }
+    return {
+        providerName,
+        className: `${(0, codemaker_1.toPascalCase)(providerName)}ProviderFunctions`,
+        functions: mappedFunctions,
+    };
+}
+exports.buildProviderFunctionsModel = buildProviderFunctionsModel;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider-function-model.js","sourceRoot":"","sources":["../../../../src/get/generator/models/provider-function-model.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) HashiCorp, Inc\n// SPDX-License-Identifier: MPL-2.0\nimport { toCamelCase, toPascalCase } from \"codemaker\";\nimport {\n  AttributeType,\n  FunctionParameter,\n  FunctionSignature,\n} from \"@cdktn/commons\";\n\n/**\n * A provider-defined function parameter (positional or the trailing\n * variadic one), mapped to the jsii-safe TypeScript type used in the\n * generated method signature.\n */\nexport interface ProviderFunctionParameterModel {\n  readonly terraformName: string;\n  readonly name: string;\n  readonly tsType: string;\n  /**\n   * The JSDoc type expression emitted inside the `@param {...}` braces.\n   * A pure type expression only - prose (Terraform list/set semantics,\n   * `cdktn.Token.nullValue()` guidance) belongs in `docstringNote`.\n   */\n  readonly docstringType: string;\n  /**\n   * Prose appended after the parameter name (and `description`, if any) in\n   * the emitted `@param` line - e.g. set-ordering semantics or how to pass\n   * an explicit Terraform `null`. Official JSDoc places only the type\n   * expression inside the braces, so this must never be folded into\n   * `docstringType`.\n   */\n  readonly docstringNote?: string;\n  readonly description?: string;\n  /**\n   * True when this (fixed, non-variadic) parameter is emitted as a\n   * jsii-optional TypeScript parameter (`name?: T`) - see the\n   * is_nullable/trailing-compatibility handling in `applyNullability`.\n   * Never set on the variadic parameter: an array parameter can't be `?`.\n   */\n  readonly optional?: boolean;\n}\n\n/**\n * `ProviderFunctionParameterModel` plus the one bit of information that's\n * only needed while building the model (see `mapParameterType`/\n * `applyNullability`), never by the emitter: whether `tsType` already\n * accepts an arbitrary `cdktn.IResolvable` in this position (a bare\n * boolean/collection-of-boolean token, `any`, or an explicit\n * `| cdktn.IResolvable` union already present). Nullability handling uses\n * this to decide whether it needs to append another `| cdktn.IResolvable`\n * so a caller can pass `cdktn.Token.nullValue()` - without resorting to\n * re-deriving that answer with a string search over `tsType`.\n */\ninterface InternalParameterModel extends ProviderFunctionParameterModel {\n  readonly acceptsResolvableAlready: boolean;\n}\n\n/**\n * A single provider-defined function, mapped to a static method on the\n * generated `<Provider>ProviderFunctions` class.\n */\nexport interface ProviderFunctionModel {\n  readonly terraformName: string;\n  readonly methodName: string;\n  readonly description?: string;\n  readonly summary?: string;\n  /**\n   * Terraform (>=1.8) deprecation message for the function, surfaced as an\n   * `@deprecated` JSDoc tag. OpenTofu never emits this field - see\n   * `FunctionSignature.deprecation_message`.\n   */\n  readonly deprecationMessage?: string;\n  readonly returnTsType: string;\n  /**\n   * The `@returns {...}` JSDoc type, describing the conceptual/Terraform\n   * shape of the return value - see `mapReturnType`. This deliberately can\n   * differ from `returnTsType` (e.g. a `bool` return is declared\n   * `cdktn.IResolvable` but documented as `boolean | IResolvable`), the same\n   * way a parameter's `docstringType` can differ from its `tsType`.\n   */\n  readonly returnDocstringType: string;\n  /**\n   * Prose appended after the `@returns {...}` braces (e.g. Terraform\n   * list/set semantics) - the return-side counterpart of a parameter's\n   * `docstringNote`.\n   */\n  readonly returnDocstringNote?: string;\n  /**\n   * Wraps the `cdktn.TerraformProviderFunction.invoke(...)` call expression\n   * into the method's `return` statement (e.g. wrapping it in\n   * `cdktn.Token.asString(...)`, or returning it unwrapped for `bool`).\n   */\n  readonly wrapReturn: (invokeExpression: string) => string;\n  readonly parameters: ProviderFunctionParameterModel[];\n  readonly variadicParameter?: ProviderFunctionParameterModel;\n}\n\n/**\n * All provider-defined functions of a single provider, mapped to a single\n * generated `providers/<provider>/provider-functions/index.ts` file.\n */\nexport interface ProviderFunctionsModel {\n  readonly providerName: string;\n  readonly className: string;\n  readonly functions: ProviderFunctionModel[];\n}\n\n// Parameter names that collide with a reserved word/identifier in one of the\n// jsii target languages. This is the sibling table for provider-defined\n// functions: tools/generate-function-bindings/scripts/generate.ts holds the\n// canonical (and separately maintained) table for built-in `Fn.*` functions.\n// The two are intentionally not shared - that script lives outside the\n// packages/ build and generates a different artifact - but any reserved name\n// added there should be considered here too.\nconst RESERVED_PARAMETER_NAMES: { [name: string]: string } = {\n  default: \"defaultValue\", // reserved word in TypeScript\n  string: \"str\", // causes issues in Go\n};\n\nfunction sanitizeParameterName(name: string): string {\n  const camelCased = toCamelCase(name);\n  return RESERVED_PARAMETER_NAMES[camelCased] ?? camelCased;\n}\n\nfunction sanitizeMethodName(name: string): string {\n  if (name === \"length\") return \"lengthOf\"; // reserved on jsii-generated classes\n  return toCamelCase(name);\n}\n\n// Members that `ProviderFunctionsEmitter` (see `emitter/provider-functions-emitter.ts`)\n// itself puts on every generated `<Provider>ProviderFunctions` wrapper class,\n// regardless of which functions a provider declares:\n//   - \"constructor\": the class's own constructor, which takes the provider's\n//     `providerLocalName`. A provider-defined function named \"constructor\"\n//     would sanitize to a *second* `constructor` member on the class, which\n//     is invalid TypeScript.\n//   - \"providerLocalName\": the `private readonly providerLocalName: string`\n//     field the constructor assigns (see the emitter's `emitClassHeader`/\n//     constructor emission). A provider-defined function sanitizing to this\n//     name would collide with that field.\n// If `ProviderFunctionsEmitter` ever grows more members on the wrapper class,\n// add them here too.\nconst RESERVED_WRAPPER_MEMBER_NAMES = new Set([\n  \"constructor\",\n  \"providerLocalName\",\n]);\n\n/**\n * Result of mapping a single Terraform attribute type into a jsii-safe\n * parameter shape (see `mapParameterType`).\n */\ninterface MappedParameterType {\n  readonly tsType: string;\n  readonly docstringType: string;\n  /** See `ProviderFunctionParameterModel.docstringNote`. */\n  readonly docstringNote?: string;\n  /**\n   * True when `tsType` already accepts an arbitrary `cdktn.IResolvable` in\n   * this position without needing an extra `| cdktn.IResolvable` union -\n   * see `InternalParameterModel`.\n   */\n  readonly acceptsResolvableAlready: boolean;\n}\n\n/**\n * The bracket-composable (\"T[]\", no top-level union) TypeScript/docstring\n * type for an element that can nest inside an array without ITSELF needing\n * the whole-collection token union at that level: `string`, `number`, or a\n * list/set of one of those, recursively (e.g. `list(list(string))` bottoms\n * out at `string`). Returns `undefined` for anything else (`bool`, `map`,\n * `object`, `dynamic`, or a nested collection that doesn't itself qualify),\n * so the caller falls back to widening the whole parameter to\n * `any[] | cdktn.IResolvable` instead.\n */\nfunction plainArrayElementType(\n  type: AttributeType,\n): { tsType: string; docstringType: string } | undefined {\n  if (type === \"string\") return { tsType: \"string\", docstringType: \"string\" };\n  if (type === \"number\") return { tsType: \"number\", docstringType: \"number\" };\n  if (Array.isArray(type) && (type[0] === \"list\" || type[0] === \"set\")) {\n    const inner = plainArrayElementType(type[1]);\n    if (!inner) return undefined;\n    return {\n      tsType: `${inner.tsType}[]`,\n      docstringType: `${type[0] === \"set\" ? \"Set\" : \"Array\"}<${inner.docstringType}>`,\n    };\n  }\n  return undefined;\n}\n\n/**\n * Maps a `list`/`set` parameter to its jsii-safe shape - mirrors\n * `ListAttributeTypeModel`/`SetAttributeTypeModel.inputTypeDefinition`\n * (both identical) branch for branch, since jsii parameters, like resource\n * inputs, are allowed to union in a whole-collection `cdktn.IResolvable`\n * token. `kind` only affects the documentation: the docstring notation\n * (`Array<...>` for a Terraform list, `Set<...>` for a Terraform set,\n * recursively via `plainArrayElementType`/`mapParameterType`) plus, for\n * sets, a prose note - the jsii type is an array either way, so the note\n * keeps a reader from literally passing a JS `Set` and flags the\n * ordering/duplicate-element semantics difference. The type-level handling\n * is identical for both.\n */\nfunction mapListOrSetParameterType(\n  kind: \"list\" | \"set\",\n  element: AttributeType,\n): MappedParameterType {\n  const wrapper = kind === \"set\" ? \"Set\" : \"Array\";\n  const docstringNote =\n    kind === \"set\"\n      ? \"Terraform set; ordering is not guaranteed and duplicate values are removed.\"\n      : undefined;\n\n  if (element === \"string\") {\n    // Mirrors the final `else` branch: encoded list tokens already satisfy\n    // `string[]`, so no union is needed.\n    return {\n      tsType: \"string[]\",\n      docstringType: `${wrapper}<string>`,\n      docstringNote,\n      acceptsResolvableAlready: false,\n    };\n  }\n  if (element === \"number\") {\n    // Same reasoning as `string` above.\n    return {\n      tsType: \"number[]\",\n      docstringType: `${wrapper}<number>`,\n      docstringNote,\n      acceptsResolvableAlready: false,\n    };\n  }\n  if (element === \"bool\") {\n    // Mirrors the `elementType.storedClassType === \"boolean\"` branch: bool\n    // has no lossless per-element token, but the WHOLE collection is still\n    // tokenizable, so the union is on the outside.\n    return {\n      tsType: \"Array<boolean | cdktn.IResolvable> | cdktn.IResolvable\",\n      docstringType: `${wrapper}<boolean | IResolvable>`,\n      docstringNote,\n      acceptsResolvableAlready: true,\n    };\n  }\n\n  const plainElement = plainArrayElementType(element);\n  if (plainElement) {\n    // Mirrors the `elementType.typeModelType !== \"simple\"` branch: a nested\n    // list/set that itself bottoms out at string/number composes into a\n    // proper nested array type (e.g. `list(list(string))` -> `string[][]`),\n    // with the whole-collection token additionally accepted alongside it.\n    return {\n      tsType: `${plainElement.tsType}[] | cdktn.IResolvable`,\n      docstringType: `${wrapper}<${plainElement.docstringType}>`,\n      docstringNote,\n      acceptsResolvableAlready: true,\n    };\n  }\n\n  // map/object/dynamic element, or a nested collection that doesn't itself\n  // reduce to string/number: no jsii-safe array-of-X type exists - widen\n  // the whole parameter to `any[]`. Unlike a bare `any` parameter, plain\n  // `any[]` does NOT structurally accept a whole-collection\n  // `cdktn.IResolvable` token, so the union is required here (this is\n  // stricter than `MapAttributeTypeModel`/`ListAttributeTypeModel` have to\n  // be, since those only ever fall back to `any[] | cdktn.IResolvable` via\n  // the same \"not simple\" branch above, which already grants it). Keep the\n  // docstring honest about the real element shape rather than just saying\n  // `any`.\n  const elementDescription = mapParameterType(element).docstringType;\n  return {\n    tsType: \"any[] | cdktn.IResolvable\",\n    docstringType: `${wrapper}<${elementDescription}>`,\n    docstringNote,\n    acceptsResolvableAlready: true,\n  };\n}\n\n/**\n * Maps a `map` parameter to its jsii-safe shape - mirrors\n * `MapAttributeTypeModel.inputTypeDefinition`. Only the `bool`-element case\n * is reachable from real provider schemas today (`string`/`number` element\n * maps stay a plain, non-union record; nested/complex map elements aren't\n * emitted for provider functions - see the `object` fallback in\n * `mapParameterType`), but the shape is kept branch-for-branch aligned with\n * the model it mirrors rather than collapsed.\n */\nfunction mapMapParameterType(element: AttributeType): MappedParameterType {\n  if (element === \"string\") {\n    return {\n      tsType: \"{ [key: string]: string }\",\n      docstringType: \"{ [key: string]: string }\",\n      acceptsResolvableAlready: false,\n    };\n  }\n  if (element === \"number\") {\n    return {\n      tsType: \"{ [key: string]: number }\",\n      docstringType: \"{ [key: string]: number }\",\n      acceptsResolvableAlready: false,\n    };\n  }\n  if (element === \"bool\") {\n    // Mirrors the `elementType.storedClassType === \"boolean\"` branch: map\n    // of booleans has PER-ENTRY token support, but the whole map itself is\n    // not additionally unioned with `cdktn.IResolvable` (unlike the list/set\n    // case) - matching `MapAttributeTypeModel.inputTypeDefinition` exactly.\n    return {\n      tsType: \"{ [key: string]: (boolean | cdktn.IResolvable) }\",\n      docstringType: \"{ [key: string]: (boolean | IResolvable) }\",\n      acceptsResolvableAlready: false,\n    };\n  }\n  // map/object/dynamic element: no structural input helper exists here -\n  // stays `any`, which (being `any`) already accepts a whole-map\n  // `cdktn.IResolvable` token too.\n  return {\n    tsType: \"any\",\n    docstringType: \"any\",\n    acceptsResolvableAlready: true,\n  };\n}\n\n/**\n * Maps a provider function parameter's declared Terraform type to a\n * jsii-safe TypeScript parameter type, recursively for collection types.\n *\n * Unlike return types, jsii allows unions in *parameter* position, so\n * `bool` is typed `boolean | cdktn.IResolvable` (mirroring\n * `SimpleAttributeTypeModel.inputTypeDefinition`'s input-side convention) -\n * this both accepts a real boolean and still accepts a token in place of\n * one. `dynamic` has no structural typing and stays `any` (which already\n * accepts anything, including a token); `object` (structural input helpers\n * are deferred to a follow-up issue) stays `any` too.\n *\n * `list`/`set` and `map` delegate to `mapListOrSetParameterType`/\n * `mapMapParameterType`, which mirror `ListAttributeTypeModel`/\n * `SetAttributeTypeModel`/`MapAttributeTypeModel.inputTypeDefinition`\n * branch for branch (see `attribute-type-model.ts`) - the same\n * whole-collection-token conventions already used for resource inputs.\n */\nfunction mapParameterType(type: AttributeType): MappedParameterType {\n  if (type === \"string\") {\n    return {\n      tsType: \"string\",\n      docstringType: \"string\",\n      acceptsResolvableAlready: false,\n    };\n  }\n  if (type === \"number\") {\n    return {\n      tsType: \"number\",\n      docstringType: \"number\",\n      acceptsResolvableAlready: false,\n    };\n  }\n  if (type === \"bool\") {\n    return {\n      tsType: \"boolean | cdktn.IResolvable\",\n      docstringType: \"boolean | IResolvable\",\n      acceptsResolvableAlready: true,\n    };\n  }\n  if (type === \"dynamic\") {\n    return {\n      tsType: \"any\",\n      docstringType: \"any\",\n      acceptsResolvableAlready: true,\n    };\n  }\n\n  if (Array.isArray(type) && (type[0] === \"list\" || type[0] === \"set\")) {\n    return mapListOrSetParameterType(type[0], type[1]);\n  }\n\n  if (Array.isArray(type) && type[0] === \"map\") {\n    return mapMapParameterType(type[1]);\n  }\n\n  // object: structural input helpers are deferred to a follow-up issue.\n  return {\n    tsType: \"any\",\n    docstringType: \"object\",\n    acceptsResolvableAlready: true,\n  };\n}\n\nfunction buildParameterModel(\n  parameter: FunctionParameter,\n  fallbackName: string,\n): InternalParameterModel {\n  const terraformName = parameter.name ?? fallbackName;\n  const { tsType, docstringType, docstringNote, acceptsResolvableAlready } =\n    mapParameterType(parameter.type);\n  return {\n    terraformName,\n    name: sanitizeParameterName(terraformName),\n    tsType,\n    docstringType,\n    docstringNote,\n    description: parameter.description,\n    acceptsResolvableAlready,\n  };\n}\n\n/**\n * Widens a mapped type's `tsType`/`docstringType` to also accept an\n * explicit `cdktn.Token.nullValue()` in this position - unless\n * `acceptsResolvableAlready` says it already does (e.g. a `bool` parameter\n * is already `boolean | cdktn.IResolvable`, so nullability adds nothing to\n * the type itself, only to the docstring note appended by the caller).\n */\nfunction withNullableResolvableUnion(\n  model: Pick<\n    InternalParameterModel,\n    \"tsType\" | \"docstringType\" | \"acceptsResolvableAlready\"\n  >,\n): { tsType: string; docstringType: string } {\n  if (model.acceptsResolvableAlready) {\n    return { tsType: model.tsType, docstringType: model.docstringType };\n  }\n  return {\n    tsType: `${model.tsType} | cdktn.IResolvable`,\n    docstringType: `${model.docstringType} | IResolvable`,\n  };\n}\n\n/**\n * Applies `is_nullable` trailing-compatibility rules across a function's\n * fixed (non-variadic) parameter list. This needs the whole list in view\n * (see `buildFunctionModel`), since whether a nullable parameter can become\n * jsii-optional depends on every parameter *after* it too:\n *\n * - A nullable parameter where it and every later fixed parameter are also\n *   nullable becomes jsii-optional (`name?: T`): omitting it in TypeScript\n *   leaves `undefined` in the invoke args array, which `FunctionCall`\n *   already renders as the Terraform `null` keyword. It additionally gains\n *   the `| cdktn.IResolvable` union (see `withNullableResolvableUnion`), so\n *   a caller who does supply the argument can pass\n *   `cdktn.Token.nullValue()` for an explicit Terraform `null` without\n *   omitting the parameter.\n * - A nullable parameter followed by a required one keeps its position\n *   (jsii can't express \"optional but not trailing\"), and instead gains the\n *   same `| cdktn.IResolvable` union so a caller can still pass an explicit\n *   `cdktn.Token.nullValue()` (an `IResolvable` resolving to `null` - see\n *   `Token.nullValue()`/`Token.asAny()`) in that fixed position - keeping\n *   the parameter's real type rather than giving up all type safety by\n *   widening it to `any`.\n *\n * Both cases document the real mechanism in the docstring note rather than\n * implying the plain TypeScript `null` literal is accepted: the trailing\n * case can also just be omitted, the mid-position case can't be omitted at\n * all (jsii can't express \"optional but not trailing\").\n */\nfunction applyNullability(\n  parameters: FunctionParameter[],\n  models: InternalParameterModel[],\n): InternalParameterModel[] {\n  const trailingCompatible = new Array(parameters.length).fill(false);\n  let allNullableSoFar = true;\n  for (let i = parameters.length - 1; i >= 0; i--) {\n    allNullableSoFar = allNullableSoFar && parameters[i].is_nullable === true;\n    trailingCompatible[i] = allNullableSoFar;\n  }\n\n  return models.map((model, index) => {\n    const parameter = parameters[index];\n    if (!parameter.is_nullable) return model;\n\n    const { tsType, docstringType } = withNullableResolvableUnion(model);\n    const nullabilityNote = trailingCompatible[index]\n      ? \"Omit or pass cdktn.Token.nullValue() to render the Terraform null keyword.\"\n      : \"Pass cdktn.Token.nullValue() for an explicit Terraform null.\";\n\n    return {\n      ...model,\n      ...(trailingCompatible[index] ? { optional: true } : {}),\n      tsType,\n      docstringType,\n      docstringNote: [model.docstringNote, nullabilityNote]\n        .filter(Boolean)\n        .join(\" \"),\n    };\n  });\n}\n\n/**\n * Maps a provider function's declared return type to the jsii-safe\n * TypeScript return type, the `@returns` JSDoc type, and the expression\n * that unwraps the `TerraformProviderFunction.invoke(...)` `IResolvable`\n * into it.\n *\n * jsii return positions can't use the `T | cdktn.IResolvable` union that\n * parameters can (see `mapParameterType`), so every shape that can't be\n * losslessly unwrapped through an `asXxx` Token helper falls back to the\n * plain `cdktn.IResolvable` produced by `invoke()` itself, unwrapped.\n * Provider functions frequently return objects (e.g. every function in the\n * `time` provider), so - unlike built-in `Fn.*` functions - the object case\n * is a primary path, not an error: it is treated the same as\n * `dynamic`/a `list`/`set` of anything other than `string`/`number` (no\n * `asAnyList` Token helper exists), and returned as the RAW `invoke()`\n * result. `map` returns, unlike those, DO have a full set of typed Token\n * helpers (`asStringMap`/`asNumberMap`/`asBooleanMap`/`asAnyMap`), so every\n * `map` shape gets an actual typed record return instead of falling back to\n * `cdktn.IResolvable`.\n *\n * Whenever the declared return type IS `cdktn.IResolvable` (not `any`):\n * unlike `helpers.ts` `asAny`, this must NOT go through\n * `cdktn.Token.asString(...)` - `Token.asString()` produces an encoded\n * string token that `Tokenization.isResolvable()` does not recognize, so\n * generated struct setters (e.g. an `OutputReference` `internalValue`) treat\n * it as a plain object with no known keys and the attribute silently\n * vanishes from synth output. The raw `IResolvable` from `invoke()` IS\n * recognized by `Tokenization.isResolvable()` and resolves correctly.\n * Declaring it as `cdktn.IResolvable` instead of `any` also gives callers\n * real type safety: `any` let a caller write `result.hours` on a token with\n * no compile-time feedback, silently producing `undefined` at runtime;\n * `IResolvable` has no such property and forces the caller through\n * `cdktn.Token`/the provider's struct types instead. `invoke()` already\n * returns `IResolvable`, so no cast is needed to return it as\n * `cdktn.IResolvable`.\n */\nfunction mapReturnType(returnType: AttributeType): {\n  tsType: string;\n  docstringType: string;\n  docstringNote?: string;\n  wrapReturn: (invokeExpression: string) => string;\n} {\n  if (returnType === \"string\") {\n    return {\n      tsType: \"string\",\n      docstringType: \"string\",\n      wrapReturn: (expr) => `cdktn.Token.asString(${expr})`,\n    };\n  }\n  if (returnType === \"number\") {\n    return {\n      tsType: \"number\",\n      docstringType: \"number\",\n      wrapReturn: (expr) => `cdktn.Token.asNumber(${expr})`,\n    };\n  }\n  if (returnType === \"bool\") {\n    // Booleans can't be represented as tokens (see helpers.ts asBoolean):\n    // return the IResolvable produced by invoke() unwrapped. The docstring\n    // still documents the real conceptual shape.\n    return {\n      tsType: \"cdktn.IResolvable\",\n      docstringType: \"boolean | IResolvable\",\n      wrapReturn: (expr) => expr,\n    };\n  }\n  if (returnType === \"dynamic\") {\n    return {\n      tsType: \"cdktn.IResolvable\",\n      docstringType: \"any\",\n      wrapReturn: (expr) => expr,\n    };\n  }\n  if (\n    Array.isArray(returnType) &&\n    (returnType[0] === \"list\" || returnType[0] === \"set\")\n  ) {\n    // Same documentation conventions as `mapListOrSetParameterType`: the\n    // notation (`Array<...>`/`Set<...>`) carries the Terraform collection\n    // structure recursively, and only sets get a prose note.\n    const wrapper = returnType[0] === \"set\" ? \"Set\" : \"Array\";\n    const docstringNote =\n      returnType[0] === \"set\"\n        ? \"Terraform set; ordering is not guaranteed and duplicate values are removed.\"\n        : undefined;\n    const element = returnType[1];\n    if (element === \"string\") {\n      return {\n        tsType: \"string[]\",\n        docstringType: `${wrapper}<string>`,\n        docstringNote,\n        wrapReturn: (expr) => `cdktn.Token.asList(${expr})`,\n      };\n    }\n    if (element === \"number\") {\n      return {\n        tsType: \"number[]\",\n        docstringType: `${wrapper}<number>`,\n        docstringNote,\n        wrapReturn: (expr) => `cdktn.Token.asNumberList(${expr})`,\n      };\n    }\n    // list/set of anything else: there is no `asAnyList` Token helper -\n    // fall back to the raw IResolvable, same reasoning as dynamic/object\n    // below, but keep the docstring honest about the real element shape\n    // (reusing mapParameterType purely for its descriptive docstringType -\n    // its tsType/acceptsResolvableAlready are irrelevant here).\n    return {\n      tsType: \"cdktn.IResolvable\",\n      docstringType: `${wrapper}<${mapParameterType(element).docstringType}>`,\n      docstringNote,\n      wrapReturn: (expr) => expr,\n    };\n  }\n  if (Array.isArray(returnType) && returnType[0] === \"map\") {\n    // Unlike list/set and object/dynamic, every `map` shape has a matching\n    // typed Token helper (see token.ts), so it gets a real typed record\n    // return instead of falling back to the raw IResolvable.\n    const element = returnType[1];\n    if (element === \"string\") {\n      return {\n        tsType: \"{ [key: string]: string }\",\n        docstringType: \"{ [key: string]: string }\",\n        wrapReturn: (expr) => `cdktn.Token.asStringMap(${expr})`,\n      };\n    }\n    if (element === \"number\") {\n      return {\n        tsType: \"{ [key: string]: number }\",\n        docstringType: \"{ [key: string]: number }\",\n        wrapReturn: (expr) => `cdktn.Token.asNumberMap(${expr})`,\n      };\n    }\n    if (element === \"bool\") {\n      // Token.asBooleanMap's declared return type is `{ [key: string]:\n      // boolean }` (see token.ts) - used verbatim, not unioned with\n      // IResolvable: the map's individual entries are plain booleans once\n      // unwrapped by the helper.\n      return {\n        tsType: \"{ [key: string]: boolean }\",\n        docstringType: \"{ [key: string]: boolean }\",\n        wrapReturn: (expr) => `cdktn.Token.asBooleanMap(${expr})`,\n      };\n    }\n    // map of anything else (object/dynamic/nested collection): asAnyMap\n    // still gives a typed (if loosely-typed) record rather than falling\n    // back to the raw IResolvable.\n    return {\n      tsType: \"{ [key: string]: any }\",\n      docstringType: \"{ [key: string]: any }\",\n      wrapReturn: (expr) => `cdktn.Token.asAnyMap(${expr})`,\n    };\n  }\n  // object: no structural typing for arbitrary provider function results -\n  // declared as `cdktn.IResolvable`, and returned as the raw `IResolvable`\n  // from invoke() (NOT wrapped in `cdktn.Token.asString(...)`, which would\n  // make the result unrecognizable to `Tokenization.isResolvable()`\n  // downstream - see the mapReturnType docstring above).\n  return {\n    tsType: \"cdktn.IResolvable\",\n    docstringType: \"object\",\n    wrapReturn: (expr) => expr,\n  };\n}\n\nfunction buildFunctionModel(\n  terraformName: string,\n  signature: FunctionSignature,\n): ProviderFunctionModel {\n  const {\n    tsType: returnTsType,\n    docstringType: returnDocstringType,\n    docstringNote: returnDocstringNote,\n    wrapReturn,\n  } = mapReturnType(signature.return_type);\n\n  const rawParameters = signature.parameters ?? [];\n  const parameters = applyNullability(\n    rawParameters,\n    rawParameters.map((parameter, index) =>\n      buildParameterModel(parameter, `arg${index}`),\n    ),\n  );\n\n  let variadicParameter: InternalParameterModel | undefined;\n  if (signature.variadic_parameter) {\n    const elementModel = buildParameterModel(\n      signature.variadic_parameter,\n      \"values\",\n    );\n    if (signature.variadic_parameter.is_nullable) {\n      // A nullable variadic parameter: jsii can't express \"each individual\n      // argument may independently be null\" on the generated `values:\n      // Array<T>` array parameter (it's an ordinary array parameter, not a\n      // true rest/spread parameter - only the invoke() call site spreads\n      // it), so every element's type instead widens to also accept an\n      // explicit `cdktn.Token.nullValue()`, the same way a fixed nullable\n      // parameter does (see `withNullableResolvableUnion`); the docstring\n      // keeps the honest per-element type plus that guidance in its note.\n      const { tsType, docstringType } =\n        withNullableResolvableUnion(elementModel);\n      variadicParameter = {\n        ...elementModel,\n        tsType,\n        docstringType: `Array<${docstringType}>`,\n        docstringNote: [\n          elementModel.docstringNote,\n          \"Pass cdktn.Token.nullValue() for an explicit Terraform null.\",\n        ]\n          .filter(Boolean)\n          .join(\" \"),\n      };\n    } else {\n      // Non-nullable: the docstring wraps the element's docstring type in\n      // `Array<...>` here (rather than in the emitter), so every parameter\n      // - fixed or variadic - can share one `@param {docstringType}`\n      // emission path.\n      variadicParameter = {\n        ...elementModel,\n        docstringType: `Array<${elementModel.docstringType}>`,\n      };\n    }\n  }\n\n  return {\n    terraformName,\n    methodName: sanitizeMethodName(terraformName),\n    description: signature.description,\n    summary: signature.summary,\n    deprecationMessage: signature.deprecation_message,\n    returnTsType,\n    returnDocstringType,\n    returnDocstringNote,\n    wrapReturn,\n    parameters,\n    variadicParameter,\n  };\n}\n\n/**\n * Throws if two functions in the same provider sanitize to the same\n * generated method name. Terraform function names are unique, but\n * `sanitizeMethodName` (camelCasing, `length` -> `lengthOf`) is not\n * necessarily injective, so a real - if unlikely - provider schema could\n * still produce a duplicate method. Generation is aborted rather than\n * silently emitting one method that shadows the other.\n */\nfunction assertNoMethodNameCollisions(\n  providerName: string,\n  functions: ProviderFunctionModel[],\n): void {\n  const seenBy = new Map<string, string>(); // methodName -> terraformName\n\n  for (const fn of functions) {\n    const existingTerraformName = seenBy.get(fn.methodName);\n    if (existingTerraformName !== undefined) {\n      throw new Error(\n        `Provider \"${providerName}\" declares two provider-defined functions, ` +\n          `\"${existingTerraformName}\" and \"${fn.terraformName}\", that both ` +\n          `sanitize to the generated method name \"${fn.methodName}\". ` +\n          `Generation aborted to avoid silently overwriting one method with ` +\n          `the other - please report this as an issue.`,\n      );\n    }\n    seenBy.set(fn.methodName, fn.terraformName);\n  }\n}\n\n/**\n * Throws if a function's sanitized `methodName` lands on a member name\n * `ProviderFunctionsEmitter` already puts on every wrapper class (see\n * `RESERVED_WRAPPER_MEMBER_NAMES`). Unlike `assertNoMethodNameCollisions`,\n * which only catches two *functions* colliding with each other, this catches\n * a single function colliding with the wrapper class itself - e.g. a\n * Terraform function literally named \"constructor\", or \"provider_local_name\"\n * camelCasing to \"providerLocalName\".\n *\n * This intentionally does NOT also check sanitized *parameter* names against\n * \"providerLocalName\": parameters are declared in the generated method's own\n * scope, not the class's, so a parameter named `providerLocalName` shadows\n * the class field within that method body without colliding with it (valid,\n * if confusing, TypeScript) - there is nothing to abort generation over.\n */\nfunction assertNoReservedWrapperMemberCollisions(\n  providerName: string,\n  functions: ProviderFunctionModel[],\n): void {\n  for (const fn of functions) {\n    if (RESERVED_WRAPPER_MEMBER_NAMES.has(fn.methodName)) {\n      throw new Error(\n        `Provider \"${providerName}\" declares a provider-defined function ` +\n          `\"${fn.terraformName}\" that sanitizes to the generated method name ` +\n          `\"${fn.methodName}\", which collides with a member that ` +\n          `ProviderFunctionsEmitter already puts on every ` +\n          `\"<Provider>ProviderFunctions\" wrapper class (the class ` +\n          `constructor, or its \"providerLocalName\" field). Generation ` +\n          `aborted to avoid emitting invalid TypeScript or silently ` +\n          `shadowing that member - please report this as an issue.`,\n      );\n    }\n  }\n}\n\n/**\n * Throws if two parameters of the same function (including the variadic\n * parameter) sanitize to the same generated parameter name, for the same\n * reason as `assertNoMethodNameCollisions` above but at the parameter level.\n */\nfunction assertNoParameterNameCollisions(\n  providerName: string,\n  fn: ProviderFunctionModel,\n): void {\n  const seenBy = new Map<string, string>(); // sanitized name -> terraformName\n  const allParameters = fn.variadicParameter\n    ? [...fn.parameters, fn.variadicParameter]\n    : fn.parameters;\n\n  for (const param of allParameters) {\n    const existingTerraformName = seenBy.get(param.name);\n    if (existingTerraformName !== undefined) {\n      throw new Error(\n        `Provider \"${providerName}\" function \"${fn.terraformName}\" declares ` +\n          `two parameters, \"${existingTerraformName}\" and ` +\n          `\"${param.terraformName}\", that both sanitize to the generated ` +\n          `parameter name \"${param.name}\". Generation aborted to avoid ` +\n          `silently dropping one parameter - please report this as an issue.`,\n      );\n    }\n    seenBy.set(param.name, param.terraformName);\n  }\n}\n\n/**\n * Throws if the provider's own config schema declares an attribute whose\n * generated property name (see `AttributeModel.name` /\n * `escapeAttributeName`) is exactly \"functions\", while the provider also\n * declares provider-defined functions. That combination would collide with\n * the memoized `functions` getter `ResourceEmitter` emits on the provider\n * class (see `resource-emitter.ts`'s `emitFunctionsGetter`) - one would\n * silently shadow the other. Same loud-failure convention as\n * `assertNoMethodNameCollisions`/`assertNoParameterNameCollisions` above:\n * generation is aborted rather than silently picking a winner.\n */\nexport function assertNoFunctionsGetterCollision(\n  providerName: string,\n  attributeNames: string[],\n): void {\n  if (attributeNames.includes(\"functions\")) {\n    throw new Error(\n      `Provider \"${providerName}\" declares provider-defined functions and its ` +\n        `own config schema also has an attribute that generates the property ` +\n        `name \"functions\" on the provider class. This collides with the ` +\n        `generated \"functions\" getter used to invoke provider-defined ` +\n        `functions. Generation aborted to avoid silently shadowing one with ` +\n        `the other - please report this as an issue.`,\n    );\n  }\n}\n\n/**\n * Builds the model for a provider's `provider-functions/index.ts` file from\n * its provider schema `functions` map. Returns `undefined` when the provider\n * declares no functions - callers should skip emitting the file entirely.\n */\nexport function buildProviderFunctionsModel(\n  providerName: string,\n  functions: { [name: string]: FunctionSignature } | undefined,\n): ProviderFunctionsModel | undefined {\n  const entries = Object.entries(functions ?? {});\n  if (entries.length === 0) return undefined;\n\n  const mappedFunctions = entries\n    .sort(([a], [b]) => a.localeCompare(b))\n    .map(([name, signature]) => buildFunctionModel(name, signature));\n\n  assertNoMethodNameCollisions(providerName, mappedFunctions);\n  assertNoReservedWrapperMemberCollisions(providerName, mappedFunctions);\n  for (const fn of mappedFunctions) {\n    assertNoParameterNameCollisions(providerName, fn);\n  }\n\n  return {\n    providerName,\n    className: `${toPascalCase(providerName)}ProviderFunctions`,\n    functions: mappedFunctions,\n  };\n}\n"]}