@ohos-ports/layer0-prefetch 4.20.0-beta.0 → 4.20.0-beta.1

package/node_modules/@layer0/core/router/normalizeCriteria.d.ts

@@ -0,0 +1,6 @@
+import RouteCriteria from './RouteCriteria';
+/**
+ * Converts null to an empty RouteCriteria and a string to a RouteCriteria with path.
+ * @param criteria null, a route pattern, or an object that implements the RouteCriteria interface
+ */
+export default function normalizeCriteria(criteria: string | RouteCriteria | null | undefined): RouteCriteria;

package/node_modules/@layer0/core/router/normalizeCriteria.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Converts null to an empty RouteCriteria and a string to a RouteCriteria with path.
+ * @param criteria null, a route pattern, or an object that implements the RouteCriteria interface
+ */
+function normalizeCriteria(criteria) {
+    if (criteria == null) {
+        return {};
+    }
+    else if (typeof criteria === 'string') {
+        return {
+            path: criteria,
+        };
+    }
+    else {
+        return criteria;
+    }
+}
+exports.default = normalizeCriteria;

package/node_modules/@layer0/core/router/stream.d.ts

@@ -0,0 +1,12 @@
+import Request from './Request';
+import Response from './Response';
+import BackendConfig from './BackendOptions';
+/**
+ * Proxies the request to the specified backend as a stream.  This can be used for event streams
+ * for hot module reloading.
+ * @param req The downstream request
+ * @param res The downstream response
+ * @param backendConfig The backend config from `layer0.config.js`
+ * @param errorHandler A function to call when an error occurs
+ */
+export default function stream(req: Request, res: Response, backendConfig: BackendConfig, errorHandler: any): void;

package/node_modules/@layer0/core/router/stream.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_proxy_1 = __importDefault(require("http-proxy"));
+const proxy = http_proxy_1.default.createProxyServer({
+    changeOrigin: true,
+});
+/**
+ * Proxies the request to the specified backend as a stream.  This can be used for event streams
+ * for hot module reloading.
+ * @param req The downstream request
+ * @param res The downstream response
+ * @param backendConfig The backend config from `layer0.config.js`
+ * @param errorHandler A function to call when an error occurs
+ */
+function stream(req, res, backendConfig, errorHandler) {
+    const protocol = backendConfig.domainOrIp === '127.0.0.1' ? 'http' : 'https';
+    const config = {
+        target: {
+            protocol,
+            host: backendConfig.domainOrIp,
+            port: backendConfig.port,
+        },
+    };
+    // @ts-ignore
+    proxy.web(req, res, config, errorHandler || Function.prototype);
+}
+exports.default = stream;

package/node_modules/@layer0/core/router/universalRouteUtils.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Compares criteria object with request object and returns Boolean.
+ *
+ * The comparison of keys is case-sensitive by default but an optional `criteriaObjKeyNameFn`
+ * parameter can be passed to force case-insensitive comparison.
+ *
+ * @param criteriaObj Object that contains the criteria ([key]: regex | null)
+ * @param requestObj Request object that contains ([key]: string | [key]: string[] | undefined)
+ * @param criteriaObjKeyNameFn Optional function to process criteria key names; by default set to `identity`
+ *
+ * @returns Boolean
+ * true when all conditions are matching
+ * false if one of the conditions failed
+ */
+export declare function matchCriteriaRegexObjectWithRequestObject(criteriaObj: {
+    [name: string]: string | RegExp | null;
+}, requestObj: {
+    [key: string]: string | string[] | undefined;
+}, criteriaObjKeyNameFn?: (key: string) => string): false | {
+    [key: string]: string;
+};
+/**
+ * Tests to see if source object deeply matches the criteria object
+ *
+ * @param source Object
+ * @param criteria Object
+ *
+ * @returns boolean
+ */
+export declare function deepMatchObject(source: any, criteria: any): boolean;
+/**
+ * Returns true if the value is a matcher that is used to extract
+ * request params, like ':id' or ':path'
+ * @param value
+ */
+export declare function isParamMatcher(value: any): boolean;
+/**
+ * Transform a route param matcher to the param name
+ * ex: ':id' -> 'id'
+ * @param value
+ */
+export declare function paramMatcherToParam(value: any): any;
+/**
+ * Ensures that the regular expression will be tested anew, without changing its internal state.
+ *
+ * Notes:
+ * - Sometimes users use global for RegExp definitions. In those cases `.test` changes the internal
+ * state and leads to different requests on subsequent calls (usually flip-flopping between
+ * subsequent requests)
+ *
+ * @private
+ * @param regexp Regular expression
+ * @param value Value to test or array of values to test
+ */
+export declare function testRegExp(regexp: RegExp, value: undefined | string | string[]): boolean;

package/node_modules/@layer0/core/router/universalRouteUtils.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+Note: this file contains functions that are needed in both the browser and the server.  These were originally
+in Route.ts, but extracted in order to keep Route.ts and it's depedencies from being pulled into the browser bundle.
+*/
+const identity = (x) => x;
+/**
+ * Compares criteria object with request object and returns Boolean.
+ *
+ * The comparison of keys is case-sensitive by default but an optional `criteriaObjKeyNameFn`
+ * parameter can be passed to force case-insensitive comparison.
+ *
+ * @param criteriaObj Object that contains the criteria ([key]: regex | null)
+ * @param requestObj Request object that contains ([key]: string | [key]: string[] | undefined)
+ * @param criteriaObjKeyNameFn Optional function to process criteria key names; by default set to `identity`
+ *
+ * @returns Boolean
+ * true when all conditions are matching
+ * false if one of the conditions failed
+ */
+function matchCriteriaRegexObjectWithRequestObject(criteriaObj, requestObj, criteriaObjKeyNameFn = identity) {
+    let params = {};
+    return (Object.entries(criteriaObj).every(([name, regex]) => {
+        const value = requestObj[criteriaObjKeyNameFn(name)];
+        // When regex is null we match that the value *does not* exist (the undefined case).
+        // When regex is string, we convert it to regex matching the whole string.
+        // When regex is a matching key (ex: ':id') and the value is a string, we extract that into
+        // matcher params
+        if (regex === null) {
+            return value === undefined;
+        }
+        else if (typeof regex === 'string') {
+            if (typeof value === 'string' && isParamMatcher(regex)) {
+                const paramName = paramMatcherToParam(regex);
+                params[paramName] = value;
+                return true;
+            }
+            regex = new RegExp(`^${regex}$`, 'i');
+        }
+        return testRegExp(regex, value);
+    }) && params);
+}
+exports.matchCriteriaRegexObjectWithRequestObject = matchCriteriaRegexObjectWithRequestObject;
+/**
+ * Tests to see if source object deeply matches the criteria object
+ *
+ * @param source Object
+ * @param criteria Object
+ *
+ * @returns boolean
+ */
+function deepMatchObject(source, criteria) {
+    return Object.entries(criteria).every(([key, criteriaValue]) => {
+        const sourceValue = source[key];
+        if (!sourceValue)
+            return false;
+        if (criteriaValue instanceof RegExp) {
+            return testRegExp(criteriaValue, sourceValue);
+        }
+        else if (typeof criteriaValue === 'object' && criteriaValue !== null) {
+            return deepMatchObject(sourceValue, criteriaValue);
+        }
+        else {
+            return sourceValue == criteriaValue;
+        }
+    });
+}
+exports.deepMatchObject = deepMatchObject;
+/**
+ * Returns true if the value is a matcher that is used to extract
+ * request params, like ':id' or ':path'
+ * @param value
+ */
+function isParamMatcher(value) {
+    return typeof value === 'string' && /^:\w+$/.test(value);
+}
+exports.isParamMatcher = isParamMatcher;
+/**
+ * Transform a route param matcher to the param name
+ * ex: ':id' -> 'id'
+ * @param value
+ */
+function paramMatcherToParam(value) {
+    return value.slice(1);
+}
+exports.paramMatcherToParam = paramMatcherToParam;
+/**
+ * Ensures that the regular expression will be tested anew, without changing its internal state.
+ *
+ * Notes:
+ * - Sometimes users use global for RegExp definitions. In those cases `.test` changes the internal
+ * state and leads to different requests on subsequent calls (usually flip-flopping between
+ * subsequent requests)
+ *
+ * @private
+ * @param regexp Regular expression
+ * @param value Value to test or array of values to test
+ */
+function testRegExp(regexp, value) {
+    if (value == null) {
+        return false;
+    }
+    if (regexp.global) {
+        regexp = new RegExp(regexp);
+    }
+    if (Array.isArray(value)) {
+        return value.some(v => regexp.test(v));
+    }
+    else {
+        return regexp.test(value);
+    }
+}
+exports.testRegExp = testRegExp;

package/node_modules/@layer0/core/router/validateWriter.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Validate Set response header
+ * @param name header name
+ * @param value header value
+ */
+export declare const validateSetResponseHeader: (name: string) => void;
+/**
+ * Validate Update response header
+ * @param name header name
+ * @param match match pattern
+ * @param replace replace value
+ */
+export declare const validateUpdateResponseHeader: (name: string) => void;
+/**
+ * Validate Remove response header
+ * @param name
+ */
+export declare const validateRemoveResponseHeader: (name: string) => void;
+/**
+ * Validate set request header
+ * @param name header name
+ * @param value header value
+ */
+export declare const validateSetRequestHeader: (name: string) => void;
+/**
+ * Validate Update request header
+ * @param name header name
+ * @param match match pattern
+ * @param replace replace value
+ */
+export declare const validateUpdateRequestHeader: (name: string) => void;
+/**
+ * Validate Remove request header
+ * @param name
+ */
+export declare const validateRemoveRequestHeader: (name: string) => void;
+/**
+ * Validate cookie name.
+ * @param name
+ */
+export declare const validateCookieName: (name: string) => void;

package/node_modules/@layer0/core/router/validateWriter.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * List of header regexes that will be matched against user provided header name.
+ * The following headers are not allowed for user to modify in any way.
+ *
+ * * `x-0-platform` headers are generated and maintained by Layer0 platform to store intermediate state during request processing
+ * * `x-0-version` header should only be manipulated by Layer0 platform
+ * * `x-0-t` header should only be manipulated by Layer0 platform
+ * * `x-0-components` header should only be manipulated by Layer0 platform
+ * * `x-0-status` header should only be manipulated by Layer0 platform
+ * * `x-0-lambda-name`  header should only be manipulated by Layer0 platform as otherwise it messes with reverse proxying. Removed by XBP
+ * * `x-0-lambda-schedule-timeout` header should only be manipulated by Layer0 platform as otherwise it messes with reverse proxying. Removed by XBP
+ * * `x-0-received-at` header should only be manipulated by Layer0 platform as otherwise it messes with reverse proxying.
+ * * `host` header should only be manipulated by Layer0 platform as otherwise it messes with reverse proxying
+ * * `x-request-id` header is generated by Layer0 platform and used as unique identifier of requests
+ * * `content-length` header cannot be manipulated apart from manipulating the body and we don't support that in the edge
+ * * `via` header is used to prevent request loops in the platform
+ */
+const LAYER0_PROHIBITED_HEADER_NAMES = [
+    // Only allowed for platform to manipulate
+    /^\s*x-0-platform\s*/i,
+    // Deny list for x-0-* headers
+    /^\s*x-0-version\s*$/i,
+    /^\s*x-0-t\s*$/i,
+    /^\s*x-0-components\s*$/i,
+    /^\s*x-0-status\s*$/i,
+    /^\s*x-0-lambda-name\s*$/i,
+    /^\s*x-0-lambda-schedule-timeout\s*$/i,
+    /^\s*x-0-received-at\s*$/i,
+    // Deny list for non x-0-* headers
+    /^\s*host\s*$/i,
+    /^\s*x-request-id\s*$/i,
+    /^\s*content-length\s*$/i,
+    /^\s*via\s*$/i,
+];
+/**
+ * List of cookie regexes that will be matched against user provided cookie name.
+ * The following cookies are not allowed for user to modify in any way.
+ *
+ * * `layer0_*` cookies are created and maintained by Layer0 platform (e.g. `layer0_buckets` and `layer0_destination`)
+ * * `layer0_devtools_*` cookies allow enabling/disabling the devtools on a per-user or per-environment bases
+ *    (cf. packages/devtools/src/addBuiltInRoutes.js)
+ */
+const LAYER0_PROHIBITED_COOKIE_NAMES = [/^layer0_/i];
+const LAYER0_WHITELISTED_COOKIE_NAMES = [/^layer0_devtools/i];
+/**
+ * Validate that prohibited header names are not overrideable by the user
+ * @param name
+ */
+const validateProhibitedHeaderNames = (name) => {
+    if (LAYER0_PROHIBITED_HEADER_NAMES.find(prohibitedRegex => name.match(prohibitedRegex))) {
+        throw new Error(`Header "${name}" is reserved and cannot be modified`);
+    }
+};
+/**
+ * Validate that prohibited cookie names are not overrideable by the user
+ * @param name
+ */
+const validateProhibitedCookieNames = (name) => {
+    if (LAYER0_PROHIBITED_COOKIE_NAMES.find(prohibitedRegex => name.match(prohibitedRegex)) &&
+        !LAYER0_WHITELISTED_COOKIE_NAMES.find(whitelistRegexp => name.match(whitelistRegexp))) {
+        throw new Error(`Cookie "${name}" is reserved and cannot be modified`);
+    }
+};
+/**
+ * Validate Set response header
+ * @param name header name
+ * @param value header value
+ */
+exports.validateSetResponseHeader = (name /* value */) => {
+    validateProhibitedHeaderNames(name);
+};
+/**
+ * Validate Update response header
+ * @param name header name
+ * @param match match pattern
+ * @param replace replace value
+ */
+exports.validateUpdateResponseHeader = (name /* match, replace */) => {
+    validateProhibitedHeaderNames(name);
+};
+/**
+ * Validate Remove response header
+ * @param name
+ */
+exports.validateRemoveResponseHeader = (name) => {
+    validateProhibitedHeaderNames(name);
+};
+/**
+ * Validate set request header
+ * @param name header name
+ * @param value header value
+ */
+exports.validateSetRequestHeader = (name) => {
+    validateProhibitedHeaderNames(name);
+};
+/**
+ * Validate Update request header
+ * @param name header name
+ * @param match match pattern
+ * @param replace replace value
+ */
+exports.validateUpdateRequestHeader = (name) => {
+    validateProhibitedHeaderNames(name);
+};
+/**
+ * Validate Remove request header
+ * @param name
+ */
+exports.validateRemoveRequestHeader = (name) => {
+    validateProhibitedHeaderNames(name);
+};
+/**
+ * Validate cookie name.
+ * @param name
+ */
+exports.validateCookieName = (name) => {
+    validateProhibitedCookieNames(name);
+};

package/node_modules/@layer0/core/serverless.yml

@@ -0,0 +1,30 @@
+service:
+  name: myApp
+
+provider:
+  name: aws
+  runtime: nodejs16.x # NODE_VERSION
+
+plugins:
+  - serverless-offline
+  - serverless-dotenv-plugin
+custom:
+  dotenv:
+    path: '../../.env'
+
+functions:
+  all:
+    handler: handler.handler
+    environment:
+      LAYER0_DEPLOYMENT_TYPE: AWS
+      LAYER0_CONFIG: '{ "backends": { "__static__": { "domainOrIp": "127.0.0.1:3002" } } }'
+    # The `events` block defines how to trigger the handler
+    events:
+      - http:
+          path: /
+          method: ANY
+          cors: true
+      - http:
+          path: /{proxy+}
+          method: ANY
+          cors: true

package/node_modules/@layer0/core/source.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Gets the directory corresponding to the root of the project source code.
+ */
+export declare function getSourceDir(): string;
+/**
+ * Sets the directory corresponding to the root of the project source code.
+ * @param dir The directory to set
+ */
+export declare function setSourceDir(dir: string): void;

package/node_modules/@layer0/core/source.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Gets the directory corresponding to the root of the project source code.
+ */
+function getSourceDir() {
+    return process.env.LAYER0_ROOT_SOURCE_DIR || process.cwd();
+}
+exports.getSourceDir = getSourceDir;
+/**
+ * Sets the directory corresponding to the root of the project source code.
+ * @param dir The directory to set
+ */
+function setSourceDir(dir) {
+    process.env.LAYER0_ROOT_SOURCE_DIR = dir;
+}
+exports.setSourceDir = setSourceDir;

package/node_modules/@layer0/core/test-utils/MockRequest.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="jest" />
+export default class MockRequest {
+    method: string;
+    headers: {
+        host: string;
+    };
+    connection: {
+        remoteAddress: string;
+    };
+    constructor(config: any);
+    setHeader: jest.Mock<any, any>;
+    updateHeader: jest.Mock<any, any>;
+    removeHeader: jest.Mock<any, any>;
+    on: jest.Mock<void, [any, any]>;
+}

package/node_modules/@layer0/core/test-utils/MockRequest.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-nocheck
+const querystring_1 = __importDefault(require("querystring"));
+class MockRequest {
+    constructor(config) {
+        this.method = 'GET';
+        this.headers = {
+            host: 'jest.layer0.co',
+        };
+        this.connection = {
+            remoteAddress: '127.0.0.1',
+        };
+        this.setHeader = jest.fn();
+        this.updateHeader = jest.fn();
+        this.removeHeader = jest.fn();
+        this.on = jest.fn((event, cb) => {
+            if (event === 'end') {
+                cb();
+            }
+        });
+        Object.assign(this, config);
+        if (config.url) {
+            const [path, qs] = config.url.split(/\?/);
+            this.path = path;
+            this.query = {
+                ...this.query,
+                ...(qs && querystring_1.default.parse(qs)),
+            };
+        }
+    }
+}
+exports.default = MockRequest;

package/node_modules/@layer0/core/test-utils/MockResponse.d.ts

@@ -0,0 +1,7 @@
+export default class MockResponse {
+    headers: {
+        'x-test': string;
+    };
+    constructor(config?: {});
+    clone: () => this;
+}

package/node_modules/@layer0/core/test-utils/MockResponse.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-nocheck
+class MockResponse {
+    constructor(config = {}) {
+        this.headers = {
+            'x-test': 'jest',
+        };
+        this.clone = () => this;
+        Object.assign(this, {
+            writeHead: jest.fn(),
+            end: jest.fn(body => (this.body = (body || '').toString())),
+            getHeader: jest.fn(name => this.headers[name.toLowerCase()] || this.headers[name]),
+            setHeader: jest.fn((name, value) => (this.headers[name] = value)),
+            removeHeader: jest.fn(name => delete this.headers[name]),
+            getHeaders: () => this.headers,
+            on: jest.fn(),
+            once: jest.fn(),
+            write: jest.fn(),
+            emit: jest.fn(),
+        }, config);
+    }
+}
+exports.default = MockResponse;

package/node_modules/@layer0/core/test-utils/expect-extend.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@layer0/core/test-utils/expect-extend.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const extensions = __importStar(require("./matchers"));
+expect.extend(extensions);

package/node_modules/@layer0/core/test-utils/index.d.ts

@@ -0,0 +1,4 @@
+import './expect-extend';
+export { default as runRoute } from './utils/runRoute';
+export { default as createRouteMock } from './utils/createRouteMock';
+export { appHost, staticHost, backendHost } from './utils/getBackend';

package/node_modules/@layer0/core/test-utils/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./expect-extend");
+var runRoute_1 = require("./utils/runRoute");
+exports.runRoute = runRoute_1.default;
+var createRouteMock_1 = require("./utils/createRouteMock");
+exports.createRouteMock = createRouteMock_1.default;
+var getBackend_1 = require("./utils/getBackend");
+exports.appHost = getBackend_1.appHost;
+exports.staticHost = getBackend_1.staticHost;
+exports.backendHost = getBackend_1.backendHost;

package/node_modules/@layer0/core/test-utils/matchers/toBeCachedByTheBrowser.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Matches the browser cache-control header in the response with an optional duration
+ *
+ * **Example**
+ * ```js
+ * expect(response).toBeCachedByTheBrowser()
+ * ...
+ * expect(response).toBeCachedByTheBrowser(60*60*24)
+ * ```
+ *
+ * @param {MockResponse} received The mocked response
+ * @param {Number} duration Optional - the duration (in seconds) the response is expected to be cached for
+ * @returns
+ */
+export declare function toBeCachedByTheBrowser(received: any, duration?: number): {
+    message: () => string;
+    pass: boolean;
+};
+export declare const toBeCachedByTheBrowserFor: typeof toBeCachedByTheBrowser;

package/node_modules/@layer0/core/test-utils/matchers/toBeCachedByTheBrowser.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../constants");
+const getMessage_1 = __importDefault(require("../utils/getMessage"));
+/**
+ * Matches the browser cache-control header in the response with an optional duration
+ *
+ * **Example**
+ * ```js
+ * expect(response).toBeCachedByTheBrowser()
+ * ...
+ * expect(response).toBeCachedByTheBrowser(60*60*24)
+ * ```
+ *
+ * @param {MockResponse} received The mocked response
+ * @param {Number} duration Optional - the duration (in seconds) the response is expected to be cached for
+ * @returns
+ */
+function toBeCachedByTheBrowser(received, duration) {
+    const response = received;
+    const request = response.request;
+    const header = response.getHeader(constants_1.HTTP_HEADERS.cacheControl);
+    let pass = !!header;
+    if (header) {
+        // @ts-ignore
+        if (this.isNot) {
+            pass = !/no-cache/.test(header);
+            duration = 0;
+        }
+        else if (pass && duration) {
+            pass = new RegExp(`max-age=${duration}`).test(header);
+        }
+    }
+    return {
+        message: () => getMessage_1.default(
+        // @ts-ignore
+        this, `toBeCachedByTheBrowser${duration ? 'For' : ''}`, `'${request.path}' [[to]] be cached by the browser${duration ? ` for ${duration}ms` : ''}`, header),
+        pass,
+    };
+}
+exports.toBeCachedByTheBrowser = toBeCachedByTheBrowser;
+exports.toBeCachedByTheBrowserFor = toBeCachedByTheBrowser;

package/node_modules/@layer0/core/test-utils/matchers/toBeCachedByTheEdge.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Matches the edge cache-control header in the response with an optional duration
+ *
+ * **Example**
+ * ```js
+ * expect(response).toBeCachedByTheEdge()
+ * ...
+ * expect(response).toBeCachedByTheEdge(60*60*24)
+ * ```
+ *
+ * @param {MockResponse} received The mocked response
+ * @param {Number} duration Optional - the duration (in seconds) the response is expected to be cached for
+ * @returns
+ */
+export declare function toBeCachedByTheEdge(received: any, duration?: number): {
+    message: () => string;
+    pass: boolean;
+};
+export declare const toBeCachedByTheEdgeFor: typeof toBeCachedByTheEdge;