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

package/npm-dist/index.cjs

@@ -0,0 +1,1326 @@
+//#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 _aws_sdk_client_sns = require("@aws-sdk/client-sns");
+let _aws_sdk_client_sts = require("@aws-sdk/client-sts");
+let sns_validator = require("sns-validator");
+sns_validator = __toESM(sns_validator);
+let _prismatic_io_spectral_http = require("@prismatic-io/spectral/http");
+//#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/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$1 = (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
+});
+(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."
+});
+(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."
+});
+(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.ts
+const accessKeySecretPair = (0, _prismatic_io_spectral.connection)({
+	key: "apiKeySecret",
+	display: {
+		label: "Access Key",
+		description: "Access Key connection for AWS SNS"
+	},
+	inputs: {
+		accessKeyId: {
+			label: "Access Key ID",
+			placeholder: "Enter Access Key ID",
+			type: "string",
+			required: true,
+			shown: true,
+			comments: "An AWS IAM Access Key ID for authenticating with Amazon SNS. [Learn more](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html)",
+			example: "AKIAIOSFODNN7EXAMPLE"
+		},
+		secretAccessKey: {
+			label: "Secret Access Key",
+			placeholder: "Enter Secret Access Key",
+			type: "password",
+			required: true,
+			shown: true,
+			comments: "An AWS IAM Secret Access Key corresponding to the Access Key ID. [Learn more](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html)",
+			example: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
+		}
+	}
+});
+var connections_default = [accessKeySecretPair, assumeRoleConnection];
+//#endregion
+//#region src/helpers/index.ts
+const validateConnection = (connection) => {
+	if (![accessKeySecretPair.key, assumeRoleConnection.key].includes(connection.key)) throw new _prismatic_io_spectral.ConnectionError(connection, `Unsupported connection method ${connection.key}.`);
+};
+const getCredentials = (connection) => {
+	validateConnection(connection);
+	return {
+		accessKeyId: toTrimmedString(connection.fields.accessKeyId),
+		secretAccessKey: toTrimmedString(connection.fields.secretAccessKey)
+	};
+};
+//#endregion
+//#region src/client.ts
+const createSNSClient = async ({ awsRegion, awsConnection, debug, logger }) => {
+	const { accessKeyId, secretAccessKey } = getCredentials(awsConnection);
+	const credentials = awsConnection.key === assumeRoleConnection.key ? await assumeRole(awsRegion, accessKeyId, secretAccessKey, toTrimmedString(awsConnection.fields.roleARN), toOptionalString(awsConnection.fields?.externalId)) : {
+		accessKeyId,
+		secretAccessKey
+	};
+	const region = awsRegion.length > 0 ? awsRegion : void 0;
+	try {
+		return new _aws_sdk_client_sns.SNSClient({
+			region,
+			credentials,
+			logger: debug ? logger : void 0
+		});
+	} catch (err) {
+		throw new _prismatic_io_spectral.ConnectionError(awsConnection, `Invalid AWS Credentials have been configured. This is sometimes caused by missing characters from a copy/paste. Original AWS error message: ${err.message}`);
+	}
+};
+//#endregion
+//#region src/constants/batchMessageEntriesExample.ts
+const batchMessageEntriesExample = [
+	{
+		Id: "AN_ID",
+		Message: "A_MESSAGE",
+		Subject: "A_SUBJECT",
+		MessageStructure: "A_MESSAGE_STRUCTURE",
+		MessageAttributes: { "<keys>": {
+			DataType: "Number",
+			StringValue: "123"
+		} },
+		MessageDeduplicationId: "A_MESSAGE_DEDUPLICATION_ID",
+		MessageGroupId: "A_MESSAGE_GROUP_ID"
+	},
+	{
+		Id: "AN_ID",
+		Message: "A_MESSAGE",
+		Subject: "A_SUBJECT",
+		MessageStructure: "A_MESSAGE_STRUCTURE",
+		MessageAttributes: { "<keys>": {
+			DataType: "String.Array",
+			StringValue: "[\"test\", true, 123]"
+		} },
+		MessageDeduplicationId: "A_MESSAGE_DEDUPLICATION_ID",
+		MessageGroupId: "A_MESSAGE_GROUP_ID"
+	},
+	{
+		Id: "AN_ID",
+		Message: "A_MESSAGE",
+		Subject: "A_SUBJECT",
+		MessageStructure: "A_MESSAGE_STRUCTURE",
+		MessageAttributes: { "<keys>": {
+			DataType: "String",
+			StringValue: "test"
+		} },
+		MessageDeduplicationId: "A_MESSAGE_DEDUPLICATION_ID",
+		MessageGroupId: "A_MESSAGE_GROUP_ID"
+	},
+	{
+		Id: "AN_ID",
+		Message: "A_MESSAGE",
+		Subject: "A_SUBJECT",
+		MessageStructure: "A_MESSAGE_STRUCTURE",
+		MessageAttributes: { "<keys>": {
+			DataType: "Binary",
+			BinaryValue: "ADD A BUFFER HERE WITH A TEMPLATE FIELD"
+		} },
+		MessageDeduplicationId: "A_MESSAGE_DEDUPLICATION_ID",
+		MessageGroupId: "A_MESSAGE_GROUP_ID"
+	}
+];
+//#endregion
+//#region src/constants.ts
+const STORE_KEY = "crossFlowState";
+//#endregion
+//#region src/utils.ts
+const cleanStringInput = toOptionalString;
+const lowerCaseHeaders = (headers) => Object.entries(headers).reduce((result, [key, val]) => {
+	result[key.toLowerCase()] = val;
+	return result;
+}, {});
+const fetchTopics = async (sns, fetchAllTopics, nextToken) => {
+	const command = new _aws_sdk_client_sns.ListTopicsCommand(fetchAllTopics ? {} : { NextToken: nextToken });
+	const response = await sns.send(command);
+	if (fetchAllTopics) {
+		const allTopics = response.Topics || [];
+		let nextToken = response.NextToken || void 0;
+		while (nextToken) {
+			const command = new _aws_sdk_client_sns.ListTopicsCommand({ NextToken: nextToken });
+			const response = await sns.send(command);
+			allTopics.push(...response.Topics);
+			nextToken = response.NextToken;
+		}
+		response.Topics = allTopics;
+		response.NextToken = void 0;
+	}
+	return response;
+};
+const fetchSubscriptions = async (sns, topicArn, fetchAllSubscriptions, nextToken) => {
+	const command = new _aws_sdk_client_sns.ListSubscriptionsByTopicCommand({
+		TopicArn: topicArn,
+		NextToken: fetchAllSubscriptions ? void 0 : nextToken
+	});
+	const response = await sns.send(command);
+	if (fetchAllSubscriptions) {
+		const allSubscriptions = response.Subscriptions || [];
+		let nextToken = response.NextToken || void 0;
+		while (nextToken) {
+			const command = new _aws_sdk_client_sns.ListSubscriptionsByTopicCommand({
+				TopicArn: topicArn,
+				NextToken: nextToken
+			});
+			const response = await sns.send(command);
+			allSubscriptions.push(...response.Subscriptions);
+			nextToken = response.NextToken;
+		}
+		response.Subscriptions = allSubscriptions;
+		response.NextToken = void 0;
+	}
+	return response;
+};
+const webhookPerformFn = async ({ logger, debug: { enabled: debug } }, payload, { parseMessage }) => {
+	const validator = new sns_validator.default();
+	const originalHeaders = payload.headers;
+	payload.headers = lowerCaseHeaders(payload.headers);
+	const _parseMessage = payload.headers["x-amz-sns-message-type"] === "Notification" && _prismatic_io_spectral.util.types.toBool(parseMessage);
+	const validateMessage = async ({ rawBody: { data }, headers }) => {
+		if (headers["x-amz-sns-rawdelivery"] === "true") return _parseMessage ? JSON.parse(_prismatic_io_spectral.util.types.toString(data) || "{}") : _prismatic_io_spectral.util.types.toString(data);
+		return await new Promise((resolve, reject) => {
+			validator.validate(_prismatic_io_spectral.util.types.toString(data), (error, message) => {
+				if (error) {
+					logger.error(`SNS Message could not be verified with error: ${error}`);
+					return reject(error);
+				}
+				return resolve(message);
+			});
+		});
+	};
+	const message = await validateMessage(payload);
+	let branch = "";
+	const messageType = payload.headers["x-amz-sns-message-type"];
+	const client = (0, _prismatic_io_spectral_http.createClient)({
+		baseUrl: message.SubscribeURL,
+		debug
+	});
+	switch (messageType) {
+		case "SubscriptionConfirmation":
+			await client.get("");
+			branch = "Subscribe";
+			break;
+		case "UnsubscribeConfirmation":
+			await client.get("");
+			branch = "Unsubscribe";
+			break;
+		case "Notification":
+			branch = "Notification";
+			break;
+		default: throw new Error(`Message type was not "Notification", "SubscriptionConfirmation" or "UnsubscribeConfirmation", but "${messageType}" instead.`);
+	}
+	if (_parseMessage && payload.headers["x-amz-sns-rawdelivery"] !== "true") try {
+		message.Message = JSON.parse(_prismatic_io_spectral.util.types.toString(message.Message));
+	} catch {
+		throw new Error(`Received a message that is not valid JSON: ${message.Message}`);
+	}
+	payload.headers = originalHeaders;
+	return {
+		branch,
+		payload: {
+			...payload,
+			body: { data: message }
+		}
+	};
+};
+const getStateKey = (context) => context.flow.stableId;
+const getLegacyStateKey = (context) => {
+	return `${context.webhookUrls[context.flow.name]?.split("/").pop()}:awsSnsTopicSubscription`;
+};
+const resolveSubscriptionState = (context) => {
+	const store = context[STORE_KEY];
+	const current = store[getStateKey(context)]?.subscriptionArn;
+	if (current) return {
+		subscriptionArn: _prismatic_io_spectral.util.types.toString(current),
+		isLegacy: false
+	};
+	const legacy = store[getLegacyStateKey(context)]?.subscriptionArn;
+	if (legacy) return {
+		subscriptionArn: _prismatic_io_spectral.util.types.toString(legacy),
+		isLegacy: true
+	};
+	return {
+		subscriptionArn: "",
+		isLegacy: false
+	};
+};
+const clearSubscriptionState = (context, isLegacy) => {
+	return { [isLegacy ? getLegacyStateKey(context) : getStateKey(context)]: null };
+};
+//#endregion
+//#region src/inputs.ts
+const name = (0, _prismatic_io_spectral.input)({
+	label: "Name",
+	type: "string",
+	required: true,
+	placeholder: "Enter topic name",
+	example: "MyExampleTopic",
+	comments: "The name of the SNS topic to create."
+});
+const topicArn = (0, _prismatic_io_spectral.input)({
+	label: "Topic ARN",
+	type: "string",
+	required: true,
+	placeholder: "Enter topic ARN",
+	example: "arn:aws:sns:us-east-1:123456789012:MyExampleTopic",
+	comments: "The Amazon Resource Name (ARN) of the SNS topic. [Learn more](https://docs.aws.amazon.com/sns/latest/api/API_CreateTopic.html)",
+	dataSource: "selectTopic",
+	clean: _prismatic_io_spectral.util.types.toString
+});
+const message = (0, _prismatic_io_spectral.input)({
+	label: "Message",
+	type: "string",
+	required: true,
+	placeholder: "Enter message content",
+	example: "Your order has been shipped!",
+	comments: "The message content to send to the topic or endpoint. [Learn more](https://docs.aws.amazon.com/sns/latest/api/API_Publish.html)"
+});
+const protocol = (0, _prismatic_io_spectral.input)({
+	label: "Protocol",
+	type: "string",
+	required: true,
+	default: "https",
+	model: [
+		{
+			label: "application",
+			value: "application"
+		},
+		{
+			label: "email",
+			value: "email"
+		},
+		{
+			label: "email-json",
+			value: "email-json"
+		},
+		{
+			label: "firehose",
+			value: "firehose"
+		},
+		{
+			label: "http",
+			value: "http"
+		},
+		{
+			label: "https",
+			value: "https"
+		},
+		{
+			label: "lambda",
+			value: "lambda"
+		},
+		{
+			label: "sms",
+			value: "sms"
+		},
+		{
+			label: "sqs",
+			value: "sqs"
+		}
+	],
+	comments: "The protocol to use for delivering messages to the endpoint (application, email, email-json, firehose, http, https, lambda, sms, or sqs). [Learn more](https://docs.aws.amazon.com/sns/latest/api/API_Subscribe.html)"
+});
+const endpoint = (0, _prismatic_io_spectral.input)({
+	label: "Endpoint",
+	type: "string",
+	required: true,
+	placeholder: "Enter endpoint",
+	example: "https://example.com/webhook",
+	comments: "The endpoint to receive notifications. Format depends on protocol: email address (email@example.com), URL (https://example.com), phone number (+12065551234), or ARN (arn:aws:sqs:us-east-1:123456789012:MyQueue). [Learn more](https://docs.aws.amazon.com/sns/latest/api/API_Subscribe.html)"
+});
+const subscriptionArn = (0, _prismatic_io_spectral.input)({
+	label: "Subscription ARN",
+	type: "string",
+	required: true,
+	placeholder: "Enter subscription ARN",
+	example: "arn:aws:sns:us-east-1:123456789012:MyExampleTopic:12345678-1234-1234-1234-123456789012",
+	comments: "The Amazon Resource Name (ARN) of the subscription. [Learn more](https://docs.aws.amazon.com/sns/latest/api/API_Unsubscribe.html)",
+	clean: _prismatic_io_spectral.util.types.toString,
+	dataSource: "selectSubscription"
+});
+const phoneNumber = (0, _prismatic_io_spectral.input)({
+	label: "Phone Number",
+	type: "string",
+	required: true,
+	placeholder: "Enter phone number (+12065551234)",
+	example: "+12065551234",
+	comments: "The phone number in E.164 format (e.g., +12065551234) to receive SMS messages. [Learn more](https://docs.aws.amazon.com/sns/latest/dg/sms_publish-to-phone.html)"
+});
+const messageAttributes = (0, _prismatic_io_spectral.input)({
+	label: "Message Attributes",
+	type: "string",
+	required: false,
+	collection: "keyvaluelist",
+	placeholder: "Enter key-value pairs",
+	example: "{\"name\": \"John Doe\", \"age\": \"30\"}",
+	comments: "Optional message attributes as key-value pairs. The value will be automatically typed (String, Number, String.Array, or Binary for Buffer). For binary data, provide a Buffer from a previous step. [Learn more](https://docs.aws.amazon.com/sns/latest/api/API_MessageAttributeValue.html)"
+});
+const parseMessage = (0, _prismatic_io_spectral.input)({
+	label: "Parse Message",
+	type: "boolean",
+	required: true,
+	default: "false",
+	comments: "When enabled, the message from SNS will be parsed as JSON and returned. When disabled, it will be passed as received."
+});
+(0, _prismatic_io_spectral.input)({
+	label: "Max Items",
+	type: "string",
+	required: false,
+	placeholder: "Enter maximum items (1-50)",
+	example: "20",
+	comments: "The maximum number of items to return per request. Valid values: 1-50."
+});
+const nextToken = (0, _prismatic_io_spectral.input)({
+	label: "Next Token",
+	type: "string",
+	required: false,
+	placeholder: "Enter pagination token",
+	example: "lslTXFcbLQKkb0vP9Kgh5hy0Y0OnC7Z9ZPHPwPmMnxSk3eiDRMkct7D8E",
+	comments: "The pagination token returned by a previous request to retrieve the next page of results.",
+	clean: cleanStringInput
+});
+const connectionInput = (0, _prismatic_io_spectral.input)({
+	label: "Connection",
+	type: "connection",
+	required: true,
+	comments: "The Amazon SNS connection to use."
+});
+const publishBatchEntries = (0, _prismatic_io_spectral.input)({
+	label: "Message Entries",
+	type: "code",
+	language: "json",
+	required: true,
+	default: JSON.stringify(batchMessageEntriesExample, null, 2),
+	comments: "An array of message entries to publish in batch. Each entry must include an Id and Message. For binary messages, add a Template Field containing a Buffer to the BinaryValue attribute. [Learn more](https://docs.aws.amazon.com/sns/latest/dg/sns-message-attributes.html)"
+});
+const fetchAll = (0, _prismatic_io_spectral.input)({
+	label: "Fetch All",
+	type: "boolean",
+	required: true,
+	default: "false",
+	clean: _prismatic_io_spectral.util.types.toBool
+});
+const fetchAllTopics = {
+	...fetchAll,
+	comments: "When set to true, fetches all paginated topics. When false, only 100 topics will be returned."
+};
+const fetchAllSubscriptions = {
+	...fetchAll,
+	comments: "When set to true, fetches all paginated subscriptions. When false, only 100 subscriptions will be returned."
+};
+//#endregion
+//#region src/examplePayloads.ts
+const createTopicExamplePayload = { data: { TopicArn: "arn:aws:sns:us-east-1:123456789012:MyExampleTopic" } };
+const publishMessageExamplePayload = { data: {
+	MessageId: "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+	SequenceNumber: "10000000000000001000"
+} };
+const publishSmsExamplePayload = { data: { MessageId: "b2c3d4e5-f6a7-8901-bcde-f12345678901" } };
+const publishBatchMessagesExamplePayload = { data: {
+	$metadata: {
+		httpStatusCode: 200,
+		requestId: "3df5ab1c-8e8a-426f-a2d1-bd7a39ef8651",
+		attempts: 1,
+		totalRetryDelay: 0
+	},
+	Successful: [{
+		Id: "msg-1",
+		MessageId: "c3d4e5f6-a7b8-9012-cdef-123456789012",
+		SequenceNumber: "10000000000000001001"
+	}, {
+		Id: "msg-2",
+		MessageId: "d4e5f6a7-b8c9-0123-def1-234567890123",
+		SequenceNumber: "10000000000000001002"
+	}],
+	Failed: [{
+		Id: "msg-3",
+		Code: "InvalidParameter",
+		Message: "Invalid message structure",
+		SenderFault: true
+	}]
+} };
+const subscribeExamplePayload = { data: { SubscriptionArn: "arn:aws:sns:us-east-1:123456789012:MyExampleTopic:a1b2c3d4-e5f6-7890-abcd-ef1234567890" } };
+const unsubscribeExamplePayload = { data: {} };
+const listTopicsExamplePayload = { data: {
+	Topics: [
+		{ TopicArn: "arn:aws:sns:us-east-1:123456789012:MyExampleTopic" },
+		{ TopicArn: "arn:aws:sns:us-east-1:123456789012:AnotherTopic" },
+		{ TopicArn: "arn:aws:sns:us-east-1:123456789012:ProductionAlerts" }
+	],
+	NextToken: "AAEBAf/8v+7MSvN8MkD9xZHCrFKL6RQ7UHJ9PJhWOH5Yqvf1H8EXAMPLE"
+} };
+const getTopicAttributesExamplePayload = { data: { Attributes: {
+	TopicArn: "arn:aws:sns:us-east-1:123456789012:MyExampleTopic",
+	Owner: "123456789012",
+	Policy: "{\"Version\":\"2012-10-17\",\"Id\":\"__default_policy_ID\",\"Statement\":[{\"Sid\":\"__default_statement_ID\",\"Effect\":\"Allow\",\"Principal\":{\"AWS\":\"*\"},\"Action\":[\"SNS:GetTopicAttributes\",\"SNS:SetTopicAttributes\",\"SNS:AddPermission\",\"SNS:RemovePermission\",\"SNS:DeleteTopic\",\"SNS:Subscribe\",\"SNS:ListSubscriptionsByTopic\",\"SNS:Publish\"],\"Resource\":\"arn:aws:sns:us-east-1:123456789012:MyExampleTopic\",\"Condition\":{\"StringEquals\":{\"AWS:SourceOwner\":\"123456789012\"}}}]}",
+	DisplayName: "My Example Topic",
+	SubscriptionsPending: "0",
+	SubscriptionsConfirmed: "3",
+	SubscriptionsDeleted: "0",
+	DeliveryPolicy: "{\"http\":{\"defaultHealthyRetryPolicy\":{\"minDelayTarget\":20,\"maxDelayTarget\":20,\"numRetries\":3,\"numMaxDelayRetries\":0,\"numNoDelayRetries\":0,\"numMinDelayRetries\":0,\"backoffFunction\":\"linear\"},\"disableSubscriptionOverrides\":false}}",
+	EffectiveDeliveryPolicy: "{\"http\":{\"defaultHealthyRetryPolicy\":{\"minDelayTarget\":20,\"maxDelayTarget\":20,\"numRetries\":3,\"numMaxDelayRetries\":0,\"numNoDelayRetries\":0,\"numMinDelayRetries\":0,\"backoffFunction\":\"linear\"},\"disableSubscriptionOverrides\":false}}",
+	TracingConfig: "PassThrough",
+	ContentBasedDeduplication: "false",
+	FifoTopic: "false"
+} } };
+const listSubscriptionsExamplePayload = { data: {
+	Subscriptions: [
+		{
+			SubscriptionArn: "arn:aws:sns:us-east-1:123456789012:MyExampleTopic:a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+			Owner: "123456789012",
+			Protocol: "https",
+			Endpoint: "https://example.com/webhook",
+			TopicArn: "arn:aws:sns:us-east-1:123456789012:MyExampleTopic"
+		},
+		{
+			SubscriptionArn: "arn:aws:sns:us-east-1:123456789012:MyExampleTopic:b2c3d4e5-f6a7-8901-bcde-f12345678901",
+			Owner: "123456789012",
+			Protocol: "sqs",
+			Endpoint: "arn:aws:sqs:us-east-1:123456789012:MyQueue",
+			TopicArn: "arn:aws:sns:us-east-1:123456789012:MyExampleTopic"
+		},
+		{
+			SubscriptionArn: "PendingConfirmation",
+			Owner: "123456789012",
+			Protocol: "email",
+			Endpoint: "admin@example.com",
+			TopicArn: "arn:aws:sns:us-east-1:123456789012:MyExampleTopic"
+		},
+		{
+			SubscriptionArn: "PendingConfirmation",
+			Owner: "123456789012",
+			Protocol: "sms",
+			Endpoint: "+12125551234",
+			TopicArn: "arn:aws:sns:us-east-1:123456789012:MyExampleTopic"
+		}
+	],
+	NextToken: "AAEBAf/8v+7MSvN8MkD9xZHCrFKL6RQ7UHJ9PJhWOH5Yqvf1H8EXAMPLE"
+} };
+const deleteTopicExamplePayload = { data: {} };
+const listOptOutNumbersExamplePayload = { data: {
+	phoneNumbers: [
+		"+12125551001",
+		"+12125551002",
+		"+12125551003"
+	],
+	nextToken: "AAEBAf/8v+7MSvN8MkD9xZHCrFKL6RQ7UHJ9PJhWOH5Yqvf1H8EXAMPLE"
+} };
+//#endregion
+//#region src/actions/createTopic.ts
+const createTopic = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Create Topic",
+		description: "Create an Amazon SNS Topic"
+	},
+	perform: async ({ logger, debug: { enabled: debug } }, { awsConnection, awsRegion, name }) => {
+		const sns = await createSNSClient({
+			awsConnection,
+			awsRegion,
+			debug,
+			logger
+		});
+		const command = new _aws_sdk_client_sns.CreateTopicCommand({ Name: _prismatic_io_spectral.util.types.toString(name) });
+		return { data: await sns.send(command) };
+	},
+	inputs: {
+		awsRegion: awsRegion$1,
+		name,
+		awsConnection: connectionInput
+	},
+	examplePayload: createTopicExamplePayload
+});
+//#endregion
+//#region src/actions/deleteTopics.ts
+const deleteTopic = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Delete Topic",
+		description: "Delete an Amazon SNS Topic"
+	},
+	perform: async ({ logger, debug: { enabled: debug } }, { awsConnection, awsRegion, topicArn }) => {
+		const sns = await createSNSClient({
+			awsConnection,
+			awsRegion,
+			debug,
+			logger
+		});
+		const command = new _aws_sdk_client_sns.DeleteTopicCommand({ TopicArn: topicArn });
+		return { data: await sns.send(command) };
+	},
+	inputs: {
+		awsRegion: awsRegion$1,
+		topicArn,
+		awsConnection: connectionInput
+	},
+	examplePayload: deleteTopicExamplePayload
+});
+//#endregion
+//#region src/actions/getTopicAttributes.ts
+const getTopicAttributes = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Get Topic Attributes",
+		description: "Retrieves the attributes of an Amazon SNS Topic."
+	},
+	perform: async ({ logger, debug: { enabled: debug } }, { awsConnection, awsRegion, topicArn }) => {
+		const sns = await createSNSClient({
+			awsConnection,
+			awsRegion,
+			debug,
+			logger
+		});
+		const command = new _aws_sdk_client_sns.GetTopicAttributesCommand({ TopicArn: topicArn });
+		return { data: await sns.send(command) };
+	},
+	inputs: {
+		awsRegion: awsRegion$1,
+		topicArn,
+		awsConnection: connectionInput
+	},
+	examplePayload: getTopicAttributesExamplePayload
+});
+//#endregion
+//#region src/actions/listTopics.ts
+const listTopics = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "List Topics",
+		description: "List available Amazon SNS Topics"
+	},
+	perform: async ({ logger, debug: { enabled: debug } }, { awsConnection, awsRegion, nextToken, fetchAllTopics }) => {
+		return { data: await fetchTopics(await createSNSClient({
+			awsConnection,
+			awsRegion,
+			debug,
+			logger
+		}), fetchAllTopics, nextToken) };
+	},
+	inputs: {
+		awsConnection: connectionInput,
+		awsRegion: awsRegion$1,
+		fetchAllTopics,
+		nextToken
+	},
+	examplePayload: listTopicsExamplePayload
+});
+//#endregion
+//#region src/actions/publishMessage.ts
+const getAttributeType = (input) => {
+	if (typeof input === "string") {
+		if (_prismatic_io_spectral.util.types.isNumber(input)) return {
+			DataType: "Number",
+			StringValue: input
+		};
+		if (_prismatic_io_spectral.util.types.isJSON(input)) try {
+			const array = JSON.parse(input);
+			if (Array.isArray(array)) return {
+				DataType: "String.Array",
+				StringValue: JSON.stringify(array)
+			};
+		} catch (_error) {}
+		return {
+			DataType: "String",
+			StringValue: input
+		};
+	}
+	if (Buffer.isBuffer(input)) return {
+		DataType: "Binary",
+		BinaryValue: input
+	};
+	return {
+		DataType: "String",
+		StringValue: JSON.stringify(input)
+	};
+};
+const attributeReducer = (kvpList = []) => {
+	return kvpList.reduce((result, { key, value }) => {
+		result[key] = getAttributeType(value);
+		return result;
+	}, {});
+};
+const publishMessage = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Publish Message",
+		description: "Publish a message to an Amazon SNS Topic"
+	},
+	perform: async ({ logger, debug: { enabled: debug } }, { awsConnection, awsRegion, message, topicArn, messageAttributes }) => {
+		const sns = await createSNSClient({
+			awsConnection,
+			awsRegion,
+			debug,
+			logger
+		});
+		const command = new _aws_sdk_client_sns.PublishCommand({
+			Message: _prismatic_io_spectral.util.types.toString(message),
+			MessageAttributes: attributeReducer(messageAttributes),
+			TopicArn: topicArn
+		});
+		return { data: await sns.send(command) };
+	},
+	inputs: {
+		awsRegion: awsRegion$1,
+		message,
+		topicArn,
+		messageAttributes,
+		awsConnection: connectionInput
+	},
+	examplePayload: publishMessageExamplePayload
+});
+//#endregion
+//#region src/actions/publishBatchMessages.ts
+const processBinaryValueIfPresent = (parsedEntries) => parsedEntries.map((entry) => {
+	if (entry.MessageAttributes) {
+		for (const key in entry.MessageAttributes) if (entry.MessageAttributes[key].BinaryValue && _prismatic_io_spectral.util.types.isBufferDataPayload(entry.MessageAttributes[key].BinaryValue)) entry.MessageAttributes[key].BinaryValue = Buffer.from(entry.MessageAttributes[key].BinaryValue.data);
+	}
+	return entry;
+});
+const publishBatchMessages = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Publish Batch Messages",
+		description: "Publishes up to ten messages to the specified Amazon SNS Topic"
+	},
+	perform: async ({ logger, debug: { enabled: debug } }, { awsConnection, awsRegion, topicArn, publishBatchEntries }) => {
+		const sns = await createSNSClient({
+			awsConnection,
+			awsRegion,
+			debug,
+			logger
+		});
+		let parsedEntries = JSON.parse(publishBatchEntries);
+		if (!Array.isArray(parsedEntries)) throw new Error("Invalid Message Entries");
+		parsedEntries = processBinaryValueIfPresent(parsedEntries);
+		const batchCommand = new _aws_sdk_client_sns.PublishBatchCommand({
+			TopicArn: topicArn,
+			PublishBatchRequestEntries: parsedEntries
+		});
+		return { data: await sns.send(batchCommand) };
+	},
+	inputs: {
+		awsRegion: awsRegion$1,
+		topicArn,
+		publishBatchEntries,
+		awsConnection: connectionInput
+	},
+	examplePayload: publishBatchMessagesExamplePayload
+});
+//#endregion
+//#region src/actions/listSubscriptions.ts
+const listSubscriptions = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "List Subscriptions",
+		description: "Retrieve the subscriptions of an Amazon SNS Topic"
+	},
+	perform: async ({ logger, debug: { enabled: debug } }, { awsConnection, awsRegion, topicArn, nextToken, fetchAllSubscriptions }) => {
+		return { data: await fetchSubscriptions(await createSNSClient({
+			awsConnection,
+			awsRegion,
+			debug,
+			logger
+		}), topicArn, fetchAllSubscriptions, nextToken) };
+	},
+	inputs: {
+		awsConnection: connectionInput,
+		awsRegion: awsRegion$1,
+		topicArn,
+		fetchAllSubscriptions,
+		nextToken
+	},
+	examplePayload: listSubscriptionsExamplePayload
+});
+//#endregion
+//#region src/actions/subscribe.ts
+const subscribe = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Subscribe to Topic",
+		description: "Subscribe to an Amazon SNS Topic"
+	},
+	perform: async ({ logger, debug: { enabled: debug } }, { awsConnection, awsRegion, topicArn, protocol, endpoint }) => {
+		const sns = await createSNSClient({
+			awsConnection,
+			awsRegion,
+			debug,
+			logger
+		});
+		const command = new _aws_sdk_client_sns.SubscribeCommand({
+			Protocol: _prismatic_io_spectral.util.types.toString(protocol),
+			TopicArn: topicArn,
+			Endpoint: _prismatic_io_spectral.util.types.toString(endpoint)
+		});
+		return { data: await sns.send(command) };
+	},
+	inputs: {
+		awsRegion: awsRegion$1,
+		topicArn,
+		protocol,
+		endpoint,
+		awsConnection: connectionInput
+	},
+	examplePayload: subscribeExamplePayload
+});
+//#endregion
+//#region src/actions/unsubscribe.ts
+const unsubscribe = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Unsubscribe from a Topic",
+		description: "Unsubscribe from an Amazon SNS Topic"
+	},
+	perform: async ({ logger, debug: { enabled: debug } }, { awsConnection, awsRegion, subscriptionArn }) => {
+		const sns = await createSNSClient({
+			awsConnection,
+			awsRegion,
+			debug,
+			logger
+		});
+		const command = new _aws_sdk_client_sns.UnsubscribeCommand({ SubscriptionArn: subscriptionArn });
+		return { data: await sns.send(command) };
+	},
+	inputs: {
+		awsRegion: awsRegion$1,
+		subscriptionArn,
+		awsConnection: connectionInput
+	},
+	examplePayload: unsubscribeExamplePayload
+});
+//#endregion
+//#region src/actions/publishSms.ts
+const publishSms = (0, _prismatic_io_spectral.action)({
+	display: {
+		label: "Publish SMS",
+		description: "Publish an SMS message to an Amazon SNS Topic"
+	},
+	perform: async ({ logger, debug: { enabled: debug } }, { awsConnection, awsRegion, message, phoneNumber }) => {
+		const sns = await createSNSClient({
+			awsConnection,
+			awsRegion,
+			debug,
+			logger
+		});
+		const command = new _aws_sdk_client_sns.PublishCommand({
+			Message: _prismatic_io_spectral.util.types.toString(message),
+			PhoneNumber: _prismatic_io_spectral.util.types.toString(phoneNumber)
+		});
+		return { data: await sns.send(command) };
+	},
+	inputs: {
+		awsRegion: awsRegion$1,
+		message,
+		phoneNumber,
+		awsConnection: connectionInput
+	},
+	examplePayload: publishSmsExamplePayload
+});
+//#endregion
+//#region src/actions/index.ts
+var actions_default = {
+	createTopic,
+	deleteTopic,
+	getTopicAttributes,
+	listTopics,
+	publishMessage,
+	publishBatchMessages,
+	listSubscriptions,
+	subscribe,
+	unsubscribe,
+	listOptOutNumbers: (0, _prismatic_io_spectral.action)({
+		display: {
+			label: "List Opt Out Numbers",
+			description: "List all opt out numbers"
+		},
+		perform: async ({ logger, debug: { enabled: debug } }, { awsConnection, awsRegion, nextToken }) => {
+			const sns = await createSNSClient({
+				awsConnection,
+				awsRegion,
+				debug,
+				logger
+			});
+			const command = new _aws_sdk_client_sns.ListPhoneNumbersOptedOutCommand({ nextToken: _prismatic_io_spectral.util.types.toString(nextToken) });
+			return { data: await sns.send(command) };
+		},
+		inputs: {
+			awsRegion: awsRegion$1,
+			nextToken,
+			awsConnection: connectionInput
+		},
+		examplePayload: listOptOutNumbersExamplePayload
+	}),
+	publishSms
+};
+const snsExamplePayload = {
+	headers: {
+		"x-amz-sns-message-type": "Notification",
+		"x-amz-sns-message-id": "da41e39f-ea4d-435a-b922-c6aae3915ebe",
+		"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:2bcfbf39-05c3-41de-beaa-fcfcc21c8f55",
+		"Content-Length": "761",
+		"Content-Type": "text/plain; charset=UTF-8",
+		Host: "ec2-50-17-44-49.compute-1.amazonaws.com",
+		Connection: "Keep-Alive",
+		"User-Agent": "Amazon Simple Notification Service Agent"
+	},
+	queryParameters: {},
+	rawBody: { data: {} },
+	webhookUrls: {},
+	webhookApiKeys: {},
+	customer: {
+		externalId: "abc-123",
+		name: "Example Corp",
+		id: "exampleId"
+	},
+	body: { data: {
+		Type: "Notification",
+		MessageId: "da41e39f-ea4d-435a-b922-c6aae3915ebe",
+		TopicArn: "arn:aws:sns:us-west-2:123456789012:MyTopic",
+		Subject: "test",
+		Message: "test message",
+		Timestamp: "2012-04-25T21:49:25.719Z",
+		SignatureVersion: "1",
+		Signature: "EXAMPLElDMXvB8r9R83tGoNn0ecwd5UjllzsvSvbItzfaMpN2nk5HVSw7XnOn/49IkxDKz8YrlH2qJXj2iZB0Zo2O71c4qQk1fMUDi3LGpij7RCW7AW9vYYsSqIKRnFS94ilu7NFhUzLiieYr4BKHpdTmdD6c0esKEYBpabxDSc=",
+		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:2bcfbf39-05c3-41de-beaa-fcfcc21c8f55"
+	} },
+	executionId: "",
+	instance: {
+		id: "example",
+		name: "exampleName"
+	},
+	pathFragment: "example",
+	invokeUrl: "Url",
+	user: {
+		email: "email@email.test",
+		externalId: "externalId",
+		id: "123",
+		name: "name"
+	},
+	flow: {
+		id: "flowId",
+		name: "flowName",
+		stableId: "flowStableId"
+	},
+	integration: {
+		id: "integrationId",
+		name: "integrationName",
+		externalVersion: "1.0.0",
+		versionSequenceId: "1"
+	},
+	startedAt: "2012-04-25T21:49:25.719Z",
+	globalDebug: false
+};
+//#endregion
+//#region ../../packages/aws-utils/src/inputs/awsRegion.ts
+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
+});
+var trigger_default = {
+	subscriptionTrigger: (0, _prismatic_io_spectral.trigger)({
+		display: {
+			label: "Manual Subscription",
+			description: "Receive and validate webhook requests from SNS for manually configured webhook subscriptions."
+		},
+		inputs: { parseMessage },
+		scheduleSupport: "invalid",
+		synchronousResponseSupport: "valid",
+		allowsBranching: true,
+		staticBranchNames: [
+			"Notification",
+			"Subscribe",
+			"Unsubscribe"
+		],
+		examplePayload: {
+			payload: snsExamplePayload,
+			branch: "Notification"
+		},
+		perform: webhookPerformFn
+	}),
+	webhookLifecycleTrigger: (0, _prismatic_io_spectral.trigger)({
+		display: {
+			label: "Topic Webhook",
+			description: "Receive notifications from an SNS topic. Automatically creates and manages a topic subscription when the instance is deployed, and removes the subscription when the instance is deleted."
+		},
+		inputs: {
+			parseMessage,
+			awsConnection: connectionInput,
+			awsRegion,
+			topicArn
+		},
+		scheduleSupport: "invalid",
+		synchronousResponseSupport: "valid",
+		allowsBranching: true,
+		staticBranchNames: [
+			"Notification",
+			"Subscribe",
+			"Unsubscribe"
+		],
+		examplePayload: {
+			payload: snsExamplePayload,
+			branch: "Notification"
+		},
+		perform: webhookPerformFn,
+		webhookLifecycleHandlers: {
+			create: async (context, { awsConnection, awsRegion, topicArn }) => {
+				const sns = await createSNSClient({
+					awsConnection,
+					awsRegion,
+					debug: context.debug.enabled,
+					logger: context.logger
+				});
+				const { subscriptionArn: existingSubscriptionArn, isLegacy } = resolveSubscriptionState(context);
+				let legacyStateCleanup = {};
+				if (existingSubscriptionArn) {
+					context.logger.info(`Existing SNS subscription found for flow ${context.flow.id}, deleting before recreating`, {
+						subscriptionArn: existingSubscriptionArn,
+						legacyState: isLegacy
+					});
+					await sns.send(new _aws_sdk_client_sns.UnsubscribeCommand({ SubscriptionArn: existingSubscriptionArn }));
+					legacyStateCleanup = clearSubscriptionState(context, isLegacy);
+				}
+				context.logger.info(`Creating SNS subscription for flow ${context.flow.id} in region ${awsRegion} and topic ${topicArn}.`);
+				const response = await sns.send(new _aws_sdk_client_sns.SubscribeCommand({
+					TopicArn: topicArn,
+					Protocol: "https",
+					Endpoint: context.webhookUrls[context.flow.name],
+					Attributes: { RawMessageDelivery: "false" },
+					ReturnSubscriptionArn: true
+				}));
+				context.logger.info(`Created SNS subscription for topic ${topicArn}. SubscriptionArn: ${response.SubscriptionArn} (pending confirmation)`);
+				return { crossFlowState: {
+					...legacyStateCleanup,
+					[context.flow.stableId]: { subscriptionArn: response.SubscriptionArn }
+				} };
+			},
+			delete: async (context, { awsConnection, awsRegion }) => {
+				const { subscriptionArn: existingSubscriptionArn, isLegacy } = resolveSubscriptionState(context);
+				if (!existingSubscriptionArn) {
+					context.logger.warn(`No subscription ARN found for flow ${context.flow.name}. Skipping deletion.`);
+					return;
+				}
+				await (await createSNSClient({
+					awsConnection,
+					awsRegion,
+					debug: context.debug.enabled,
+					logger: context.logger
+				})).send(new _aws_sdk_client_sns.UnsubscribeCommand({ SubscriptionArn: existingSubscriptionArn }));
+				context.logger.info(`Deleted SNS subscription for flow ${context.flow.id}. SubscriptionArn: ${existingSubscriptionArn}`);
+				return { crossFlowState: clearSubscriptionState(context, isLegacy) };
+			}
+		}
+	})
+};
+//#endregion
+//#region src/dataSources/index.ts
+var dataSources_default = {
+	selectRegion,
+	selectSubscription: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Subscription",
+			description: "Select a subscription from the list of subscriptions"
+		},
+		inputs: {
+			awsConnection: connectionInput,
+			awsRegion: {
+				...awsRegion$1,
+				dataSource: void 0,
+				model: void 0
+			},
+			topicArn: {
+				...topicArn,
+				dataSource: void 0
+			}
+		},
+		perform: async (_, { awsConnection, awsRegion, topicArn }) => {
+			const { Subscriptions: subscriptions } = await fetchSubscriptions(await createSNSClient({
+				awsConnection,
+				awsRegion
+			}), topicArn, true, void 0);
+			return { result: subscriptions ? subscriptions.map((subscription) => ({
+				label: `Endpoint: ${subscription.Endpoint}`,
+				key: subscription.SubscriptionArn
+			})) : [] };
+		},
+		dataSourceType: "picklist"
+	}),
+	selectTopic: (0, _prismatic_io_spectral.dataSource)({
+		display: {
+			label: "Select Topic",
+			description: "Select a topic from the list of topics"
+		},
+		inputs: {
+			awsConnection: connectionInput,
+			awsRegion: {
+				...awsRegion$1,
+				dataSource: void 0,
+				model: void 0
+			}
+		},
+		perform: async ({ logger }, { awsConnection, awsRegion }) => {
+			const { Topics: topics } = await fetchTopics(await createSNSClient({
+				awsConnection,
+				awsRegion
+			}), true, void 0);
+			return { result: topics ? topics.map((topic) => ({
+				label: `Topic: ${topic.TopicArn.split(":").pop()}`,
+				key: topic.TopicArn
+			})) : [] };
+		},
+		dataSourceType: "picklist"
+	})
+};
+//#endregion
+//#region src/index.ts
+var src_default = (0, _prismatic_io_spectral.component)({
+	key: "aws-sns",
+	documentationUrl: "https://prismatic.io/docs/components/aws-sns/",
+	public: true,
+	display: {
+		label: "Amazon SNS",
+		description: "Manage topics, subscriptions, and messages in Amazon SNS.",
+		iconPath: "icon.png",
+		category: "Data Platforms"
+	},
+	actions: actions_default,
+	triggers: trigger_default,
+	connections: connections_default,
+	dataSources: dataSources_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;