@remotion/lambda-client 4.0.362 → 4.0.364

package/dist/cjs/index.d.ts

@@ -0,0 +1,129 @@
+export type { EnhancedErrorInfo, GetOrCreateBucketInput, GetOrCreateBucketOutput, } from '@remotion/serverless-client';
+export type { RuntimePreference } from './runtime-preference';
+import { validateAwsRegion } from './validate-aws-region';
+export type { CustomCredentials, DeleteAfter, WebhookErrorPayload, WebhookPayload, WebhookSuccessPayload, WebhookTimeoutPayload, } from '@remotion/serverless-client';
+export { appRouterWebhook, NextWebhookArgs } from './app-router-webhook';
+export { AwsProvider } from './aws-provider';
+export type { RenderProgress } from './constants';
+export { deleteFunction, DeleteFunctionInput } from './delete-function';
+export { deleteRender, type DeleteRenderInput } from './delete-render';
+export { estimatePrice, EstimatePriceInput } from './estimate-price';
+export { expressWebhook } from './express-webhook';
+export { getAwsClient, type GetAwsClientInput, type GetAwsClientOutput, } from './get-aws-client';
+export { getCompositionsOnLambda, type GetCompositionsOnLambdaInput, type GetCompositionsOnLambdaOutput, } from './get-compositions-on-lambda';
+export { getFunctionVersion } from './get-function-version';
+export { getFunctions, type GetFunctionsInput } from './get-functions';
+export { getRenderProgress } from './get-render-progress';
+export type { GetRenderProgressInput } from './get-render-progress';
+export { getSites, type GetSitesInput, type GetSitesOutput } from './get-sites';
+export { pagesRouterWebhook } from './pages-router-webhook';
+export { presignUrl, type PresignUrlInput } from './presign-url';
+export type { AwsRegion } from './regions';
+export { renderMediaOnLambda, renderVideoOnLambda, type RenderMediaOnLambdaInput, type RenderMediaOnLambdaOutput, } from './render-media-on-lambda';
+export { renderStillOnLambda, type RenderStillOnLambdaInput, type RenderStillOnLambdaOutput, } from './render-still-on-lambda';
+export { speculateFunctionName, type SpeculateFunctionNameInput, } from './speculate-function-name';
+export type { RequestHandler } from './types';
+export { validateWebhookSignature } from './validate-webhook-signature';
+export declare const LambdaClientInternals: {
+    generateRandomHashWithLifeCycleRule: <Provider extends import("@remotion/serverless-client").CloudProvider>({ deleteAfter, randomHashFn, }: {
+        deleteAfter: import("@remotion/serverless-client").DeleteAfter | null;
+        randomHashFn: import("@remotion/serverless-client").ProviderSpecifics<Provider>["randomHash"];
+    }) => string;
+    getLambdaClient: (region: import("./regions").AwsRegion, _timeoutInTest: number | undefined, requestHandler: import("./types").RequestHandler | null) => import("@aws-sdk/client-lambda").LambdaClient;
+    getS3Client: ({ region, customCredentials, forcePathStyle, requestHandler, }: {
+        region: import("./regions").AwsRegion;
+        customCredentials: import("@remotion/serverless-client").CustomCredentials<import("./aws-provider").AwsProvider> | null;
+        forcePathStyle: boolean;
+        requestHandler: import("./types").RequestHandler | null;
+    }) => import("@aws-sdk/client-s3").S3Client;
+    getS3RenderUrl: ({ renderId, region, bucketName, }: {
+        renderId: string;
+        region: import("./regions").AwsRegion;
+        bucketName: string;
+    }) => string;
+    getIamClient: (region: import("./regions").AwsRegion, requestHandler: import("./types").RequestHandler | null) => import("@aws-sdk/client-iam").IAMClient;
+    getStsClient: (region: import("./regions").AwsRegion, requestHandler: import("./types").RequestHandler | null) => import("@aws-sdk/client-sts").STSClient;
+    getCloudWatchLogsClient: (region: import("./regions").AwsRegion, requestHandler: import("./types").RequestHandler | null) => import("@aws-sdk/client-cloudwatch-logs").CloudWatchLogsClient;
+    getServiceQuotasClient: (region: import("./regions").AwsRegion, requestHandler: import("./types").RequestHandler | null) => import("@aws-sdk/client-service-quotas").ServiceQuotasClient;
+    parseJsonOrThrowSource: (data: Uint8Array, type: string) => any;
+    getCloudwatchMethodUrl: ({ region, functionName, renderId, rendererFunctionName, method, }: {
+        region: import("./regions").AwsRegion;
+        functionName: string;
+        method: import("@remotion/serverless-client").ServerlessRoutines;
+        rendererFunctionName: string | null;
+        renderId: string;
+    }) => string;
+    getCloudwatchRendererUrl: import("@remotion/serverless-client").GetLoggingUrlForRendererFunction<import("./aws-provider").AwsProvider>;
+    MAX_EPHEMERAL_STORAGE_IN_MB: number;
+    parseFunctionName: (functionName: string) => {
+        version: string;
+        memorySizeInMb: number;
+        diskSizeInMb: number;
+        timeoutInSeconds: number;
+    } | null;
+    isFlakyError: (err: Error) => boolean;
+    convertToServeUrlImplementation: ({ urlOrId, region, bucketName, }: {
+        urlOrId: string;
+        region: import("./regions").AwsRegion;
+        bucketName: string;
+    }) => string;
+    randomHashImplementation: () => string;
+    parseBucketName: (name: string) => {
+        region: import("./regions").AwsRegion | null;
+    };
+    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, }: import("./make-lambda-payload").InnerRenderMediaOnLambdaInput) => Promise<import("@remotion/serverless-client").ServerlessStartPayload<import("./aws-provider").AwsProvider>>;
+    renderMediaOnLambdaOptionalToRequired: (options: import("./render-media-on-lambda").RenderMediaOnLambdaInput) => import("./make-lambda-payload").InnerRenderMediaOnLambdaInput;
+    internalDeleteRender: (input: import("./delete-render").DeleteRenderInput & {
+        providerSpecifics: import("@remotion/serverless-client").ProviderSpecifics<import("./aws-provider").AwsProvider>;
+        forcePathStyle: boolean;
+    }) => Promise<{
+        freedBytes: number;
+    }>;
+    internalGetSites: ({ region, forceBucketName, providerSpecifics, forcePathStyle, requestHandler, }: ({
+        region: import("./regions").AwsRegion;
+    } & {
+        forceBucketName: string | null;
+        forcePathStyle: boolean;
+        requestHandler: import("./types").RequestHandler | null;
+    }) & {
+        providerSpecifics: import("@remotion/serverless-client").ProviderSpecifics<import("./aws-provider").AwsProvider>;
+    }) => Promise<import("./get-sites").GetSitesOutput>;
+    getLifeCycleRules: () => import("@aws-sdk/client-s3").LifecycleRule[];
+    awsImplementation: import("@remotion/serverless-client").ProviderSpecifics<import("./aws-provider").AwsProvider>;
+    runtimePreferenceOptions: readonly ["default", "apple-emojis", "cjk"];
+    validateAwsRegion: typeof validateAwsRegion;
+    validateDiskSizeInMb: (diskSizeInMb: unknown) => void;
+    validateMemorySize: (memorySizeInMb: unknown) => void;
+    DEFAULT_CLOUDWATCH_RETENTION_PERIOD: number;
+    DEFAULT_EPHEMERAL_STORAGE_IN_MB: number;
+    LAMBDA_VERSION_STRING: string;
+    pLimit: (concurrency: number) => <Arguments extends unknown[], ReturnType>(fn: (..._arguments: Arguments) => PromiseLike<ReturnType> | ReturnType, ...args: Arguments) => Promise<ReturnType>;
+    makeS3ServeUrl: ({ bucketName, subFolder, region, }: {
+        bucketName: string;
+        subFolder: string;
+        region: import("./regions").AwsRegion;
+    }) => string;
+    validateServeUrl: (serveUrl: unknown) => void;
+    getEnvVariable: (name: string) => string | undefined;
+    internalRenderMediaOnLambdaRaw: (input: import("./make-lambda-payload").InnerRenderMediaOnLambdaInput) => Promise<import("./render-media-on-lambda").RenderMediaOnLambdaOutput>;
+    internalRenderStillOnLambda: (input: import("./render-still-on-lambda").RenderStillOnLambdaNonNullInput) => Promise<import("./render-still-on-lambda").RenderStillOnLambdaOutput>;
+    cleanItems: <Provider extends import("@remotion/serverless-client").CloudProvider>({ bucket, onAfterItemDeleted, onBeforeItemDeleted, region, list, providerSpecifics, forcePathStyle, requestHandler, }: {
+        bucket: string;
+        region: Provider["region"];
+        list: string[];
+        onBeforeItemDeleted: (data: {
+            bucketName: string;
+            itemName: string;
+        }) => void;
+        onAfterItemDeleted: (data: {
+            bucketName: string;
+            itemName: string;
+        }) => void;
+        providerSpecifics: import("@remotion/serverless-client").ProviderSpecifics<Provider>;
+        forcePathStyle: boolean;
+        requestHandler: Provider["requestHandler"] | null;
+    }) => Promise<void[]>;
+    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, }: import("./render-still-on-lambda").RenderStillOnLambdaNonNullInput) => Promise<import("@remotion/serverless-client").ServerlessPayloads<import("./aws-provider").AwsProvider>[import("@remotion/serverless-client").ServerlessRoutines.still]>;
+    getRenderProgressPayload: ({ bucketName, renderId, s3OutputProvider, logLevel, forcePathStyle, }: import("./get-render-progress").GetRenderProgressInput) => import("@remotion/serverless-client").ServerlessStatusPayload<import("./aws-provider").AwsProvider>;
+    innerSpeculateFunctionName: ({ diskSizeInMb, memorySizeInMb, timeoutInSeconds, }: import("./speculate-function-name").SpeculateFunctionNameInput) => string;
+};