export type {
	EnhancedErrorInfo,
	GetOrCreateBucketInput,
	GetOrCreateBucketOutput,
} from '@remotion/serverless-client';
export type {RuntimePreference} from './runtime-preference';
import {
	getCloudWatchLogsClient,
	getIamClient,
	getLambdaClient,
	getServiceQuotasClient,
	getStsClient,
} from './aws-clients';
import {awsImplementation} from './aws-provider';
import {parseJsonOrThrowSource} from './call-lambda-streaming';
import {cleanItems} from './clean-items';
import {
	DEFAULT_CLOUDWATCH_RETENTION_PERIOD,
	DEFAULT_EPHEMERAL_STORAGE_IN_MB,
	MAX_EPHEMERAL_STORAGE_IN_MB,
} from './constants';
import {convertToServeUrlImplementation} from './convert-to-serve-url';
import {internalDeleteRender} from './delete-render';
import {
	getCloudwatchMethodUrl,
	getCloudwatchRendererUrl,
	getS3RenderUrl,
} from './get-aws-urls';
import {getEnvVariable} from './get-env-variable';
import {getS3Client} from './get-s3-client';
import {internalGetSites} from './get-sites';
import {isFlakyError} from './is-flaky-error';
import {LAMBDA_VERSION_STRING} from './lambda-version-string';
import {
	generateRandomHashWithLifeCycleRule,
	getLifeCycleRules,
} from './lifecycle';
import {
	getRenderProgressPayload,
	makeLambdaRenderMediaPayload,
	makeLambdaRenderStillPayload,
} from './make-lambda-payload';
import {makeS3ServeUrl} from './make-s3-url';
import {pLimit} from './p-limit';
import {parseFunctionName} from './parse-function-name';
import {randomHashImplementation} from './random-hash';
import {
	internalRenderMediaOnLambdaRaw,
	renderMediaOnLambdaOptionalToRequired,
} from './render-media-on-lambda';
import {internalRenderStillOnLambda} from './render-still-on-lambda';
import {runtimePreferenceOptions} from './runtime-preference';
import {innerSpeculateFunctionName} from './speculate-function-name';
import {validateAwsRegion} from './validate-aws-region';
import {parseBucketName} from './validate-bucketname';
import {validateDiskSizeInMb} from './validate-disk-size-in-mb';
import {validateMemorySize} from './validate-memory-size';
import {validateServeUrl} from './validate-serveurl';

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 const LambdaClientInternals: {
	generateRandomHashWithLifeCycleRule: typeof generateRandomHashWithLifeCycleRule;
	getLambdaClient: typeof getLambdaClient;
	getS3Client: typeof getS3Client;
	getS3RenderUrl: typeof getS3RenderUrl;
	getIamClient: typeof getIamClient;
	getStsClient: typeof getStsClient;
	getCloudWatchLogsClient: typeof getCloudWatchLogsClient;
	getServiceQuotasClient: typeof getServiceQuotasClient;
	parseJsonOrThrowSource: typeof parseJsonOrThrowSource;
	getCloudwatchMethodUrl: typeof getCloudwatchMethodUrl;
	getCloudwatchRendererUrl: typeof getCloudwatchRendererUrl;
	MAX_EPHEMERAL_STORAGE_IN_MB: typeof MAX_EPHEMERAL_STORAGE_IN_MB;
	parseFunctionName: typeof parseFunctionName;
	isFlakyError: typeof isFlakyError;
	convertToServeUrlImplementation: typeof convertToServeUrlImplementation;
	randomHashImplementation: typeof randomHashImplementation;
	parseBucketName: typeof parseBucketName;
	makeLambdaRenderMediaPayload: typeof makeLambdaRenderMediaPayload;
	renderMediaOnLambdaOptionalToRequired: typeof renderMediaOnLambdaOptionalToRequired;
	internalDeleteRender: typeof internalDeleteRender;
	internalGetSites: typeof internalGetSites;
	getLifeCycleRules: typeof getLifeCycleRules;
	awsImplementation: typeof awsImplementation;
	runtimePreferenceOptions: typeof runtimePreferenceOptions;
	validateAwsRegion: typeof validateAwsRegion;
	validateDiskSizeInMb: typeof validateDiskSizeInMb;
	validateMemorySize: typeof validateMemorySize;
	DEFAULT_CLOUDWATCH_RETENTION_PERIOD: typeof DEFAULT_CLOUDWATCH_RETENTION_PERIOD;
	DEFAULT_EPHEMERAL_STORAGE_IN_MB: typeof DEFAULT_EPHEMERAL_STORAGE_IN_MB;
	LAMBDA_VERSION_STRING: typeof LAMBDA_VERSION_STRING;
	pLimit: typeof pLimit;
	makeS3ServeUrl: typeof makeS3ServeUrl;
	validateServeUrl: typeof validateServeUrl;
	getEnvVariable: typeof getEnvVariable;
	internalRenderMediaOnLambdaRaw: typeof internalRenderMediaOnLambdaRaw;
	internalRenderStillOnLambda: typeof internalRenderStillOnLambda;
	cleanItems: typeof cleanItems;
	makeLambdaRenderStillPayload: typeof makeLambdaRenderStillPayload;
	getRenderProgressPayload: typeof getRenderProgressPayload;
	innerSpeculateFunctionName: typeof innerSpeculateFunctionName;
} = {
	generateRandomHashWithLifeCycleRule,
	getLambdaClient,
	getS3Client,
	getS3RenderUrl,
	getIamClient,
	getStsClient,
	getCloudWatchLogsClient,
	getServiceQuotasClient,
	parseJsonOrThrowSource,
	getCloudwatchMethodUrl,
	getCloudwatchRendererUrl,
	MAX_EPHEMERAL_STORAGE_IN_MB,
	parseFunctionName,
	isFlakyError,
	convertToServeUrlImplementation,
	randomHashImplementation,
	parseBucketName,
	makeLambdaRenderMediaPayload,
	renderMediaOnLambdaOptionalToRequired,
	internalDeleteRender,
	internalGetSites,
	getLifeCycleRules,
	awsImplementation,
	runtimePreferenceOptions,
	validateAwsRegion,
	validateDiskSizeInMb,
	validateMemorySize,
	DEFAULT_CLOUDWATCH_RETENTION_PERIOD,
	DEFAULT_EPHEMERAL_STORAGE_IN_MB,
	LAMBDA_VERSION_STRING,
	pLimit,
	makeS3ServeUrl,
	validateServeUrl,
	getEnvVariable,
	internalRenderMediaOnLambdaRaw,
	internalRenderStillOnLambda,
	cleanItems,
	makeLambdaRenderStillPayload,
	getRenderProgressPayload,
	innerSpeculateFunctionName,
};