@remotion/lambda-client 4.0.363 → 4.0.365

package/dist/cjs/is-cli.d.ts

@@ -0,0 +1,2 @@
+export declare const getIsCli: () => boolean;
+export declare const setIsCli: (cli: boolean) => void;

package/dist/cjs/is-flaky-error.d.ts

@@ -0,0 +1 @@
+export declare const isFlakyError: (err: Error) => boolean;

package/dist/cjs/is-in-lambda.d.ts

@@ -0,0 +1 @@
+export declare const isInsideLambda: () => boolean;

package/dist/cjs/is-likely-to-have-aws-profile.d.ts

@@ -0,0 +1 @@
+export declare const isLikelyToHaveAwsProfile: () => boolean;

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

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

package/dist/cjs/lifecycle-rules.d.ts

@@ -0,0 +1,12 @@
+import type { CustomCredentials } from '@remotion/serverless-client';
+import type { AwsProvider } from './aws-provider';
+import type { AwsRegion } from './regions';
+import type { RequestHandler } from './types';
+export declare const applyLifeCyleOperation: ({ enableFolderExpiry, bucketName, region, customCredentials, forcePathStyle, requestHandler, }: {
+    enableFolderExpiry: boolean | null;
+    bucketName: string;
+    region: AwsRegion;
+    customCredentials: CustomCredentials<AwsProvider> | null;
+    forcePathStyle: boolean;
+    requestHandler: RequestHandler | null;
+}) => Promise<void>;

package/dist/cjs/lifecycle.d.ts

@@ -0,0 +1,7 @@
+import type { LifecycleRule } from '@aws-sdk/client-s3';
+import type { CloudProvider, DeleteAfter, ProviderSpecifics } from '@remotion/serverless-client';
+export declare const getLifeCycleRules: () => LifecycleRule[];
+export declare const generateRandomHashWithLifeCycleRule: <Provider extends CloudProvider>({ deleteAfter, randomHashFn, }: {
+    deleteAfter: DeleteAfter | null;
+    randomHashFn: ProviderSpecifics<Provider>["randomHash"];
+}) => string;

package/dist/cjs/list-objects.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderSpecifics } from '@remotion/serverless-client';
+import type { AwsProvider } from './aws-provider';
+export declare const lambdaLsImplementation: ProviderSpecifics<AwsProvider>['listObjects'];

package/dist/cjs/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/cjs/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/cjs/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/cjs/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) => Promise<void>;

package/dist/cjs/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/cjs/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/cjs/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;
+        };
+    };
+};

package/dist/cjs/random-hash.d.ts

@@ -0,0 +1 @@
+export declare const randomHashImplementation: () => string;

package/dist/cjs/read-file.d.ts

@@ -0,0 +1,11 @@
+import type { Readable } from 'stream';
+import type { AwsRegion } from './regions';
+import type { RequestHandler } from './types';
+export declare const lambdaReadFileImplementation: ({ bucketName, key, region, expectedBucketOwner, forcePathStyle, requestHandler, }: {
+    bucketName: string;
+    key: string;
+    region: AwsRegion;
+    expectedBucketOwner: string | null;
+    forcePathStyle: boolean;
+    requestHandler: RequestHandler | null;
+}) => Promise<Readable>;

package/dist/cjs/regions.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_AWS_REGIONS: readonly ["eu-central-1", "eu-west-1", "eu-west-2", "eu-west-3", "eu-north-1", "us-east-1", "us-east-2", "us-west-1", "us-west-2", "ap-south-1", "ap-southeast-1", "ap-southeast-2", "ap-northeast-1", "ap-northeast-2", "ap-northeast-3", "ca-central-1", "sa-east-1"];
+export declare const AWS_REGIONS: readonly ["eu-central-1", "eu-central-2", "eu-west-1", "eu-west-2", "eu-west-3", "eu-south-1", "eu-north-1", "us-east-1", "us-east-2", "us-west-1", "us-west-2", "af-south-1", "ap-south-1", "ap-east-1", "ap-southeast-1", "ap-southeast-2", "ap-northeast-1", "ap-northeast-2", "ap-northeast-3", "ap-southeast-4", "ap-southeast-5", "ca-central-1", "me-south-1", "sa-east-1"];
+export type AwsRegion = (typeof AWS_REGIONS)[number];

package/dist/cjs/regions.js

@@ -0,0 +1,80 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/regions.ts
+var exports_regions = {};
+__export(exports_regions, {
+  DEFAULT_AWS_REGIONS: () => DEFAULT_AWS_REGIONS,
+  AWS_REGIONS: () => AWS_REGIONS
+});
+module.exports = __toCommonJS(exports_regions);
+var DEFAULT_AWS_REGIONS = [
+  "eu-central-1",
+  "eu-west-1",
+  "eu-west-2",
+  "eu-west-3",
+  "eu-north-1",
+  "us-east-1",
+  "us-east-2",
+  "us-west-1",
+  "us-west-2",
+  "ap-south-1",
+  "ap-southeast-1",
+  "ap-southeast-2",
+  "ap-northeast-1",
+  "ap-northeast-2",
+  "ap-northeast-3",
+  "ca-central-1",
+  "sa-east-1"
+];
+var AWS_REGIONS = [
+  "eu-central-1",
+  "eu-central-2",
+  "eu-west-1",
+  "eu-west-2",
+  "eu-west-3",
+  "eu-south-1",
+  "eu-north-1",
+  "us-east-1",
+  "us-east-2",
+  "us-west-1",
+  "us-west-2",
+  "af-south-1",
+  "ap-south-1",
+  "ap-east-1",
+  "ap-southeast-1",
+  "ap-southeast-2",
+  "ap-northeast-1",
+  "ap-northeast-2",
+  "ap-northeast-3",
+  "ap-southeast-4",
+  "ap-southeast-5",
+  "ca-central-1",
+  "me-south-1",
+  "sa-east-1"
+];

package/dist/cjs/render-media-on-lambda.d.ts

@@ -0,0 +1,66 @@
+import type { StorageClass } from '@aws-sdk/client-s3';
+import type { AudioCodec, BrowserSafeApis, ChromiumOptions, DownloadBehavior, FrameRange, OutNameInput, PixelFormat, Privacy, ProResProfile, ServerlessCodec, ToOptions, VideoImageFormat, WebhookOption } from '@remotion/serverless-client';
+import { type AwsProvider } from './aws-provider';
+import type { InnerRenderMediaOnLambdaInput } from './make-lambda-payload';
+import type { AwsRegion } from './regions';
+import type { RequestHandler } from './types';
+export type RenderMediaOnLambdaInput = {
+    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;
+    proResProfile?: ProResProfile;
+    privacy?: Privacy;
+    /**
+     * @deprecated Renamed to `jpegQuality`
+     */
+    quality?: never;
+    jpegQuality?: number;
+    maxRetries?: number;
+    framesPerLambda?: number;
+    concurrency?: number;
+    frameRange?: FrameRange;
+    outName?: OutNameInput<AwsProvider>;
+    chromiumOptions?: Omit<ChromiumOptions, 'enableMultiProcessOnLinux'>;
+    scale?: number;
+    everyNthFrame?: number;
+    concurrencyPerLambda?: number;
+    downloadBehavior?: DownloadBehavior | null;
+    overwrite?: boolean;
+    webhook?: WebhookOption | null;
+    forceWidth?: number | null;
+    forceHeight?: number | null;
+    rendererFunctionName?: string | null;
+    forceBucketName?: string;
+    audioCodec?: AudioCodec | null;
+    /**
+     * @deprecated in favor of `logLevel`: true
+     */
+    dumpBrowserLogs?: boolean;
+    forcePathStyle?: boolean;
+    metadata?: Record<string, string> | null;
+    storageClass?: StorageClass | null;
+    requestHandler?: RequestHandler;
+} & Partial<ToOptions<typeof BrowserSafeApis.optionsMap.renderMediaOnLambda>>;
+export type RenderMediaOnLambdaOutput = {
+    renderId: string;
+    bucketName: string;
+    cloudWatchLogs: string;
+    cloudWatchMainLogs: string;
+    lambdaInsightsLogs: string;
+    folderInS3Console: string;
+    progressJsonInConsole: string;
+};
+export declare const internalRenderMediaOnLambdaRaw: (input: InnerRenderMediaOnLambdaInput) => Promise<RenderMediaOnLambdaOutput>;
+export declare const renderMediaOnLambdaOptionalToRequired: (options: RenderMediaOnLambdaInput) => InnerRenderMediaOnLambdaInput;
+export declare const renderMediaOnLambda: (options: RenderMediaOnLambdaInput) => Promise<RenderMediaOnLambdaOutput>;
+/**
+ * @deprecated Renamed to renderMediaOnLambda()
+ */
+export declare const renderVideoOnLambda: (options: RenderMediaOnLambdaInput) => Promise<RenderMediaOnLambdaOutput>;

package/dist/cjs/render-still-on-lambda.d.ts

@@ -0,0 +1,61 @@
+import type { BrowserSafeApis, ChromiumOptions, DownloadBehavior, StillImageFormat, ToOptions } from '@remotion/serverless-client';
+import type { StorageClass } from '@aws-sdk/client-s3';
+import type { CostsInfo, OutNameInput, Privacy, ReceivedArtifact } from '@remotion/serverless-client';
+import { type AwsProvider } from './aws-provider';
+import type { AwsRegion } from './regions';
+import type { RequestHandler } from './types';
+type MandatoryParameters = {
+    region: AwsRegion;
+    functionName: string;
+    serveUrl: string;
+    composition: string;
+    inputProps: Record<string, unknown>;
+    imageFormat: StillImageFormat;
+    privacy: Privacy;
+};
+type OptionalParameters = {
+    maxRetries: number;
+    envVariables: Record<string, string>;
+    frame: number;
+    outName: OutNameInput<AwsProvider> | null;
+    chromiumOptions: ChromiumOptions;
+    downloadBehavior: DownloadBehavior;
+    forceWidth: number | null;
+    forceHeight: number | null;
+    forceBucketName: string | null;
+    onInit: (data: {
+        renderId: string;
+        cloudWatchLogs: string;
+        lambdaInsightsUrl: string;
+    }) => void;
+    indent: boolean;
+    forcePathStyle: boolean;
+    storageClass: StorageClass | null;
+    requestHandler: RequestHandler | null | undefined;
+} & ToOptions<typeof BrowserSafeApis.optionsMap.renderStillOnLambda>;
+export type RenderStillOnLambdaNonNullInput = MandatoryParameters & OptionalParameters;
+export type RenderStillOnLambdaInput = MandatoryParameters & Partial<OptionalParameters> & {
+    requestHandler?: RequestHandler;
+};
+export type RenderStillOnLambdaOutput = {
+    estimatedPrice: CostsInfo;
+    url: string;
+    outKey: string;
+    sizeInBytes: number;
+    bucketName: string;
+    renderId: string;
+    cloudWatchLogs: string;
+    artifacts: ReceivedArtifact<AwsProvider>[];
+};
+export declare const internalRenderStillOnLambda: (input: RenderStillOnLambdaNonNullInput) => Promise<RenderStillOnLambdaOutput>;
+export declare const renderStillOnLambda: (input: RenderStillOnLambdaInput & {
+    /**
+     * @deprecated Renamed to `jpegQuality`
+     */
+    quality?: never;
+    /**
+     * @deprecated Renamed to `logLevel`
+     */
+    dumpBrowserLogs?: boolean;
+}) => Promise<RenderStillOnLambdaOutput>;
+export {};

package/dist/cjs/runtime-preference.d.ts

@@ -0,0 +1,2 @@
+export declare const runtimePreferenceOptions: readonly ["default", "apple-emojis", "cjk"];
+export type RuntimePreference = (typeof runtimePreferenceOptions)[number];

package/dist/cjs/speculate-function-name.d.ts

@@ -0,0 +1,7 @@
+export type SpeculateFunctionNameInput = {
+    memorySizeInMb: string | number;
+    diskSizeInMb: string | number;
+    timeoutInSeconds: string | number;
+};
+export declare const innerSpeculateFunctionName: ({ diskSizeInMb, memorySizeInMb, timeoutInSeconds, }: SpeculateFunctionNameInput) => string;
+export declare const speculateFunctionName: ({ memorySizeInMb, diskSizeInMb, timeoutInSeconds, }: SpeculateFunctionNameInput) => string;

package/dist/cjs/types.d.ts

@@ -0,0 +1,4 @@
+import type { LambdaClient } from '@aws-sdk/client-lambda';
+type LambdaClientConfig = NonNullable<ConstructorParameters<typeof LambdaClient>[0]>;
+export type RequestHandler = LambdaClientConfig['requestHandler'];
+export {};

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

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

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

@@ -0,0 +1,4 @@
+import type { AwsRegion } from './regions';
+export declare const parseBucketName: (name: string) => {
+    region: AwsRegion | null;
+};

package/dist/cjs/validate-disk-size-in-mb.d.ts

@@ -0,0 +1 @@
+export declare const validateDiskSizeInMb: (diskSizeInMb: unknown) => void;

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

@@ -0,0 +1,2 @@
+import type { ServerlessCodec } from '@remotion/serverless-client';
+export declare const validateLambdaCodec: (codec: unknown) => ServerlessCodec;

package/dist/cjs/validate-memory-size.d.ts

@@ -0,0 +1 @@
+export declare const validateMemorySize: (memorySizeInMb: unknown) => void;

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

@@ -0,0 +1 @@
+export declare const validatePresignExpiration: (presignExpiration: unknown) => void;

package/dist/cjs/validate-serveurl.d.ts

@@ -0,0 +1 @@
+export declare const validateServeUrl: (serveUrl: unknown) => void;

package/dist/cjs/validate-webhook-signature.d.ts

@@ -0,0 +1,5 @@
+export declare const validateWebhookSignature: ({ secret, body, signatureHeader, }: {
+    secret: string;
+    body: unknown;
+    signatureHeader: string;
+}) => void;

package/dist/cjs/write-file.d.ts

@@ -0,0 +1,5 @@
+import type { WriteFileInput } from '@remotion/serverless-client';
+import type { AwsProvider } from './aws-provider';
+export declare const lambdaWriteFileImplementation: (params: WriteFileInput<AwsProvider> & {
+    retries?: number;
+}) => Promise<void>;