@remotion/serverless-client 4.0.261

package/src/min-max.ts

@@ -0,0 +1,34 @@
+// Standard library Math.min and Math.max can throw
+// if array length is very long. Fixing this with own implementation
+
+export const min = (arr: number[]) => {
+	if (arr.length === 0) {
+		throw new Error('Array of 0 length');
+	}
+
+	let smallest = arr[0];
+	for (let i = 0; i < arr.length; i++) {
+		const elem = arr[i];
+		if (elem < smallest) {
+			smallest = elem;
+		}
+	}
+
+	return smallest;
+};
+
+export const max = (arr: number[]) => {
+	if (arr.length === 0) {
+		throw new Error('Array of 0 length');
+	}
+
+	let biggest = arr[0];
+	for (let i = 0; i < arr.length; i++) {
+		const elem = arr[i];
+		if (elem > biggest) {
+			biggest = elem;
+		}
+	}
+
+	return biggest;
+};

package/src/most-expensive-chunks.ts

@@ -0,0 +1,46 @@
+import type {ParsedTiming} from './types';
+
+export const OVERHEAD_TIME_PER_LAMBDA = 100;
+
+export type ExpensiveChunk = {
+	chunk: number;
+	frameRange: [number, number];
+	timeInMilliseconds: number;
+};
+
+export const getMostExpensiveChunks = ({
+	parsedTimings,
+	framesPerFunction: framesPerLambda,
+	firstFrame,
+	lastFrame,
+}: {
+	parsedTimings: ParsedTiming[];
+	framesPerFunction: number;
+	firstFrame: number;
+	lastFrame: number;
+}): ExpensiveChunk[] => {
+	const mostExpensiveChunks = parsedTimings
+		.slice(0)
+		.sort((a, b) => {
+			const durA = a.rendered - a.start;
+			const durB = b.rendered - b.start;
+
+			return durB - durA;
+		})
+		.slice(0, 5);
+
+	return mostExpensiveChunks.map((c) => {
+		const isLastChunk = c.chunk === parsedTimings.length - 1;
+
+		return {
+			timeInMilliseconds: c.rendered - c.start,
+			chunk: c.chunk,
+			frameRange: [
+				framesPerLambda * c.chunk + firstFrame,
+				isLastChunk
+					? lastFrame
+					: framesPerLambda * (c.chunk + 1) - 1 + firstFrame,
+			],
+		};
+	});
+};

package/src/overall-render-progress.ts

@@ -0,0 +1,30 @@
+import type {PostRenderData} from './constants';
+import type {RenderMetadata} from './render-metadata';
+import type {
+	ChunkRetry,
+	CloudProvider,
+	ParsedTiming,
+	ReceivedArtifact,
+} from './types';
+import type {FunctionErrorInfo} from './write-error-to-storage';
+
+export type OverallRenderProgress<Provider extends CloudProvider> = {
+	chunks: number[];
+	framesRendered: number;
+	framesEncoded: number;
+	combinedFrames: number;
+	timeToCombine: number | null;
+	timeToEncode: number | null;
+	timeToRenderFrames: number | null;
+	lambdasInvoked: number;
+	retries: ChunkRetry[];
+	postRenderData: PostRenderData<Provider> | null;
+	timings: ParsedTiming[];
+	renderMetadata: RenderMetadata<Provider> | null;
+	errors: FunctionErrorInfo[];
+	timeoutTimestamp: number;
+	functionLaunched: number;
+	serveUrlOpened: number | null;
+	compositionValidated: number | null;
+	receivedArtifact: ReceivedArtifact<Provider>[];
+};

package/src/progress.ts

@@ -0,0 +1,327 @@
+import {NoReactAPIs} from '@remotion/renderer/pure';
+
+import {calculateChunkTimes} from './calculate-chunk-times';
+import type {CustomCredentials} from './constants';
+import {estimatePriceFromMetadata} from './estimate-price-from-bucket';
+import {getExpectedOutName} from './expected-out-name';
+import {formatCostsInfo} from './format-costs-info';
+import {getOverallProgress} from './get-overall-progress';
+import {getOverallProgressFromStorage} from './get-overall-progress-from-storage';
+import {inspectErrors} from './inspect-error';
+import {makeTimeoutError} from './make-timeout-error';
+import type {ProviderSpecifics} from './provider-implementation';
+import {lambdaRenderHasAudioVideo} from './render-has-audio-video';
+import type {CleanupInfo, GenericRenderProgress} from './render-progress';
+import {truthy} from './truthy';
+import type {CloudProvider} from './types';
+import type {EnhancedErrorInfo} from './write-error-to-storage';
+
+export const getProgress = async <Provider extends CloudProvider>({
+	bucketName,
+	renderId,
+	expectedBucketOwner,
+	region,
+	memorySizeInMb,
+	timeoutInMilliseconds,
+	customCredentials,
+	providerSpecifics,
+	forcePathStyle,
+	functionName,
+}: {
+	bucketName: string;
+	renderId: string;
+	expectedBucketOwner: string | null;
+	region: Provider['region'];
+	memorySizeInMb: number;
+	timeoutInMilliseconds: number;
+	customCredentials: CustomCredentials<Provider> | null;
+	providerSpecifics: ProviderSpecifics<Provider>;
+	forcePathStyle: boolean;
+	functionName: string;
+}): Promise<GenericRenderProgress<Provider>> => {
+	const overallProgress = await getOverallProgressFromStorage({
+		renderId,
+		bucketName,
+		expectedBucketOwner,
+		region,
+		providerSpecifics,
+		forcePathStyle,
+	});
+
+	if (overallProgress.postRenderData) {
+		if (!overallProgress.renderMetadata) {
+			throw new Error(
+				'No render metadata found even though render is finished',
+			);
+		}
+
+		if (overallProgress.renderMetadata.type === 'still') {
+			throw new Error(
+				"You don't need to call getRenderProgress() on a still render. Once you have obtained the `renderId`, the render is already done! 😉",
+			);
+		}
+
+		const outData = getExpectedOutName({
+			renderMetadata: overallProgress.renderMetadata,
+			bucketName,
+			customCredentials,
+			bucketNamePrefix: providerSpecifics.getBucketPrefix(),
+		});
+
+		const totalFrameCount = NoReactAPIs.getFramesToRender(
+			overallProgress.renderMetadata.frameRange,
+			overallProgress.renderMetadata.everyNthFrame,
+		).length;
+
+		return {
+			framesRendered: totalFrameCount,
+			bucket: bucketName,
+			renderSize: overallProgress.postRenderData.renderSize,
+			chunks: overallProgress.renderMetadata.totalChunks,
+			cleanup: {
+				doneIn: overallProgress.postRenderData.timeToCleanUp,
+				filesDeleted: overallProgress.postRenderData.filesCleanedUp,
+				minFilesToDelete: overallProgress.postRenderData.filesCleanedUp,
+			},
+			costs: {
+				accruedSoFar: overallProgress.postRenderData.cost.estimatedCost,
+				displayCost: overallProgress.postRenderData.cost.estimatedDisplayCost,
+				currency: overallProgress.postRenderData.cost.currency,
+				disclaimer: overallProgress.postRenderData.cost.disclaimer,
+			},
+			currentTime: Date.now(),
+			done: true,
+			encodingStatus: {
+				framesEncoded: totalFrameCount,
+				combinedFrames: totalFrameCount,
+				timeToCombine: overallProgress.postRenderData.timeToCombine,
+			},
+			errors: overallProgress.postRenderData.errors,
+			fatalErrorEncountered: false,
+			lambdasInvoked: overallProgress.renderMetadata.totalChunks,
+			outputFile: overallProgress.postRenderData.outputFile,
+			renderId,
+			timeToFinish: overallProgress.postRenderData.timeToFinish,
+			timeToFinishChunks: overallProgress.postRenderData.timeToRenderChunks,
+			timeToRenderFrames: overallProgress.postRenderData.timeToRenderFrames,
+			overallProgress: 1,
+			retriesInfo: overallProgress.postRenderData.retriesInfo,
+			outKey: outData.key,
+			outBucket: outData.renderBucketName,
+			mostExpensiveFrameRanges:
+				overallProgress.postRenderData.mostExpensiveFrameRanges ?? null,
+			timeToEncode: overallProgress.postRenderData.timeToEncode,
+			outputSizeInBytes: overallProgress.postRenderData.outputSize,
+			type: 'success',
+			estimatedBillingDurationInMilliseconds:
+				overallProgress.postRenderData.estimatedBillingDurationInMilliseconds,
+			timeToCombine: overallProgress.postRenderData.timeToCombine,
+			combinedFrames: totalFrameCount,
+			renderMetadata: overallProgress.renderMetadata,
+			timeoutTimestamp: overallProgress.timeoutTimestamp,
+			compositionValidated: overallProgress.compositionValidated,
+			functionLaunched: overallProgress.functionLaunched,
+			serveUrlOpened: overallProgress.serveUrlOpened,
+			artifacts: overallProgress.receivedArtifact,
+		};
+	}
+
+	const {renderMetadata} = overallProgress;
+
+	const errorExplanations = inspectErrors({
+		errors: overallProgress.errors,
+	});
+
+	const {hasAudio, hasVideo} = renderMetadata
+		? lambdaRenderHasAudioVideo(renderMetadata)
+		: {hasAudio: false, hasVideo: false};
+
+	const chunkCount = overallProgress.chunks.length ?? 0;
+
+	const cleanup: CleanupInfo = {
+		doneIn: null,
+		minFilesToDelete: 0,
+		filesDeleted: 0,
+	};
+
+	if (renderMetadata === null) {
+		return {
+			framesRendered: overallProgress.framesRendered ?? 0,
+			chunks: chunkCount,
+			done: false,
+			encodingStatus: {
+				framesEncoded: overallProgress.framesEncoded,
+				combinedFrames: overallProgress.combinedFrames,
+				timeToCombine: overallProgress.timeToCombine,
+			},
+			timeToRenderFrames: overallProgress.timeToRenderFrames,
+			costs: formatCostsInfo(0),
+			renderId,
+			renderMetadata,
+			bucket: bucketName,
+			outputFile: null,
+			timeToFinish: null,
+			errors: errorExplanations,
+			fatalErrorEncountered: errorExplanations.some(
+				(f) => f.isFatal && !f.willRetry,
+			),
+			currentTime: Date.now(),
+			renderSize: 0,
+			lambdasInvoked: overallProgress.lambdasInvoked ?? 0,
+			cleanup,
+			timeToFinishChunks: null,
+			overallProgress: getOverallProgress({
+				encoding: 0,
+				invoking: 0,
+				frames: 0,
+				gotComposition: overallProgress.compositionValidated,
+				visitedServeUrl: overallProgress.serveUrlOpened,
+				invokedLambda: overallProgress.lambdasInvoked,
+				combining: 0,
+			}),
+			retriesInfo: overallProgress.retries ?? [],
+			outKey: null,
+			outBucket: null,
+			mostExpensiveFrameRanges: null,
+			timeToEncode: overallProgress.timeToEncode,
+			outputSizeInBytes: null,
+			estimatedBillingDurationInMilliseconds: null,
+			combinedFrames: overallProgress.combinedFrames ?? 0,
+			timeToCombine: overallProgress.timeToCombine ?? null,
+			timeoutTimestamp: overallProgress.timeoutTimestamp,
+			type: 'success',
+			compositionValidated: overallProgress.compositionValidated,
+			functionLaunched: overallProgress.functionLaunched,
+			serveUrlOpened: overallProgress.serveUrlOpened,
+			artifacts: overallProgress.receivedArtifact,
+		};
+	}
+
+	const priceFromBucket = estimatePriceFromMetadata({
+		renderMetadata,
+		memorySizeInMb:
+			providerSpecifics.parseFunctionName(renderMetadata.rendererFunctionName)
+				?.memorySizeInMb ?? memorySizeInMb,
+		functionsInvoked: renderMetadata.estimatedRenderLambdaInvokations ?? 0,
+		diskSizeInMb: providerSpecifics.getEphemeralStorageForPriceCalculation(),
+		timings: overallProgress.timings ?? [],
+		region,
+		providerSpecifics,
+	});
+
+	const chunkMultiplier = [hasAudio, hasVideo].filter(truthy).length;
+
+	if (renderMetadata.type === 'still') {
+		throw new Error(
+			"You don't need to call getRenderProgress() on a still render. Once you have obtained the `renderId`, the render is already done! 😉",
+		);
+	}
+
+	const allChunks =
+		(overallProgress.chunks ?? []).length / chunkMultiplier ===
+		(renderMetadata.totalChunks ?? Infinity);
+
+	const frameCount = NoReactAPIs.getFramesToRender(
+		renderMetadata.frameRange,
+		renderMetadata.everyNthFrame,
+	).length;
+
+	const missingChunks = new Array(renderMetadata.totalChunks)
+		.fill(true)
+		.map((_, i) => i)
+		.filter((index) => {
+			return (
+				typeof (overallProgress.chunks ?? []).find((c) => c === index) ===
+				'undefined'
+			);
+		});
+	// We add a 20 second buffer for it, since AWS timeshifts can be quite a lot. Once it's 20sec over the limit, we consider it timed out
+
+	// 1. If we have missing chunks, we consider it timed out
+	const isBeyondTimeoutAndMissingChunks =
+		Date.now() > renderMetadata.startedDate + timeoutInMilliseconds + 20000 &&
+		missingChunks &&
+		missingChunks.length > 0;
+
+	// 2. If we have no missing chunks, but the encoding is not done, even after the additional `merge` function has been spawned, we consider it timed out
+	const isBeyondTimeoutAndHasStitchTimeout =
+		Date.now() > renderMetadata.startedDate + timeoutInMilliseconds * 2 + 20000;
+
+	const allErrors: EnhancedErrorInfo[] = [
+		isBeyondTimeoutAndMissingChunks || isBeyondTimeoutAndHasStitchTimeout
+			? makeTimeoutError({
+					timeoutInMilliseconds,
+					renderMetadata,
+					renderId,
+					missingChunks: missingChunks ?? [],
+					region,
+					functionName,
+					providerSpecifics,
+				})
+			: null,
+		...errorExplanations,
+	].filter(truthy);
+
+	return {
+		framesRendered: overallProgress.framesRendered ?? 0,
+		chunks: chunkCount,
+		done: false,
+		encodingStatus: {
+			framesEncoded: overallProgress.framesEncoded,
+			combinedFrames: overallProgress.combinedFrames,
+			timeToCombine: overallProgress.timeToCombine,
+		},
+		timeToRenderFrames: overallProgress.timeToRenderFrames,
+		costs: priceFromBucket
+			? formatCostsInfo(priceFromBucket.accruedSoFar)
+			: formatCostsInfo(0),
+		renderId,
+		renderMetadata,
+		bucket: bucketName,
+		outputFile: null,
+		timeToFinish: null,
+		errors: allErrors,
+		fatalErrorEncountered: allErrors.some((f) => f.isFatal && !f.willRetry),
+		currentTime: Date.now(),
+		renderSize: 0,
+		lambdasInvoked: overallProgress.lambdasInvoked ?? 0,
+		cleanup,
+		timeToFinishChunks:
+			allChunks && overallProgress
+				? calculateChunkTimes({
+						type: 'absolute-time',
+						timings: overallProgress.timings,
+					})
+				: null,
+		overallProgress: getOverallProgress({
+			encoding: frameCount
+				? (overallProgress.framesEncoded ?? 0) / frameCount
+				: 0,
+			invoking:
+				(overallProgress.lambdasInvoked ?? 0) /
+				renderMetadata.estimatedRenderLambdaInvokations,
+			frames: (overallProgress.framesRendered ?? 0) / (frameCount ?? 1),
+			gotComposition: overallProgress.compositionValidated,
+			visitedServeUrl: overallProgress.serveUrlOpened,
+			invokedLambda: overallProgress.lambdasInvoked,
+			combining: overallProgress.combinedFrames / (frameCount ?? 1),
+		}),
+		retriesInfo: overallProgress.retries ?? [],
+		outKey: null,
+		outBucket: null,
+		mostExpensiveFrameRanges: null,
+		timeToEncode: overallProgress.timeToEncode,
+		outputSizeInBytes: null,
+		estimatedBillingDurationInMilliseconds: priceFromBucket
+			? priceFromBucket.estimatedBillingDurationInMilliseconds
+			: null,
+		combinedFrames: overallProgress.combinedFrames ?? 0,
+		timeToCombine: overallProgress.timeToCombine ?? null,
+		timeoutTimestamp: overallProgress.timeoutTimestamp,
+		type: 'success',
+		compositionValidated: overallProgress.compositionValidated,
+		functionLaunched: overallProgress.functionLaunched,
+		serveUrlOpened: overallProgress.serveUrlOpened,
+		artifacts: overallProgress.receivedArtifact,
+	};
+};

package/src/provider-implementation.ts

@@ -0,0 +1,261 @@
+import type {LogLevel} from '@remotion/renderer';
+import type {Readable} from 'node:stream';
+import type {
+	CustomCredentials,
+	DownloadBehavior,
+	Privacy,
+	ServerlessRoutines,
+} from './constants';
+import type {RenderMetadata} from './render-metadata';
+import type {ServerlessReturnValues} from './return-values';
+import type {OnMessage} from './streaming/streaming';
+import type {CallFunctionOptions, CloudProvider} from './types';
+
+export type ParseFunctionName = (functionName: string) => {
+	version: string;
+	memorySizeInMb: number;
+	diskSizeInMb: number;
+	timeoutInSeconds: number;
+} | null;
+
+type DeleteFile<Provider extends CloudProvider> = (params: {
+	bucketName: string;
+	key: string;
+	region: Provider['region'];
+	customCredentials: CustomCredentials<Provider> | null;
+	forcePathStyle: boolean;
+}) => Promise<void>;
+
+export type BucketWithLocation<Provider extends CloudProvider> = {
+	name: string;
+	creationDate: number;
+	region: Provider['region'];
+};
+
+type BucketExists<Provider extends CloudProvider> = (params: {
+	bucketName: string;
+	region: Provider['region'];
+	expectedBucketOwner: string | null;
+	forcePathStyle: boolean;
+}) => Promise<boolean>;
+
+type ReadFile<Provider extends CloudProvider> = (params: {
+	bucketName: string;
+	key: string;
+	region: Provider['region'];
+	expectedBucketOwner: string | null;
+	forcePathStyle: boolean;
+}) => Promise<Readable>;
+
+type GetBuckets<Provider extends CloudProvider> = (options: {
+	region: Provider['region'];
+	forceBucketName: string | null;
+	forcePathStyle: boolean;
+}) => Promise<BucketWithLocation<Provider>[]>;
+
+type CreateBucket<Provider extends CloudProvider> = (params: {
+	region: Provider['region'];
+	bucketName: string;
+	forcePathStyle: boolean;
+	skipPutAcl: boolean;
+}) => Promise<void>;
+
+type ApplyLifeCycle<Provider extends CloudProvider> = (params: {
+	enableFolderExpiry: boolean | null;
+	bucketName: string;
+	region: Provider['region'];
+	customCredentials: CustomCredentials<Provider> | null;
+	forcePathStyle: boolean;
+}) => Promise<void>;
+
+type ListObjects<Provider extends CloudProvider> = (params: {
+	bucketName: string;
+	prefix: string;
+	region: Provider['region'];
+	expectedBucketOwner: string | null;
+	forcePathStyle: boolean;
+	continuationToken?: string;
+}) => Promise<BucketObject[]>;
+
+type BucketObject = {
+	Key: string;
+	LastModified: Date;
+	ETag: string;
+	Size: number;
+};
+
+type HeadFile<Provider extends CloudProvider> = (
+	params: HeadFileInput<Provider>,
+) => Promise<HeadFileOutput>;
+
+type RandomHash = () => string;
+
+type ConvertToServeUrl<Provider extends CloudProvider> = (params: {
+	urlOrId: string;
+	region: Provider['region'];
+	bucketName: string;
+}) => string;
+
+type HeadFileOutput = {
+	LastModified?: Date | undefined;
+	ContentLength?: number | undefined;
+};
+
+export type DeleteFunctionInput<Provider extends CloudProvider> = {
+	region: Provider['region'];
+	functionName: string;
+};
+
+export type DeleteFunction<Provider extends CloudProvider> = (
+	options: DeleteFunctionInput<Provider>,
+) => Promise<void>;
+
+export type WriteFileInput<Provider extends CloudProvider> = {
+	bucketName: string;
+	key: string;
+	body: Readable | string | Uint8Array;
+	region: Provider['region'];
+	privacy: Privacy;
+	expectedBucketOwner: string | null;
+	downloadBehavior: DownloadBehavior | null;
+	customCredentials: CustomCredentials<Provider> | null;
+	forcePathStyle: boolean;
+};
+
+type WriteFile<Provider extends CloudProvider> = (
+	params: WriteFileInput<Provider>,
+) => Promise<void>;
+
+type HeadFileInput<Provider extends CloudProvider> = {
+	bucketName: string;
+	key: string;
+	region: Provider['region'];
+	customCredentials: CustomCredentials<Provider> | null;
+	forcePathStyle: boolean;
+};
+
+export type CallFunctionAsync<Provider extends CloudProvider> = <
+	T extends ServerlessRoutines,
+>({
+	functionName,
+	payload,
+	region,
+	timeoutInTest,
+}: CallFunctionOptions<T, Provider>) => Promise<void>;
+
+export type CallFunctionStreaming<Provider extends CloudProvider> = <
+	T extends ServerlessRoutines,
+>(
+	options: CallFunctionOptions<T, Provider> & {
+		receivedStreamingPayload: OnMessage<Provider>;
+		retriesRemaining: number;
+	},
+) => Promise<void>;
+
+export type CallFunctionSync<Provider extends CloudProvider> = <
+	T extends ServerlessRoutines,
+>({
+	functionName,
+	payload,
+	region,
+	timeoutInTest,
+}: CallFunctionOptions<T, Provider>) => Promise<
+	ServerlessReturnValues<Provider>[T]
+>;
+
+export type GetOutputUrl<Provider extends CloudProvider> = (options: {
+	renderMetadata: RenderMetadata<Provider>;
+	bucketName: string;
+	customCredentials: CustomCredentials<Provider> | null;
+	currentRegion: Provider['region'];
+}) => {url: string; key: string};
+
+export type EstimatePriceInput<Provider extends CloudProvider> = {
+	region: Provider['region'];
+	memorySizeInMb: number;
+	diskSizeInMb: number;
+	lambdasInvoked: number;
+	durationInMilliseconds: number;
+};
+
+export type EstimatePrice<Provider extends CloudProvider> = ({
+	region,
+	memorySizeInMb,
+	diskSizeInMb,
+	lambdasInvoked,
+	...other
+}: EstimatePriceInput<Provider>) => number;
+
+export type GetLoggingUrlForRendererFunction<Provider extends CloudProvider> =
+	(options: {
+		region: Provider['region'];
+		functionName: string;
+		rendererFunctionName: string | null;
+		renderId: string;
+		chunk: null | number;
+	}) => string;
+
+export type GetFunctionsInput<Provider extends CloudProvider> = {
+	region: Provider['region'];
+	compatibleOnly: boolean;
+	logLevel?: LogLevel;
+};
+
+export type GetLoggingUrlForMethod<Provider extends CloudProvider> = (options: {
+	region: Provider['region'];
+	functionName: string;
+	method: ServerlessRoutines;
+	rendererFunctionName: string | null;
+	renderId: string;
+}) => string;
+
+export type GetAccountId<Provider extends CloudProvider> = (options: {
+	region: Provider['region'];
+}) => Promise<string>;
+
+export type FunctionInfo = {
+	functionName: string;
+	timeoutInSeconds: number;
+	memorySizeInMb: number;
+	version: string | null;
+	diskSizeInMb: number;
+};
+
+export type GetFunctions<Provider extends CloudProvider> = (
+	params: GetFunctionsInput<Provider>,
+) => Promise<FunctionInfo[]>;
+
+export type ProviderSpecifics<Provider extends CloudProvider> = {
+	getChromiumPath: () => string | null;
+	getBuckets: GetBuckets<Provider>;
+	getBucketPrefix: () => string;
+	createBucket: CreateBucket<Provider>;
+	applyLifeCycle: ApplyLifeCycle<Provider>;
+	listObjects: ListObjects<Provider>;
+	deleteFile: DeleteFile<Provider>;
+	bucketExists: BucketExists<Provider>;
+	randomHash: RandomHash;
+	readFile: ReadFile<Provider>;
+	writeFile: WriteFile<Provider>;
+	headFile: HeadFile<Provider>;
+	convertToServeUrl: ConvertToServeUrl<Provider>;
+	printLoggingHelper: boolean;
+	validateDeleteAfter: (lifeCycleValue: unknown) => void;
+	callFunctionAsync: CallFunctionAsync<Provider>;
+	callFunctionStreaming: CallFunctionStreaming<Provider>;
+	callFunctionSync: CallFunctionSync<Provider>;
+	estimatePrice: EstimatePrice<Provider>;
+	getLoggingUrlForRendererFunction: GetLoggingUrlForRendererFunction<Provider>;
+	getLoggingUrlForMethod: GetLoggingUrlForMethod<Provider>;
+	getEphemeralStorageForPriceCalculation: () => number;
+	getOutputUrl: GetOutputUrl<Provider>;
+	isFlakyError: (err: Error) => boolean;
+	serverStorageProductName: () => string;
+	getMaxStillInlinePayloadSize: () => number;
+	getMaxNonInlinePayloadSizePerFunction: () => number;
+	getAccountId: GetAccountId<Provider>;
+	deleteFunction: DeleteFunction<Provider>;
+	getFunctions: GetFunctions<Provider>;
+	parseFunctionName: ParseFunctionName;
+	checkCredentials: () => void;
+};