@remotion/lambda-client 4.0.390 → 4.0.392

package/dist/make-lambda-payload.d.ts

@@ -0,0 +1,59 @@
+import type { AudioCodec, BrowserSafeApis, ChromiumOptions, ColorSpace, DeleteAfter, DownloadBehavior, FrameRange, LogLevel, OutNameInput, PixelFormat, Privacy, ProResProfile, ServerlessCodec, ServerlessPayloads, ServerlessStartPayload, ServerlessStatusPayload, ToOptions, VideoImageFormat, WebhookOption, X264Preset } from '@remotion/serverless-client';
+import { ServerlessRoutines } from '@remotion/serverless-client';
+import type { AwsProvider } from './aws-provider';
+import type { StorageClass } from '@aws-sdk/client-s3';
+import type { GetRenderProgressInput } from './get-render-progress';
+import type { AwsRegion } from './regions';
+import type { RenderStillOnLambdaNonNullInput } from './render-still-on-lambda';
+import type { RequestHandler } from './types';
+export type InnerRenderMediaOnLambdaInput = {
+    region: AwsRegion;
+    functionName: string;
+    serveUrl: string;
+    composition: string;
+    inputProps: Record<string, unknown>;
+    codec: ServerlessCodec;
+    imageFormat: VideoImageFormat;
+    crf: number | undefined;
+    envVariables: Record<string, string>;
+    pixelFormat: PixelFormat | undefined;
+    proResProfile: ProResProfile | undefined;
+    x264Preset: X264Preset | null;
+    privacy: Privacy;
+    jpegQuality: number;
+    maxRetries: number;
+    framesPerLambda: number | null;
+    concurrency: number | null;
+    logLevel: LogLevel;
+    frameRange: FrameRange | null;
+    outName: OutNameInput<AwsProvider> | null;
+    timeoutInMilliseconds: number;
+    chromiumOptions: ChromiumOptions;
+    scale: number;
+    everyNthFrame: number;
+    numberOfGifLoops: number | null;
+    concurrencyPerLambda: number;
+    downloadBehavior: DownloadBehavior;
+    muted: boolean;
+    overwrite: boolean;
+    audioBitrate: string | null;
+    videoBitrate: string | null;
+    encodingMaxRate: string | null;
+    encodingBufferSize: string | null;
+    webhook: WebhookOption | null;
+    forceWidth: number | null;
+    forceHeight: number | null;
+    rendererFunctionName: string | null;
+    forceBucketName: string | null;
+    audioCodec: AudioCodec | null;
+    colorSpace: ColorSpace | null;
+    deleteAfter: DeleteAfter | null;
+    indent: boolean;
+    forcePathStyle: boolean;
+    metadata: Record<string, string> | null;
+    storageClass: StorageClass | null;
+    requestHandler: RequestHandler | null;
+} & ToOptions<typeof BrowserSafeApis.optionsMap.renderMediaOnLambda>;
+export declare const makeLambdaRenderMediaPayload: ({ rendererFunctionName, frameRange, framesPerLambda, concurrency, forceBucketName: bucketName, codec, composition, serveUrl, imageFormat, inputProps, region, crf, envVariables, pixelFormat, proResProfile, x264Preset, maxRetries, privacy, logLevel, outName, timeoutInMilliseconds, chromiumOptions, scale, everyNthFrame, numberOfGifLoops, audioBitrate, concurrencyPerLambda, audioCodec, forceHeight, forceWidth, webhook, videoBitrate, encodingMaxRate, encodingBufferSize, downloadBehavior, muted, overwrite, jpegQuality, offthreadVideoCacheSizeInBytes, mediaCacheSizeInBytes, deleteAfter, colorSpace, preferLossless, forcePathStyle, metadata, apiKey, offthreadVideoThreads, storageClass, requestHandler, }: InnerRenderMediaOnLambdaInput) => Promise<ServerlessStartPayload<AwsProvider>>;
+export declare const getRenderProgressPayload: ({ bucketName, renderId, s3OutputProvider, logLevel, forcePathStyle, }: GetRenderProgressInput) => ServerlessStatusPayload<AwsProvider>;
+export declare const makeLambdaRenderStillPayload: ({ serveUrl, inputProps, imageFormat, envVariables, jpegQuality, region, maxRetries, composition, privacy, frame, logLevel, outName, timeoutInMilliseconds, chromiumOptions, scale, downloadBehavior, forceHeight, forceWidth, forceBucketName, offthreadVideoCacheSizeInBytes, deleteAfter, forcePathStyle, apiKey, storageClass, requestHandler, offthreadVideoThreads, mediaCacheSizeInBytes, }: RenderStillOnLambdaNonNullInput) => Promise<ServerlessPayloads<AwsProvider>[ServerlessRoutines.still]>;

package/dist/make-lambda-payload.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLambdaRenderStillPayload = exports.getRenderProgressPayload = exports.makeLambdaRenderMediaPayload = void 0;
+const serverless_client_1 = require("@remotion/serverless-client");
+const aws_provider_1 = require("./aws-provider");
+const serverless_client_2 = require("@remotion/serverless-client");
+const validate_lambda_codec_1 = require("./validate-lambda-codec");
+const validate_serveurl_1 = require("./validate-serveurl");
+const makeLambdaRenderMediaPayload = async ({ rendererFunctionName, frameRange, framesPerLambda, concurrency, forceBucketName: bucketName, codec, composition, serveUrl, imageFormat, inputProps, region, crf, envVariables, pixelFormat, proResProfile, x264Preset, maxRetries, privacy, logLevel, outName, timeoutInMilliseconds, chromiumOptions, scale, everyNthFrame, numberOfGifLoops, audioBitrate, concurrencyPerLambda, audioCodec, forceHeight, forceWidth, webhook, videoBitrate, encodingMaxRate, encodingBufferSize, downloadBehavior, muted, overwrite, jpegQuality, offthreadVideoCacheSizeInBytes, mediaCacheSizeInBytes, deleteAfter, colorSpace, preferLossless, forcePathStyle, metadata, apiKey, offthreadVideoThreads, storageClass, requestHandler, }) => {
+    const actualCodec = (0, validate_lambda_codec_1.validateLambdaCodec)(codec);
+    (0, validate_serveurl_1.validateServeUrl)(serveUrl);
+    (0, serverless_client_1.validateDownloadBehavior)(downloadBehavior);
+    (0, serverless_client_2.validateWebhook)(webhook);
+    const stringifiedInputProps = (0, serverless_client_1.serializeOrThrow)(inputProps !== null && inputProps !== void 0 ? inputProps : {}, 'input-props');
+    const serialized = await (0, serverless_client_1.compressInputProps)({
+        stringifiedInputProps,
+        region,
+        needsToUpload: (0, serverless_client_1.getNeedsToUpload)({
+            type: 'video-or-audio',
+            sizes: [
+                stringifiedInputProps.length,
+                JSON.stringify(envVariables).length,
+            ],
+            providerSpecifics: aws_provider_1.awsImplementation,
+        }),
+        userSpecifiedBucketName: bucketName !== null && bucketName !== void 0 ? bucketName : null,
+        propsType: 'input-props',
+        providerSpecifics: aws_provider_1.awsImplementation,
+        forcePathStyle: forcePathStyle !== null && forcePathStyle !== void 0 ? forcePathStyle : false,
+        skipPutAcl: privacy === 'no-acl',
+        requestHandler: requestHandler !== null && requestHandler !== void 0 ? requestHandler : null,
+    });
+    return {
+        rendererFunctionName,
+        framesPerLambda,
+        concurrency,
+        composition,
+        serveUrl,
+        inputProps: serialized,
+        codec: actualCodec,
+        imageFormat,
+        crf: crf !== null && crf !== void 0 ? crf : null,
+        envVariables,
+        pixelFormat: pixelFormat !== null && pixelFormat !== void 0 ? pixelFormat : null,
+        proResProfile: proResProfile !== null && proResProfile !== void 0 ? proResProfile : null,
+        x264Preset,
+        jpegQuality,
+        maxRetries,
+        privacy,
+        logLevel,
+        frameRange,
+        outName,
+        timeoutInMilliseconds,
+        chromiumOptions,
+        scale,
+        everyNthFrame,
+        numberOfGifLoops,
+        concurrencyPerLambda,
+        downloadBehavior,
+        muted,
+        version: serverless_client_1.VERSION,
+        overwrite: overwrite !== null && overwrite !== void 0 ? overwrite : serverless_client_1.ENABLE_V5_BREAKING_CHANGES,
+        audioBitrate: audioBitrate !== null && audioBitrate !== void 0 ? audioBitrate : null,
+        videoBitrate: videoBitrate !== null && videoBitrate !== void 0 ? videoBitrate : null,
+        encodingBufferSize: encodingBufferSize !== null && encodingBufferSize !== void 0 ? encodingBufferSize : null,
+        encodingMaxRate: encodingMaxRate !== null && encodingMaxRate !== void 0 ? encodingMaxRate : null,
+        webhook: webhook !== null && webhook !== void 0 ? webhook : null,
+        forceHeight: forceHeight !== null && forceHeight !== void 0 ? forceHeight : null,
+        forceWidth: forceWidth !== null && forceWidth !== void 0 ? forceWidth : null,
+        bucketName: bucketName !== null && bucketName !== void 0 ? bucketName : null,
+        audioCodec: audioCodec !== null && audioCodec !== void 0 ? audioCodec : null,
+        type: serverless_client_1.ServerlessRoutines.start,
+        offthreadVideoCacheSizeInBytes: offthreadVideoCacheSizeInBytes !== null && offthreadVideoCacheSizeInBytes !== void 0 ? offthreadVideoCacheSizeInBytes : null,
+        deleteAfter: deleteAfter !== null && deleteAfter !== void 0 ? deleteAfter : null,
+        colorSpace: colorSpace !== null && colorSpace !== void 0 ? colorSpace : null,
+        preferLossless: preferLossless !== null && preferLossless !== void 0 ? preferLossless : false,
+        forcePathStyle: forcePathStyle !== null && forcePathStyle !== void 0 ? forcePathStyle : false,
+        metadata: metadata !== null && metadata !== void 0 ? metadata : null,
+        apiKey: apiKey !== null && apiKey !== void 0 ? apiKey : null,
+        offthreadVideoThreads: offthreadVideoThreads !== null && offthreadVideoThreads !== void 0 ? offthreadVideoThreads : null,
+        mediaCacheSizeInBytes: mediaCacheSizeInBytes !== null && mediaCacheSizeInBytes !== void 0 ? mediaCacheSizeInBytes : null,
+        storageClass: storageClass !== null && storageClass !== void 0 ? storageClass : null,
+    };
+};
+exports.makeLambdaRenderMediaPayload = makeLambdaRenderMediaPayload;
+const getRenderProgressPayload = ({ bucketName, renderId, s3OutputProvider, logLevel, forcePathStyle, }) => {
+    return {
+        type: serverless_client_1.ServerlessRoutines.status,
+        bucketName,
+        renderId,
+        version: serverless_client_1.VERSION,
+        s3OutputProvider: s3OutputProvider !== null && s3OutputProvider !== void 0 ? s3OutputProvider : null,
+        logLevel: logLevel !== null && logLevel !== void 0 ? logLevel : 'info',
+        forcePathStyle: forcePathStyle !== null && forcePathStyle !== void 0 ? forcePathStyle : false,
+    };
+};
+exports.getRenderProgressPayload = getRenderProgressPayload;
+const makeLambdaRenderStillPayload = async ({ serveUrl, inputProps, imageFormat, envVariables, jpegQuality, region, maxRetries, composition, privacy, frame, logLevel, outName, timeoutInMilliseconds, chromiumOptions, scale, downloadBehavior, forceHeight, forceWidth, forceBucketName, offthreadVideoCacheSizeInBytes, deleteAfter, forcePathStyle, apiKey, storageClass, requestHandler, offthreadVideoThreads, mediaCacheSizeInBytes, }) => {
+    const stringifiedInputProps = (0, serverless_client_1.serializeOrThrow)(inputProps, 'input-props');
+    const serializedInputProps = await (0, serverless_client_1.compressInputProps)({
+        stringifiedInputProps,
+        region,
+        needsToUpload: (0, serverless_client_1.getNeedsToUpload)({
+            type: 'still',
+            sizes: [
+                stringifiedInputProps.length,
+                JSON.stringify(envVariables).length,
+            ],
+            providerSpecifics: aws_provider_1.awsImplementation,
+        }),
+        userSpecifiedBucketName: forceBucketName !== null && forceBucketName !== void 0 ? forceBucketName : null,
+        propsType: 'input-props',
+        providerSpecifics: aws_provider_1.awsImplementation,
+        forcePathStyle,
+        skipPutAcl: privacy === 'no-acl',
+        requestHandler,
+    });
+    return {
+        composition,
+        serveUrl,
+        inputProps: serializedInputProps,
+        imageFormat,
+        envVariables,
+        jpegQuality,
+        maxRetries,
+        frame,
+        privacy,
+        attempt: 1,
+        logLevel,
+        outName,
+        timeoutInMilliseconds,
+        chromiumOptions,
+        scale,
+        downloadBehavior,
+        version: serverless_client_1.VERSION,
+        forceHeight,
+        forceWidth,
+        bucketName: forceBucketName,
+        offthreadVideoCacheSizeInBytes,
+        deleteAfter,
+        type: serverless_client_1.ServerlessRoutines.still,
+        streamed: true,
+        forcePathStyle,
+        apiKey: apiKey !== null && apiKey !== void 0 ? apiKey : null,
+        offthreadVideoThreads: offthreadVideoThreads !== null && offthreadVideoThreads !== void 0 ? offthreadVideoThreads : null,
+        mediaCacheSizeInBytes: mediaCacheSizeInBytes !== null && mediaCacheSizeInBytes !== void 0 ? mediaCacheSizeInBytes : null,
+        storageClass: storageClass !== null && storageClass !== void 0 ? storageClass : null,
+    };
+};
+exports.makeLambdaRenderStillPayload = makeLambdaRenderStillPayload;

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

@@ -0,0 +1,6 @@
+import type { AwsRegion } from './regions';
+export declare const makeS3ServeUrl: ({ bucketName, subFolder, region, }: {
+    bucketName: string;
+    subFolder: string;
+    region: AwsRegion;
+}) => string;

package/dist/make-s3-url.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeS3ServeUrl = void 0;
+const makeS3ServeUrl = ({ bucketName, subFolder, region, }) => {
+    return `https://${bucketName}.s3.${region}.amazonaws.com/${subFolder}/index.html`;
+};
+exports.makeS3ServeUrl = makeS3ServeUrl;

package/dist/p-limit.d.ts

@@ -0,0 +1 @@
+export declare const pLimit: (concurrency: number) => <Arguments extends unknown[], ReturnType>(fn: (..._arguments: Arguments) => PromiseLike<ReturnType> | ReturnType, ...args: Arguments) => Promise<ReturnType>;

package/dist/p-limit.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pLimit = void 0;
+const pLimit = (concurrency) => {
+    const queue = [];
+    let activeCount = 0;
+    const next = () => {
+        var _a;
+        activeCount--;
+        if (queue.length > 0) {
+            (_a = queue.shift()) === null || _a === void 0 ? void 0 : _a();
+        }
+    };
+    const run = async (fn, resolve, ...args) => {
+        activeCount++;
+        // eslint-disable-next-line require-await
+        const result = (async () => fn(...args))();
+        resolve(result);
+        try {
+            await result;
+        }
+        catch (_a) { }
+        next();
+    };
+    const enqueue = (fn, resolve, ...args) => {
+        queue.push(() => run(fn, resolve, ...args));
+        (async () => {
+            var _a;
+            // This function needs to wait until the next microtask before comparing
+            // `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
+            // when the run function is dequeued and called. The comparison in the if-statement
+            // needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
+            await Promise.resolve();
+            if (activeCount < concurrency && queue.length > 0) {
+                (_a = queue.shift()) === null || _a === void 0 ? void 0 : _a();
+            }
+        })();
+    };
+    const generator = (fn, ...args) => new Promise((resolve) => {
+        enqueue(fn, resolve, ...args);
+    });
+    Object.defineProperties(generator, {
+        activeCount: {
+            get: () => activeCount,
+        },
+        pendingCount: {
+            get: () => queue.length,
+        },
+        clearQueue: {
+            value: () => {
+                queue.length = 0;
+            },
+        },
+    });
+    return generator;
+};
+exports.pLimit = pLimit;

package/dist/pages-router-webhook.d.ts

@@ -0,0 +1,5 @@
+import type { Response } from 'express';
+import type { NextApiRequest, NextApiResponse } from 'next';
+import type { NextWebhookArgs } from './app-router-webhook';
+export declare const addHeaders: (res: NextApiResponse | Response, headers: Record<string, string>) => void;
+export declare const pagesRouterWebhook: (options: NextWebhookArgs) => (req: NextApiRequest, res: NextApiResponse) => void;

package/dist/pages-router-webhook.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pagesRouterWebhook = exports.addHeaders = void 0;
+const validate_webhook_signature_1 = require("./validate-webhook-signature");
+const addHeaders = (res, headers) => {
+    Object.entries(headers).forEach(([key, value]) => {
+        res.setHeader(key, value);
+    });
+};
+exports.addHeaders = addHeaders;
+const pagesRouterWebhook = (options) => {
+    const { testing, extraHeaders, secret, onSuccess, onTimeout, onError } = options;
+    return function (req, res) {
+        (0, exports.addHeaders)(res, extraHeaders || {});
+        if (testing) {
+            const testingheaders = {
+                'Access-Control-Allow-Origin': 'https://www.remotion.dev',
+                'Access-Control-Allow-Headers': 'X-CSRF-Token, X-Requested-With, Accept, Accept-Version, Content-Length, Content-MD5, Content-Type, Date, X-Api-Version, X-Remotion-Status, X-Remotion-Signature, X-Remotion-Mode',
+                'Access-Control-Allow-Methods': 'OPTIONS,POST',
+            };
+            (0, exports.addHeaders)(res, testingheaders);
+        }
+        if (req.method === 'OPTIONS') {
+            res.status(200).end();
+            return;
+        }
+        (0, validate_webhook_signature_1.validateWebhookSignature)({
+            secret,
+            body: req.body,
+            signatureHeader: req.headers['x-remotion-signature'],
+        });
+        // If code reaches this path, the webhook is authentic.
+        const payload = req.body;
+        if (payload.type === 'success' && onSuccess) {
+            onSuccess(payload);
+        }
+        else if (payload.type === 'timeout' && onTimeout) {
+            onTimeout(payload);
+        }
+        else if (payload.type === 'error' && onError) {
+            onError(payload);
+        }
+        res.status(200).json({
+            success: true,
+        });
+    };
+};
+exports.pagesRouterWebhook = pagesRouterWebhook;

package/dist/parse-function-name.d.ts

@@ -0,0 +1,8 @@
+type ReturnType = {
+    version: string;
+    memorySizeInMb: number;
+    diskSizeInMb: number;
+    timeoutInSeconds: number;
+};
+export declare const parseFunctionName: (functionName: string) => ReturnType | null;
+export {};

package/dist/parse-function-name.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFunctionName = void 0;
+const constants_1 = require("./constants");
+const parseFunctionName = (functionName) => {
+    const match = functionName.match(new RegExp(constants_1.RENDER_FN_PREFIX + '(.*)-mem(\\d+)mb-disk(\\d+)mb-(\\d+)sec$'));
+    if (!match) {
+        return null;
+    }
+    return {
+        version: match[1],
+        memorySizeInMb: parseInt(match[2], 10),
+        diskSizeInMb: parseInt(match[3], 10),
+        timeoutInSeconds: parseInt(match[4], 10),
+    };
+};
+exports.parseFunctionName = parseFunctionName;

package/dist/presign-url.d.ts

@@ -0,0 +1,17 @@
+import type { AwsRegion } from './regions';
+import type { RequestHandler } from './types';
+type MandatoryParameters = {
+    region: AwsRegion;
+    bucketName: string;
+    objectKey: string;
+    expiresInSeconds: number;
+};
+type OptionalParameters<CheckIfObjectExists extends boolean> = {
+    checkIfObjectExists: CheckIfObjectExists;
+    forcePathStyle: boolean;
+};
+export type PresignUrlInput<CheckIfObjectExists extends boolean = boolean> = MandatoryParameters & Partial<OptionalParameters<CheckIfObjectExists>> & {
+    requestHandler?: RequestHandler;
+};
+export declare const presignUrl: <CheckIfObjectExists extends boolean = false>({ region, bucketName, objectKey, checkIfObjectExists, expiresInSeconds, forcePathStyle, requestHandler, }: PresignUrlInput<CheckIfObjectExists>) => Promise<CheckIfObjectExists extends true ? string | null : string>;
+export {};

package/dist/presign-url.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.presignUrl = void 0;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
+const serverless_client_1 = require("@remotion/serverless-client");
+const constants_1 = require("./constants");
+const get_s3_client_1 = require("./get-s3-client");
+const validate_presign_expiration_1 = require("./validate-presign-expiration");
+const internalPresignUrl = async ({ region, bucketName, objectKey, checkIfObjectExists, expiresInSeconds, forcePathStyle, requestHandler, }) => {
+    (0, serverless_client_1.validateBucketName)({
+        bucketName,
+        bucketNamePrefix: constants_1.REMOTION_BUCKET_PREFIX,
+        options: { mustStartWithRemotion: false },
+    });
+    (0, validate_presign_expiration_1.validatePresignExpiration)(expiresInSeconds);
+    const s3Client = (0, get_s3_client_1.getS3Client)({
+        region,
+        customCredentials: null,
+        forcePathStyle,
+        requestHandler: requestHandler !== null && requestHandler !== void 0 ? requestHandler : null,
+    });
+    if (checkIfObjectExists === true) {
+        try {
+            await s3Client.send(new client_s3_1.HeadObjectCommand({
+                Bucket: bucketName,
+                Key: objectKey,
+            }));
+        }
+        catch (err) {
+            if (err.name === 'NotFound') {
+                return null;
+            }
+            if (err.message === 'UnknownError' ||
+                err.$metadata
+                    .httpStatusCode === 403) {
+                throw new Error(`Unable to access item "${objectKey}" from bucket "${bucketName}". You must have permission for both "s3:GetObject" and "s3:ListBucket" actions.`);
+            }
+            throw err;
+        }
+    }
+    const objCommand = new client_s3_1.GetObjectCommand({
+        Bucket: bucketName,
+        Key: objectKey,
+    });
+    const publicUrl = await (0, s3_request_presigner_1.getSignedUrl)(s3Client, objCommand, {
+        expiresIn: expiresInSeconds,
+    });
+    return publicUrl;
+};
+/*
+ * @description Takes a private S3 object and turns it into a public URL by signing it with your AWS credentials.
+ * @see [Documentation](https://remotion.dev/docs/lambda/presignurl)
+ */
+const presignUrl = ({ region, bucketName, objectKey, checkIfObjectExists, expiresInSeconds, forcePathStyle, requestHandler, }) => {
+    return internalPresignUrl({
+        region,
+        bucketName,
+        objectKey,
+        checkIfObjectExists: checkIfObjectExists !== null && checkIfObjectExists !== void 0 ? checkIfObjectExists : false,
+        expiresInSeconds,
+        forcePathStyle: forcePathStyle !== null && forcePathStyle !== void 0 ? forcePathStyle : false,
+        requestHandler,
+    });
+};
+exports.presignUrl = presignUrl;

package/dist/price-per-1s.d.ts

@@ -0,0 +1,37 @@
+import type { AwsRegion } from './regions';
+export declare const pricing: {
+    [key in AwsRegion]: {
+        'Lambda Duration': {
+            rateCode: string;
+            price: string;
+        };
+        'Lambda Duration-Provisioned': {
+            rateCode: string;
+            price: string;
+        };
+        'Lambda Provisioned-Concurrency': {
+            rateCode: string;
+            price: string;
+        };
+        'Lambda Requests': {
+            rateCode: string;
+            price: string;
+        };
+        'Lambda Duration-ARM': {
+            rateCode: string;
+            price: string;
+        };
+        'Lambda Requests-ARM': {
+            rateCode: string;
+            price: string;
+        };
+        'Lambda Storage-Duration': {
+            rateCode: string;
+            price: string;
+        };
+        'Lambda Storage-Duration-ARM': {
+            rateCode: string;
+            price: string;
+        };
+    };
+};