firebase-functions 3.24.1 → 4.0.0-rc.0

package/lib/params/types.d.ts

@@ -0,0 +1,180 @@
+export declare abstract class Expression<T extends string | number | boolean | string[]> {
+    /** Returns the Expression's runtime value, based on the CLI's resolution of params. */
+    value(): T;
+    /** Returns the Expression's representation as a braced CEL expression. */
+    toCEL(): string;
+    toJSON(): string;
+}
+/**
+ * A CEL expression corresponding to a ternary operator, e.g {{ cond ? ifTrue : ifFalse }}
+ */
+export declare class TernaryExpression<T extends string | number | boolean | string[]> extends Expression<T> {
+    private readonly test;
+    private readonly ifTrue;
+    private readonly ifFalse;
+    constructor(test: Expression<boolean>, ifTrue: T | Expression<T>, ifFalse: T | Expression<T>);
+    toString(): string;
+}
+/**
+ * A CEL expression that evaluates to boolean true or false based on a comparison
+ * between the value of another expression and a literal of that same type.
+ */
+export declare class CompareExpression<T extends string | number | boolean | string[]> extends Expression<boolean> {
+    cmp: "==" | "!=" | ">" | ">=" | "<" | "<=";
+    lhs: Expression<T>;
+    rhs: T | Expression<T>;
+    constructor(cmp: "==" | "!=" | ">" | ">=" | "<" | "<=", lhs: Expression<T>, rhs: T | Expression<T>);
+    toString(): string;
+    /** Returns a TernaryExpression which can resolve to one of two values, based on the resolution of this comparison. */
+    then<retT extends string | number | boolean | string[]>(ifTrue: retT | Expression<retT>, ifFalse: retT | Expression<retT>): TernaryExpression<retT>;
+}
+/** @hidden */
+declare type ParamValueType = "string" | "list" | "boolean" | "int" | "float" | "secret";
+declare type ParamInput<T> = {
+    text: TextInput<T>;
+} | {
+    select: SelectInput<T>;
+} | {
+    resource: ResourceInput;
+};
+/**
+ * Specifies that a Param's value should be determined by prompting the user
+ * to type it in interactively at deploy-time. Input that does not match the
+ * provided validationRegex, if present, will be retried.
+ */
+export interface TextInput<T = unknown> {
+    example?: string;
+    /**
+     * A regular expression (or an escaped string to compile into a regular
+     * expression) which the prompted text must satisfy; the prompt will retry
+     * until input matching the regex is provided.
+     */
+    validationRegex?: string | RegExp;
+    /**
+     * A custom error message to display when retrying the prompt based on input
+     * failing to conform to the validationRegex,
+     */
+    validationErrorMessage?: string;
+}
+/**
+ * Specifies that a Param's value should be determined by having the user
+ * select from a list containing all the project's resources of a certain
+ * type. Currently, only type:"storage.googleapis.com/Bucket" is supported.
+ */
+export interface ResourceInput {
+    resource: {
+        type: string;
+    };
+}
+/**
+ * Specifies that a Param's value should be determined by having the user select
+ * from a list of pre-canned options interactively at deploy-time.
+ */
+export interface SelectInput<T = unknown> {
+    options: Array<SelectOptions<T>>;
+}
+/**
+ * One of the options provided to a SelectInput, containing a value and
+ * optionally a human-readable label to display in the selection interface.
+ */
+export interface SelectOptions<T = unknown> {
+    label?: string;
+    value: T;
+}
+/** The wire representation of a Param when it's sent to the CLI. A superset of ParamOptions. */
+export declare type ParamSpec<T extends string | number | boolean | string[]> = {
+    /** The name of the parameter which will be stored in .env files. Use UPPERCASE. */
+    name: string;
+    /** An optional default value to be used while prompting for input. Can be a literal or another parametrized expression. */
+    default?: T | Expression<T>;
+    /** An optional human-readable string to be used as a replacement for the Param's name when prompting. */
+    label?: string;
+    /** An optional long-form description of the Param to be displayed while prompting. */
+    description?: string;
+    /** The way in which the Firebase CLI will prompt for the value of this Param. Defaults to a TextInput. */
+    input?: ParamInput<T>;
+};
+/**
+ * Representation of parameters for the stack over the wire.
+ *
+ * @remarks
+ * N.B: a WireParamSpec is just a ParamSpec with default expressions converted into a CEL literal
+ *
+ * @alpha
+ */
+export declare type WireParamSpec<T extends string | number | boolean | string[]> = {
+    name: string;
+    default?: T | string;
+    label?: string;
+    description?: string;
+    type: ParamValueType;
+    input?: ParamInput<T>;
+};
+/** Configuration options which can be used to customize the prompting behavior of a Param. */
+export declare type ParamOptions<T extends string | number | boolean | string[]> = Omit<ParamSpec<T>, "name" | "type">;
+/**
+ * Represents a parametrized value that will be read from .env files if present,
+ * or prompted for by the CLI if missing. Instantiate these with the defineX
+ * methods exported by the firebase-functions/params namespace.
+ */
+export declare abstract class Param<T extends string | number | boolean | string[]> extends Expression<T> {
+    readonly name: string;
+    readonly options: ParamOptions<T>;
+    static type: ParamValueType;
+    constructor(name: string, options?: ParamOptions<T>);
+    /** Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression. */
+    cmp(cmp: "==" | "!=" | ">" | ">=" | "<" | "<=", rhs: T | Expression<T>): CompareExpression<T>;
+    /** Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression. */
+    equals(rhs: T | Expression<T>): CompareExpression<T>;
+    /** Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression. */
+    notEquals(rhs: T | Expression<T>): CompareExpression<T>;
+    /** Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression. */
+    greaterThan(rhs: T | Expression<T>): CompareExpression<T>;
+    /** Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression. */
+    greaterThanOrEqualTo(rhs: T | Expression<T>): CompareExpression<T>;
+    /** Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression. */
+    lessThan(rhs: T | Expression<T>): CompareExpression<T>;
+    /** Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression. */
+    lessThanorEqualTo(rhs: T | Expression<T>): CompareExpression<T>;
+    toString(): string;
+}
+/**
+ * A parametrized string whose value is stored in Cloud Secret Manager
+ * instead of the local filesystem. Supply instances of SecretParams to
+ * the secrets array while defining a Function to make their values accessible
+ * during execution of that Function.
+ */
+export declare class SecretParam {
+    static type: ParamValueType;
+    name: string;
+    constructor(name: string);
+}
+/**
+ *  A parametrized value of String type that will be read from .env files
+ *  if present, or prompted for by the CLI if missing.
+ */
+export declare class StringParam extends Param<string> {
+}
+/**
+ *  A parametrized value of Integer type that will be read from .env files
+ *  if present, or prompted for by the CLI if missing.
+ */
+export declare class IntParam extends Param<number> {
+    static type: ParamValueType;
+}
+/**
+ *  A parametrized value of Float type that will be read from .env files
+ *  if present, or prompted for by the CLI if missing.
+ */
+export declare class FloatParam extends Param<number> {
+    static type: ParamValueType;
+}
+/**
+ *  A parametrized value of Boolean type that will be read from .env files
+ *  if present, or prompted for by the CLI if missing.
+ */
+export declare class BooleanParam extends Param<boolean> {
+    static type: ParamValueType;
+    then<T extends string | number | boolean>(ifTrue: T | Expression<T>, ifFalse: T | Expression<T>): TernaryExpression<T>;
+}
+export {};

package/lib/params/types.js

@@ -0,0 +1,289 @@
+"use strict";
+// The MIT License (MIT)
+//
+// Copyright (c) 2021 Firebase
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanParam = exports.FloatParam = exports.IntParam = exports.InternalExpression = exports.StringParam = exports.SecretParam = exports.Param = exports.CompareExpression = exports.TernaryExpression = exports.Expression = void 0;
+const logger = require("../logger");
+/*
+ * A CEL expression which can be evaluated during function deployment, and
+ * resolved to a value of the generic type parameter: i.e, you can pass
+ * an Expression<number> as the value of an option that normally accepts numbers.
+ */
+class Expression {
+    /** Returns the Expression's runtime value, based on the CLI's resolution of params. */
+    value() {
+        if (process.env.FUNCTIONS_CONTROL_API === "true") {
+            logger.warn(`${this.toString()}.value() invoked during function deployment, instead of during runtime.`);
+            logger.warn(`This is usually a mistake. In configs, use Params directly without calling .value().`);
+            logger.warn(`example: { memory: memoryParam } not { memory: memoryParam.value() }`);
+        }
+        return this.runtimeValue();
+    }
+    /** @internal */
+    runtimeValue() {
+        throw new Error("Not implemented");
+    }
+    /** Returns the Expression's representation as a braced CEL expression. */
+    toCEL() {
+        return `{{ ${this.toString()} }}`;
+    }
+    toJSON() {
+        return this.toString();
+    }
+}
+exports.Expression = Expression;
+function quoteIfString(literal) {
+    // TODO(vsfan@): CEL's string escape semantics are slightly different than Javascript's, what do we do here?
+    return typeof literal === "string" ? `"${literal}"` : literal;
+}
+function valueOf(arg) {
+    return arg instanceof Expression ? arg.runtimeValue() : arg;
+}
+function refOf(arg) {
+    return arg instanceof Expression ? arg.toString() : quoteIfString(arg).toString();
+}
+/**
+ * A CEL expression corresponding to a ternary operator, e.g {{ cond ? ifTrue : ifFalse }}
+ */
+class TernaryExpression extends Expression {
+    constructor(test, ifTrue, ifFalse) {
+        super();
+        this.test = test;
+        this.ifTrue = ifTrue;
+        this.ifFalse = ifFalse;
+        this.ifTrue = ifTrue;
+        this.ifFalse = ifFalse;
+    }
+    /** @internal */
+    runtimeValue() {
+        return this.test.runtimeValue() ? valueOf(this.ifTrue) : valueOf(this.ifFalse);
+    }
+    toString() {
+        return `${this.test} ? ${refOf(this.ifTrue)} : ${refOf(this.ifFalse)}`;
+    }
+}
+exports.TernaryExpression = TernaryExpression;
+/**
+ * A CEL expression that evaluates to boolean true or false based on a comparison
+ * between the value of another expression and a literal of that same type.
+ */
+class CompareExpression extends Expression {
+    constructor(cmp, lhs, rhs) {
+        super();
+        this.cmp = cmp;
+        this.lhs = lhs;
+        this.rhs = rhs;
+    }
+    /** @internal */
+    runtimeValue() {
+        const left = this.lhs.runtimeValue();
+        const right = valueOf(this.rhs);
+        switch (this.cmp) {
+            case "==":
+                return left === right;
+            case "!=":
+                return left !== right;
+            case ">":
+                return left > right;
+            case ">=":
+                return left >= right;
+            case "<":
+                return left < right;
+            case "<=":
+                return left <= right;
+            default:
+                throw new Error(`Unknown comparator ${this.cmp}`);
+        }
+    }
+    toString() {
+        const rhsStr = refOf(this.rhs);
+        return `${this.lhs} ${this.cmp} ${rhsStr}`;
+    }
+    /** Returns a TernaryExpression which can resolve to one of two values, based on the resolution of this comparison. */
+    then(ifTrue, ifFalse) {
+        return new TernaryExpression(this, ifTrue, ifFalse);
+    }
+}
+exports.CompareExpression = CompareExpression;
+/**
+ * Represents a parametrized value that will be read from .env files if present,
+ * or prompted for by the CLI if missing. Instantiate these with the defineX
+ * methods exported by the firebase-functions/params namespace.
+ */
+class Param extends Expression {
+    constructor(name, options = {}) {
+        super();
+        this.name = name;
+        this.options = options;
+    }
+    /** @internal */
+    runtimeValue() {
+        throw new Error("Not implemented");
+    }
+    /** Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression. */
+    cmp(cmp, rhs) {
+        return new CompareExpression(cmp, this, rhs);
+    }
+    /** Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression. */
+    equals(rhs) {
+        return this.cmp("==", rhs);
+    }
+    /** Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression. */
+    notEquals(rhs) {
+        return this.cmp("!=", rhs);
+    }
+    /** Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression. */
+    greaterThan(rhs) {
+        return this.cmp(">", rhs);
+    }
+    /** Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression. */
+    greaterThanOrEqualTo(rhs) {
+        return this.cmp(">=", rhs);
+    }
+    /** Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression. */
+    lessThan(rhs) {
+        return this.cmp("<", rhs);
+    }
+    /** Returns a parametrized expression of Boolean type, based on comparing the value of this param to a literal or a different expression. */
+    lessThanorEqualTo(rhs) {
+        return this.cmp("<=", rhs);
+    }
+    toString() {
+        return `params.${this.name}`;
+    }
+    /** @internal */
+    toSpec() {
+        const { default: paramDefault, ...otherOptions } = this.options;
+        const out = {
+            name: this.name,
+            ...otherOptions,
+            type: this.constructor.type,
+        };
+        if (paramDefault instanceof Expression) {
+            out.default = paramDefault.toCEL();
+        }
+        else if (paramDefault !== undefined) {
+            out.default = paramDefault;
+        }
+        if (out.input && "text" in out.input && out.input.text.validationRegex instanceof RegExp) {
+            out.input.text.validationRegex = out.input.text.validationRegex.source;
+        }
+        return out;
+    }
+}
+exports.Param = Param;
+Param.type = "string";
+/**
+ * A parametrized string whose value is stored in Cloud Secret Manager
+ * instead of the local filesystem. Supply instances of SecretParams to
+ * the secrets array while defining a Function to make their values accessible
+ * during execution of that Function.
+ */
+class SecretParam {
+    constructor(name) {
+        this.name = name;
+    }
+    /** @internal */
+    runtimeValue() {
+        return process.env[this.name] || "";
+    }
+    /** @internal */
+    toSpec() {
+        return {
+            type: "secret",
+            name: this.name,
+        };
+    }
+}
+exports.SecretParam = SecretParam;
+SecretParam.type = "secret";
+/**
+ *  A parametrized value of String type that will be read from .env files
+ *  if present, or prompted for by the CLI if missing.
+ */
+class StringParam extends Param {
+    /** @internal */
+    runtimeValue() {
+        return process.env[this.name] || "";
+    }
+}
+exports.StringParam = StringParam;
+/**
+ * A CEL expression which represents an internal Firebase variable. This class
+ * cannot be instantiated by developers, but we provide several canned instances
+ * of it to make available params that will never have to be defined at
+ * deployment time, and can always be read from process.env.
+ * @internal
+ */
+class InternalExpression extends Param {
+    constructor(name, getter) {
+        super(name);
+        this.getter = getter;
+    }
+    /** @internal */
+    runtimeValue() {
+        return this.getter(process.env) || "";
+    }
+    toSpec() {
+        throw new Error("An InternalExpression should never be marshalled for wire transmission.");
+    }
+}
+exports.InternalExpression = InternalExpression;
+/**
+ *  A parametrized value of Integer type that will be read from .env files
+ *  if present, or prompted for by the CLI if missing.
+ */
+class IntParam extends Param {
+    /** @internal */
+    runtimeValue() {
+        return parseInt(process.env[this.name] || "0", 10) || 0;
+    }
+}
+exports.IntParam = IntParam;
+IntParam.type = "int";
+/**
+ *  A parametrized value of Float type that will be read from .env files
+ *  if present, or prompted for by the CLI if missing.
+ */
+class FloatParam extends Param {
+    /** @internal */
+    runtimeValue() {
+        return parseFloat(process.env[this.name] || "0") || 0;
+    }
+}
+exports.FloatParam = FloatParam;
+FloatParam.type = "float";
+/**
+ *  A parametrized value of Boolean type that will be read from .env files
+ *  if present, or prompted for by the CLI if missing.
+ */
+class BooleanParam extends Param {
+    /** @internal */
+    runtimeValue() {
+        return !!process.env[this.name] && process.env[this.name] === "true";
+    }
+    then(ifTrue, ifFalse) {
+        return new TernaryExpression(this, ifTrue, ifFalse);
+    }
+}
+exports.BooleanParam = BooleanParam;
+BooleanParam.type = "boolean";

package/lib/runtime/loader.js

@@ -24,26 +24,26 @@ exports.loadStack = exports.mergeRequiredAPIs = exports.extractStack = void 0;
 // SOFTWARE.
 const path = require("path");
 const url = require("url");
-const params = require("../v2/params");
+const params = require("../params");
 /**
  * Dynamically load import function to prevent TypeScript from
  * transpiling into a require.
  *
  * See https://github.com/microsoft/TypeScript/issues/43329.
+ *
  */
-const dynamicImport = new Function('modulePath', 'return import(modulePath)');
+// eslint-disable-next-line @typescript-eslint/no-implied-eval
+const dynamicImport = new Function("modulePath", "return import(modulePath)");
 async function loadModule(functionsDir) {
     const absolutePath = path.resolve(functionsDir);
     try {
         return require(path.resolve(absolutePath));
     }
     catch (e) {
-        if (e.code === 'ERR_REQUIRE_ESM') {
+        if (e.code === "ERR_REQUIRE_ESM") {
             // This is an ESM package!
             const modulePath = require.resolve(absolutePath);
             // Resolve module path to file:// URL. Required for windows support.
-            // @ts-ignore pathToFileURL exists for Node.js v10 and up. Since ESM support exists for Node.js v13 and up, we
-            // can be sure that this function exists here.
             const moduleURL = url.pathToFileURL(modulePath).href;
             return await dynamicImport(moduleURL);
         }
@@ -51,24 +51,22 @@ async function loadModule(functionsDir) {
     }
 }
 /* @internal */
-function extractStack(module, endpoints, requiredAPIs, prefix = '') {
+function extractStack(module, endpoints, requiredAPIs, prefix = "") {
     for (const [name, valAsUnknown] of Object.entries(module)) {
         // We're introspecting untrusted code here. Any is appropraite
         const val = valAsUnknown;
-        if (typeof val === 'function' &&
-            val.__endpoint &&
-            typeof val.__endpoint === 'object') {
+        if (typeof val === "function" && val.__endpoint && typeof val.__endpoint === "object") {
             const funcName = prefix + name;
             endpoints[funcName] = {
                 ...val.__endpoint,
-                entryPoint: funcName.replace(/-/g, '.'),
+                entryPoint: funcName.replace(/-/g, "."),
             };
             if (val.__requiredAPIs && Array.isArray(val.__requiredAPIs)) {
                 requiredAPIs.push(...val.__requiredAPIs);
             }
         }
-        else if (typeof val === 'object' && val !== null) {
-            extractStack(val, endpoints, requiredAPIs, prefix + name + '-');
+        else if (typeof val === "object" && val !== null) {
+            extractStack(val, endpoints, requiredAPIs, prefix + name + "-");
         }
     }
 }
@@ -83,7 +81,7 @@ function mergeRequiredAPIs(requiredAPIs) {
     }
     const merged = [];
     for (const [api, reasons] of Object.entries(apiToReasons)) {
-        merged.push({ api, reason: Array.from(reasons).join(' ') });
+        merged.push({ api, reason: Array.from(reasons).join(" ") });
     }
     return merged;
 }
@@ -96,7 +94,7 @@ async function loadStack(functionsDir) {
     extractStack(mod, endpoints, requiredAPIs);
     const stack = {
         endpoints,
-        specVersion: 'v1alpha1',
+        specVersion: "v1alpha1",
         requiredAPIs: mergeRequiredAPIs(requiredAPIs),
     };
     if (params.declaredParams.length > 0) {

package/lib/runtime/manifest.d.ts

@@ -1,25 +1,28 @@
-import { Expression } from '../v2/params';
-import { ParamSpec } from '../v2/params/types';
+import { ResetValue } from "../common/options";
+import { Expression } from "../params";
+import { WireParamSpec } from "../params/types";
 /**
  * An definition of a function as appears in the Manifest.
+ *
+ * @alpha
  */
 export interface ManifestEndpoint {
     entryPoint?: string;
     region?: string[];
     platform?: string;
-    availableMemoryMb?: number | Expression<number>;
-    maxInstances?: number | Expression<number>;
-    minInstances?: number | Expression<number>;
-    concurrency?: number | Expression<number>;
-    serviceAccountEmail?: string;
-    timeoutSeconds?: number | Expression<number>;
-    cpu?: number | 'gcf_gen1';
+    availableMemoryMb?: number | Expression<number> | ResetValue;
+    maxInstances?: number | Expression<number> | ResetValue;
+    minInstances?: number | Expression<number> | ResetValue;
+    concurrency?: number | Expression<number> | ResetValue;
+    timeoutSeconds?: number | Expression<number> | ResetValue;
     vpc?: {
         connector: string | Expression<string>;
-        egressSettings?: string;
-    };
+        egressSettings?: string | Expression<string> | ResetValue;
+    } | ResetValue;
+    serviceAccountEmail?: string | Expression<string> | ResetValue;
+    cpu?: number | "gcf_gen1";
     labels?: Record<string, string>;
-    ingressSettings?: string;
+    ingressSettings?: string | Expression<string> | ResetValue;
     environmentVariables?: Record<string, string>;
     secretEnvironmentVariables?: Array<{
         key: string;
@@ -28,25 +31,41 @@ export interface ManifestEndpoint {
     httpsTrigger?: {
         invoker?: string[];
     };
-    callableTrigger?: {};
+    callableTrigger?: Record<string, never>;
     eventTrigger?: {
         eventFilters: Record<string, string | Expression<string>>;
         eventFilterPathPatterns?: Record<string, string | Expression<string>>;
         channel?: string;
         eventType: string;
-        retry: boolean | Expression<boolean>;
+        retry: boolean | Expression<boolean> | ResetValue;
         region?: string;
-        serviceAccountEmail?: string;
+        serviceAccountEmail?: string | ResetValue;
+    };
+    taskQueueTrigger?: {
+        retryConfig?: {
+            maxAttempts?: number | Expression<number> | ResetValue;
+            maxRetrySeconds?: number | Expression<number> | ResetValue;
+            maxBackoffSeconds?: number | Expression<number> | ResetValue;
+            maxDoublings?: number | Expression<number> | ResetValue;
+            minBackoffSeconds?: number | Expression<number> | ResetValue;
+        };
+        rateLimits?: {
+            maxConcurrentDispatches?: number | Expression<number> | ResetValue;
+            maxDispatchesPerSecond?: number | Expression<number> | ResetValue;
+        };
     };
     scheduleTrigger?: {
-        schedule?: string | Expression<string>;
-        timeZone?: string | Expression<string>;
+        schedule: string | Expression<string>;
+        timeZone?: string | Expression<string> | ResetValue;
         retryConfig?: {
-            retryCount?: number | Expression<number>;
-            maxRetrySeconds?: string | Expression<string>;
-            minBackoffSeconds?: string | Expression<string>;
-            maxBackoffSeconds?: string | Expression<string>;
-            maxDoublings?: number | Expression<number>;
+            retryCount?: number | Expression<number> | ResetValue;
+            maxRetrySeconds?: string | Expression<string> | ResetValue;
+            minBackoffSeconds?: string | Expression<string> | ResetValue;
+            maxBackoffSeconds?: string | Expression<string> | ResetValue;
+            maxDoublings?: number | Expression<number> | ResetValue;
+            maxRetryDuration?: string | Expression<string> | ResetValue;
+            minBackoffDuration?: string | Expression<string> | ResetValue;
+            maxBackoffDuration?: string | Expression<string> | ResetValue;
         };
     };
     blockingTrigger?: {
@@ -54,16 +73,29 @@ export interface ManifestEndpoint {
         options?: Record<string, unknown>;
     };
 }
+/**
+ * Description of API required for this stack.
+ * @alpha
+ */
 export interface ManifestRequiredAPI {
     api: string;
     reason: string;
 }
 /**
  * An definition of a function deployment as appears in the Manifest.
+ * @alpha
  */
 export interface ManifestStack {
-    specVersion: 'v1alpha1';
-    params?: ParamSpec[];
+    specVersion: "v1alpha1";
+    params?: WireParamSpec<any>[];
     requiredAPIs: ManifestRequiredAPI[];
     endpoints: Record<string, ManifestEndpoint>;
 }
+/**
+ * Returns the JSON representation of a ManifestStack, which has CEL
+ * expressions in its options as object types, with its expressions
+ * transformed into the actual CEL strings.
+ *
+ * @alpha
+ */
+export declare function stackToWire(stack: ManifestStack): Record<string, unknown>;