@prismatic-io/components-aws-s3 0.0.0-stage → 0.1.0

package/npm-dist/index.cjs

@@ -0,0 +1,3941 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _prismatic_io_spectral = require("@prismatic-io/spectral");
+let _prismatic_io_spectral_http = require("@prismatic-io/spectral/http");
+let _aws_sdk_client_s3 = require("@aws-sdk/client-s3");
+let _aws_sdk_client_sns = require("@aws-sdk/client-sns");
+let _aws_sdk_client_sts = require("@aws-sdk/client-sts");
+let node_crypto = require("node:crypto");
+let node_querystring = require("node:querystring");
+node_querystring = __toESM(node_querystring);
+let _aws_sdk_s3_request_presigner = require("@aws-sdk/s3-request-presigner");
+let node_stream = require("node:stream");
+let _aws_sdk_lib_storage = require("@aws-sdk/lib-storage");
+let uuid = require("uuid");
+//#region ../../packages/aws-utils/dist/connection/assumeRole.js
+var __awaiter$3 = function(thisArg, _arguments, P, generator) {
+	function adopt(value) {
+		return value instanceof P ? value : new P(function(resolve) {
+			resolve(value);
+		});
+	}
+	return new (P || (P = Promise))(function(resolve, reject) {
+		function fulfilled(value) {
+			try {
+				step(generator.next(value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function rejected(value) {
+			try {
+				step(generator["throw"](value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function step(result) {
+			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+		}
+		step((generator = generator.apply(thisArg, _arguments || [])).next());
+	});
+};
+const assumeRole = (region, accessKeyId, secretAccessKey, roleArn, externalId) => __awaiter$3(void 0, void 0, void 0, function* () {
+	const { Credentials: { AccessKeyId, SecretAccessKey, SessionToken } } = yield new _aws_sdk_client_sts.STSClient(Object.assign(Object.assign({}, region.length > 0 && { region }), { credentials: {
+		accessKeyId,
+		secretAccessKey
+	} })).send(new _aws_sdk_client_sts.AssumeRoleCommand({
+		RoleArn: _prismatic_io_spectral.util.types.toString(roleArn),
+		RoleSessionName: "integration-session",
+		ExternalId: externalId
+	}));
+	return {
+		accessKeyId: AccessKeyId,
+		secretAccessKey: SecretAccessKey,
+		sessionToken: SessionToken
+	};
+});
+//#endregion
+//#region ../../packages/aws-utils/dist/connection/assumeRoleConnection.js
+const assumeRoleConnection = {
+	key: "awsAssumeRole",
+	display: {
+		label: "AWS Role ARN",
+		description: "Connect to AWS using an assumed role"
+	},
+	inputs: {
+		roleARN: {
+			label: "Role ARN",
+			placeholder: "arn:aws:iam::OtherAccount-ID:role/assumed-role-name",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "An AWS IAM Role ARN",
+			example: "arn:aws:iam::OtherAccount-ID:role/assumed-role-name"
+		},
+		accessKeyId: {
+			label: "Access Key ID",
+			placeholder: "Access Key ID",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "An AWS IAM Access Key ID",
+			example: "AKIAIOSFODNN7EXAMPLE"
+		},
+		secretAccessKey: {
+			label: "Secret Access Key",
+			placeholder: "Secret Access Key",
+			type: "password",
+			required: true,
+			shown: true,
+			comments: "An AWS IAM Secret Access Key",
+			example: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
+		},
+		externalId: {
+			label: "External ID",
+			placeholder: "shared-common-secret",
+			type: "string",
+			required: false,
+			shown: true,
+			comments: "Provides enhanced security measures to the connection. Optional, but recommended. Please check [AWS docs](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_third-party.html#id_roles_third-party_external-id) for more information.",
+			example: "shared-common-secret"
+		}
+	}
+};
+//#endregion
+//#region ../../packages/aws-utils/dist/helpers/misc.js
+const toTrimmedString = (value) => _prismatic_io_spectral.util.types.toString(value).trim();
+const toOptionalString = (value) => value ? _prismatic_io_spectral.util.types.toString(value) : void 0;
+//#endregion
+//#region ../../packages/aws-utils/dist/helpers/getCredentials.js
+const getCredentials = (connection) => {
+	return {
+		accessKeyId: toTrimmedString(connection.fields.accessKeyId),
+		secretAccessKey: toTrimmedString(connection.fields.secretAccessKey)
+	};
+};
+//#endregion
+//#region ../../packages/aws-utils/dist/helpers/validateConnection.js
+const validateConnection = (connection, validConnectionKeys) => {
+	if (![assumeRoleConnection.key, ...validConnectionKeys].includes(connection.key)) throw new _prismatic_io_spectral.ConnectionError(connection, `Unsupported connection method ${connection.key}.`);
+};
+//#endregion
+//#region ../../packages/aws-utils/dist/client/getClientParams.js
+var __awaiter$2 = function(thisArg, _arguments, P, generator) {
+	function adopt(value) {
+		return value instanceof P ? value : new P(function(resolve) {
+			resolve(value);
+		});
+	}
+	return new (P || (P = Promise))(function(resolve, reject) {
+		function fulfilled(value) {
+			try {
+				step(generator.next(value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function rejected(value) {
+			try {
+				step(generator["throw"](value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function step(result) {
+			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+		}
+		step((generator = generator.apply(thisArg, _arguments || [])).next());
+	});
+};
+const getClientParams = (_a) => __awaiter$2(void 0, [_a], void 0, function* ({ awsRegion, awsConnection, validConnectionKeys, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) {
+	var _b;
+	let shouldAssumeRole = false;
+	if (awsConnection) {
+		validateConnection(awsConnection, validConnectionKeys);
+		if (dynamicAccessKeyId || dynamicSecretAccessKey) throw new Error("Please specify either a connection or dynamic access key and secret inputs.");
+		shouldAssumeRole = awsConnection.key === assumeRoleConnection.key;
+	}
+	if (!awsConnection && (!dynamicAccessKeyId || !dynamicSecretAccessKey)) throw new Error("You must specify either a connection input or dynamic access key and secret inputs.");
+	const { accessKeyId, secretAccessKey } = awsConnection ? getCredentials(awsConnection) : {
+		accessKeyId: dynamicAccessKeyId,
+		secretAccessKey: dynamicSecretAccessKey
+	};
+	const credentials = shouldAssumeRole ? yield assumeRole(awsRegion, accessKeyId, secretAccessKey, toTrimmedString(awsConnection.fields.roleARN), toOptionalString((_b = awsConnection.fields) === null || _b === void 0 ? void 0 : _b.externalId)) : {
+		accessKeyId,
+		secretAccessKey,
+		sessionToken: dynamicSessionToken
+	};
+	return {
+		region: awsRegion.length > 0 ? awsRegion : void 0,
+		credentials
+	};
+});
+//#endregion
+//#region ../../packages/aws-utils/dist/data/awsRegions.js
+const awsRegions = [
+	"af-south-1",
+	"ap-east-1",
+	"ap-east-2",
+	"ap-northeast-1",
+	"ap-northeast-2",
+	"ap-northeast-3",
+	"ap-south-1",
+	"ap-south-2",
+	"ap-southeast-1",
+	"ap-southeast-2",
+	"ap-southeast-3",
+	"ap-southeast-4",
+	"ap-southeast-5",
+	"ap-southeast-6",
+	"ap-southeast-7",
+	"ca-central-1",
+	"ca-west-1",
+	"eu-central-1",
+	"eu-central-2",
+	"eu-north-1",
+	"eu-south-1",
+	"eu-south-2",
+	"eu-west-1",
+	"eu-west-2",
+	"eu-west-3",
+	"il-central-1",
+	"me-central-1",
+	"me-south-1",
+	"mx-central-1",
+	"sa-east-1",
+	"us-east-1",
+	"us-east-2",
+	"us-gov-east-1",
+	"us-gov-west-1",
+	"us-west-1",
+	"us-west-2"
+];
+//#endregion
+//#region ../../packages/aws-utils/dist/dataSources/selectRegion.js
+var __awaiter$1 = function(thisArg, _arguments, P, generator) {
+	function adopt(value) {
+		return value instanceof P ? value : new P(function(resolve) {
+			resolve(value);
+		});
+	}
+	return new (P || (P = Promise))(function(resolve, reject) {
+		function fulfilled(value) {
+			try {
+				step(generator.next(value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function rejected(value) {
+			try {
+				step(generator["throw"](value));
+			} catch (e) {
+				reject(e);
+			}
+		}
+		function step(result) {
+			result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+		}
+		step((generator = generator.apply(thisArg, _arguments || [])).next());
+	});
+};
+const selectRegion = (0, _prismatic_io_spectral.dataSource)({
+	display: {
+		label: "Select AWS Region",
+		description: "Select an AWS region"
+	},
+	dataSourceType: "picklist",
+	perform: () => __awaiter$1(void 0, void 0, void 0, function* () {
+		return Promise.resolve({ result: awsRegions.map((region) => ({
+			label: region,
+			key: region
+		})) });
+	}),
+	inputs: {}
+});
+//#endregion
+//#region ../../packages/aws-utils/dist/inputs/awsRegion.js
+const awsRegion = (0, _prismatic_io_spectral.input)({
+	label: "AWS Region",
+	placeholder: "AWS Region",
+	type: "string",
+	required: false,
+	comments: "AWS provides services in multiple regions, like us-west-2 or eu-west-1.",
+	example: "us-east-1",
+	dataSource: "selectRegion",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+(0, _prismatic_io_spectral.input)({
+	label: "Connection",
+	type: "connection",
+	required: false
+});
+const dynamicAccessAllInputs = {
+	dynamicAccessKeyId: (0, _prismatic_io_spectral.input)({
+		label: "Dynamic Access Key ID",
+		type: "string",
+		required: false,
+		clean: _prismatic_io_spectral.util.types.toString,
+		comments: "Use this input to authenticate with AWS if you are using a dynamically-generated access key. Otherwise, use the connection to enter a static access key ID."
+	}),
+	dynamicSecretAccessKey: (0, _prismatic_io_spectral.input)({
+		label: "Dynamic Secret Access Key",
+		type: "password",
+		required: false,
+		clean: _prismatic_io_spectral.util.types.toString,
+		comments: "Use this input to authenticate with AWS if you are using a dynamically-generated secret access key. Otherwise, use the connection to enter a static secret access key."
+	}),
+	dynamicSessionToken: (0, _prismatic_io_spectral.input)({
+		label: "Dynamic Session Token",
+		type: "password",
+		required: false,
+		clean: (value) => _prismatic_io_spectral.util.types.toString(value) || void 0,
+		comments: "Use this input to authenticate with AWS if you are using a OPTIONAL dynamically-generated session token."
+	})
+};
+//#endregion
+//#region src/connections/accessKeySecretPair.ts
+const accessKeySecretPair = (0, _prismatic_io_spectral.connection)({
+	key: "apiKeySecret",
+	display: {
+		label: "AWS S3 Access Key and Secret",
+		description: "Authenticates requests to AWS S3 using an API Key and Secret."
+	},
+	inputs: {
+		accessKeyId: {
+			label: "Access Key ID",
+			placeholder: "Enter AWS IAM Access Key ID",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "AWS IAM Access Key ID used for programmatic access. Create access keys in the [AWS IAM Console](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) under Security Credentials.",
+			example: "AKIAIOSFODNN7EXAMPLE"
+		},
+		secretAccessKey: {
+			label: "Secret Access Key",
+			placeholder: "Enter AWS IAM Secret Access Key",
+			type: "password",
+			required: true,
+			shown: true,
+			comments: "AWS IAM Secret Access Key paired with the Access Key ID. <strong>Important:</strong> This value is only shown once when created in the [AWS IAM Console](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html).",
+			example: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
+		}
+	}
+});
+//#endregion
+//#region src/connections/index.ts
+var connections_default = [accessKeySecretPair, assumeRoleConnection];
+//#endregion
+//#region src/client.ts
+const throwConnectionError = (connection, error) => {
+	throw new _prismatic_io_spectral.ConnectionError(connection, `Invalid AWS Credentials have been configured. This is sometimes caused by missing characters from a copy/paste. Original AWS error message: ${error.message}`);
+};
+const createS3Client = async ({ awsRegion, awsConnection, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken, debug, logger }) => {
+	const { region, credentials } = await getClientParams({
+		awsRegion,
+		awsConnection,
+		validConnectionKeys: [accessKeySecretPair.key],
+		dynamicAccessKeyId,
+		dynamicSecretAccessKey,
+		dynamicSessionToken
+	});
+	try {
+		return new _aws_sdk_client_s3.S3Client({
+			region,
+			credentials,
+			logger: debug ? logger : void 0
+		});
+	} catch (error) {
+		throwConnectionError(awsConnection, error);
+	}
+};
+const createSNSClient = async ({ awsRegion, awsConnection, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken, logger, debug }) => {
+	const { region, credentials } = await getClientParams({
+		awsRegion,
+		awsConnection,
+		validConnectionKeys: [accessKeySecretPair.key],
+		dynamicAccessKeyId,
+		dynamicSecretAccessKey,
+		dynamicSessionToken
+	});
+	try {
+		return new _aws_sdk_client_sns.SNSClient({
+			region,
+			credentials,
+			logger: debug ? logger : void 0
+		});
+	} catch (error) {
+		throwConnectionError(awsConnection, error);
+	}
+};
+//#endregion
+//#region src/examplePayloads/bucketNotifications.ts
+const putBucketNotificationConfigurationExamplePayload = { data: { $metadata: {
+	httpStatusCode: 200,
+	requestId: "3G6FNXP71KGVQ",
+	extendedRequestId: "epeRYyT9tl3QOMTMck4AG+NqmGa5fRKv5nME7gRl8KMxfnCAKWZzKbWVKp4ED7RaZIGvVcS=",
+	cfId: null,
+	attempts: 1,
+	totalRetryDelay: 0
+} } };
+const getBucketNotificationConfigurationExamplePayload = { data: {
+	$metadata: {
+		httpStatusCode: 200,
+		requestId: "2KMYXFM4GHPES",
+		extendedRequestId: "dLu9EloFaZ2UeACk5l4IovjfHXHTkM7kFLdThrbIJIjn05dgO7bdU3TUJ7/8DzZvcQ==",
+		cfId: null,
+		attempts: 1,
+		totalRetryDelay: 0
+	},
+	LambdaFunctionConfigurations: [{
+		Id: "Lambda",
+		LambdaFunctionArn: "arn:aws:lambda:us-east-2:1234:function:Function",
+		Events: ["s3:ObjectRemoved:*"]
+	}],
+	QueueConfigurations: [{
+		Id: "Queue",
+		QueueArn: "arn:aws:sqs:us-east-2:1234:Queue",
+		Events: ["s3:ObjectCreated:*"]
+	}],
+	TopicConfigurations: [{
+		Id: "Topic",
+		TopicArn: "arn:aws:sns:us-east-2:1234:Topic",
+		Events: ["s3:ObjectRestore:*"]
+	}]
+} };
+//#endregion
+//#region src/examplePayloads/buckets.ts
+const headBucketExamplePayload = { data: { $metadata: {
+	httpStatusCode: 200,
+	requestId: "A6R8PTRGRVGVB123",
+	extendedRequestId: "O1lqC0pMNa1+juScFrJbqgtJDQgkqvkcWDvLPfmcZBQNbxe+Bl4JE0WeIuswg/123456==",
+	cfId: null,
+	attempts: 1,
+	totalRetryDelay: 0
+} } };
+const deleteBucketExamplePayload = { data: { $metadata: {
+	httpStatusCode: 204,
+	requestId: "CBD415E7",
+	extendedRequestId: "WXvHrStedS7jFJZVw0Pt1LH3K3Nn99XFGuyELkK7UQANs3IOHs9GsR=",
+	cfId: null,
+	attempts: 1,
+	totalRetryDelay: 0
+} } };
+const listBucketsExamplePayload = { data: [{
+	Name: "bucket-1",
+	CreationDate: /* @__PURE__ */ new Date("2024-03-08T23:30:22.000Z")
+}] };
+const getBucketLocationExamplePayload = { data: "us-east-1" };
+//#endregion
+//#region src/examplePayloads/dataSources.ts
+const selectBucketExamplePayload = { result: [{
+	label: "bucket-1",
+	key: "bucket-1"
+}] };
+//#endregion
+//#region src/examplePayloads/misc.ts
+const getCurrentAccountExamplePayload = { data: {
+	$metadata: {
+		httpStatusCode: 200,
+		requestId: "b81eb768-e79a-52a1-9be8-e90175212345",
+		extendedRequestId: null,
+		cfId: null,
+		attempts: 1,
+		totalRetryDelay: 0
+	},
+	Account: "123456789012",
+	Arn: "arn:aws:iam::123456789012:user/Alice",
+	UserId: "AIDACKCEVSQ6C2EXAMPLE"
+} };
+//#endregion
+//#region src/examplePayloads/multipartUploads.ts
+const listMultipartUploadsExamplePayload = { data: {
+	$metadata: {
+		httpStatusCode: 200,
+		requestId: "MSB2RAFETTBCQ123",
+		extendedRequestId: "Ax6cjVx4lugZGOI+yo3dApqbvrtLD3U",
+		cfId: null,
+		attempts: 1,
+		totalRetryDelay: 0
+	},
+	Bucket: "some-bucket",
+	IsTruncated: false,
+	KeyMarker: "",
+	MaxUploads: 1e3,
+	NextKeyMarker: "file.txt",
+	NextUploadIdMarker: "itQ2Dw8eMZ01dGiwRIj2dwDqpx",
+	UploadIdMarker: "",
+	Uploads: [{
+		UploadId: "hbZQmDNtym9xtdh8XwgT7Ys..FkRWJfV0MUgmNWg",
+		Key: "new_file.txt",
+		Initiated: /* @__PURE__ */ new Date("2024-01-25T16:06:31.000Z"),
+		StorageClass: "STANDARD",
+		Owner: { ID: "0edc4b00d" },
+		Initiator: { ID: "0edc4b00d" }
+	}]
+} };
+const generatePresignedForMultiparUploadsExamplePayload = { data: [{
+	url: "https://my-bucket.s3.us-east-2.amazonaws.com/my-file.txt?X-Amz-Algorithm=AWS4-HMAC-SHA256...",
+	partNumber: 1
+}] };
+const createMultipartUploadExamplePayload = { data: {
+	$metadata: {
+		httpStatusCode: 200,
+		requestId: "J4Q9AY99DPMR1234",
+		extendedRequestId: "P59zKeH2C4Jz3VAC1I+12345Gty4d4gyl9JYQmc4udM6bCB6w/MEg8AKKWUuBH1x0EU2dufwkw=",
+		cfId: null,
+		attempts: 1,
+		totalRetryDelay: 0
+	},
+	ServerSideEncryption: "AES256",
+	Bucket: "bucket-name",
+	Key: "file.txt",
+	UploadId: "9DWJzLdFIcK05G2Yq.TNhJbCU57dDZyIRlO_tHcdFgYqWQgtu6XdASs7h.DJlcWk2M9vmEx72gXcS8q5SBu_12345ccg-"
+} };
+const abortMultipartUploadExamplePayload = { data: { $metadata: {
+	httpStatusCode: 204,
+	requestId: "DZ1ZJB3H2JB1234",
+	extendedRequestId: "0D9BDVoAGoHqu3dIW4WHmaO4kkiWecrbf0yLRMe/JmUfX7N/12345=",
+	cfId: null,
+	attempts: 1,
+	totalRetryDelay: 0
+} } };
+const uploadPartExamplePayload = { data: {
+	$metadata: {
+		httpStatusCode: 200,
+		requestId: "3Z9FSV3QYRYCK123",
+		extendedRequestId: "nhNCxtYGnVN+nxfdPaCPgAc23cJw2rphbIU1Z5ZUEmUDXIvF+Ra3eUXv2MNdOoWTIKXEym12345=",
+		cfId: null,
+		attempts: 1,
+		totalRetryDelay: 0
+	},
+	ServerSideEncryption: "AES256",
+	ETag: "\"266b7131485849fcefe583dcce071234\"",
+	part: {
+		ETag: "\"266b7131485849fcefe583dcce071234\"",
+		PartNumber: 1
+	}
+} };
+const listPartsExamplePayload = { data: {
+	$metadata: {
+		httpStatusCode: 200,
+		requestId: "3Z9CNHKT01WVE123",
+		extendedRequestId: "AYcUJyiexeUBBf5Uynsj4m1PojM18tHSxlyKMWzjM+123456=",
+		cfId: null,
+		attempts: 1,
+		totalRetryDelay: 0
+	},
+	Bucket: "bucket-name",
+	Initiator: { ID: "0edc4b00d1bfae1ebe33617c5cfe04e17b6f1fb9c5c2c55796123456" },
+	IsTruncated: false,
+	Key: "image.jpg",
+	MaxParts: 1e3,
+	NextPartNumberMarker: "1",
+	Owner: { ID: "0edc4b00d1bfae1ebe33617c5cfe04e17b6f1fb9c5c2c55796123456" },
+	PartNumberMarker: "0",
+	Parts: [{
+		PartNumber: 1,
+		LastModified: /* @__PURE__ */ new Date("2024-03-11T23:47:51.000Z"),
+		ETag: "\"266b7131485849fcefe583dcce071234\"",
+		Size: 65338
+	}],
+	StorageClass: "STANDARD",
+	UploadId: "iHtFwRT6d6IAPwGTlT6tO1iBApulQGCA2sG7yn_BzUKItrnLrWykCbDheQBJrb1MUGHgGfihOY07XfnCeU2CWCZM0kD6VbyC46MJ4123456-"
+} };
+const completeMultipartUploadExamplePayload = { data: {
+	$metadata: {
+		httpStatusCode: 200,
+		requestId: "GD4Y1XMZ6MFV1234",
+		extendedRequestId: "Ego8CAUdYnt2THhZmBLnbfmTPY0HR8zA9rEMkSg+OB0t/uldGkuBlI6UF9X+123456=",
+		cfId: null,
+		attempts: 1,
+		totalRetryDelay: 0
+	},
+	ServerSideEncryption: "AES256",
+	Bucket: "bucket-name",
+	ETag: "\"d96cf49f8c439501eb19c4728712345-1\"",
+	Key: "image.jpg",
+	Location: "https://bucketname.s3.us-east-2.amazonaws.com/image.jpg"
+} };
+//#endregion
+//#region src/examplePayloads/objectLock.ts
+const putObjectLockConfigurationExamplePayload = { data: { $metadata: {
+	httpStatusCode: 200,
+	requestId: "HRTN",
+	extendedRequestId: "n2j6gnXOgOKm+PomoHrLsbOhatc7LMw1Su",
+	cfId: null,
+	attempts: 1,
+	totalRetryDelay: 0
+} } };
+const getObjectLockConfigurationExamplePayload = { data: {
+	$metadata: {
+		httpStatusCode: 200,
+		requestId: "J58R459KF4NH",
+		extendedRequestId: "YLfHsBUyeXU06tYjF7ZLX7f7JhBL1FFZhA/UZKUr4WNTy0OHDOjYN=",
+		cfId: null,
+		attempts: 1,
+		totalRetryDelay: 0
+	},
+	ObjectLockConfiguration: {
+		ObjectLockEnabled: "Enabled",
+		Rule: { DefaultRetention: {
+			Mode: "GOVERNANCE",
+			Years: 2
+		} }
+	}
+} };
+const putObjectRetentionExamplePayload = { data: { $metadata: {
+	httpStatusCode: 200,
+	requestId: "9GKTJZDRMJCGMNY6",
+	extendedRequestId: "NKjiPDGEYKYtH7sHPWKSVpy9y9NtjbXzeJ7whq75y62jiH9JLuZOpMLCBiYyc+/hOlnOTCaTpWo=",
+	cfId: null,
+	attempts: 1,
+	totalRetryDelay: 0
+} } };
+const getObjectRetentionExamplePayload = { data: {
+	$metadata: {
+		httpStatusCode: 200,
+		requestId: "88W3KJSMC9E",
+		extendedRequestId: "aJ3Rpb+v2F6Fqy47J6fWoPPCqe+LC8UX8vo5x3KK/YhN/=",
+		cfId: null,
+		attempts: 1,
+		totalRetryDelay: 0
+	},
+	Retention: {
+		Mode: "COMPLIANCE",
+		RetainUntilDate: /* @__PURE__ */ new Date("2024-08-25T20:00:00.000Z")
+	}
+} };
+//#endregion
+//#region src/examplePayloads/objects.ts
+const headObjectExamplePayload = { data: {
+	$metadata: {
+		httpStatusCode: 200,
+		requestId: "2GNCNQ9QYJF91H2H3",
+		extendedRequestId: "20td2yhMFyFEFYm7Wh+P+qr8DDva152du5KA+JFU7ZRuHWLFZZxdLCOVfnMF41K2BYQ/12345=",
+		cfId: null,
+		attempts: 1,
+		totalRetryDelay: 0
+	},
+	AcceptRanges: "bytes",
+	LastModified: /* @__PURE__ */ new Date("2021-08-25T20:00:00.000Z"),
+	ContentLength: 65338,
+	ETag: "\"266b7131485849fcefe583dcce654321\"",
+	VersionId: "0Ec_RdbYOEQ1Un2HllBJbGG758RS3UuZ",
+	ContentType: "image/jpeg",
+	ServerSideEncryption: "AES256",
+	Metadata: {}
+} };
+const deleteObjectsExamplePayload = { data: {
+	$metadata: {
+		httpStatusCode: 200,
+		requestId: "FAQAVT",
+		extendedRequestId: "T/nk6UtPuVs11K6ji59C8phr==",
+		cfId: null,
+		attempts: 1,
+		totalRetryDelay: 0
+	},
+	Deleted: [{ Key: "file.csv" }, { Key: "audio.mp3" }]
+} };
+const getObjectAttributesExamplePayload = { data: {
+	$metadata: {
+		httpStatusCode: 200,
+		requestId: "0AJN29JBC3D5BNB6",
+		extendedRequestId: "sVW4/xKq7DkMI8kgvbJUNWbzzZ9H6GKqyVocDm3uE4y7dZ6GmZcFrIC9MPGDjSNXMMn8CtLO8Vy0SxOcNOwl2A==",
+		cfId: null,
+		attempts: 1,
+		totalRetryDelay: 0
+	},
+	LastModified: /* @__PURE__ */ new Date("2024-03-08T22:20:41.000Z"),
+	VersionId: "0Ec_RdbYOEQ1Un2HllBJbGG758RS3UuZ",
+	ObjectSize: 515400
+} };
+const copyObjectExamplePayload = { data: {
+	$metadata: {
+		httpStatusCode: 200,
+		requestId: "C4KXHZ9F2QQEM123",
+		extendedRequestId: "8pTnwvKfHXQyoNr3xJ2mZcVbLdE9qASgWx4RfUo6hP1cB0iYkMz5T7uV+123456=",
+		cfId: null,
+		attempts: 1,
+		totalRetryDelay: 0
+	},
+	CopyObjectResult: {
+		ETag: "\"9a0364b9e99bb480dd25e1f0284c8555\"",
+		LastModified: /* @__PURE__ */ new Date("2024-03-11T23:47:51.000Z")
+	}
+} };
+const deleteObjectExamplePayload = { data: {
+	$metadata: {
+		httpStatusCode: 204,
+		requestId: "FAQAVT3H2JB1234",
+		extendedRequestId: "0D9BDVoAGoHqu3dIW4WHmaO4kkiWecrbf0yLRMe/JmUfX7N/12345=",
+		cfId: null,
+		attempts: 1,
+		totalRetryDelay: 0
+	},
+	DeleteMarker: true,
+	VersionId: "3/L4kqtJlcpXroDTDmJ+rmSpXd3dIbrHY+MTRCxf3vjVBH40Nr8X8gdRQBpUMLUo",
+	RequestCharged: "requester"
+} };
+const getObjectExamplePayload = {
+	data: Buffer.from("Example File Contents"),
+	contentType: "application/octet"
+};
+const listObjectsExamplePayload = { data: [
+	"invoices/2024-01-15.pdf",
+	"images/logo.png",
+	"backups/database-dump.sql"
+] };
+const putObjectExamplePayload = { data: {
+	$metadata: {
+		httpStatusCode: 200,
+		requestId: "R8N3F7QZ9KXWM123",
+		extendedRequestId: "P59zKeH2C4Jz3VAC1I+12345Gty4d4gyl9JYQmc4udM6bCB6w/MEg8AKKWUuBH1x0EU2dufwkw=",
+		cfId: null,
+		attempts: 1,
+		totalRetryDelay: 0
+	},
+	ETag: "\"9a0364b9e99bb480dd25e1f0284c8555\"",
+	VersionId: "3sL4kqtJlcpXroDTDmJ+rmSpXd3dIbrHY+MTRCxf3vjVBH40Nr8X8gdRQBpUMLUo"
+} };
+const generatePresignedUrlExamplePayload = { data: "https://my-bucket.s3.us-east-2.amazonaws.com/my-file.txt?X-Amz-Algorithm=AWS4-HMAC-SHA256..." };
+//#endregion
+//#region src/examplePayloads/sns.ts
+const createTopicExamplePayload = { data: {
+	$metadata: {
+		httpStatusCode: 200,
+		requestId: "a91d4b8e-c6c5-52f3-9b45-3e6d3f8a1234",
+		extendedRequestId: null,
+		cfId: null,
+		attempts: 1,
+		totalRetryDelay: 0
+	},
+	TopicArn: "arn:aws:sns:us-east-2:123456789012:MyTopic"
+} };
+const subscribeToTopicExamplePayload = { data: {
+	$metadata: {
+		httpStatusCode: 200,
+		requestId: "c72f9a3d-1b6e-54a2-8d7f-5a1b2c3d4e5f",
+		extendedRequestId: null,
+		cfId: null,
+		attempts: 1,
+		totalRetryDelay: 0
+	},
+	SubscriptionArn: "arn:aws:sns:us-east-2:123456789012:MyTopic:8a21d249-4bcd-4f7e-9abc-b1a2c3d4e5f6"
+} };
+const updateTopicPolicyExamplePayload = { data: { $metadata: {
+	httpStatusCode: 200,
+	requestId: "b81eb768-e79a-52a1-9be8-e90175212345",
+	extendedRequestId: null,
+	cfId: null,
+	attempts: 1,
+	totalRetryDelay: 0
+} } };
+const bucketEventTriggerConfigurationExamplePayload = { data: { $metadata: {
+	httpStatusCode: 200,
+	requestId: "73B4K590MABCMWV",
+	extendedRequestId: "AHYlhdFxyrlbc3otaMb/gcjlmDEY+UT3xt7Vz6ZQ8F4B1234GZQSGN7D6yDV7mEC+U/1xU0pKc=",
+	cfId: null,
+	attempts: 1,
+	totalRetryDelay: 0
+} } };
+const unsubscribeFromTopicExamplePayload = { data: { $metadata: {
+	httpStatusCode: 200,
+	requestId: "059f8a07-f312-5e3b-9b7c-d46e66ee8a58",
+	extendedRequestId: null,
+	cfId: null,
+	attempts: 1,
+	totalRetryDelay: 0
+} } };
+//#endregion
+//#region src/examplePayloads/triggers.ts
+const exampleTriggerPayloadBase = {
+	queryParameters: {},
+	rawBody: { data: null },
+	pathFragment: "",
+	webhookUrls: {},
+	webhookApiKeys: {},
+	invokeUrl: "",
+	executionId: "RXhhbXBsZUV4ZWN1dGlvblJlc3VsdElk",
+	customer: {
+		id: "testCustomerId",
+		name: "Test Customer",
+		externalId: "testExternalId"
+	},
+	instance: {
+		id: "testInstanceId",
+		name: "Test Instance"
+	},
+	user: {
+		id: "testUserId",
+		email: "user@example.com",
+		name: "Test User",
+		externalId: "testUserExternalId"
+	},
+	integration: {
+		id: "testIntegrationId",
+		name: "Test Integration",
+		versionSequenceId: "1",
+		externalVersion: ""
+	},
+	flow: {
+		id: "testFlowId",
+		name: "Test Flow",
+		stableId: "testFlowStableId"
+	},
+	startedAt: "2024-01-15T00:00:00.000Z",
+	globalDebug: false
+};
+const snsS3NotificationWebhookExamplePayload = {
+	branch: "Notification",
+	payload: {
+		...exampleTriggerPayloadBase,
+		headers: {
+			"x-amz-sns-message-type": "Notification",
+			"x-amz-sns-message-id": "22b80b92-fdea-4c2c-8f9d-bdfb0c7bf324",
+			"x-amz-sns-topic-arn": "arn:aws:sns:us-west-2:123456789012:MyTopic",
+			"x-amz-sns-subscription-arn": "arn:aws:sns:us-west-2:123456789012:MyTopic:c9135db0-26c4-47ec-8998-413945fb5a96",
+			"Content-Type": "text/plain; charset=UTF-8",
+			"User-Agent": "Amazon Simple Notification Service Agent"
+		},
+		body: { data: {
+			Type: "Notification",
+			MessageId: "22b80b92-fdea-4c2c-8f9d-bdfb0c7bf324",
+			TopicArn: "arn:aws:sns:us-west-2:123456789012:MyTopic",
+			Subject: "Amazon S3 Notification",
+			Message: JSON.stringify({ Records: [{
+				eventVersion: "2.6",
+				eventSource: "aws:s3",
+				awsRegion: "us-west-2",
+				eventTime: "2024-01-15T00:00:00.000Z",
+				eventName: "ObjectCreated:Put",
+				userIdentity: { principalId: "AIDAJDPLRKLG7UEXAMPLE" },
+				requestParameters: { sourceIPAddress: "172.16.0.1" },
+				responseElements: {
+					"x-amz-request-id": "C3D13FE58DE4C810",
+					"x-amz-id-2": "FMyUVURIY8/IgAtTv8xRjskZQpcIZ9KG4V5Wp6S7S/JRWeUWerMUE5JgHvANOjpD"
+				},
+				s3: {
+					s3SchemaVersion: "1.0",
+					configurationId: "testConfigRule",
+					bucket: {
+						name: "amzn-s3-demo-bucket",
+						ownerIdentity: { principalId: "A3NL1KOZZKExample" },
+						arn: "arn:aws:s3:::amzn-s3-demo-bucket"
+					},
+					object: {
+						key: "HappyFace.jpg",
+						size: 1024,
+						eTag: "d41d8cd98f00b204e9800998ecf8427e",
+						versionId: "096fKKXTRTtl3on89fVO.nfljtsv6qko",
+						sequencer: "0055AED6DCD90281E5"
+					}
+				}
+			}] }),
+			Timestamp: "2024-01-15T00:00:01.000Z",
+			SignatureVersion: "1",
+			Signature: "EXAMPLEw6JRN...",
+			SigningCertURL: "https://sns.us-west-2.amazonaws.com/SimpleNotificationService-f3ecfb7224c7233fe7bb5f59f96de52f.pem",
+			UnsubscribeURL: "https://sns.us-west-2.amazonaws.com/?Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-west-2:123456789012:MyTopic:c9135db0-26c4-47ec-8998-413945fb5a96"
+		} }
+	}
+};
+const pollChangesFilesTriggerExamplePayload = {
+	payload: {
+		...exampleTriggerPayloadBase,
+		headers: {},
+		body: { data: ["invoices/2024-01-15.pdf", "images/logo.png"] }
+	},
+	polledNoChanges: false
+};
+const pollNewBucketsTriggerExamplePayload = {
+	payload: {
+		...exampleTriggerPayloadBase,
+		headers: {},
+		body: { data: [{
+			Name: "bucket-1",
+			CreationDate: "2024-03-08T23:30:22.000Z"
+		}] }
+	},
+	polledNoChanges: false
+};
+//#endregion
+//#region src/examplePayloads/uploadStreams.ts
+const createUploadStreamExamplePayload = { data: "711B632B-C025-4E26-9E34-525822E3C0ED" };
+const writeUploadStreamExamplePayload = { data: null };
+const closeUploadStreamExamplePayload = { data: null };
+//#endregion
+//#region src/constants.ts
+const INPUT_EVENT_TYPES_MODEL = [
+	{
+		label: "s3:ObjectCreated:*",
+		value: "s3:ObjectCreated:*"
+	},
+	{
+		label: "s3:ObjectCreated:Put",
+		value: "s3:ObjectCreated:Put"
+	},
+	{
+		label: "s3:ObjectCreated:Post",
+		value: "s3:ObjectCreated:Post"
+	},
+	{
+		label: "s3:ObjectCreated:Copy",
+		value: "s3:ObjectCreated:Copy"
+	},
+	{
+		label: "s3:ObjectCreated:CompleteMultipartUpload",
+		value: "s3:ObjectCreated:CompleteMultipartUpload"
+	},
+	{
+		label: "s3:ObjectRemoved:*",
+		value: "s3:ObjectRemoved:*"
+	},
+	{
+		label: "s3:ObjectRemoved:Delete",
+		value: "s3:ObjectRemoved:Delete"
+	},
+	{
+		label: "s3:ObjectRemoved:DeleteMarkerCreated",
+		value: "s3:ObjectRemoved:DeleteMarkerCreated"
+	},
+	{
+		label: "s3:ObjectRestore:*",
+		value: "s3:ObjectRestore:*"
+	},
+	{
+		label: "s3:ObjectRestore:Post",
+		value: "s3:ObjectRestore:Post"
+	},
+	{
+		label: "s3:ObjectRestore:Completed",
+		value: "s3:ObjectRestore:Completed"
+	},
+	{
+		label: "s3:ObjectRestore:Delete",
+		value: "s3:ObjectRestore:Delete"
+	},
+	{
+		label: "s3:ReducedRedundancyLostObject",
+		value: "s3:ReducedRedundancyLostObject"
+	},
+	{
+		label: "s3:Replication:*",
+		value: "s3:Replication:*"
+	},
+	{
+		label: "s3:Replication:OperationFailedReplication",
+		value: "s3:Replication:OperationFailedReplication"
+	},
+	{
+		label: "s3:Replication:OperationMissedThreshold",
+		value: "s3:Replication:OperationMissedThreshold"
+	},
+	{
+		label: "s3:Replication:OperationReplicatedAfterThreshold",
+		value: "s3:Replication:OperationReplicatedAfterThreshold"
+	},
+	{
+		label: "s3:Replication:OperationNotTracked",
+		value: "s3:Replication:OperationNotTracked"
+	},
+	{
+		label: "s3:LifecycleExpiration:*",
+		value: "s3:LifecycleExpiration:*"
+	},
+	{
+		label: "s3:LifecycleExpiration:Delete",
+		value: "s3:LifecycleExpiration:Delete"
+	},
+	{
+		label: "s3:LifecycleExpiration:DeleteMarkerCreated",
+		value: "s3:LifecycleExpiration:DeleteMarkerCreated"
+	},
+	{
+		label: "s3:LifecycleTransition",
+		value: "s3:LifecycleTransition"
+	},
+	{
+		label: "s3:IntelligentTiering",
+		value: "s3:IntelligentTiering"
+	},
+	{
+		label: "s3:ObjectTagging:*",
+		value: "s3:ObjectTagging:*"
+	},
+	{
+		label: "s3:ObjectTagging:Put",
+		value: "s3:ObjectTagging:Put"
+	},
+	{
+		label: "s3:ObjectTagging:Delete",
+		value: "s3:ObjectTagging:Delete"
+	},
+	{
+		label: "s3:ObjectAcl:Put",
+		value: "s3:ObjectAcl:Put"
+	}
+];
+const TOPIC_CONFIGURATIONS_EXAMPLE = [{
+	Id: "topic-1",
+	TopicArn: "arn:aws:sns:us-west-2:123456789012:mytopic",
+	Events: ["s3:ObjectCreated:*"],
+	Filter: { Key: { FilterRules: [{
+		Name: "prefix",
+		Value: "images/"
+	}] } }
+}];
+const QUEUE_CONFIGURATIONS_EXAMPLE = [{
+	Id: "queue-1",
+	QueueArn: "arn:aws:sqs:us-west-2:123456789012:myqueue",
+	Events: ["s3:ObjectCreated:*"],
+	Filter: { Key: { FilterRules: [{
+		Name: "prefix",
+		Value: "images/"
+	}] } }
+}];
+const LAMBDA_FUNCTION_CONFIGURATIONS_EXAMPLE = [{
+	Id: "lambda-1",
+	LambdaFunctionArn: "arn:aws:lambda:us-west-2:123456789012:function:my-function",
+	Events: ["s3:ObjectCreated:*"],
+	Filter: { Key: { FilterRules: [{
+		Name: "prefix",
+		Value: "images/"
+	}] } }
+}];
+const EVENT_BRIDGE_CONFIGURATION_EXAMPLE = {
+	Id: "event-bridge-1",
+	EventBridgeArn: "arn:aws:eventbridge:us-west-2:123456789012:myeventbridge",
+	Events: ["s3:ObjectCreated:*"],
+	Filter: { Key: { FilterRules: [{
+		Name: "prefix",
+		Value: "images/"
+	}] } }
+};
+const OBJECT_ATTRIBUTES = [
+	"ETag",
+	"Checksum",
+	"ObjectParts",
+	"StorageClass",
+	"ObjectSize"
+];
+const LIST_OBJECTS_V2_MAX_KEYS = 1e3;
+const LIST_BUCKETS_MAX_BUCKETS = 1e4;
+const LOOK_BACK_DATE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+//#endregion
+//#region src/utils/bucketNotifications.ts
+const parseConfigurationValue = (value) => {
+	if (value === void 0 || value === null || value === "") return void 0;
+	return typeof value === "string" ? JSON.parse(value) : value;
+};
+const parseConfigurationArray = (value, label, example) => {
+	const parsed = parseConfigurationValue(value);
+	if (parsed === void 0) return void 0;
+	if (!Array.isArray(parsed)) throw new Error(`${label} must be an array with the following structure: ${JSON.stringify(example)}`);
+	return parsed;
+};
+const getTopicConfigurations = (topicConfigurations) => parseConfigurationArray(topicConfigurations, "Topic configurations", TOPIC_CONFIGURATIONS_EXAMPLE);
+const getQueueConfigurations = (queueConfigurations) => parseConfigurationArray(queueConfigurations, "Queue configurations", QUEUE_CONFIGURATIONS_EXAMPLE);
+const getLambdaFunctionConfigurations = (lambdaFunctionConfigurations) => parseConfigurationArray(lambdaFunctionConfigurations, "Lambda function configurations", LAMBDA_FUNCTION_CONFIGURATIONS_EXAMPLE);
+const getEventBridgeConfiguration = (eventBridgeConfiguration) => parseConfigurationValue(eventBridgeConfiguration);
+const getBucketNotificationConfiguration$1 = async (s3Client, bucket, bucketOwnerAccountid, removeMetadata = true) => {
+	const getBucketNotificationConfigurationCommand = new _aws_sdk_client_s3.GetBucketNotificationConfigurationCommand({
+		Bucket: bucket,
+		ExpectedBucketOwner: bucketOwnerAccountid
+	});
+	const getBucketNotificationConfigurationCommandOutput = await s3Client.send(getBucketNotificationConfigurationCommand);
+	if (removeMetadata) getBucketNotificationConfigurationCommandOutput.$metadata = void 0;
+	return getBucketNotificationConfigurationCommandOutput;
+};
+const putBucketNotificationConfiguration$1 = async (s3Client, bucket, notificationConfiguration) => {
+	const putBucketNotificationConfigurationCommand = new _aws_sdk_client_s3.PutBucketNotificationConfigurationCommand({
+		Bucket: bucket,
+		NotificationConfiguration: notificationConfiguration,
+		SkipDestinationValidation: true
+	});
+	return await s3Client.send(putBucketNotificationConfigurationCommand);
+};
+const processTopicConfiguration = async (s3Client, bucket, bucketOwnerAccountid, eventNotificationName, topicConfiguration) => {
+	const notificationConfiguration = await getBucketNotificationConfiguration$1(s3Client, bucket, bucketOwnerAccountid);
+	if (!("TopicConfigurations" in notificationConfiguration)) notificationConfiguration.TopicConfigurations = [];
+	let existingTopicConfigurationIndex = -1;
+	notificationConfiguration.TopicConfigurations.find((topicConfiguration, index) => {
+		const topicConfigurationIdEqualsEventNotificationName = topicConfiguration.Id === eventNotificationName;
+		if (topicConfigurationIdEqualsEventNotificationName) existingTopicConfigurationIndex = index;
+		return topicConfigurationIdEqualsEventNotificationName;
+	});
+	if (existingTopicConfigurationIndex === -1) notificationConfiguration.TopicConfigurations.push(topicConfiguration);
+	else notificationConfiguration.TopicConfigurations[existingTopicConfigurationIndex] = topicConfiguration;
+	return await putBucketNotificationConfiguration$1(s3Client, bucket, notificationConfiguration);
+};
+//#endregion
+//#region src/utils/buckets.ts
+const listAllBuckets = async (s3) => {
+	const buckets = [];
+	let continuationToken;
+	do {
+		const response = await s3.send(new _aws_sdk_client_s3.ListBucketsCommand({
+			MaxBuckets: LIST_BUCKETS_MAX_BUCKETS,
+			ContinuationToken: continuationToken
+		}));
+		buckets.push(...response.Buckets ?? []);
+		continuationToken = response.ContinuationToken;
+	} while (continuationToken);
+	return buckets;
+};
+//#endregion
+//#region src/utils/clean.ts
+const cleanString = (value) => {
+	const str = _prismatic_io_spectral.util.types.toString(value).trim();
+	return str ? str : void 0;
+};
+const toPositiveInt = (value, fallback) => {
+	const str = cleanString(value);
+	if (str === void 0) return fallback;
+	if (!/^\d+$/.test(str) || Number(str) < 1) throw new Error(`"${str}" must be a whole number greater than 0.`);
+	return Number(str);
+};
+const toOptionalInt = (value) => cleanString(value) === void 0 ? void 0 : _prismatic_io_spectral.util.types.toInt(value) || void 0;
+const toTrimmedStringArray = (value) => value.map((item) => _prismatic_io_spectral.util.types.toString(item).trim());
+const toObjectCannedACL = (value) => _prismatic_io_spectral.util.types.toString(value);
+const toObjectLockRetentionMode = (value) => _prismatic_io_spectral.util.types.toString(value);
+const toBufferFromData = (value) => _prismatic_io_spectral.util.types.isBufferDataPayload(value) ? value.data : value;
+const toKeyValuePairList = (value) => value;
+const toPartList = (value) => value;
+const getObjectIdentifiers = (objectKeys) => {
+	if (Array.isArray(objectKeys)) return objectKeys.map((key) => ({ Key: key }));
+	return [];
+};
+const getObjectAttributes$1 = (attributes) => {
+	if (Array.isArray(attributes)) {
+		if (attributes.length === 0) throw new Error("Object Attributes must contain at least one attribute");
+		return attributes;
+	}
+};
+const lookBackDateClean = (value) => {
+	const raw = cleanString(value);
+	if (raw === void 0) return "";
+	const match = typeof value === "string" ? raw.match(LOOK_BACK_DATE_PATTERN) : null;
+	if (!match) throw new Error(`Look-back Date must be a date in YYYY-MM-DD format. Received: ${raw}`);
+	const [, yearStr, monthStr, dayStr] = match;
+	const year = Number(yearStr);
+	const month = Number(monthStr);
+	const day = Number(dayStr);
+	const parsed = new Date(Date.UTC(year, month - 1, day));
+	if (parsed.getUTCFullYear() !== year || parsed.getUTCMonth() !== month - 1 || parsed.getUTCDate() !== day) throw new Error(`Look-back Date must be a date in YYYY-MM-DD format. Received: ${raw}`);
+	if (parsed.getTime() > Date.now()) throw new Error(`Look-back Date cannot be a future date. Received: ${raw}`);
+	return parsed.toISOString();
+};
+//#endregion
+//#region src/utils/polling.ts
+const objectMapper = (object, key) => {
+	return {
+		...object,
+		[key]: new Date(object[key]).toISOString()
+	};
+};
+const floorToSecond = (timestamp) => (/* @__PURE__ */ new Date(Math.floor(Date.parse(timestamp) / 1e3) * 1e3)).toISOString();
+const readLastPolledAt = (context, now, lookBackDate) => {
+	const pollState = context.polling.getState();
+	const since = pollState.lastPolledAt || lookBackDate || now;
+	const inclusive = !pollState.lastPolledAt && Boolean(lookBackDate);
+	context.logger.debug(`Polled for changes from: ${since} to ${now}`);
+	if (context.debug.enabled) context.logger.debug(`Polling state: ${JSON.stringify(pollState)}`);
+	return {
+		since,
+		inclusive
+	};
+};
+const resolveFileListingWindow = (state, incoming, isBatching, lookBackDate, now) => {
+	const inFlight = isBatching ? incoming ?? state.cursor : void 0;
+	if (inFlight) return inFlight;
+	const windowEnd = floorToSecond(now);
+	return {
+		windowStart: state.lastPolledAt || lookBackDate || windowEnd,
+		windowEnd
+	};
+};
+const listObjectsInWindow = async (s3, bucket, { windowStart, windowEnd, startAfter }, singlePage) => {
+	const keys = [];
+	let resumeAfter = startAfter;
+	do {
+		const response = await s3.send(new _aws_sdk_client_s3.ListObjectsV2Command({
+			Bucket: bucket,
+			MaxKeys: LIST_OBJECTS_V2_MAX_KEYS,
+			StartAfter: resumeAfter
+		}));
+		const contents = response.Contents ?? [];
+		for (const object of contents) {
+			const { Key, LastModified } = objectMapper(object, "LastModified");
+			if (Key !== void 0 && LastModified >= windowStart && LastModified < windowEnd) keys.push(Key);
+		}
+		resumeAfter = response.IsTruncated ? contents[contents.length - 1]?.Key : void 0;
+	} while (resumeAfter && !singlePage);
+	return {
+		keys,
+		startAfter: resumeAfter
+	};
+};
+const listBucketsCreatedSince = async (s3, since, inclusive = false) => {
+	return (await listAllBuckets(s3)).map((bucket) => objectMapper(bucket, "CreationDate")).filter(({ CreationDate }) => inclusive ? CreationDate >= since : CreationDate > since);
+};
+const resolvePolledFileChanges = (data) => (data ?? []).map((record) => ({
+	changeType: "changed",
+	record
+}));
+const resolvePolledBucketChanges = (data) => (data ?? []).map((record) => ({
+	changeType: "created",
+	record
+}));
+//#endregion
+//#region src/utils/snsMessages.ts
+const SNS_HOSTNAME = /^sns\.[a-z0-9-]+\.amazonaws\.com(\.cn)?$/;
+const SIGNED_FIELDS = {
+	Notification: [
+		"Message",
+		"MessageId",
+		"Subject",
+		"Timestamp",
+		"TopicArn",
+		"Type"
+	],
+	SubscriptionConfirmation: [
+		"Message",
+		"MessageId",
+		"SubscribeURL",
+		"Timestamp",
+		"Token",
+		"TopicArn",
+		"Type"
+	],
+	UnsubscribeConfirmation: [
+		"Message",
+		"MessageId",
+		"SubscribeURL",
+		"Timestamp",
+		"Token",
+		"TopicArn",
+		"Type"
+	]
+};
+const SIGNATURE_ALGORITHMS = {
+	"1": "sha1",
+	"2": "sha256"
+};
+const assertSnsUrl = (value, field) => {
+	let url;
+	try {
+		url = new URL(String(value));
+	} catch {
+		url = void 0;
+	}
+	if (url?.protocol !== "https:" || !SNS_HOSTNAME.test(url.hostname)) throw new Error(`${field} must be an HTTPS URL on an Amazon SNS domain.`);
+	return url;
+};
+const downloadCertificate = async (certificateUrl) => {
+	const { data } = await (0, _prismatic_io_spectral_http.createClient)({
+		baseUrl: certificateUrl,
+		responseType: "text"
+	}).get("");
+	return data;
+};
+const verifySnsMessageSignature = async (message, fetchCertificate = downloadCertificate) => {
+	const algorithm = SIGNATURE_ALGORITHMS[message.SignatureVersion];
+	if (!algorithm) throw new Error(`Unsupported Amazon SNS SignatureVersion "${message.SignatureVersion}".`);
+	const certificate = await fetchCertificate(assertSnsUrl(message.SigningCertURL, "SigningCertURL").href);
+	if (!(typeof message.Signature === "string" && message.Signature.length > 0 && (0, node_crypto.verify)(algorithm, Buffer.from(buildSnsStringToSign(message)), certificate, Buffer.from(message.Signature, "base64")))) throw new Error("Amazon SNS message signature is invalid; the message was rejected.");
+};
+const buildSnsStringToSign = (message) => (SIGNED_FIELDS[message.Type] ?? []).filter((field) => message[field] !== void 0).map((field) => `${field}\n${message[field]}\n`).join("");
+//#endregion
+//#region src/utils/tags.ts
+const encodeTags = (tags) => node_querystring.default.encode(_prismatic_io_spectral.util.types.keyValPairListToObject(tags || []));
+//#endregion
+//#region src/utils/uploadStreams.ts
+const getUploadStream = (executionState, uploadId) => {
+	const uploadStream = executionState[uploadId];
+	if (!uploadStream) throw new Error(`Upload stream "${uploadId}" was not found. Upload streams exist only within the execution that created them; use the ID returned by Create Upload Stream in the same execution.`);
+	return uploadStream;
+};
+//#endregion
+//#region src/inputs/common.ts
+const objectKey = (0, _prismatic_io_spectral.input)({
+	label: "Object Key",
+	placeholder: "Enter object key",
+	type: "string",
+	required: true,
+	comments: "An object in S3 is a file that is saved in a 'bucket'. This represents the object's key (file path). Do not include a leading /.",
+	example: "path/to/file.txt",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const fileContents = (0, _prismatic_io_spectral.input)({
+	label: "File Contents",
+	placeholder: "Output data from previous step or string content",
+	type: "data",
+	required: true,
+	comments: "The contents to write to the object. Accepts text strings or binary data (images, PDFs, etc.) from previous steps.",
+	example: "My File Contents",
+	clean: _prismatic_io_spectral.util.types.toData
+});
+const bucket = (0, _prismatic_io_spectral.input)({
+	label: "Bucket Name",
+	placeholder: "Enter bucket name",
+	type: "string",
+	required: true,
+	comments: "An Amazon S3 'bucket' is a container where files are stored. Buckets can be created from within the AWS console. Bucket names contain only letters, numbers, and dashes.",
+	example: "my-s3-bucket-abc123",
+	dataSource: "selectBucket",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const tagging = (0, _prismatic_io_spectral.input)({
+	label: "Object Tags",
+	placeholder: "Enter tag value",
+	type: "string",
+	collection: "keyvaluelist",
+	required: false,
+	comments: "Key-value pairs to tag the object for filtering and organization. For more information, see [S3 Object Tagging](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-tagging.html).",
+	example: "Environment, Production",
+	clean: toKeyValuePairList
+});
+const accessKeyInput = (0, _prismatic_io_spectral.input)({
+	label: "Connection",
+	type: "connection",
+	required: false,
+	comments: "The AWS S3 connection to use for authentication. Access keys provide programmatic access to AWS resources. [Learn more](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html)."
+});
+const acl = (0, _prismatic_io_spectral.input)({
+	label: "ACL Permissions",
+	comments: "Canned ACL permissions to apply to the object. For more information, see [S3 Canned ACLs](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl).",
+	type: "string",
+	model: [
+		{
+			label: "BUCKET DEFAULT",
+			value: ""
+		},
+		{
+			label: "authenticated-read",
+			value: "authenticated-read"
+		},
+		{
+			label: "aws-exec-read",
+			value: "aws-exec-read"
+		},
+		{
+			label: "bucket-owner-full-control",
+			value: "bucket-owner-full-control"
+		},
+		{
+			label: "bucket-owner-read",
+			value: "bucket-owner-read"
+		},
+		{
+			label: "private",
+			value: "private"
+		},
+		{
+			label: "public-read",
+			value: "public-read"
+		},
+		{
+			label: "public-read-write",
+			value: "public-read-write"
+		}
+	],
+	default: "",
+	clean: toObjectCannedACL
+});
+const expirationSeconds = (0, _prismatic_io_spectral.input)({
+	label: "Expiration Seconds",
+	type: "string",
+	required: true,
+	default: "3600",
+	placeholder: "Enter seconds (e.g., 3600 for 1 hour)",
+	comments: "Number of seconds until the presigned URL expires. Default is 3600 (1 hour).",
+	clean: _prismatic_io_spectral.util.types.toInt
+});
+const versionId = (0, _prismatic_io_spectral.input)({
+	label: "Version ID",
+	type: "string",
+	required: false,
+	placeholder: "Enter version ID",
+	example: "AMn71WZYnWqbvfy0unBOdtaBC.DRiN_r",
+	comments: "The version ID of the object to apply the retention configuration to.",
+	clean: cleanString
+});
+//#endregion
+//#region src/inputs/bucketNotifications.ts
+const topicConfigurations = (0, _prismatic_io_spectral.input)({
+	label: "Topic Configurations",
+	type: "code",
+	language: "json",
+	placeholder: "Enter topic configurations JSON",
+	required: false,
+	default: JSON.stringify(TOPIC_CONFIGURATIONS_EXAMPLE, null, 2),
+	example: JSON.stringify(TOPIC_CONFIGURATIONS_EXAMPLE, null, 2),
+	comments: "List of SNS topic configurations for bucket event notifications. For more information, see [S3 Event Notifications](https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html).",
+	clean: getTopicConfigurations
+});
+const queueConfigurations = (0, _prismatic_io_spectral.input)({
+	label: "Queue Configurations",
+	type: "code",
+	language: "json",
+	placeholder: "Enter queue configurations JSON",
+	required: false,
+	default: JSON.stringify(QUEUE_CONFIGURATIONS_EXAMPLE, null, 2),
+	example: JSON.stringify(QUEUE_CONFIGURATIONS_EXAMPLE, null, 2),
+	comments: "List of SQS queue configurations for bucket event notifications. For more information, see [S3 Event Notifications](https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html).",
+	clean: getQueueConfigurations
+});
+const lambdaFunctionConfigurations = (0, _prismatic_io_spectral.input)({
+	label: "Lambda Function Configurations",
+	type: "code",
+	language: "json",
+	placeholder: "Enter Lambda function configurations JSON",
+	required: false,
+	default: JSON.stringify(LAMBDA_FUNCTION_CONFIGURATIONS_EXAMPLE, null, 2),
+	example: JSON.stringify(LAMBDA_FUNCTION_CONFIGURATIONS_EXAMPLE, null, 2),
+	comments: "List of Lambda function configurations for bucket event notifications. For more information, see [S3 Event Notifications](https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventNotifications.html).",
+	clean: getLambdaFunctionConfigurations
+});
+const eventBridgeConfiguration = (0, _prismatic_io_spectral.input)({
+	label: "EventBridge Configuration",
+	type: "code",
+	language: "json",
+	placeholder: "Enter EventBridge configuration JSON",
+	required: false,
+	default: JSON.stringify(EVENT_BRIDGE_CONFIGURATION_EXAMPLE, null, 2),
+	example: JSON.stringify(EVENT_BRIDGE_CONFIGURATION_EXAMPLE, null, 2),
+	comments: "EventBridge configuration for bucket event notifications. For more information, see [Using EventBridge with S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/EventBridge.html).",
+	clean: getEventBridgeConfiguration
+});
+const getBucketNotificationConfigurationInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	awsRegion
+};
+const putBucketNotificationConfigurationInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	topicConfigurations,
+	queueConfigurations,
+	lambdaFunctionConfigurations,
+	eventBridgeConfiguration,
+	awsRegion
+};
+//#endregion
+//#region src/inputs/buckets.ts
+const deleteBucketInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	awsRegion
+};
+const getBucketLocationInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket
+};
+const headBucketInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	awsRegion
+};
+const listBucketsInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	awsRegion
+};
+//#endregion
+//#region src/inputs/dataSources.ts
+const selectBucketInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs
+};
+//#endregion
+//#region src/inputs/misc.ts
+const getCurrentAccountInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs
+};
+//#endregion
+//#region src/inputs/multipartUploads.ts
+const urlsToGenerate = (0, _prismatic_io_spectral.input)({
+	label: "URLs to Generate",
+	type: "string",
+	required: true,
+	default: "5",
+	placeholder: "Enter number of URLs",
+	example: "10",
+	comments: "The number of presigned URLs to generate for multipart uploads.",
+	clean: (value) => toPositiveInt(value, 5)
+});
+const uploadId = (0, _prismatic_io_spectral.input)({
+	label: "Upload ID",
+	type: "string",
+	required: true,
+	comments: "The unique identifier for the multipart upload, returned by 'Create Multipart Upload' action.",
+	clean: _prismatic_io_spectral.util.types.toString,
+	example: "xadcOB_7YPBOJuoFiQ9cz4P3Pe6FIZwO4f7wN93uHsNBEw97pl5eNwzExg0LAT2dUN91cOmrEQHDsP3WA60CEg",
+	placeholder: "Enter multipart upload ID"
+});
+const fileChunk = (0, _prismatic_io_spectral.input)({
+	label: "File Chunk",
+	type: "data",
+	required: true,
+	comments: "The binary data chunk to upload as part of a multipart upload. Reference output from a previous step.",
+	placeholder: "Select file chunk data",
+	clean: toBufferFromData
+});
+const partNumber = (0, _prismatic_io_spectral.input)({
+	label: "Part Number",
+	type: "string",
+	required: true,
+	comments: "The part number for this chunk in the multipart upload sequence (1-10,000).",
+	placeholder: "Enter part number (1-10,000)",
+	example: "1",
+	clean: _prismatic_io_spectral.util.types.toInt
+});
+const parts = (0, _prismatic_io_spectral.input)({
+	label: "Parts",
+	type: "data",
+	comments: "The list of uploaded parts to complete the multipart upload. Reference the 'Parts' field from the 'List Parts' action output.",
+	placeholder: "Select parts data from List Parts action",
+	required: true,
+	clean: toPartList
+});
+const abortMultipartUploadInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	objectKey,
+	uploadId,
+	awsRegion
+};
+const completeMultipartUploadInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	objectKey,
+	uploadId,
+	parts,
+	awsRegion
+};
+const createMultipartUploadInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	objectKey,
+	tagging,
+	acl,
+	awsRegion
+};
+const generatePresignedForMultiparUploadsInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	objectKey,
+	urlsToGenerate,
+	uploadId,
+	expirationSeconds,
+	awsRegion
+};
+const listMultipartUploadsInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	awsRegion
+};
+const listPartsInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	objectKey,
+	uploadId,
+	awsRegion
+};
+const uploadPartInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	objectKey,
+	uploadId,
+	partNumber,
+	fileChunk,
+	awsRegion
+};
+//#endregion
+//#region src/inputs/objectLock.ts
+const defaultRetentionDays = (0, _prismatic_io_spectral.input)({
+	label: "Default Retention Days",
+	type: "string",
+	required: false,
+	placeholder: "Enter retention days",
+	example: "90",
+	comments: "Number of days for the default retention period. Mutually exclusive with Default Retention Years.",
+	clean: _prismatic_io_spectral.util.types.toInt
+});
+const defaultRetentionYears = (0, _prismatic_io_spectral.input)({
+	label: "Default Retention Years",
+	type: "string",
+	required: false,
+	placeholder: "Enter retention years",
+	example: "7",
+	comments: "Number of years for the default retention period. Mutually exclusive with Default Retention Days.",
+	clean: _prismatic_io_spectral.util.types.toInt
+});
+const defaultRetentionMode = (0, _prismatic_io_spectral.input)({
+	label: "Default Retention Mode",
+	type: "string",
+	required: false,
+	comments: "Object Lock retention mode for new objects. Must be used with either Default Retention Days or Years. For more information, see [S3 Object Lock](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lock.html).",
+	placeholder: "Select retention mode",
+	model: [
+		{
+			label: "Unset",
+			value: ""
+		},
+		{
+			label: "Governance",
+			value: "GOVERNANCE"
+		},
+		{
+			label: "Compliance",
+			value: "COMPLIANCE"
+		}
+	],
+	clean: toObjectLockRetentionMode
+});
+const retainUntilDate = (0, _prismatic_io_spectral.input)({
+	label: "Retain Until Date",
+	type: "string",
+	placeholder: "Enter date (YYYY-MM-DDTHH:MM:SSZ)",
+	example: "2025-12-31T23:59:59.000Z",
+	required: false,
+	comments: "The date and time when Object Retention expires. Required when using Retention Mode. Must be in ISO 8601 format.",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const getObjectLockConfigurationInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	awsRegion
+};
+const getObjectRetentionInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	objectKey,
+	versionId: {
+		...versionId,
+		comments: "The version ID for the object whose retention settings to retrieve."
+	},
+	awsRegion
+};
+const putObjectLockConfigurationInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	defaultRetentionMode,
+	defaultRetentionDays,
+	defaultRetentionYears,
+	awsRegion
+};
+const putObjectRetentionInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	objectKey,
+	retentionMode: {
+		...defaultRetentionMode,
+		label: "Retention Mode",
+		comments: "Retention mode for the specified object. Required when Retain Until Date is set."
+	},
+	retainUntilDate,
+	versionId,
+	awsRegion
+};
+//#endregion
+//#region src/inputs/objects.ts
+const objectKeys = (0, _prismatic_io_spectral.input)({
+	label: "Object Keys",
+	placeholder: "Enter object keys",
+	type: "string",
+	collection: "valuelist",
+	required: true,
+	comments: "A list of object keys to delete. These are the file paths of the objects to delete. Do not include a leading /.",
+	example: "path/to/file1.txt",
+	clean: getObjectIdentifiers
+});
+const sourceKey = (0, _prismatic_io_spectral.input)({
+	label: "Source Key",
+	placeholder: "Enter source object key",
+	type: "string",
+	required: true,
+	comments: "The source object's key (file path) to copy from. Do not include a leading /.",
+	example: "backups/2024/database-backup.sql",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const destinationKey = (0, _prismatic_io_spectral.input)({
+	label: "Destination Key",
+	placeholder: "Enter destination object key",
+	type: "string",
+	required: true,
+	comments: "The destination object's key (file path) to copy to. Do not include a leading /.",
+	example: "archive/2024/database-backup.sql",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const sourceBucket = (0, _prismatic_io_spectral.input)({
+	label: "Source Bucket Name",
+	placeholder: "Enter source bucket name",
+	type: "string",
+	required: true,
+	comments: "The source bucket containing the object to copy. For same-bucket copies, use the same name for both source and destination buckets.",
+	example: "my-company-data-prod",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const destinationBucket = (0, _prismatic_io_spectral.input)({
+	label: "Destination Bucket Name",
+	placeholder: "Enter destination bucket name",
+	type: "string",
+	required: true,
+	comments: "The destination bucket where the object will be copied. For same-bucket copies, use the same name for both source and destination buckets.",
+	example: "my-company-archive",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const prefix = (0, _prismatic_io_spectral.input)({
+	label: "Prefix",
+	placeholder: "Enter prefix",
+	type: "string",
+	required: false,
+	default: "",
+	comments: "List only objects prefixed with this string. For example, to list only files in a directory called 'unprocessed', enter 'unprocessed/'. If this is left blank, all files in the selected bucket will be listed.",
+	example: "path/to/files/",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const pagination = (0, _prismatic_io_spectral.structuredObjectInput)({
+	label: "Pagination",
+	required: false,
+	comments: "Cursor and page-size controls for paging through results.",
+	inputs: {
+		maxKeys: (0, _prismatic_io_spectral.input)({
+			label: "Max Keys",
+			type: "string",
+			required: false,
+			comments: "Maximum number of objects to return (1-1000). Defaults to 1000 if not specified.",
+			example: "1000",
+			placeholder: "Enter max keys (1-1000)",
+			clean: toOptionalInt
+		}),
+		continuationToken: (0, _prismatic_io_spectral.input)({
+			label: "Continuation Token",
+			type: "string",
+			required: false,
+			comments: "Pagination token returned by a previous request to retrieve the next page of results.",
+			example: "lslTXFcbLQKkb0vP9Kgh5hy0Y0OnC7Z9ZPHPwPmMnxSk3eiDRMkct7D8E",
+			placeholder: "Enter continuation token",
+			clean: cleanString
+		})
+	}
+});
+const actionType = (0, _prismatic_io_spectral.input)({
+	label: "Action Type",
+	type: "string",
+	comments: "Specifies whether the presigned URL will allow download or upload operations.",
+	clean: _prismatic_io_spectral.util.types.toString,
+	required: true,
+	default: "download",
+	placeholder: "Select action type",
+	model: [{
+		label: "Download",
+		value: "download"
+	}, {
+		label: "Upload",
+		value: "upload"
+	}]
+});
+const objectAttributes = (0, _prismatic_io_spectral.input)({
+	label: "Object Attributes",
+	type: "string",
+	collection: "valuelist",
+	required: true,
+	model: OBJECT_ATTRIBUTES.map((attribute) => ({
+		label: attribute,
+		value: attribute
+	})),
+	comments: "The object attributes to return in the response. Unspecified attributes are not returned.",
+	placeholder: "Select object attributes",
+	clean: getObjectAttributes$1
+});
+const includeMetadata = (0, _prismatic_io_spectral.input)({
+	label: "Include Metadata",
+	type: "boolean",
+	required: true,
+	default: "false",
+	comments: "When true, returns full object metadata and pagination information instead of just object keys.",
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const copyObjectInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	sourceBucket,
+	destinationBucket,
+	sourceKey,
+	destinationKey,
+	acl,
+	awsRegion
+};
+const deleteObjectInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	objectKey,
+	awsRegion
+};
+const deleteObjectsInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	objectKeys,
+	awsRegion
+};
+const generatePresignedUrlInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	objectKey,
+	actionType,
+	expirationSeconds,
+	awsRegion
+};
+const getObjectInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	objectKey,
+	versionId: {
+		...versionId,
+		comments: "The version ID of the object to retrieve. When omitted, the current version is returned."
+	},
+	awsRegion
+};
+const getObjectAttributesInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	objectKey,
+	objectAttributes,
+	versionId: {
+		...versionId,
+		comments: "The version ID for the object whose metadata to retrieve."
+	},
+	awsRegion
+};
+const headObjectInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	objectKey,
+	versionId: {
+		...versionId,
+		comments: "The version ID of the object whose metadata to retrieve."
+	},
+	awsRegion
+};
+const listObjectsInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	includeMetadata,
+	pagination,
+	prefix,
+	awsRegion
+};
+const putObjectInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	fileContents,
+	objectKey,
+	tagging,
+	acl,
+	awsRegion
+};
+//#endregion
+//#region src/inputs/sns.ts
+const name = (0, _prismatic_io_spectral.input)({
+	label: "Name",
+	type: "string",
+	required: true,
+	example: "ProductionNotifications",
+	placeholder: "Enter topic name",
+	comments: "The name of the SNS topic to create.",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const snsTopicArn = (0, _prismatic_io_spectral.input)({
+	label: "SNS Topic ARN",
+	type: "string",
+	required: true,
+	example: "arn:aws:sns:us-east-1:123456789012:S3EventNotifications",
+	placeholder: "Enter SNS topic ARN",
+	comments: "The Amazon Resource Name (ARN) of the SNS topic. For more information, see [Getting started with Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-getting-started.html).",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const bucketOwnerAccountid = (0, _prismatic_io_spectral.input)({
+	label: "Bucket Owner Account ID",
+	type: "string",
+	required: true,
+	example: "123456789012",
+	placeholder: "Enter 12-digit AWS account ID",
+	comments: "The 12-digit AWS Account ID of the bucket owner. Find this in the AWS Console account settings or use the 'Get Current Account' action.",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const endpoint = (0, _prismatic_io_spectral.input)({
+	label: "Webhook Endpoint",
+	type: "string",
+	required: true,
+	example: "https://hooks.example.com/trigger/SW5zdGFuY2VGbG93Q29uZmlnOjhiNGY0ZTRkLWIyODMtNDE4Yy04YmZhLTg1NGI11234567890==",
+	placeholder: "Enter webhook URL",
+	comments: "The HTTPS endpoint URL that will receive S3 event notifications.",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const subscriptionArn = (0, _prismatic_io_spectral.input)({
+	label: "Subscription ARN",
+	type: "string",
+	required: true,
+	example: "arn:aws:sns:us-east-2:123456789012:MyTopic:a1b2c3d4-e5f6-7890-a1b2-c3d4e5f67890",
+	placeholder: "Enter subscription ARN",
+	comments: "The Amazon Resource Name (ARN) of the SNS topic subscription.",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const eventsList = (0, _prismatic_io_spectral.input)({
+	label: "Event Types",
+	comments: "S3 event types that will trigger notifications. For more information, see [S3 Event Notification Types](https://docs.aws.amazon.com/AmazonS3/latest/userguide/notification-how-to-event-types-and-destinations.html).",
+	type: "string",
+	collection: "valuelist",
+	model: INPUT_EVENT_TYPES_MODEL,
+	example: "s3:ObjectCreated:*",
+	placeholder: "Select event types",
+	required: true,
+	clean: toTrimmedStringArray
+});
+const eventNotificationName = (0, _prismatic_io_spectral.input)({
+	label: "Event Notification Name",
+	type: "string",
+	required: true,
+	example: "S3ObjectCreatedAlert",
+	placeholder: "Enter event notification name",
+	comments: "A unique name for the event notification configuration.",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const bucketEventTriggerConfigurationInputs = {
+	awsConnection: accessKeyInput,
+	...dynamicAccessAllInputs,
+	snsTopicArn,
+	eventsList,
+	bucket,
+	eventNotificationName,
+	bucketOwnerAccountid,
+	awsRegion
+};
+const createTopicInputs = {
+	awsConnection: accessKeyInput,
+	...dynamicAccessAllInputs,
+	name,
+	awsRegion
+};
+const subscribeToTopicInputs = {
+	awsConnection: accessKeyInput,
+	...dynamicAccessAllInputs,
+	snsTopicArn,
+	endpoint,
+	awsRegion
+};
+const unsubscribeFromTopicInputs = {
+	awsConnection: accessKeyInput,
+	...dynamicAccessAllInputs,
+	subscriptionArn,
+	awsRegion
+};
+const updateTopicPolicyInputs = {
+	awsConnection: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	snsTopicArn,
+	bucketOwnerAccountid,
+	awsRegion
+};
+//#endregion
+//#region src/inputs/triggers.ts
+const filesLookBackDate = (0, _prismatic_io_spectral.input)({
+	label: "Look-back Date",
+	placeholder: "Enter look-back date (YYYY-MM-DD)",
+	type: "string",
+	required: false,
+	comments: "The date the initial sync starts from, in YYYY-MM-DD format. Cannot be a future date. Leave empty to start from the first recurrence with no backfill. When set, the initial sync seeds each file modified on or after this date once.",
+	example: "2026-01-01",
+	clean: lookBackDateClean
+});
+const bucketsLookBackDate = (0, _prismatic_io_spectral.input)({
+	label: "Look-back Date",
+	placeholder: "Enter look-back date (YYYY-MM-DD)",
+	type: "string",
+	required: false,
+	comments: "The date the initial sync starts from, in YYYY-MM-DD format. Cannot be a future date. Leave empty to start from the first recurrence with no backfill. When set, the initial sync seeds each bucket created on or after this date once.",
+	example: "2026-01-01",
+	clean: lookBackDateClean
+});
+const pollChangesFilesTriggerInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	bucket,
+	lookBackDate: filesLookBackDate,
+	awsRegion
+};
+const pollNewBucketsTriggerInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	lookBackDate: bucketsLookBackDate,
+	awsRegion
+};
+const snsS3NotificationWebhookInputs = { expectedTopicArn: (0, _prismatic_io_spectral.input)({
+	label: "Topic ARN",
+	placeholder: "Enter the expected Amazon SNS Topic ARN",
+	type: "string",
+	required: false,
+	comments: "The Amazon SNS Topic ARN this webhook should accept messages from. When set, a validly signed message from any other topic is rejected, including a subscription confirmation, so a foreign subscription is never confirmed. Leave empty to accept a validly signed message from any topic.",
+	example: "arn:aws:sns:us-west-2:123456789012:MyTopic",
+	clean: cleanString
+}) };
+//#endregion
+//#region src/inputs/uploadStreams.ts
+const uploadIdInput = (0, _prismatic_io_spectral.input)({
+	label: "Upload Stream ID",
+	type: "string",
+	required: true,
+	placeholder: "Enter upload stream ID",
+	comments: "The ID of the upload stream to write to. Generate this with the 'Create Stream' action.",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const closeUploadStreamInputs = { uploadId: uploadIdInput };
+const createUploadStreamInputs = {
+	accessKey: accessKeyInput,
+	...dynamicAccessAllInputs,
+	objectKey,
+	bucket,
+	tagging,
+	acl,
+	awsRegion
+};
+const writeUploadStreamInputs = {
+	uploadId: uploadIdInput,
+	fileContents
+};
+//#endregion
+//#region src/outputSchemas/bucketNotifications.ts
+const notificationFilterSchema = {
+	type: "object",
+	properties: { Key: {
+		type: "object",
+		properties: { FilterRules: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					Name: { type: "string" },
+					Value: { type: "string" }
+				},
+				required: []
+			}
+		} },
+		required: []
+	} },
+	required: []
+};
+const eventsSchema = {
+	type: "array",
+	items: { type: "string" }
+};
+const getBucketNotificationConfigurationOutputSchema = {
+	type: "object",
+	properties: {
+		TopicConfigurations: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					Id: { type: "string" },
+					TopicArn: { type: "string" },
+					Events: eventsSchema,
+					Filter: notificationFilterSchema
+				},
+				required: ["TopicArn", "Events"]
+			}
+		},
+		QueueConfigurations: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					Id: { type: "string" },
+					QueueArn: { type: "string" },
+					Events: eventsSchema,
+					Filter: notificationFilterSchema
+				},
+				required: ["QueueArn", "Events"]
+			}
+		},
+		LambdaFunctionConfigurations: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					Id: { type: "string" },
+					LambdaFunctionArn: { type: "string" },
+					Events: eventsSchema,
+					Filter: notificationFilterSchema
+				},
+				required: ["LambdaFunctionArn", "Events"]
+			}
+		},
+		EventBridgeConfiguration: { type: "object" }
+	},
+	required: []
+};
+//#endregion
+//#region src/outputSchemas/shared.ts
+const dateTimeSchema = {
+	type: "string",
+	format: "date-time"
+};
+const requestChargedSchema = {
+	type: "string",
+	enum: ["requester"]
+};
+const checksumTypeSchema = {
+	type: "string",
+	enum: ["COMPOSITE", "FULL_OBJECT"]
+};
+const retentionModeSchema = {
+	type: "string",
+	enum: ["GOVERNANCE", "COMPLIANCE"]
+};
+const checksumValueProperties = {
+	ChecksumCRC32: { type: "string" },
+	ChecksumCRC32C: { type: "string" },
+	ChecksumCRC64NVME: { type: "string" },
+	ChecksumSHA1: { type: "string" },
+	ChecksumSHA256: { type: "string" },
+	ChecksumSHA512: { type: "string" },
+	ChecksumMD5: { type: "string" },
+	ChecksumXXHASH64: { type: "string" },
+	ChecksumXXHASH3: { type: "string" },
+	ChecksumXXHASH128: { type: "string" }
+};
+const serverSideEncryptionProperties = {
+	ServerSideEncryption: { type: "string" },
+	SSECustomerAlgorithm: { type: "string" },
+	SSECustomerKeyMD5: { type: "string" },
+	SSEKMSKeyId: { type: "string" },
+	BucketKeyEnabled: { type: "boolean" }
+};
+const ownerSchema = {
+	type: "object",
+	properties: {
+		DisplayName: { type: "string" },
+		ID: { type: "string" }
+	},
+	required: []
+};
+const initiatorSchema = {
+	type: "object",
+	properties: {
+		ID: { type: "string" },
+		DisplayName: { type: "string" }
+	},
+	required: []
+};
+const commonPrefixSchema = {
+	type: "object",
+	properties: { Prefix: { type: "string" } },
+	required: []
+};
+//#endregion
+//#region src/outputSchemas/buckets.ts
+const getBucketLocationOutputSchema = { type: "string" };
+const listBucketsOutputSchema = {
+	type: ["array", "null"],
+	items: {
+		type: "object",
+		properties: {
+			Name: { type: "string" },
+			CreationDate: dateTimeSchema,
+			BucketRegion: { type: "string" },
+			BucketArn: { type: "string" }
+		},
+		required: []
+	}
+};
+const headBucketOutputSchema = {
+	type: "object",
+	properties: {
+		BucketArn: { type: "string" },
+		BucketLocationType: { type: "string" },
+		BucketLocationName: { type: "string" },
+		BucketRegion: { type: "string" },
+		AccessPointAlias: { type: "boolean" }
+	},
+	required: []
+};
+//#endregion
+//#region src/outputSchemas/misc.ts
+const getCurrentAccountOutputSchema = {
+	type: "object",
+	properties: {
+		UserId: { type: "string" },
+		Account: { type: "string" },
+		Arn: { type: "string" }
+	},
+	required: []
+};
+//#endregion
+//#region src/outputSchemas/multipartUploads.ts
+const createMultipartUploadOutputSchema = {
+	type: "object",
+	properties: {
+		AbortDate: dateTimeSchema,
+		AbortRuleId: { type: "string" },
+		Bucket: { type: "string" },
+		Key: { type: "string" },
+		UploadId: { type: "string" },
+		...serverSideEncryptionProperties,
+		SSEKMSEncryptionContext: { type: "string" },
+		RequestCharged: requestChargedSchema,
+		ChecksumAlgorithm: { type: "string" },
+		ChecksumType: checksumTypeSchema
+	},
+	required: []
+};
+const uploadPartOutputSchema = {
+	type: "object",
+	properties: {
+		ETag: { type: "string" },
+		...checksumValueProperties,
+		...serverSideEncryptionProperties,
+		RequestCharged: requestChargedSchema,
+		part: {
+			type: "object",
+			properties: {
+				ETag: { type: "string" },
+				PartNumber: { type: "number" }
+			},
+			required: ["PartNumber"]
+		}
+	},
+	required: []
+};
+const generatePresignedForMultiparUploadsOutputSchema = {
+	type: "array",
+	items: {
+		type: "object",
+		properties: {
+			url: {
+				type: "string",
+				format: "uri"
+			},
+			partNumber: { type: "number" }
+		},
+		required: ["url", "partNumber"]
+	}
+};
+const completeMultipartUploadOutputSchema = {
+	type: "object",
+	properties: {
+		Location: { type: "string" },
+		Bucket: { type: "string" },
+		Key: { type: "string" },
+		Expiration: { type: "string" },
+		ETag: { type: "string" },
+		...checksumValueProperties,
+		ChecksumType: checksumTypeSchema,
+		ServerSideEncryption: { type: "string" },
+		VersionId: { type: "string" },
+		SSEKMSKeyId: { type: "string" },
+		BucketKeyEnabled: { type: "boolean" },
+		RequestCharged: requestChargedSchema
+	},
+	required: []
+};
+const listPartsOutputSchema = {
+	type: "object",
+	properties: {
+		AbortDate: dateTimeSchema,
+		AbortRuleId: { type: "string" },
+		Bucket: { type: "string" },
+		Key: { type: "string" },
+		UploadId: { type: "string" },
+		PartNumberMarker: { type: "string" },
+		NextPartNumberMarker: { type: "string" },
+		MaxParts: { type: "number" },
+		IsTruncated: { type: "boolean" },
+		Parts: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					PartNumber: { type: "number" },
+					LastModified: dateTimeSchema,
+					ETag: { type: "string" },
+					Size: { type: "number" },
+					...checksumValueProperties
+				},
+				required: []
+			}
+		},
+		Initiator: initiatorSchema,
+		Owner: ownerSchema,
+		StorageClass: { type: "string" },
+		RequestCharged: requestChargedSchema,
+		ChecksumAlgorithm: { type: "string" },
+		ChecksumType: checksumTypeSchema
+	},
+	required: []
+};
+const listMultipartUploadsOutputSchema = {
+	type: "object",
+	properties: {
+		Bucket: { type: "string" },
+		KeyMarker: { type: "string" },
+		UploadIdMarker: { type: "string" },
+		NextKeyMarker: { type: "string" },
+		Prefix: { type: "string" },
+		Delimiter: { type: "string" },
+		NextUploadIdMarker: { type: "string" },
+		MaxUploads: { type: "number" },
+		IsTruncated: { type: "boolean" },
+		Uploads: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					UploadId: { type: "string" },
+					Key: { type: "string" },
+					Initiated: dateTimeSchema,
+					StorageClass: { type: "string" },
+					Owner: ownerSchema,
+					Initiator: initiatorSchema,
+					ChecksumAlgorithm: { type: "string" },
+					ChecksumType: checksumTypeSchema
+				},
+				required: []
+			}
+		},
+		CommonPrefixes: {
+			type: "array",
+			items: commonPrefixSchema
+		},
+		EncodingType: {
+			type: "string",
+			enum: ["url"]
+		},
+		RequestCharged: requestChargedSchema
+	},
+	required: []
+};
+const abortMultipartUploadOutputSchema = {
+	type: "object",
+	properties: { RequestCharged: requestChargedSchema },
+	required: []
+};
+//#endregion
+//#region src/outputSchemas/objectLock.ts
+const getObjectLockConfigurationOutputSchema = {
+	type: "object",
+	properties: { ObjectLockConfiguration: {
+		type: "object",
+		properties: {
+			ObjectLockEnabled: {
+				type: "string",
+				enum: ["Enabled"]
+			},
+			Rule: {
+				type: "object",
+				properties: { DefaultRetention: {
+					type: "object",
+					properties: {
+						Mode: retentionModeSchema,
+						Days: { type: "number" },
+						Years: { type: "number" }
+					},
+					required: []
+				} },
+				required: []
+			}
+		},
+		required: []
+	} },
+	required: ["ObjectLockConfiguration"]
+};
+const getObjectRetentionOutputSchema = {
+	type: "object",
+	properties: { Retention: {
+		type: "object",
+		properties: {
+			Mode: retentionModeSchema,
+			RetainUntilDate: dateTimeSchema
+		},
+		required: []
+	} },
+	required: ["Retention"]
+};
+const putObjectLockConfigurationOutputSchema = {
+	type: "object",
+	properties: { RequestCharged: requestChargedSchema },
+	required: []
+};
+const putObjectRetentionOutputSchema = {
+	type: "object",
+	properties: { RequestCharged: requestChargedSchema },
+	required: []
+};
+//#endregion
+//#region src/outputSchemas/objects.ts
+const generatePresignedUrlOutputSchema = {
+	type: "string",
+	format: "uri"
+};
+const copyObjectOutputSchema = {
+	type: "object",
+	properties: {
+		CopyObjectResult: {
+			type: "object",
+			properties: {
+				ETag: { type: "string" },
+				LastModified: dateTimeSchema,
+				ChecksumType: checksumTypeSchema,
+				...checksumValueProperties
+			},
+			required: []
+		},
+		Expiration: { type: "string" },
+		CopySourceVersionId: { type: "string" },
+		VersionId: { type: "string" },
+		...serverSideEncryptionProperties,
+		SSEKMSEncryptionContext: { type: "string" },
+		RequestCharged: requestChargedSchema
+	},
+	required: ["CopyObjectResult"]
+};
+const putObjectOutputSchema = {
+	type: "object",
+	properties: {
+		Expiration: { type: "string" },
+		ETag: { type: "string" },
+		...checksumValueProperties,
+		ChecksumType: checksumTypeSchema,
+		VersionId: { type: "string" },
+		...serverSideEncryptionProperties,
+		SSEKMSEncryptionContext: { type: "string" },
+		Size: { type: "number" },
+		RequestCharged: requestChargedSchema
+	},
+	required: []
+};
+const headObjectOutputSchema = {
+	type: "object",
+	properties: {
+		DeleteMarker: { type: "boolean" },
+		AcceptRanges: { type: "string" },
+		Expiration: { type: "string" },
+		Restore: { type: "string" },
+		ArchiveStatus: { type: "string" },
+		LastModified: dateTimeSchema,
+		ContentLength: { type: "number" },
+		...checksumValueProperties,
+		ChecksumType: checksumTypeSchema,
+		ETag: { type: "string" },
+		MissingMeta: { type: "number" },
+		VersionId: { type: "string" },
+		CacheControl: { type: "string" },
+		ContentDisposition: { type: "string" },
+		ContentEncoding: { type: "string" },
+		ContentLanguage: { type: "string" },
+		ContentType: { type: "string" },
+		ContentRange: { type: "string" },
+		Expires: dateTimeSchema,
+		ExpiresString: { type: "string" },
+		WebsiteRedirectLocation: { type: "string" },
+		...serverSideEncryptionProperties,
+		Metadata: {
+			type: "object",
+			additionalProperties: { type: "string" }
+		},
+		StorageClass: { type: "string" },
+		RequestCharged: requestChargedSchema,
+		ReplicationStatus: { type: "string" },
+		PartsCount: { type: "number" },
+		TagCount: { type: "number" },
+		ObjectLockMode: retentionModeSchema,
+		ObjectLockRetainUntilDate: dateTimeSchema,
+		ObjectLockLegalHoldStatus: {
+			type: "string",
+			enum: ["ON", "OFF"]
+		}
+	},
+	required: []
+};
+const deleteObjectOutputSchema = {
+	type: "object",
+	properties: {
+		DeleteMarker: { type: "boolean" },
+		VersionId: { type: "string" },
+		RequestCharged: requestChargedSchema
+	},
+	required: []
+};
+const deleteObjectsOutputSchema = {
+	type: "object",
+	properties: {
+		Deleted: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					Key: { type: "string" },
+					VersionId: { type: "string" },
+					DeleteMarker: { type: "boolean" },
+					DeleteMarkerVersionId: { type: "string" }
+				},
+				required: []
+			}
+		},
+		Errors: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					Key: { type: "string" },
+					VersionId: { type: "string" },
+					Code: { type: "string" },
+					Message: { type: "string" }
+				},
+				required: []
+			}
+		},
+		RequestCharged: requestChargedSchema
+	},
+	required: []
+};
+const listObjectsOutputSchema = {
+	type: ["array", "object"],
+	items: { type: "string" },
+	properties: {
+		IsTruncated: { type: "boolean" },
+		Contents: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					Key: { type: "string" },
+					LastModified: dateTimeSchema,
+					ETag: { type: "string" },
+					ChecksumAlgorithm: {
+						type: "array",
+						items: { type: "string" }
+					},
+					ChecksumType: checksumTypeSchema,
+					Size: { type: "number" },
+					StorageClass: { type: "string" },
+					Owner: ownerSchema,
+					RestoreStatus: {
+						type: "object",
+						properties: {
+							IsRestoreInProgress: { type: "boolean" },
+							RestoreExpiryDate: dateTimeSchema
+						},
+						required: []
+					}
+				},
+				required: []
+			}
+		},
+		Name: { type: "string" },
+		Prefix: { type: "string" },
+		Delimiter: { type: "string" },
+		MaxKeys: { type: "number" },
+		CommonPrefixes: {
+			type: "array",
+			items: commonPrefixSchema
+		},
+		EncodingType: {
+			type: "string",
+			enum: ["url"]
+		},
+		KeyCount: { type: "number" },
+		ContinuationToken: { type: "string" },
+		NextContinuationToken: { type: "string" },
+		StartAfter: { type: "string" },
+		RequestCharged: requestChargedSchema
+	},
+	required: [],
+	additionalProperties: true
+};
+const getObjectAttributesOutputSchema = {
+	type: "object",
+	properties: {
+		DeleteMarker: { type: "boolean" },
+		LastModified: dateTimeSchema,
+		VersionId: { type: "string" },
+		RequestCharged: requestChargedSchema,
+		ETag: { type: "string" },
+		Checksum: {
+			type: "object",
+			properties: {
+				...checksumValueProperties,
+				ChecksumType: checksumTypeSchema
+			},
+			required: []
+		},
+		ObjectParts: {
+			type: "object",
+			properties: {
+				TotalPartsCount: { type: "number" },
+				PartNumberMarker: { type: "string" },
+				NextPartNumberMarker: { type: "string" },
+				MaxParts: { type: "number" },
+				IsTruncated: { type: "boolean" },
+				Parts: {
+					type: "array",
+					items: {
+						type: "object",
+						properties: {
+							PartNumber: { type: "number" },
+							Size: { type: "number" },
+							...checksumValueProperties
+						},
+						required: []
+					}
+				}
+			},
+			required: []
+		},
+		StorageClass: { type: "string" },
+		ObjectSize: { type: "number" }
+	},
+	required: [],
+	additionalProperties: true
+};
+//#endregion
+//#region src/outputSchemas/sns.ts
+const createTopicOutputSchema = {
+	type: "object",
+	properties: { TopicArn: { type: "string" } },
+	required: []
+};
+const subscribeToTopicOutputSchema = {
+	type: "object",
+	properties: { SubscriptionArn: { type: "string" } },
+	required: []
+};
+//#endregion
+//#region src/outputSchemas/uploadStreams.ts
+const createUploadStreamOutputSchema = {
+	type: "string",
+	format: "uuid"
+};
+const writeUploadStreamOutputSchema = { type: "null" };
+const closeUploadStreamOutputSchema = { type: "null" };
+//#endregion
+//#region src/actions/bucketNotifications/index.ts
+var bucketNotifications_default = {
+	getBucketNotificationConfiguration: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get Bucket Notification Configuration",
+			description: "Returns the notification configuration of a bucket"
+		},
+		performSafety: "safe",
+		perform: async (context, { awsRegion, accessKey, bucket, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			return { data: await getBucketNotificationConfiguration$1(await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			}), bucket, void 0, false) };
+		},
+		inputs: getBucketNotificationConfigurationInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: getBucketNotificationConfigurationOutputSchema
+		}),
+		examplePayload: getBucketNotificationConfigurationExamplePayload
+	}),
+	putBucketNotificationConfiguration: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Put Bucket Notification Configuration",
+			description: "Replace an existing bucket notification configuration with a new one"
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { awsRegion, accessKey, bucket, topicConfigurations, queueConfigurations, lambdaFunctionConfigurations, eventBridgeConfiguration, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			return { data: await putBucketNotificationConfiguration$1(await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			}), bucket, {
+				TopicConfigurations: topicConfigurations,
+				QueueConfigurations: queueConfigurations,
+				LambdaFunctionConfigurations: lambdaFunctionConfigurations,
+				EventBridgeConfiguration: eventBridgeConfiguration
+			}) };
+		},
+		inputs: putBucketNotificationConfigurationInputs,
+		examplePerform: async () => putBucketNotificationConfigurationExamplePayload,
+		examplePayload: putBucketNotificationConfigurationExamplePayload
+	})
+};
+//#endregion
+//#region src/actions/buckets/index.ts
+var buckets_default = {
+	deleteBucket: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Delete Bucket",
+			description: "Deletes the S3 bucket. All objects in the bucket must be deleted before the bucket itself can be deleted"
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { awsRegion, accessKey, bucket, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const s3 = await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const command = new _aws_sdk_client_s3.DeleteBucketCommand({ Bucket: bucket });
+			return { data: await s3.send(command) };
+		},
+		inputs: deleteBucketInputs,
+		examplePerform: async () => deleteBucketExamplePayload,
+		examplePayload: deleteBucketExamplePayload
+	}),
+	getBucketLocation: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get Bucket Location",
+			description: "Get the location (AWS region) of a bucket by name"
+		},
+		performSafety: "safe",
+		perform: async (context, { accessKey, bucket, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const s3 = await createS3Client({
+				awsConnection: accessKey,
+				awsRegion: "",
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const command = new _aws_sdk_client_s3.GetBucketLocationCommand({ Bucket: bucket });
+			return { data: (await s3.send(command)).LocationConstraint || "us-east-1" };
+		},
+		inputs: getBucketLocationInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: getBucketLocationOutputSchema
+		}),
+		examplePayload: getBucketLocationExamplePayload
+	}),
+	headBucket: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Head Bucket",
+			description: "Determine if a bucket exists and whether the connection has permission to access it."
+		},
+		performSafety: "safe",
+		perform: async (context, { awsRegion, accessKey, bucket, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const s3 = await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const command = new _aws_sdk_client_s3.HeadBucketCommand({ Bucket: bucket });
+			return { data: await s3.send(command) };
+		},
+		inputs: headBucketInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: headBucketOutputSchema
+		}),
+		examplePayload: headBucketExamplePayload
+	}),
+	listBuckets: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List Buckets",
+			description: "List all buckets in an AWS account"
+		},
+		performSafety: "safe",
+		perform: async (context, { awsRegion, accessKey, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			return { data: await listAllBuckets(await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			})) };
+		},
+		inputs: listBucketsInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: listBucketsOutputSchema
+		}),
+		examplePayload: listBucketsExamplePayload
+	})
+};
+//#endregion
+//#region src/actions/misc/index.ts
+var misc_default = { getCurrentAccount: (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Get Current Account",
+		description: "Get the current AWS account"
+	},
+	performSafety: "safe",
+	perform: async (context, { accessKey, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+		const sts = new _aws_sdk_client_sts.STSClient({ credentials: (await createS3Client({
+			awsConnection: accessKey,
+			awsRegion: "",
+			dynamicAccessKeyId,
+			dynamicSecretAccessKey,
+			dynamicSessionToken,
+			logger: context.logger,
+			debug: context.debug.enabled
+		})).config.credentials });
+		const command = new _aws_sdk_client_sts.GetCallerIdentityCommand({});
+		return { data: await sts.send(command) };
+	},
+	inputs: getCurrentAccountInputs,
+	outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+		type: "actionOutput",
+		schema: getCurrentAccountOutputSchema
+	}),
+	examplePayload: getCurrentAccountExamplePayload
+}) };
+//#endregion
+//#region src/actions/multipartUploads/index.ts
+var multipartUploads_default = {
+	abortMultipartUpload: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Abort Multipart Upload",
+			description: "Abort a multipart upload"
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { awsRegion, accessKey, bucket, objectKey, uploadId, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const s3 = await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const command = new _aws_sdk_client_s3.AbortMultipartUploadCommand({
+				Bucket: bucket,
+				Key: objectKey,
+				UploadId: uploadId
+			});
+			return { data: await s3.send(command) };
+		},
+		inputs: abortMultipartUploadInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: abortMultipartUploadOutputSchema
+		}),
+		examplePerform: async () => abortMultipartUploadExamplePayload,
+		examplePayload: abortMultipartUploadExamplePayload
+	}),
+	completeMultipartUpload: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Complete Multipart Upload",
+			description: "Complete a multipart upload"
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { awsRegion, accessKey, bucket, objectKey, uploadId, parts, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const s3 = await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const command = new _aws_sdk_client_s3.CompleteMultipartUploadCommand({
+				Bucket: bucket,
+				Key: objectKey,
+				UploadId: uploadId,
+				MultipartUpload: { Parts: parts }
+			});
+			return { data: await s3.send(command) };
+		},
+		inputs: completeMultipartUploadInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: completeMultipartUploadOutputSchema
+		}),
+		examplePerform: async () => completeMultipartUploadExamplePayload,
+		examplePayload: completeMultipartUploadExamplePayload
+	}),
+	createMultipartUpload: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Create Multipart Upload",
+			description: "Create a multipart upload"
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { acl, awsRegion, accessKey, bucket, objectKey, tagging, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const s3 = await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const command = new _aws_sdk_client_s3.CreateMultipartUploadCommand({
+				ACL: acl || null,
+				Bucket: bucket,
+				Key: objectKey,
+				Tagging: encodeTags(tagging)
+			});
+			return { data: await s3.send(command) };
+		},
+		inputs: createMultipartUploadInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: createMultipartUploadOutputSchema
+		}),
+		examplePerform: async () => createMultipartUploadExamplePayload,
+		examplePayload: createMultipartUploadExamplePayload
+	}),
+	generatePresignedForMultiparUploads: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Generate Presigned URL for Multipart Uploads",
+			description: "Generate presigned URLs for uploading the parts of a multipart upload to S3."
+		},
+		inputs: generatePresignedForMultiparUploadsInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: generatePresignedForMultiparUploadsOutputSchema
+		}),
+		performSafety: "notAllowed",
+		perform: async (context, params) => {
+			const s3 = await createS3Client({
+				awsConnection: params.accessKey,
+				awsRegion: params.awsRegion,
+				dynamicAccessKeyId: params.dynamicAccessKeyId,
+				dynamicSecretAccessKey: params.dynamicSecretAccessKey,
+				dynamicSessionToken: params.dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const urlArray = [];
+			for (let i = 1; i <= params.urlsToGenerate; i++) {
+				const command = new _aws_sdk_client_s3.UploadPartCommand({
+					Bucket: params.bucket,
+					Key: params.objectKey,
+					PartNumber: i,
+					UploadId: params.uploadId
+				});
+				urlArray.push((0, _aws_sdk_s3_request_presigner.getSignedUrl)(s3, command, { expiresIn: params.expirationSeconds }));
+			}
+			return { data: (await Promise.all(urlArray)).map((value, index) => ({
+				url: value,
+				partNumber: index + 1
+			})) };
+		},
+		examplePerform: async () => generatePresignedForMultiparUploadsExamplePayload,
+		examplePayload: generatePresignedForMultiparUploadsExamplePayload
+	}),
+	listMultipartUploads: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List Multipart Uploads",
+			description: "Lists in-progress multipart uploads in a bucket"
+		},
+		performSafety: "safe",
+		perform: async (context, { awsRegion, accessKey, bucket, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const s3 = await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const command = new _aws_sdk_client_s3.ListMultipartUploadsCommand({ Bucket: bucket });
+			return { data: await s3.send(command) };
+		},
+		inputs: listMultipartUploadsInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: listMultipartUploadsOutputSchema
+		}),
+		examplePayload: listMultipartUploadsExamplePayload
+	}),
+	listParts: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List Parts",
+			description: "List parts of a multipart upload"
+		},
+		performSafety: "safe",
+		perform: async (context, { awsRegion, accessKey, bucket, objectKey, uploadId, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const s3 = await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const command = new _aws_sdk_client_s3.ListPartsCommand({
+				Bucket: bucket,
+				Key: objectKey,
+				UploadId: uploadId
+			});
+			return { data: await s3.send(command) };
+		},
+		inputs: listPartsInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: listPartsOutputSchema
+		}),
+		examplePayload: listPartsExamplePayload
+	}),
+	uploadPart: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Upload Part",
+			description: "Upload a chunk of a multipart file upload"
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { awsRegion, accessKey, bucket, fileChunk, objectKey, uploadId, partNumber, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const s3 = await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const command = new _aws_sdk_client_s3.UploadPartCommand({
+				Bucket: bucket,
+				Key: objectKey,
+				PartNumber: partNumber,
+				UploadId: uploadId,
+				Body: fileChunk
+			});
+			const result = await s3.send(command);
+			return { data: {
+				...result,
+				part: {
+					ETag: result.ETag,
+					PartNumber: partNumber
+				}
+			} };
+		},
+		inputs: uploadPartInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: uploadPartOutputSchema
+		}),
+		examplePerform: async () => uploadPartExamplePayload,
+		examplePayload: uploadPartExamplePayload
+	})
+};
+//#endregion
+//#region src/actions/objectLock/index.ts
+var objectLock_default = {
+	getObjectLockConfiguration: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get Object Lock Configuration",
+			description: "Gets the Object Lock configuration for a bucket"
+		},
+		performSafety: "safe",
+		perform: async (context, { awsRegion, accessKey, bucket, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const s3 = await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const command = new _aws_sdk_client_s3.GetObjectLockConfigurationCommand({ Bucket: bucket });
+			return { data: await s3.send(command) };
+		},
+		inputs: getObjectLockConfigurationInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: getObjectLockConfigurationOutputSchema
+		}),
+		examplePayload: getObjectLockConfigurationExamplePayload
+	}),
+	getObjectRetention: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get Object Retention",
+			description: "Retrieves an object's retention settings"
+		},
+		performSafety: "safe",
+		perform: async (context, { awsRegion, accessKey, bucket, objectKey, versionId, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const s3 = await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const command = new _aws_sdk_client_s3.GetObjectRetentionCommand({
+				Bucket: bucket,
+				Key: objectKey,
+				VersionId: versionId
+			});
+			return { data: await s3.send(command) };
+		},
+		inputs: getObjectRetentionInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: getObjectRetentionOutputSchema
+		}),
+		examplePayload: getObjectRetentionExamplePayload
+	}),
+	putObjectLockConfiguration: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Put Object Lock Configuration",
+			description: "Places an Object Lock configuration on the specified bucket"
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { awsRegion, accessKey, bucket, defaultRetentionDays, defaultRetentionMode, defaultRetentionYears, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const s3 = await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const defaultRetentionDaysPresent = defaultRetentionDays > 0;
+			const defaultRetentionYearsPresent = defaultRetentionYears > 0;
+			const defaultRetentionModePresent = defaultRetentionMode.length > 0;
+			if (defaultRetentionDaysPresent && defaultRetentionYearsPresent) throw new Error("You cannot specify both Default Retention Years and Default Retention Days. Please specify one or the other.");
+			if (defaultRetentionModePresent && !defaultRetentionDaysPresent && !defaultRetentionYearsPresent) throw new Error("You must specify either Default Retention Years or Default Retention Days.");
+			if (!defaultRetentionModePresent && (defaultRetentionDaysPresent || defaultRetentionYearsPresent)) throw new Error("You must specify a Default Retention Mode.");
+			const command = new _aws_sdk_client_s3.PutObjectLockConfigurationCommand({
+				ObjectLockConfiguration: {
+					ObjectLockEnabled: "Enabled",
+					Rule: defaultRetentionModePresent ? { DefaultRetention: {
+						Days: defaultRetentionDaysPresent ? defaultRetentionDays : void 0,
+						Mode: defaultRetentionMode,
+						Years: defaultRetentionYearsPresent ? defaultRetentionYears : void 0
+					} } : void 0
+				},
+				Bucket: bucket
+			});
+			return { data: await s3.send(command) };
+		},
+		inputs: putObjectLockConfigurationInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: putObjectLockConfigurationOutputSchema
+		}),
+		examplePerform: async () => putObjectLockConfigurationExamplePayload,
+		examplePayload: putObjectLockConfigurationExamplePayload
+	}),
+	putObjectRetention: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Put Object Retention",
+			description: "Places an Object Retention configuration on an object"
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { awsRegion, accessKey, bucket, objectKey, retentionMode, retainUntilDate, versionId, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const s3 = await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const retentionModePresent = retentionMode.length > 0;
+			const retainUntilDatePresent = retainUntilDate.length > 0;
+			if (retentionModePresent && !retainUntilDatePresent || !retentionModePresent && retainUntilDatePresent) throw new Error("Both Retention Mode and Retain Until Date must be set when either is set.");
+			const command = new _aws_sdk_client_s3.PutObjectRetentionCommand({
+				Bucket: bucket,
+				Key: objectKey,
+				Retention: retentionModePresent ? {
+					Mode: retentionMode,
+					RetainUntilDate: new Date(retainUntilDate)
+				} : {},
+				VersionId: versionId
+			});
+			return { data: await s3.send(command) };
+		},
+		inputs: putObjectRetentionInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: putObjectRetentionOutputSchema
+		}),
+		examplePerform: async () => putObjectRetentionExamplePayload,
+		examplePayload: putObjectRetentionExamplePayload
+	})
+};
+//#endregion
+//#region src/actions/objects/index.ts
+var objects_default = {
+	copyObject: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Copy Object",
+			description: "Copy an object in S3 from one location to another"
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { acl, awsRegion, accessKey, sourceBucket, destinationBucket, sourceKey, destinationKey, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const s3 = await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const command = new _aws_sdk_client_s3.CopyObjectCommand({
+				ACL: acl || null,
+				Bucket: destinationBucket,
+				CopySource: `${sourceBucket}/${sourceKey}`,
+				Key: destinationKey
+			});
+			return { data: await s3.send(command) };
+		},
+		inputs: copyObjectInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: copyObjectOutputSchema
+		}),
+		examplePerform: async () => copyObjectExamplePayload,
+		examplePayload: copyObjectExamplePayload
+	}),
+	deleteObject: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Delete Object",
+			description: "Delete an Object within an S3 Bucket"
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { awsRegion, accessKey, bucket, objectKey, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const s3 = await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const command = new _aws_sdk_client_s3.DeleteObjectCommand({
+				Bucket: bucket,
+				Key: objectKey
+			});
+			return { data: await s3.send(command) };
+		},
+		inputs: deleteObjectInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: deleteObjectOutputSchema
+		}),
+		examplePerform: async () => deleteObjectExamplePayload,
+		examplePayload: deleteObjectExamplePayload
+	}),
+	deleteObjects: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Delete Objects",
+			description: "Delete multiple objects from a bucket"
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { awsRegion, accessKey, bucket, objectKeys, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const s3 = await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const command = new _aws_sdk_client_s3.DeleteObjectsCommand({
+				Bucket: bucket,
+				Delete: { Objects: objectKeys }
+			});
+			return { data: await s3.send(command) };
+		},
+		inputs: deleteObjectsInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: deleteObjectsOutputSchema
+		}),
+		examplePerform: async () => deleteObjectsExamplePayload,
+		examplePayload: deleteObjectsExamplePayload
+	}),
+	generatePresignedUrl: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Generate Presigned URL",
+			description: "Generate a presigned URL that can be used to upload or download an object in S3"
+		},
+		inputs: generatePresignedUrlInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: generatePresignedUrlOutputSchema
+		}),
+		performSafety: "notAllowed",
+		perform: async (context, params) => {
+			return { data: await (0, _aws_sdk_s3_request_presigner.getSignedUrl)(await createS3Client({
+				awsConnection: params.accessKey,
+				awsRegion: params.awsRegion,
+				dynamicAccessKeyId: params.dynamicAccessKeyId,
+				dynamicSecretAccessKey: params.dynamicSecretAccessKey,
+				dynamicSessionToken: params.dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			}), params.actionType === "download" ? new _aws_sdk_client_s3.GetObjectCommand({
+				Bucket: params.bucket,
+				Key: params.objectKey
+			}) : new _aws_sdk_client_s3.PutObjectCommand({
+				Bucket: params.bucket,
+				Key: params.objectKey
+			}), { expiresIn: params.expirationSeconds }) };
+		},
+		examplePerform: async () => generatePresignedUrlExamplePayload,
+		examplePayload: generatePresignedUrlExamplePayload
+	}),
+	getObject: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get Object",
+			description: "Get the contents of an object"
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { awsRegion, accessKey, bucket, objectKey, versionId, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const s3 = await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const command = new _aws_sdk_client_s3.GetObjectCommand({
+				Bucket: bucket,
+				Key: objectKey,
+				VersionId: versionId
+			});
+			const response = await s3.send(command);
+			const objectBodyAsArray = await response.Body.transformToByteArray();
+			return {
+				data: Buffer.from(objectBodyAsArray),
+				contentType: response.ContentType
+			};
+		},
+		inputs: getObjectInputs,
+		examplePerform: async () => getObjectExamplePayload,
+		examplePayload: getObjectExamplePayload
+	}),
+	getObjectAttributes: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Get Object Attributes",
+			description: "Retrieves all the metadata from an object without returning the object itself"
+		},
+		performSafety: "safe",
+		perform: async (context, { awsRegion, accessKey, bucket, objectKey, versionId, objectAttributes, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const s3 = await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const command = new _aws_sdk_client_s3.GetObjectAttributesCommand({
+				Bucket: bucket,
+				Key: objectKey,
+				ObjectAttributes: objectAttributes,
+				VersionId: versionId
+			});
+			return { data: await s3.send(command) };
+		},
+		inputs: getObjectAttributesInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: getObjectAttributesOutputSchema
+		}),
+		examplePayload: getObjectAttributesExamplePayload
+	}),
+	headObject: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Head Object",
+			description: "Retrieve metadata from an object without returning the object itself"
+		},
+		performSafety: "safe",
+		perform: async (context, { awsRegion, accessKey, bucket, objectKey, versionId, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const s3 = await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const command = new _aws_sdk_client_s3.HeadObjectCommand({
+				Bucket: bucket,
+				Key: objectKey,
+				VersionId: versionId
+			});
+			return { data: await s3.send(command) };
+		},
+		inputs: headObjectInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: headObjectOutputSchema
+		}),
+		examplePayload: headObjectExamplePayload
+	}),
+	listObjects: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List Objects",
+			description: "List Objects in a Bucket"
+		},
+		performSafety: "safe",
+		perform: async (context, params) => {
+			const s3 = await createS3Client({
+				awsConnection: params.accessKey,
+				awsRegion: params.awsRegion,
+				dynamicAccessKeyId: params.dynamicAccessKeyId,
+				dynamicSecretAccessKey: params.dynamicSecretAccessKey,
+				dynamicSessionToken: params.dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const command = new _aws_sdk_client_s3.ListObjectsV2Command({
+				Bucket: params.bucket,
+				Prefix: params.prefix,
+				MaxKeys: params.pagination.maxKeys,
+				ContinuationToken: params.pagination.continuationToken
+			});
+			const response = await s3.send(command);
+			return { data: params.includeMetadata ? response : (response.Contents || []).map(({ Key }) => Key) };
+		},
+		inputs: listObjectsInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: listObjectsOutputSchema
+		}),
+		examplePayload: listObjectsExamplePayload
+	}),
+	putObject: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Put Object",
+			description: "Write an object to S3"
+		},
+		performSafety: "notAllowed",
+		perform: async (context, { acl, awsRegion, accessKey, bucket, fileContents, objectKey, tagging, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const s3 = await createS3Client({
+				awsConnection: accessKey,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken,
+				logger: context.logger,
+				debug: context.debug.enabled
+			});
+			const { data, contentType } = fileContents;
+			const command = new _aws_sdk_client_s3.PutObjectCommand({
+				ACL: acl || null,
+				Bucket: bucket,
+				Key: objectKey,
+				Body: data,
+				ContentType: contentType,
+				Tagging: encodeTags(tagging)
+			});
+			return { data: await s3.send(command) };
+		},
+		inputs: putObjectInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: putObjectOutputSchema
+		}),
+		examplePerform: async () => putObjectExamplePayload,
+		examplePayload: putObjectExamplePayload
+	})
+};
+//#endregion
+//#region src/actions/sns/index.ts
+var sns_default = {
+	bucketEventTriggerConfiguration: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Add Bucket SNS Event Notification",
+			description: "Add events to send notifications to SNS Topic"
+		},
+		performSafety: "notAllowed",
+		perform: async (_context, { awsRegion, awsConnection, snsTopicArn, eventsList, bucket, eventNotificationName, bucketOwnerAccountid, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			return { data: await processTopicConfiguration(await createS3Client({
+				awsConnection,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken
+			}), bucket, bucketOwnerAccountid, eventNotificationName, {
+				Id: eventNotificationName,
+				TopicArn: snsTopicArn,
+				Events: eventsList
+			}) };
+		},
+		inputs: bucketEventTriggerConfigurationInputs,
+		examplePerform: async () => bucketEventTriggerConfigurationExamplePayload,
+		examplePayload: bucketEventTriggerConfigurationExamplePayload
+	}),
+	createTopic: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Create SNS Topic for S3 Event Notification",
+			description: "Create an Amazon SNS Topic to be used with S3 Event Notifications"
+		},
+		performSafety: "notAllowed",
+		perform: async (_context, { awsConnection, awsRegion, name, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const sns = await createSNSClient({
+				awsConnection,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken
+			});
+			const command = new _aws_sdk_client_sns.CreateTopicCommand({
+				Name: name,
+				Attributes: { FifoTopic: "false" }
+			});
+			return { data: await sns.send(command) };
+		},
+		inputs: createTopicInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: createTopicOutputSchema
+		}),
+		examplePerform: async () => createTopicExamplePayload,
+		examplePayload: createTopicExamplePayload
+	}),
+	subscribeToTopic: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Subscribe to SNS Topic",
+			description: "Subscribe to an Amazon SNS Topic for S3 Event Notifications"
+		},
+		performSafety: "notAllowed",
+		perform: async (_context, { awsRegion, awsConnection, snsTopicArn, endpoint, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const sns = await createSNSClient({
+				awsConnection,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken
+			});
+			const subscribeCommand = new _aws_sdk_client_sns.SubscribeCommand({
+				Protocol: "https",
+				TopicArn: snsTopicArn,
+				Endpoint: endpoint
+			});
+			return { data: await sns.send(subscribeCommand) };
+		},
+		inputs: subscribeToTopicInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: subscribeToTopicOutputSchema
+		}),
+		examplePerform: async () => subscribeToTopicExamplePayload,
+		examplePayload: subscribeToTopicExamplePayload
+	}),
+	unsubscribeFromTopic: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Unsubscribe from SNS Topic",
+			description: "Unsubscribe from an Amazon SNS Topic for S3 Event Notifications"
+		},
+		performSafety: "notAllowed",
+		perform: async (_context, { awsConnection, awsRegion, subscriptionArn, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const sns = await createSNSClient({
+				awsConnection,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken
+			});
+			const command = new _aws_sdk_client_sns.UnsubscribeCommand({ SubscriptionArn: subscriptionArn });
+			return { data: await sns.send(command) };
+		},
+		inputs: unsubscribeFromTopicInputs,
+		examplePerform: async () => unsubscribeFromTopicExamplePayload,
+		examplePayload: unsubscribeFromTopicExamplePayload
+	}),
+	updateTopicPolicy: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Update SNS Topic Policy for S3 Event Notification",
+			description: "Update an Amazon SNS Topic Policy to grant S3 permission to publish"
+		},
+		performSafety: "notAllowed",
+		perform: async (_context, { awsConnection, awsRegion, snsTopicArn, bucketOwnerAccountid, bucket, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+			const sns = await createSNSClient({
+				awsConnection,
+				awsRegion,
+				dynamicAccessKeyId,
+				dynamicSecretAccessKey,
+				dynamicSessionToken
+			});
+			const policy = {
+				Version: "2012-10-17",
+				Id: "allow-s3-to-publish",
+				Statement: [{
+					Sid: "allow-s3-to-publish",
+					Effect: "Allow",
+					Principal: { Service: "s3.amazonaws.com" },
+					Action: ["SNS:Publish"],
+					Resource: snsTopicArn,
+					Condition: {
+						ArnLike: { "aws:SourceArn": `arn:aws:s3:*:*:${bucket}` },
+						StringEquals: { "aws:SourceAccount": bucketOwnerAccountid }
+					}
+				}]
+			};
+			const command = new _aws_sdk_client_sns.SetTopicAttributesCommand({
+				TopicArn: snsTopicArn,
+				AttributeName: "Policy",
+				AttributeValue: JSON.stringify(policy)
+			});
+			return { data: await sns.send(command) };
+		},
+		inputs: updateTopicPolicyInputs,
+		examplePerform: async () => updateTopicPolicyExamplePayload,
+		examplePayload: updateTopicPolicyExamplePayload
+	})
+};
+//#endregion
+//#region src/actions/uploadStreams/index.ts
+var uploadStreams_default = {
+	closeUploadStream: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Close Upload Stream",
+			description: "Close an upload stream"
+		},
+		inputs: closeUploadStreamInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: closeUploadStreamOutputSchema
+		}),
+		performSafety: "notAllowed",
+		perform: async ({ executionState }, params) => {
+			const { uploadFinisher, fileStream } = getUploadStream(executionState, params.uploadId);
+			fileStream.end();
+			await uploadFinisher;
+			return { data: null };
+		},
+		examplePerform: async () => closeUploadStreamExamplePayload,
+		examplePayload: closeUploadStreamExamplePayload
+	}),
+	createUploadStream: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Create Upload Stream",
+			description: "Create an upload stream to S3"
+		},
+		inputs: createUploadStreamInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: createUploadStreamOutputSchema
+		}),
+		performSafety: "notAllowed",
+		perform: async ({ executionState }, params) => {
+			const s3 = await createS3Client({
+				awsConnection: params.accessKey,
+				awsRegion: params.awsRegion,
+				dynamicAccessKeyId: params.dynamicAccessKeyId,
+				dynamicSecretAccessKey: params.dynamicSecretAccessKey,
+				dynamicSessionToken: params.dynamicSessionToken
+			});
+			const uploadId = (0, uuid.v4)();
+			const fileStream = new node_stream.PassThrough({ highWaterMark: 1024 * 1024 });
+			executionState[uploadId] = {
+				uploadFinisher: new _aws_sdk_lib_storage.Upload({
+					client: s3,
+					params: {
+						ACL: params.acl || null,
+						Bucket: params.bucket,
+						Key: params.objectKey,
+						Body: fileStream,
+						Tagging: encodeTags(params.tagging)
+					}
+				}).done(),
+				fileStream
+			};
+			return { data: uploadId };
+		},
+		examplePerform: async () => createUploadStreamExamplePayload,
+		examplePayload: createUploadStreamExamplePayload
+	}),
+	writeUploadStream: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "Write Upload Stream",
+			description: "Write to an upload stream"
+		},
+		inputs: writeUploadStreamInputs,
+		outputSchema: (0, _prismatic_io_spectral.outputSchema)({
+			type: "actionOutput",
+			schema: writeUploadStreamOutputSchema
+		}),
+		performSafety: "notAllowed",
+		perform: async ({ executionState }, params) => {
+			const { fileStream } = getUploadStream(executionState, params.uploadId);
+			await new Promise((resolve) => {
+				if (!fileStream.write(params.fileContents.data)) fileStream.once("drain", resolve);
+				else resolve(true);
+			});
+			return { data: null };
+		},
+		examplePerform: async () => writeUploadStreamExamplePayload,
+		examplePayload: writeUploadStreamExamplePayload
+	})
+};
+//#endregion
+//#region src/actions/index.ts
+var actions_default = {
+	...bucketNotifications_default,
+	...buckets_default,
+	...misc_default,
+	...multipartUploads_default,
+	...objectLock_default,
+	...objects_default,
+	...sns_default,
+	...uploadStreams_default
+};
+//#endregion
+//#region src/dataSources/index.ts
+var dataSources_default = {
+	selectBucket: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Bucket",
+			description: "A picklist of buckets in the AWS account."
+		},
+		dataSourceType: "picklist",
+		perform: async (_, params) => {
+			return { result: (await listAllBuckets(await createS3Client({
+				awsConnection: params.accessKey,
+				awsRegion: "",
+				dynamicAccessKeyId: params.dynamicAccessKeyId,
+				dynamicSecretAccessKey: params.dynamicSecretAccessKey,
+				dynamicSessionToken: params.dynamicSessionToken
+			}))).map((bucket) => ({
+				label: bucket.Name,
+				key: bucket.Name
+			})) };
+		},
+		inputs: selectBucketInputs,
+		examplePayload: selectBucketExamplePayload
+	}),
+	selectRegion
+};
+//#endregion
+//#region src/triggers/pollChangesFilesTrigger.ts
+const pollChangesFilesTrigger = (0, _prismatic_io_spectral.pollingTrigger)({
+	display: {
+		label: "New and Updated Files",
+		description: "Checks for new and updated files in a specified S3 bucket on a configured schedule."
+	},
+	inputs: pollChangesFilesTriggerInputs,
+	triggerResolverSupport: "valid",
+	batchConfig: { batchSize: 50 },
+	triggerResolver: {
+		resolveItems: (_context, { payload }) => resolvePolledFileChanges(payload.body.data),
+		getNextPaginationState: (_context, { payload }) => payload.paginationState ?? null
+	},
+	perform: async (context, payload, { accessKey, awsRegion, bucket, lookBackDate, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+		const isBatching = context.batch?.enabled === true;
+		const incoming = payload.paginationState;
+		const state = context.polling.getState();
+		const window = resolveFileListingWindow(state, incoming, isBatching, lookBackDate, (/* @__PURE__ */ new Date()).toISOString());
+		const windowIsEmpty = window.windowStart >= window.windowEnd;
+		const s3 = await createS3Client({
+			awsConnection: accessKey,
+			awsRegion,
+			dynamicAccessKeyId,
+			dynamicSecretAccessKey,
+			dynamicSessionToken,
+			logger: context.logger,
+			debug: context.debug.enabled
+		});
+		const { keys, startAfter } = windowIsEmpty ? {
+			keys: [],
+			startAfter: void 0
+		} : await listObjectsInWindow(s3, bucket, window, isBatching);
+		const nextCursor = startAfter ? {
+			windowStart: window.windowStart,
+			windowEnd: window.windowEnd,
+			startAfter
+		} : void 0;
+		context.polling.setState(nextCursor ? {
+			...state.lastPolledAt ? { lastPolledAt: state.lastPolledAt } : {},
+			cursor: nextCursor
+		} : { lastPolledAt: windowIsEmpty ? window.windowStart : window.windowEnd });
+		if (context.debug.enabled) context.logger.debug(`Listed ${bucket} from ${window.startAfter ?? "the first key"}: ${keys.length} keys modified between ${window.windowStart} and ${window.windowEnd}; ${nextCursor ? "more pages remain" : "window exhausted"}`);
+		return {
+			payload: {
+				...payload,
+				paginationState: nextCursor,
+				body: { data: keys }
+			},
+			polledNoChanges: keys.length === 0 && !nextCursor && !incoming
+		};
+	},
+	examplePayload: pollChangesFilesTriggerExamplePayload
+});
+//#endregion
+//#region src/triggers/pollNewBucketsTrigger.ts
+const pollNewBucketsTrigger = (0, _prismatic_io_spectral.pollingTrigger)({
+	display: {
+		label: "New Buckets",
+		description: "Checks for new buckets in Amazon S3 on a configured schedule."
+	},
+	inputs: pollNewBucketsTriggerInputs,
+	triggerResolverSupport: "valid",
+	batchConfig: { batchSize: 50 },
+	triggerResolver: { resolveItems: (_context, { payload }) => resolvePolledBucketChanges(payload.body.data) },
+	perform: async (context, payload, { accessKey, awsRegion, lookBackDate, dynamicAccessKeyId, dynamicSecretAccessKey, dynamicSessionToken }) => {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const { since, inclusive } = readLastPolledAt(context, now, lookBackDate);
+		const changes = await listBucketsCreatedSince(await createS3Client({
+			awsConnection: accessKey,
+			awsRegion,
+			dynamicAccessKeyId,
+			dynamicSecretAccessKey,
+			dynamicSessionToken,
+			logger: context.logger,
+			debug: context.debug.enabled
+		}), since, inclusive);
+		context.polling.setState({ lastPolledAt: now });
+		return {
+			payload: {
+				...payload,
+				body: { data: changes }
+			},
+			polledNoChanges: changes.length === 0
+		};
+	},
+	examplePayload: pollNewBucketsTriggerExamplePayload
+});
+//#endregion
+//#region src/triggers/index.ts
+var triggers_default = {
+	snsS3NotificationWebhook: (0, _prismatic_io_spectral.trigger)({
+		display: {
+			label: "Webhook",
+			description: "Receive Amazon SNS notifications for Amazon S3 events. Confirms SNS subscription requests automatically."
+		},
+		allowsBranching: true,
+		staticBranchNames: ["Notification", "Subscribe"],
+		perform: async (_context, payload, { expectedTopicArn }) => {
+			const bodyData = _prismatic_io_spectral.util.types.toString(payload.rawBody.data);
+			if (!bodyData.length) throw new Error("Missing data in payload");
+			const data = JSON.parse(bodyData);
+			const eventType = data.Type;
+			if (!eventType) throw new Error("Event type not received");
+			if (eventType !== "Notification" && eventType !== "SubscriptionConfirmation") throw new Error(`Message type was not "Notification" or "SubscriptionConfirmation", but "${eventType}" instead.`);
+			await verifySnsMessageSignature(data);
+			if (expectedTopicArn && data.TopicArn !== expectedTopicArn) throw new Error(`Amazon SNS message TopicArn "${data.TopicArn}" did not match the configured Topic ARN; the message was rejected.`);
+			if (eventType === "SubscriptionConfirmation") {
+				assertSnsUrl(data.SubscribeURL, "SubscribeURL");
+				await (0, _prismatic_io_spectral_http.createClient)({ baseUrl: data.SubscribeURL }).get("");
+				return {
+					branch: "Subscribe",
+					payload: {
+						...payload,
+						body: { data }
+					}
+				};
+			}
+			return {
+				branch: "Notification",
+				payload: {
+					...payload,
+					body: { data }
+				}
+			};
+		},
+		inputs: snsS3NotificationWebhookInputs,
+		synchronousResponseSupport: "invalid",
+		scheduleSupport: "invalid",
+		examplePayload: snsS3NotificationWebhookExamplePayload
+	}),
+	pollChangesFilesTrigger,
+	pollNewBucketsTrigger
+};
+//#endregion
+//#region src/index.ts
+var src_default = (0, _prismatic_io_spectral.component)({
+	key: "aws-s3",
+	documentationUrl: "https://prismatic.io/docs/components/aws-s3/",
+	public: true,
+	display: {
+		label: "Amazon S3",
+		description: "Manage objects and buckets in Amazon S3.",
+		iconPath: "icon.png",
+		category: "Data Platforms"
+	},
+	connections: connections_default,
+	actions: actions_default,
+	dataSources: dataSources_default,
+	triggers: triggers_default,
+	hooks: { error: _prismatic_io_spectral_http.handleErrors }
+});
+//#endregion
+//#region npm-dist/.entry.ts
+var _entry_default = (0, _prismatic_io_spectral.callableComponent)(src_default);
+//#endregion
+module.exports = _entry_default;