@remotion/lambda 4.0.0-lambda.3 → 4.0.0-newpaths.1

package/dist/shared/invoke-webhook.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import http from 'http';
+import https from 'https';
+import type { EnhancedErrorInfo } from '../functions/helpers/write-lambda-error';
+import type { AfterRenderCost } from './constants';
+/**
+ * @description Calculates cryptographically secure signature for webhooks using Hmac.
+ * @link https://remotion.dev/docs/lambda/webhooks#validate-webhooks
+ * @param payload Stringified request body to encode in the signature.
+ * @param secret User-provided webhook secret used to sign the request.
+ * @returns {string} Calculated signature
+ */
+export declare function calculateSignature(payload: string, secret: string | null): string;
+declare type DynamicWebhookPayload = {
+    type: 'error';
+    errors: {
+        message: string;
+        name: string;
+        stack: string;
+    }[];
+} | {
+    type: 'success';
+    lambdaErrors: EnhancedErrorInfo[];
+    outputUrl: string | undefined;
+    outputFile: string | undefined;
+    timeToFinish: number | undefined;
+    costs: AfterRenderCost;
+} | {
+    type: 'timeout';
+};
+export declare type WebhookPayload = {
+    renderId: string;
+    expectedBucketOwner: string;
+    bucketName: string;
+} & DynamicWebhookPayload;
+export declare const mockableHttpClients: {
+    http: typeof http.request;
+    https: typeof https.request;
+};
+export declare function invokeWebhook({ payload, secret, url, }: {
+    payload: WebhookPayload;
+    url: string;
+    secret: string | null;
+}): Promise<void>;
+export {};

package/dist/shared/invoke-webhook.js

@@ -0,0 +1,89 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeWebhook = exports.mockableHttpClients = exports.calculateSignature = void 0;
+const Crypto = __importStar(require("crypto"));
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+/**
+ * @description Calculates cryptographically secure signature for webhooks using Hmac.
+ * @link https://remotion.dev/docs/lambda/webhooks#validate-webhooks
+ * @param payload Stringified request body to encode in the signature.
+ * @param secret User-provided webhook secret used to sign the request.
+ * @returns {string} Calculated signature
+ */
+function calculateSignature(payload, secret) {
+    if (!secret) {
+        return 'NO_SECRET_PROVIDED';
+    }
+    const hmac = Crypto.createHmac('sha512', secret);
+    const signature = 'sha512=' + hmac.update(payload).digest('hex');
+    return signature;
+}
+exports.calculateSignature = calculateSignature;
+const getWebhookClient = (url) => {
+    if (url.startsWith('https://')) {
+        return exports.mockableHttpClients.https;
+    }
+    if (url.startsWith('http://')) {
+        return exports.mockableHttpClients.http;
+    }
+    throw new Error('Can only request URLs starting with http:// or https://');
+};
+exports.mockableHttpClients = {
+    http: http_1.default.request,
+    https: https_1.default.request,
+};
+function invokeWebhook({ payload, secret, url, }) {
+    const jsonPayload = JSON.stringify(payload);
+    return new Promise((resolve, reject) => {
+        const req = getWebhookClient(url)(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': jsonPayload.length,
+                'X-Remotion-Mode': 'production',
+                'X-Remotion-Signature': calculateSignature(jsonPayload, secret),
+                'X-Remotion-Status': payload.type,
+            },
+            timeout: 5000,
+        }, (res) => {
+            if (res.statusCode && res.statusCode > 299) {
+                reject(new Error(`Sent a webhook but got a status code of ${res.statusCode} with message '${res.statusMessage}'`));
+                return;
+            }
+            resolve();
+        });
+        req.write(jsonPayload);
+        req.on('error', (err) => {
+            reject(err);
+        });
+        req.end();
+    });
+}
+exports.invokeWebhook = invokeWebhook;

package/dist/shared/is-in-lambda.js

@@ -1,5 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isInsideLambda = void 0;
-const isInsideLambda = () => { var _a; return Boolean(typeof process !== 'undefined' && ((_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a.REMOTION_LAMBDA)); };
+const isInsideLambda = () => {
+    var _a;
+    return Boolean(typeof process !== 'undefined' &&
+        ((_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a.__RESERVED_IS_INSIDE_REMOTION_LAMBDA));
+};
 exports.isInsideLambda = isInsideLambda;

package/dist/shared/lambda-version-string.d.ts

@@ -0,0 +1 @@
+export declare const LAMBDA_VERSION_STRING: string;

package/dist/shared/lambda-version-string.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LAMBDA_VERSION_STRING = void 0;
+const version_1 = require("remotion/version");
+exports.LAMBDA_VERSION_STRING = version_1.VERSION.replace(/\./g, '-')
+    .replace(/\+/g, '-')
+    .substring(0, 10);

package/dist/shared/make-s3-url.d.ts

@@ -1,4 +1,4 @@
-import { AwsRegion } from '../pricing/aws-regions';
+import type { AwsRegion } from '../pricing/aws-regions';
 export declare const makeS3ServeUrl: ({ bucketName, subFolder, region, }: {
     bucketName: string;
     subFolder: string;

package/dist/shared/parse-chunk-key.d.ts

@@ -0,0 +1,4 @@
+export declare const parseLambdaChunkKey: (key: string) => {
+    renderId: string;
+    chunk: number;
+};

package/dist/shared/parse-chunk-key.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLambdaChunkKey = void 0;
+const parseLambdaChunkKey = (key) => {
+    const match = key.match(/^renders\/(.*)\/chunks\/chunk:([0-9]+)$/);
+    if (!match) {
+        throw new Error(`Cannot parse filename ${key} into timing information. Malformed data.`);
+    }
+    return {
+        renderId: match[1],
+        chunk: Number(match[2]),
+    };
+};
+exports.parseLambdaChunkKey = parseLambdaChunkKey;

package/dist/shared/read-dir.d.ts

@@ -0,0 +1,9 @@
+export declare function readDirectory({ dir, etags, originalDir, }: {
+    dir: string;
+    etags: {
+        [key: string]: string;
+    };
+    originalDir: string;
+}): Promise<{
+    [key: string]: string;
+}>;

package/dist/shared/read-dir.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readDirectory = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const get_etag_1 = require("./get-etag");
+// Function to recursively read a directory and return a list of files
+// with their etags and file names
+async function readDirectory({ dir, etags, originalDir, }) {
+    const files = fs.readdirSync(dir);
+    for (const file of files) {
+        if (file.startsWith('.DS_Store'))
+            continue;
+        const filePath = path.join(dir, file);
+        if (fs.lstatSync(filePath).isDirectory()) {
+            etags = {
+                ...etags,
+                ...(await readDirectory({ dir: filePath, etags, originalDir })),
+            };
+            continue;
+        }
+        // eslint-disable-next-line no-lonely-if
+        if (fs.lstatSync(filePath).isSymbolicLink()) {
+            const realPath = fs.realpathSync(filePath);
+            etags[path.relative(originalDir, filePath)] = await (0, get_etag_1.getEtagOfFile)(realPath);
+        }
+        else {
+            etags[path.relative(originalDir, filePath)] = await (0, get_etag_1.getEtagOfFile)(filePath);
+        }
+    }
+    // Return the list of files with their etags and file names
+    return etags;
+}
+exports.readDirectory = readDirectory;

package/dist/shared/return-values.d.ts

@@ -1,10 +1,11 @@
-import { infoHandler } from '../functions/info';
-import { launchHandler } from '../functions/launch';
-import { progressHandler } from '../functions/progress';
-import { rendererHandler } from '../functions/renderer';
-import { startHandler } from '../functions/start';
-import { stillHandler } from '../functions/still';
-import { LambdaRoutines } from './constants';
+import type { compositionsHandler } from '../functions/compositions';
+import type { infoHandler } from '../functions/info';
+import type { launchHandler } from '../functions/launch';
+import type { progressHandler } from '../functions/progress';
+import type { rendererHandler } from '../functions/renderer';
+import type { startHandler } from '../functions/start';
+import type { stillHandler } from '../functions/still';
+import type { LambdaRoutines } from './constants';
 export interface LambdaReturnValues {
     [LambdaRoutines.start]: ReturnType<typeof startHandler>;
     [LambdaRoutines.launch]: ReturnType<typeof launchHandler>;
@@ -12,4 +13,5 @@ export interface LambdaReturnValues {
     [LambdaRoutines.status]: ReturnType<typeof progressHandler>;
     [LambdaRoutines.info]: ReturnType<typeof infoHandler>;
     [LambdaRoutines.still]: ReturnType<typeof stillHandler>;
+    [LambdaRoutines.compositions]: ReturnType<typeof compositionsHandler>;
 }

package/dist/shared/return-values.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("./constants");

package/dist/shared/serialize-input-props.d.ts

@@ -0,0 +1,7 @@
+import type { AwsRegion } from '../client';
+import type { SerializedInputProps } from './constants';
+export declare const serializeInputProps: ({ inputProps, region, type, }: {
+    inputProps: unknown;
+    region: AwsRegion;
+    type: 'still' | 'video-or-audio';
+}) => Promise<SerializedInputProps>;

package/dist/shared/serialize-input-props.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeInputProps = void 0;
+const get_or_create_bucket_1 = require("../api/get-or-create-bucket");
+const io_1 = require("../functions/helpers/io");
+const constants_1 = require("./constants");
+const random_hash_1 = require("./random-hash");
+const serializeInputProps = async ({ inputProps, region, type, }) => {
+    try {
+        const payload = JSON.stringify(inputProps);
+        const hash = (0, random_hash_1.randomHash)();
+        const MAX_INLINE_PAYLOAD_SIZE = type === 'still' ? 5000000 : 200000;
+        if (payload.length > MAX_INLINE_PAYLOAD_SIZE) {
+            console.warn(`Warning: inputProps are over ${Math.round(MAX_INLINE_PAYLOAD_SIZE / 1000)}KB (${Math.ceil(payload.length / 1024)}KB) in size. Uploading them to S3 to circumvent AWS Lambda payload size.`);
+            const { bucketName } = await (0, get_or_create_bucket_1.getOrCreateBucket)({
+                region,
+            });
+            await (0, io_1.lambdaWriteFile)({
+                body: payload,
+                bucketName,
+                region,
+                customCredentials: null,
+                downloadBehavior: null,
+                expectedBucketOwner: null,
+                key: (0, constants_1.inputPropsKey)(hash),
+                privacy: 'public',
+            });
+            return {
+                type: 'bucket-url',
+                hash,
+            };
+        }
+        return {
+            type: 'payload',
+            payload,
+        };
+    }
+    catch (err) {
+        throw new Error('Error serializing inputProps. Check it has no circular references or reduce the size if the object is big.');
+    }
+};
+exports.serializeInputProps = serializeInputProps;

package/dist/shared/stream-to-string.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { Readable } from 'stream';
+import type { Readable } from 'stream';
 export declare function streamToString(stream: Readable | Buffer): string | Promise<string>;

package/dist/shared/truthy.d.ts

@@ -0,0 +1,3 @@
+declare type Truthy<T> = T extends false | '' | 0 | null | undefined ? never : T;
+export declare function truthy<T>(value: T): value is Truthy<T>;
+export {};

package/dist/shared/truthy.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truthy = void 0;
+function truthy(value) {
+    return Boolean(value);
+}
+exports.truthy = truthy;

package/dist/shared/validate-aws-region.d.ts

@@ -1,2 +1,2 @@
-import { AwsRegion } from '../pricing/aws-regions';
+import type { AwsRegion } from '../pricing/aws-regions';
 export declare function validateAwsRegion(region: unknown): asserts region is AwsRegion;

package/dist/shared/validate-bucketname.d.ts

@@ -1,3 +1,8 @@
+import type { AwsRegion } from '../client';
 export declare const validateBucketName: (bucketName: unknown, options: {
     mustStartWithRemotion: boolean;
 }) => void;
+export declare const parseBucketName: (name: string) => {
+    region: AwsRegion | null;
+};
+export declare const makeBucketName: (region: AwsRegion) => string;

package/dist/shared/validate-bucketname.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateBucketName = void 0;
+exports.makeBucketName = exports.parseBucketName = exports.validateBucketName = void 0;
+const regions_1 = require("../regions");
 const constants_1 = require("./constants");
+const random_hash_1 = require("./random-hash");
 const validateBucketName = (bucketName, options) => {
     if (typeof bucketName !== 'string') {
         throw new TypeError(`'bucketName' must be a string, but is ${JSON.stringify(bucketName)}`);
@@ -15,3 +17,19 @@ const validateBucketName = (bucketName, options) => {
     }
 };
 exports.validateBucketName = validateBucketName;
+const parseBucketName = (name) => {
+    const parsed = name.match(new RegExp(`^${constants_1.REMOTION_BUCKET_PREFIX}(.*)-([a-z0-9A-Z]+)$`));
+    const region = parsed === null || parsed === void 0 ? void 0 : parsed[1];
+    if (!region) {
+        return { region: null };
+    }
+    const realRegionFound = regions_1.AWS_REGIONS.find((r) => r.replace(/-/g, '') === region);
+    return { region: realRegionFound !== null && realRegionFound !== void 0 ? realRegionFound : null };
+};
+exports.parseBucketName = parseBucketName;
+const makeBucketName = (region) => {
+    return `${constants_1.REMOTION_BUCKET_PREFIX}${region.replace(/-/g, '')}-${(0, random_hash_1.randomHash)({
+        randomInTests: false,
+    })}`;
+};
+exports.makeBucketName = makeBucketName;

package/dist/shared/validate-download-behavior.d.ts

@@ -0,0 +1 @@
+export declare const validateDownloadBehavior: (downloadBehavior: unknown) => null | undefined;

package/dist/shared/validate-download-behavior.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDownloadBehavior = void 0;
+const validateDownloadBehavior = (downloadBehavior) => {
+    if (downloadBehavior === null || downloadBehavior === undefined) {
+        return null;
+    }
+    if (typeof downloadBehavior !== 'object') {
+        throw new Error('downloadBehavior must be null or an object');
+    }
+    const behavior = downloadBehavior;
+    if (behavior.type !== 'download' && behavior.type !== 'play-in-browser') {
+        throw new Error('Download behavior must be either "download" or "play-in-browser"');
+    }
+    if (behavior.type === 'download') {
+        if (typeof behavior.fileName !== 'string' && behavior.fileName !== null) {
+            throw new Error('If "downloadBehavior.type" is "download", then fileName must be "null" or a string');
+        }
+    }
+};
+exports.validateDownloadBehavior = validateDownloadBehavior;

package/dist/shared/validate-frames-per-lambda.d.ts

@@ -1 +1,4 @@
-export declare const validateFramesPerLambda: (framesPerLambda: unknown) => void;
+export declare const validateFramesPerLambda: ({ framesPerLambda, durationInFrames, }: {
+    framesPerLambda: unknown;
+    durationInFrames: number;
+}) => void;

package/dist/shared/validate-frames-per-lambda.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateFramesPerLambda = void 0;
 const constants_1 = require("./constants");
-const validateFramesPerLambda = (framesPerLambda) => {
+const validateFramesPerLambda = ({ framesPerLambda, durationInFrames, }) => {
     if (framesPerLambda === null) {
         return;
     }
@@ -21,8 +21,9 @@ const validateFramesPerLambda = (framesPerLambda) => {
     if (framesPerLambda % 1 !== 0) {
         throw new TypeError(`'framesPerLambda' needs to be an integer, passed ${framesPerLambda}`);
     }
-    if (framesPerLambda < constants_1.MINIMUM_FRAMES_PER_LAMBDA) {
-        throw new TypeError(`The framesPerLambda needs to be at least 4, but is ${framesPerLambda}`);
+    const effectiveMinimum = Math.min(constants_1.MINIMUM_FRAMES_PER_LAMBDA, durationInFrames);
+    if (framesPerLambda < effectiveMinimum) {
+        throw new TypeError(`The framesPerLambda needs to be at least ${effectiveMinimum}, but is ${framesPerLambda}`);
     }
 };
 exports.validateFramesPerLambda = validateFramesPerLambda;

package/dist/shared/validate-lambda-codec.d.ts

@@ -0,0 +1,4 @@
+declare const lambdaCodecs: readonly ["h264", "vp8", "mp3", "aac", "wav", "gif", "prores"];
+export declare type LambdaCodec = typeof lambdaCodecs[number];
+export declare const validateLambdaCodec: (codec: unknown) => LambdaCodec;
+export {};

package/dist/shared/validate-lambda-codec.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateLambdaCodec = void 0;
+const lambdaCodecs = [
+    'h264',
+    'vp8',
+    'mp3',
+    'aac',
+    'wav',
+    'gif',
+    'prores',
+];
+const validateLambdaCodec = (codec) => {
+    if (typeof codec !== 'string') {
+        throw new TypeError('"codec" must be a string ');
+    }
+    if (!lambdaCodecs.includes(codec)) {
+        throw new TypeError("'" +
+            codec +
+            "' is not a valid codec for Lambda. The following values are supported: " +
+            lambdaCodecs.join(', '));
+    }
+    if (codec === 'h264-mkv') {
+        console.warn('The "h264-mkv" codec for renderMediaOnLambda() is deprecated - it\'s now just "h264".');
+        return 'h264';
+    }
+    return codec;
+};
+exports.validateLambdaCodec = validateLambdaCodec;

package/dist/shared/validate-outname.d.ts

@@ -1,2 +1,3 @@
-import { OutNameInput } from './constants';
-export declare const validateOutname: (outName: OutNameInput | undefined | null) => void;
+import type { Codec } from '@remotion/renderer';
+import type { OutNameInputWithoutCredentials } from './constants';
+export declare const validateOutname: (outName: OutNameInputWithoutCredentials | undefined | null, codec?: Codec) => void;

package/dist/shared/validate-outname.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateOutname = void 0;
+const renderer_1 = require("@remotion/renderer");
 const validate_bucketname_1 = require("./validate-bucketname");
 const validateS3Key = (s3Key) => {
     if (typeof s3Key !== 'string') {
@@ -12,11 +13,14 @@ const validateS3Key = (s3Key) => {
             '. Check for invalid characters.');
     }
 };
-const validateOutname = (outName) => {
+const validateOutname = (outName, codec) => {
     if (typeof outName === 'undefined' || outName === null) {
         return;
     }
     if (typeof outName === 'string') {
+        if (codec) {
+            (0, renderer_1.validateOutputFilename)(codec, renderer_1.RenderInternals.getExtensionOfFilename(outName !== null && outName !== void 0 ? outName : null));
+        }
         validateS3Key(outName);
         return;
     }

package/dist/shared/validate-presign-expiration.d.ts

@@ -1,3 +1 @@
-export declare const MAX_PRESIGN_EXPIRATION = 604800;
-export declare const MIN_PRESIGN_EXPIRATION = 1;
 export declare const validatePresignExpiration: (presignExpiration: unknown) => void;

package/dist/shared/validate-presign-expiration.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validatePresignExpiration = exports.MIN_PRESIGN_EXPIRATION = exports.MAX_PRESIGN_EXPIRATION = void 0;
-exports.MAX_PRESIGN_EXPIRATION = 604800;
-exports.MIN_PRESIGN_EXPIRATION = 1;
+exports.validatePresignExpiration = void 0;
+const MAX_PRESIGN_EXPIRATION = 604800;
+const MIN_PRESIGN_EXPIRATION = 1;
 const validatePresignExpiration = (presignExpiration) => {
     if (typeof presignExpiration === 'undefined' || presignExpiration === null) {
         return;
@@ -19,11 +19,11 @@ const validatePresignExpiration = (presignExpiration) => {
     if (presignExpiration % 1 !== 0) {
         throw new TypeError(`'expiresIn' should be an integer but is ${JSON.stringify(presignExpiration)}`);
     }
-    if (presignExpiration > exports.MAX_PRESIGN_EXPIRATION) {
-        throw new TypeError(`The 'expiresIn' parameter must be less or equal than ${exports.MAX_PRESIGN_EXPIRATION} (7 days) as enforced by AWS`);
+    if (presignExpiration > MAX_PRESIGN_EXPIRATION) {
+        throw new TypeError(`The 'expiresIn' parameter must be less or equal than ${MAX_PRESIGN_EXPIRATION} (7 days) as enforced by AWS`);
     }
-    if (presignExpiration < exports.MIN_PRESIGN_EXPIRATION) {
-        throw new TypeError(`The 'expiresIn' parameter must be greater or equal than ${exports.MIN_PRESIGN_EXPIRATION}`);
+    if (presignExpiration < MIN_PRESIGN_EXPIRATION) {
+        throw new TypeError(`The 'expiresIn' parameter must be greater or equal than ${MIN_PRESIGN_EXPIRATION}`);
     }
 };
 exports.validatePresignExpiration = validatePresignExpiration;

package/dist/shared/validate-privacy.d.ts

@@ -1,2 +1,2 @@
-import { Privacy } from './constants';
+import type { Privacy } from './constants';
 export declare function validatePrivacy(privacy: unknown): asserts privacy is Privacy;