firebase-functions 3.21.0 → 3.22.0

package/lib/common/providers/database.js

@@ -0,0 +1,271 @@
+"use strict";
+// The MIT License (MIT)
+//
+// Copyright (c) 2022 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.DataSnapshot = void 0;
+const _ = require("lodash");
+const path_1 = require("../../utilities/path");
+/**
+ * Interface representing a Firebase Realtime Database data snapshot.
+ */
+class DataSnapshot {
+    constructor(data, path, // path will be undefined for the database root
+    app, instance) {
+        var _a, _b;
+        this.app = app;
+        if ((_b = (_a = app === null || app === void 0 ? void 0 : app.options) === null || _a === void 0 ? void 0 : _a.databaseURL) === null || _b === void 0 ? void 0 : _b.startsWith('http:')) {
+            // In this case we're dealing with an emulator
+            this.instance = app.options.databaseURL;
+        }
+        else if (instance) {
+            // SDK always supplies instance, but user's unit tests may not
+            this.instance = instance;
+        }
+        else if (app) {
+            this.instance = app.options.databaseURL;
+        }
+        else if (process.env.GCLOUD_PROJECT) {
+            this.instance =
+                'https://' + process.env.GCLOUD_PROJECT + '.firebaseio.com';
+        }
+        this._path = path;
+        this._data = data;
+    }
+    /**
+     * Returns a [`Reference`](/docs/reference/admin/node/admin.database.Reference)
+     * to the Database location where the triggering write occurred. Has
+     * full read and write access.
+     */
+    get ref() {
+        if (!this.app) {
+            // may be unpopulated in user's unit tests
+            throw new Error('Please supply a Firebase app in the constructor for DataSnapshot' +
+                ' in order to use the .ref method.');
+        }
+        if (!this._ref) {
+            this._ref = this.app.database(this.instance).ref(this._fullPath());
+        }
+        return this._ref;
+    }
+    /**
+     * The key (last part of the path) of the location of this `DataSnapshot`.
+     *
+     * The last token in a Database location is considered its key. For example,
+     * "ada" is the key for the `/users/ada/` node. Accessing the key on any
+     * `DataSnapshot` will return the key for the location that generated it.
+     * However, accessing the key on the root URL of a Database will return `null`.
+     */
+    get key() {
+        const last = _.last((0, path_1.pathParts)(this._fullPath()));
+        return !last || last === '' ? null : last;
+    }
+    /**
+     * Extracts a JavaScript value from a `DataSnapshot`.
+     *
+     * Depending on the data in a `DataSnapshot`, the `val()` method may return a
+     * scalar type (string, number, or boolean), an array, or an object. It may also
+     * return `null`, indicating that the `DataSnapshot` is empty (contains no
+     * data).
+     *
+     * @return The DataSnapshot's contents as a JavaScript value (Object,
+     *   Array, string, number, boolean, or `null`).
+     */
+    val() {
+        const parts = (0, path_1.pathParts)(this._childPath);
+        const source = this._data;
+        const node = _.cloneDeep(parts.length ? _.get(source, parts, null) : source);
+        return this._checkAndConvertToArray(node);
+    }
+    /**
+     * Exports the entire contents of the `DataSnapshot` as a JavaScript object.
+     *
+     * The `exportVal()` method is similar to `val()`, except priority information
+     * is included (if available), making it suitable for backing up your data.
+     *
+     * @return The contents of the `DataSnapshot` as a JavaScript value
+     *   (Object, Array, string, number, boolean, or `null`).
+     */
+    exportVal() {
+        return this.val();
+    }
+    /**
+     * Gets the priority value of the data in this `DataSnapshot`.
+     *
+     * As an alternative to using priority, applications can order collections by
+     * ordinary properties. See [Sorting and filtering
+     * data](/docs/database/web/lists-of-data#sorting_and_filtering_data).
+     *
+     * @return The priority value of the data.
+     */
+    getPriority() {
+        return 0;
+    }
+    /**
+     * Returns `true` if this `DataSnapshot` contains any data. It is slightly more
+     * efficient than using `snapshot.val() !== null`.
+     *
+     * @return `true` if this `DataSnapshot` contains any data; otherwise, `false`.
+     */
+    exists() {
+        return !_.isNull(this.val());
+    }
+    /**
+     * Gets a `DataSnapshot` for the location at the specified relative path.
+     *
+     * The relative path can either be a simple child name (for example, "ada") or
+     * a deeper slash-separated path (for example, "ada/name/first").
+     *
+     * @param path A relative path from this location to the desired child
+     *   location.
+     * @return The specified child location.
+     */
+    child(childPath) {
+        if (!childPath) {
+            return this;
+        }
+        return this._dup(childPath);
+    }
+    /**
+     * Enumerates the `DataSnapshot`s of the children items.
+     *
+     * Because of the way JavaScript objects work, the ordering of data in the
+     * JavaScript object returned by `val()` is not guaranteed to match the ordering
+     * on the server nor the ordering of `child_added` events. That is where
+     * `forEach()` comes in handy. It guarantees the children of a `DataSnapshot`
+     * will be iterated in their query order.
+     *
+     * If no explicit `orderBy*()` method is used, results are returned
+     * ordered by key (unless priorities are used, in which case, results are
+     * returned by priority).
+     *
+     * @param action A function that will be called for each child `DataSnapshot`.
+     *   The callback can return `true` to cancel further enumeration.
+     *
+     * @return `true` if enumeration was canceled due to your callback
+     *   returning `true`.
+     */
+    forEach(action) {
+        const val = this.val();
+        if (_.isPlainObject(val)) {
+            return _.some(val, (value, key) => action(this.child(key)) === true);
+        }
+        return false;
+    }
+    /**
+     * Returns `true` if the specified child path has (non-`null`) data.
+     *
+     * @param path A relative path to the location of a potential child.
+     * @return `true` if data exists at the specified child path; otherwise,
+     *   `false`.
+     */
+    hasChild(childPath) {
+        return this.child(childPath).exists();
+    }
+    /**
+     * Returns whether or not the `DataSnapshot` has any non-`null` child
+     * properties.
+     *
+     * You can use `hasChildren()` to determine if a `DataSnapshot` has any
+     * children. If it does, you can enumerate them using `forEach()`. If it
+     * doesn't, then either this snapshot contains a primitive value (which can be
+     * retrieved with `val()`) or it is empty (in which case, `val()` will return
+     * `null`).
+     *
+     * @return `true` if this snapshot has any children; else `false`.
+     */
+    hasChildren() {
+        const val = this.val();
+        return _.isPlainObject(val) && _.keys(val).length > 0;
+    }
+    /**
+     * Returns the number of child properties of this `DataSnapshot`.
+     *
+     * @return Number of child properties of this `DataSnapshot`.
+     */
+    numChildren() {
+        const val = this.val();
+        return _.isPlainObject(val) ? Object.keys(val).length : 0;
+    }
+    /**
+     * Returns a JSON-serializable representation of this object.
+     *
+     * @return A JSON-serializable representation of this object.
+     */
+    toJSON() {
+        return this.val();
+    }
+    /** Recursive function to check if keys are numeric & convert node object to array if they are
+     *
+     * @hidden
+     */
+    _checkAndConvertToArray(node) {
+        if (node === null || typeof node === 'undefined') {
+            return null;
+        }
+        if (typeof node !== 'object') {
+            return node;
+        }
+        const obj = {};
+        let numKeys = 0;
+        let maxKey = 0;
+        let allIntegerKeys = true;
+        for (const key in node) {
+            if (!node.hasOwnProperty(key)) {
+                continue;
+            }
+            const childNode = node[key];
+            obj[key] = this._checkAndConvertToArray(childNode);
+            numKeys++;
+            const integerRegExp = /^(0|[1-9]\d*)$/;
+            if (allIntegerKeys && integerRegExp.test(key)) {
+                maxKey = Math.max(maxKey, Number(key));
+            }
+            else {
+                allIntegerKeys = false;
+            }
+        }
+        if (allIntegerKeys && maxKey < 2 * numKeys) {
+            // convert to array.
+            const array = [];
+            _.forOwn(obj, (val, key) => {
+                array[key] = val;
+            });
+            return array;
+        }
+        return obj;
+    }
+    /** @hidden */
+    _dup(childPath) {
+        const dup = new DataSnapshot(this._data, undefined, this.app, this.instance);
+        [dup._path, dup._childPath] = [this._path, this._childPath];
+        if (childPath) {
+            dup._childPath = (0, path_1.joinPath)(dup._childPath, childPath);
+        }
+        return dup;
+    }
+    /** @hidden */
+    _fullPath() {
+        const out = (this._path || '') + '/' + (this._childPath || '');
+        return out;
+    }
+}
+exports.DataSnapshot = DataSnapshot;

package/lib/common/providers/https.d.ts

@@ -4,6 +4,7 @@ import * as firebase from 'firebase-admin';
 import { TaskContext } from './tasks';
 /** @hidden */
 export interface Request extends express.Request {
+    /** The wire format representation of the request body. */
     rawBody: Buffer;
 }
 interface DecodedAppCheckToken {
@@ -114,37 +115,53 @@ export interface CallableRequest<T = any> {
  * https://github.com/grpc/grpc/blob/master/doc/statuscodes.md
  *
  * Possible values:
- * - 'cancelled': The operation was cancelled (typically by the caller).
- * - 'unknown': Unknown error or an error from a different error domain.
- * - 'invalid-argument': Client specified an invalid argument. Note that this
- *   differs from 'failed-precondition'. 'invalid-argument' indicates
+ *
+ * - `cancelled`: The operation was cancelled (typically by the caller).
+ *
+ * - `unknown`: Unknown error or an error from a different error domain.
+ *
+ * - `invalid-argument`: Client specified an invalid argument. Note that this
+ *   differs from `failed-precondition`. `invalid-argument` indicates
  *   arguments that are problematic regardless of the state of the system
  *   (e.g. an invalid field name).
- * - 'deadline-exceeded': Deadline expired before operation could complete.
+ *
+ * - `deadline-exceeded`: Deadline expired before operation could complete.
  *   For operations that change the state of the system, this error may be
  *   returned even if the operation has completed successfully. For example,
  *   a successful response from a server could have been delayed long enough
  *   for the deadline to expire.
- * - 'not-found': Some requested document was not found.
- * - 'already-exists': Some document that we attempted to create already
+ *
+ * - `not-found`: Some requested document was not found.
+ *
+ * - `already-exists`: Some document that we attempted to create already
  *   exists.
- * - 'permission-denied': The caller does not have permission to execute the
+ *
+ * - `permission-denied`: The caller does not have permission to execute the
  *   specified operation.
- * - 'resource-exhausted': Some resource has been exhausted, perhaps a
+ *
+ * - `resource-exhausted`: Some resource has been exhausted, perhaps a
  *   per-user quota, or perhaps the entire file system is out of space.
- * - 'failed-precondition': Operation was rejected because the system is not
+ *
+ * - `failed-precondition`: Operation was rejected because the system is not
  *   in a state required for the operation's execution.
- * - 'aborted': The operation was aborted, typically due to a concurrency
+ *
+ * - `aborted`: The operation was aborted, typically due to a concurrency
  *   issue like transaction aborts, etc.
- * - 'out-of-range': Operation was attempted past the valid range.
- * - 'unimplemented': Operation is not implemented or not supported/enabled.
- * - 'internal': Internal errors. Means some invariants expected by
+ *
+ * - `out-of-range`: Operation was attempted past the valid range.
+ *
+ * - `unimplemented`: Operation is not implemented or not supported/enabled.
+ *
+ * - `internal`: Internal errors. Means some invariants expected by
  *   underlying system has been broken. If you see one of these errors,
  *   something is very broken.
- * - 'unavailable': The service is currently unavailable. This is most likely
+ *
+ * - `unavailable`: The service is currently unavailable. This is most likely
  *   a transient condition and may be corrected by retrying with a backoff.
- * - 'data-loss': Unrecoverable data loss or corruption.
- * - 'unauthenticated': The request does not have valid authentication
+ *
+ * - `data-loss`: Unrecoverable data loss or corruption.
+ *
+ * - `unauthenticated`: The request does not have valid authentication
  *   credentials for the operation.
  */
 export declare type FunctionsErrorCode = 'ok' | 'cancelled' | 'unknown' | 'invalid-argument' | 'deadline-exceeded' | 'not-found' | 'already-exists' | 'permission-denied' | 'resource-exhausted' | 'failed-precondition' | 'aborted' | 'out-of-range' | 'unimplemented' | 'internal' | 'unavailable' | 'data-loss' | 'unauthenticated';
@@ -182,6 +199,9 @@ export declare class HttpsError extends Error {
      */
     readonly httpErrorCode: HttpErrorCode;
     constructor(code: FunctionsErrorCode, message: string, details?: unknown);
+    /**
+     * Returns a JSON-serializable representation of this object.
+     */
     toJSON(): HttpErrorWireFormat;
 }
 /** @hidden */

package/lib/common/providers/https.js

@@ -72,6 +72,9 @@ class HttpsError extends Error {
         this.details = details;
         this.httpErrorCode = errorCodeMap[code];
     }
+    /**
+     * Returns a JSON-serializable representation of this object.
+     */
     toJSON() {
         const { details, httpErrorCode: { canonicalName: status }, message, } = this;
         return {

package/lib/common/providers/identity.d.ts

@@ -2,7 +2,11 @@ import * as firebase from 'firebase-admin';
 import { EventContext } from '../../cloud-functions';
 import { HttpsError } from './https';
 export { HttpsError };
-/** Shorthand auth blocking events from GCIP. */
+/**
+ * Shorthand auth blocking events from GCIP.
+ * @hidden
+ * @alpha
+ */
 export declare type AuthBlockingEventType = 'beforeCreate' | 'beforeSignIn';
 /**
  * The UserRecord passed to Cloud Functions is the same UserRecord that is returned by the Firebase Admin

package/lib/common/providers/identity.js

@@ -110,7 +110,11 @@ function userRecordConstructor(wireData) {
         };
         json.metadata = record.metadata.toJSON();
         json.customClaims = JSON.parse(JSON.stringify(record.customClaims));
-        json.providerData = record.providerData.map((entry) => entry.toJSON());
+        json.providerData = record.providerData.map((entry) => {
+            const newEntry = { ...entry };
+            newEntry.toJSON = () => entry;
+            return newEntry;
+        });
         return json;
     };
     return record;
@@ -422,9 +426,13 @@ function wrapHandler(eventType, handler) {
             }
             const decodedPayload = (0, debug_1.isDebugFeatureEnabled)('skipTokenVerification')
                 ? unsafeDecodeAuthBlockingToken(req.body.data.jwt)
-                : await (0, apps_1.apps)()
-                    .admin.auth()
-                    ._verifyAuthBlockingToken(req.body.data.jwt);
+                : handler.length === 2
+                    ? await (0, apps_1.apps)()
+                        .admin.auth()
+                        ._verifyAuthBlockingToken(req.body.data.jwt)
+                    : await (0, apps_1.apps)()
+                        .admin.auth()
+                        ._verifyAuthBlockingToken(req.body.data.jwt, 'run.app');
             const authUserRecord = parseAuthUserRecord(decodedPayload.user_record);
             const authEventContext = parseAuthEventContext(decodedPayload, projectId);
             let authResponse;

package/lib/common/providers/tasks.d.ts

@@ -29,9 +29,18 @@ export interface RetryConfig {
 }
 /** How congestion control should be applied to the function. */
 export interface RateLimits {
+    /**
+     * The maximum number of requests that can be outstanding at a time.
+     * If left unspecified, will default to 1000.
+     */
     maxConcurrentDispatches?: number;
+    /**
+     * The maximum number of requests that can be invoked per second.
+     * If left unspecified, will default to 500.
+     */
     maxDispatchesPerSecond?: number;
 }
+/** Metadata about the authorization used to invoke a function. */
 export interface AuthData {
     uid: string;
     token: firebase.auth.DecodedIdToken;

package/lib/common/providers/tasks.js

@@ -33,20 +33,21 @@ function onDispatchHandler(handler) {
                 logger.error('Invalid request, unable to process.');
                 throw new https.HttpsError('invalid-argument', 'Bad Request');
             }
-            const authHeader = req.header('Authorization') || '';
-            const token = (_a = authHeader.match(/^Bearer (.*)$/)) === null || _a === void 0 ? void 0 : _a[1];
-            // Note: this should never happen since task queue functions are guarded by IAM.
-            if (!token) {
-                throw new https.HttpsError('unauthenticated', 'Unauthenticated');
-            }
-            // We skip authenticating the token since tq functions are guarded by IAM.
-            const authToken = await https.unsafeDecodeIdToken(token);
-            const context = {
-                auth: {
+            const context = {};
+            if (!process.env.FUNCTIONS_EMULATOR) {
+                const authHeader = req.header('Authorization') || '';
+                const token = (_a = authHeader.match(/^Bearer (.*)$/)) === null || _a === void 0 ? void 0 : _a[1];
+                // Note: this should never happen since task queue functions are guarded by IAM.
+                if (!token) {
+                    throw new https.HttpsError('unauthenticated', 'Unauthenticated');
+                }
+                // We skip authenticating the token since tq functions are guarded by IAM.
+                const authToken = await https.unsafeDecodeIdToken(token);
+                context.auth = {
                     uid: authToken.uid,
                     token: authToken,
-                },
-            };
+                };
+            }
             const data = https.decode(req.body.data);
             if (handler.length === 2) {
                 await handler(data, context);

package/lib/function-builder.d.ts

@@ -24,7 +24,7 @@ export declare function region(...regions: Array<typeof SUPPORTED_REGIONS[number
  * Configure runtime options for the function.
  * @param runtimeOptions Object with optional fields:
  * 1. `memory`: amount of memory to allocate to the function, possible values
- *    are: '128MB', '256MB', '512MB', '1GB', '2GB', and '4GB'.
+ *    are: '128MB', '256MB', '512MB', '1GB', '2GB', '4GB', and '8GB'.
  * 2. `timeoutSeconds`: timeout for the function in seconds, possible values are
  *    0 to 540.
  * 3. `failurePolicy`: failure policy of the function, with boolean `true` being
@@ -55,7 +55,7 @@ export declare class FunctionBuilder {
      * Configure runtime options for the function.
      * @param runtimeOptions Object with optional fields:
      * 1. `memory`: amount of memory to allocate to the function, possible values
-     *    are: '128MB', '256MB', '512MB', '1GB', '2GB', and '4GB'.
+     *    are: '128MB', '256MB', '512MB', '1GB', '2GB', '4GB', and '8GB'.
      * 2. `timeoutSeconds`: timeout for the function in seconds, possible values are
      *    0 to 540.
      * 3. `failurePolicy`: failure policy of the function, with boolean `true` being
@@ -78,7 +78,7 @@ export declare class FunctionBuilder {
          * Declares a callable method for clients to call using a Firebase SDK.
          * @param handler A method that takes a data and context and returns a value.
          */
-        onCall: (handler: (data: any, context: https.CallableContext) => any | Promise<any>) => import("./cloud-functions").TriggerAnnotated & import("./cloud-functions").EndpointAnnotated & ((req: express.Request<import("express-serve-static-core").ParamsDictionary>, resp: express.Response<any>) => void | Promise<void>) & import("./cloud-functions").Runnable<any>;
+        onCall: (handler: (data: any, context: https.CallableContext) => any | Promise<any>) => import("./cloud-functions").HttpsFunction & import("./cloud-functions").Runnable<any>;
     };
     get tasks(): {
         /**

package/lib/function-builder.js

@@ -164,7 +164,7 @@ exports.region = region;
  * Configure runtime options for the function.
  * @param runtimeOptions Object with optional fields:
  * 1. `memory`: amount of memory to allocate to the function, possible values
- *    are: '128MB', '256MB', '512MB', '1GB', '2GB', and '4GB'.
+ *    are: '128MB', '256MB', '512MB', '1GB', '2GB', '4GB', and '8GB'.
  * 2. `timeoutSeconds`: timeout for the function in seconds, possible values are
  *    0 to 540.
  * 3. `failurePolicy`: failure policy of the function, with boolean `true` being
@@ -206,7 +206,7 @@ class FunctionBuilder {
      * Configure runtime options for the function.
      * @param runtimeOptions Object with optional fields:
      * 1. `memory`: amount of memory to allocate to the function, possible values
-     *    are: '128MB', '256MB', '512MB', '1GB', '2GB', and '4GB'.
+     *    are: '128MB', '256MB', '512MB', '1GB', '2GB', '4GB', and '8GB'.
      * 2. `timeoutSeconds`: timeout for the function in seconds, possible values are
      *    0 to 540.
      * 3. `failurePolicy`: failure policy of the function, with boolean `true` being

package/lib/logger/common.js

@@ -1,4 +1,25 @@
 "use strict";
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 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.
 var _a, _b, _c;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UNPATCHED_CONSOLE = exports.CONSOLE_SEVERITY = exports.SUPPORTS_STRUCTURED_LOGS = void 0;

package/lib/logger/compat.js

@@ -1,4 +1,25 @@
 "use strict";
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 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 });
 const util_1 = require("util");
 const common_1 = require("./common");

package/lib/logger/index.d.ts

@@ -1,11 +1,13 @@
 /**
  * `LogSeverity` indicates the detailed severity of the log entry. See [LogSeverity](https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#logseverity).
+ * @public
  */
 export declare type LogSeverity = 'DEBUG' | 'INFO' | 'NOTICE' | 'WARNING' | 'ERROR' | 'CRITICAL' | 'ALERT' | 'EMERGENCY';
 /**
  * `LogEntry` represents a [structured Cloud Logging](https://cloud.google.com/logging/docs/structured-logging)
  * entry. All keys aside from `severity` and `message` are
  * included in the `jsonPayload` of the logged entry.
+ * @public
  */
 export interface LogEntry {
     severity: LogSeverity;
@@ -14,36 +16,42 @@ export interface LogEntry {
 }
 /**
  * Writes a `LogEntry` to `stdout`/`stderr` (depending on severity).
- * @param entry The `LogEntry` including severity, message, and any additional structured metadata.
+ * @param entry - The `LogEntry` including severity, message, and any additional structured metadata.
+ * @public
  */
 export declare function write(entry: LogEntry): void;
 /**
  * Writes a `DEBUG` severity log. If the last argument provided is a plain object,
  * it is added to the `jsonPayload` in the Cloud Logging entry.
- * @param args Arguments, concatenated into the log message with space separators.
+ * @param args - Arguments, concatenated into the log message with space separators.
+ * @public
  */
 export declare function debug(...args: any[]): void;
 /**
  * Writes an `INFO` severity log. If the last argument provided is a plain object,
  * it is added to the `jsonPayload` in the Cloud Logging entry.
- * @param args Arguments, concatenated into the log message with space separators.
+ * @param args - Arguments, concatenated into the log message with space separators.
+ * @public
  */
 export declare function log(...args: any[]): void;
 /**
  * Writes an `INFO` severity log. If the last argument provided is a plain object,
  * it is added to the `jsonPayload` in the Cloud Logging entry.
- * @param args Arguments, concatenated into the log message with space separators.
+ * @param args - Arguments, concatenated into the log message with space separators.
+ * @public
  */
 export declare function info(...args: any[]): void;
 /**
  * Writes a `WARNING` severity log. If the last argument provided is a plain object,
  * it is added to the `jsonPayload` in the Cloud Logging entry.
- * @param args Arguments, concatenated into the log message with space separators.
+ * @param args - Arguments, concatenated into the log message with space separators.
+ * @public
  */
 export declare function warn(...args: any[]): void;
 /**
  * Writes an `ERROR` severity log. If the last argument provided is a plain object,
  * it is added to the `jsonPayload` in the Cloud Logging entry.
- * @param args Arguments, concatenated into the log message with space separators.
+ * @param args - Arguments, concatenated into the log message with space separators.
+ * @public
  */
 export declare function error(...args: any[]): void;