@loadstrike/loadstrike-sdk 1.0.22801 → 1.0.23001

package/dist/esm/transports.js

@@ -218,6 +218,35 @@ class AzureEventHubsEndpointDefinitionModel extends TrafficEndpointDefinitionMod
         }
     }
 }
+class SqsEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
+    constructor(initial) {
+        super(initial);
+        this.Kind = "Sqs";
+        this.QueueUrl = "";
+        this.Region = "";
+        this.WaitTimeSeconds = 1;
+        this.MaxNumberOfMessages = 1;
+        this.DeleteAfterConsume = true;
+        initializeSqsEndpointDefinitionModel(this, initial);
+    }
+    Validate() {
+        super.Validate();
+        requireNonEmptyString(this.QueueUrl, "QueueUrl must be provided for AWS SQS endpoint.");
+        requireNonEmptyString(this.Region, "Region must be provided for AWS SQS endpoint.");
+        if (String(this.AccessKeyId ?? "").trim() && !String(this.SecretAccessKey ?? "").trim()) {
+            throw new Error("SecretAccessKey must be provided when AccessKeyId is configured for AWS SQS endpoint.");
+        }
+        if (this.WaitTimeSeconds < 0 || this.WaitTimeSeconds > 20) {
+            throw new RangeError("WaitTimeSeconds must be between 0 and 20 for AWS SQS endpoint.");
+        }
+        if (this.MaxNumberOfMessages <= 0 || this.MaxNumberOfMessages > 10) {
+            throw new RangeError("MaxNumberOfMessages must be between 1 and 10 for AWS SQS endpoint.");
+        }
+        if (this.VisibilityTimeoutSeconds != null && this.VisibilityTimeoutSeconds < 0) {
+            throw new RangeError("VisibilityTimeoutSeconds must be zero or greater when configured.");
+        }
+    }
+}
 class DelegateStreamEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
     constructor(initial) {
         super(initial);
@@ -263,6 +292,7 @@ export const RabbitMqEndpointDefinition = RabbitMqEndpointDefinitionModel;
 export const NatsEndpointDefinition = NatsEndpointDefinitionModel;
 export const RedisStreamsEndpointDefinition = RedisStreamsEndpointDefinitionModel;
 export const AzureEventHubsEndpointDefinition = AzureEventHubsEndpointDefinitionModel;
+export const SqsEndpointDefinition = SqsEndpointDefinitionModel;
 export const DelegateStreamEndpointDefinition = DelegateStreamEndpointDefinitionModel;
 export const PushDiffusionEndpointDefinition = PushDiffusionEndpointDefinitionModel;
 export const HttpOAuth2ClientCredentialsOptions = HttpOAuth2ClientCredentialsOptionsModel;
@@ -626,6 +656,44 @@ function initializeAzureEventHubsEndpointDefinitionModel(target, initial) {
         target.PartitionCount = pickOptionalEndpointNumber(raw, "PartitionCount", "partitionCount");
     }
 }
+function initializeSqsEndpointDefinitionModel(target, initial) {
+    const raw = asRecordOrEmpty(initial);
+    const queueUrl = pickOptionalEndpointString(raw, "QueueUrl", "queueUrl");
+    if (queueUrl) {
+        target.QueueUrl = queueUrl;
+    }
+    const region = pickOptionalEndpointString(raw, "Region", "region");
+    if (region) {
+        target.Region = region;
+    }
+    if (hasAnyEndpointField(raw, ["ServiceUrl", "serviceUrl"])) {
+        target.ServiceUrl = pickOptionalEndpointString(raw, "ServiceUrl", "serviceUrl");
+    }
+    if (hasAnyEndpointField(raw, ["AccessKeyId", "accessKeyId"])) {
+        target.AccessKeyId = pickOptionalEndpointString(raw, "AccessKeyId", "accessKeyId");
+    }
+    if (hasAnyEndpointField(raw, ["SecretAccessKey", "secretAccessKey"])) {
+        target.SecretAccessKey = pickOptionalEndpointStringAllowEmpty(raw, "SecretAccessKey", "secretAccessKey");
+    }
+    if (hasAnyEndpointField(raw, ["SessionToken", "sessionToken"])) {
+        target.SessionToken = pickOptionalEndpointString(raw, "SessionToken", "sessionToken");
+    }
+    const waitTimeSeconds = pickOptionalEndpointNumber(raw, "WaitTimeSeconds", "waitTimeSeconds");
+    if (waitTimeSeconds != null) {
+        target.WaitTimeSeconds = waitTimeSeconds;
+    }
+    const maxNumberOfMessages = pickOptionalEndpointNumber(raw, "MaxNumberOfMessages", "maxNumberOfMessages");
+    if (maxNumberOfMessages != null) {
+        target.MaxNumberOfMessages = maxNumberOfMessages;
+    }
+    if (hasAnyEndpointField(raw, ["VisibilityTimeoutSeconds", "visibilityTimeoutSeconds"])) {
+        target.VisibilityTimeoutSeconds = pickOptionalEndpointNumber(raw, "VisibilityTimeoutSeconds", "visibilityTimeoutSeconds");
+    }
+    const deleteAfterConsume = pickEndpointBoolean(raw, "DeleteAfterConsume", "deleteAfterConsume");
+    if (deleteAfterConsume != null) {
+        target.DeleteAfterConsume = deleteAfterConsume;
+    }
+}
 function initializeDelegateStreamEndpointDefinitionModel(target, initial) {
     const raw = asRecordOrEmpty(initial);
     const produce = pickEndpointFunction(raw, "Produce", "produce");
@@ -762,6 +830,7 @@ const protocolBus = new class InMemoryProtocolBus {
         this.redisCounters = new Map();
         this.eventHubs = new Map();
         this.eventHubOffsets = new Map();
+        this.sqsQueues = new Map();
         this.pushTopics = new Map();
         this.pushOffsets = new Map();
     }
@@ -776,6 +845,7 @@ const protocolBus = new class InMemoryProtocolBus {
         this.redisCounters.clear();
         this.eventHubs.clear();
         this.eventHubOffsets.clear();
+        this.sqsQueues.clear();
         this.pushTopics.clear();
         this.pushOffsets.clear();
     }
@@ -940,6 +1010,25 @@ const protocolBus = new class InMemoryProtocolBus {
         this.eventHubOffsets.set(cursorKey, rows.length);
         return null;
     }
+    produceSqs(endpoint, payload) {
+        const options = endpoint.sqs ?? {};
+        const queueUrl = optionString(options, "QueueUrl", "queueUrl") || endpoint.name;
+        const queue = this.sqsQueues.get(queueUrl) ?? [];
+        queue.push({ payload: clonePayload(payload), timestampMs: Date.now() });
+        this.sqsQueues.set(queueUrl, queue);
+        return clonePayload(payload);
+    }
+    consumeSqs(endpoint) {
+        const options = endpoint.sqs ?? {};
+        const queueUrl = optionString(options, "QueueUrl", "queueUrl") || endpoint.name;
+        const queue = this.sqsQueues.get(queueUrl) ?? [];
+        if (!queue.length) {
+            return null;
+        }
+        const next = queue.shift() ?? null;
+        this.sqsQueues.set(queueUrl, queue);
+        return next ? clonePayload(next.payload) : null;
+    }
     producePush(endpoint, payload) {
         const options = endpoint.pushDiffusion ?? {};
         const topic = optionString(options, "TopicPath", "topicPath")
@@ -1681,6 +1770,104 @@ class AzureEventHubsEndpointAdapter extends CallbackAdapter {
         await this.subscriptionPromise;
     }
 }
+let sqsClientFactoryForTests = null;
+class SqsEndpointAdapter extends CallbackAdapter {
+    constructor() {
+        super(...arguments);
+        this.clientPromise = null;
+    }
+    async produce(payload) {
+        if (resolveProduceDelegate(this.endpoint)) {
+            return super.produce(payload);
+        }
+        if (this.endpoint.mode !== "Produce") {
+            return null;
+        }
+        const client = await this.getClient();
+        const options = this.endpoint.sqs ?? {};
+        const resolved = prepareProducedPayload(this.endpoint, payload);
+        const wire = toWirePayload(resolved, this.endpoint);
+        const { SendMessageCommand } = await import("@aws-sdk/client-sqs");
+        await client.send(new SendMessageCommand({
+            QueueUrl: optionString(options, "QueueUrl", "queueUrl"),
+            MessageBody: payloadBodyAsUtf8(wire.body),
+            MessageAttributes: toSqsMessageAttributes(wire.headers, wire.contentType)
+        }));
+        return clonePayload(resolved);
+    }
+    async consume() {
+        if (resolveConsumeDelegate(this.endpoint)) {
+            return super.consume();
+        }
+        if (this.endpoint.mode !== "Consume") {
+            return null;
+        }
+        const client = await this.getClient();
+        const options = this.endpoint.sqs ?? {};
+        const { ReceiveMessageCommand, DeleteMessageCommand } = await import("@aws-sdk/client-sqs");
+        const input = {
+            QueueUrl: optionString(options, "QueueUrl", "queueUrl"),
+            MaxNumberOfMessages: hasOptionValue(options, "MaxNumberOfMessages", "maxNumberOfMessages")
+                ? optionNumber(options, "MaxNumberOfMessages", "maxNumberOfMessages")
+                : 1,
+            WaitTimeSeconds: hasOptionValue(options, "WaitTimeSeconds", "waitTimeSeconds")
+                ? optionNumber(options, "WaitTimeSeconds", "waitTimeSeconds")
+                : 1,
+            MessageAttributeNames: ["All"]
+        };
+        const visibilityTimeout = optionNumber(options, "VisibilityTimeoutSeconds", "visibilityTimeoutSeconds");
+        if (visibilityTimeout > 0) {
+            input.VisibilityTimeout = visibilityTimeout;
+        }
+        const response = await client.send(new ReceiveMessageCommand(input));
+        const message = response.Messages?.[0];
+        if (!message) {
+            return null;
+        }
+        const { headers, contentType } = fromSqsMessageAttributes(message.MessageAttributes);
+        const payload = createBrokerPayload(headers, Buffer.from(message.Body ?? "", "utf8"), this.endpoint, contentType);
+        if (optionBoolean(options, true, "DeleteAfterConsume", "deleteAfterConsume") && message.ReceiptHandle) {
+            await client.send(new DeleteMessageCommand({
+                QueueUrl: optionString(options, "QueueUrl", "queueUrl"),
+                ReceiptHandle: message.ReceiptHandle
+            }));
+        }
+        return payload;
+    }
+    async dispose() {
+        const client = await this.clientPromise?.catch(() => null);
+        client?.destroy?.();
+    }
+    async getClient() {
+        if (!this.clientPromise) {
+            this.clientPromise = (async () => {
+                if (sqsClientFactoryForTests) {
+                    return await sqsClientFactoryForTests(this.endpoint);
+                }
+                const { SQSClient } = await import("@aws-sdk/client-sqs");
+                const options = this.endpoint.sqs ?? {};
+                const accessKeyId = optionString(options, "AccessKeyId", "accessKeyId");
+                const secretAccessKey = optionString(options, "SecretAccessKey", "secretAccessKey");
+                const config = {
+                    region: optionString(options, "Region", "region")
+                };
+                const serviceUrl = optionString(options, "ServiceUrl", "serviceUrl");
+                if (serviceUrl) {
+                    config.endpoint = serviceUrl;
+                }
+                if (accessKeyId) {
+                    config.credentials = {
+                        accessKeyId,
+                        secretAccessKey,
+                        sessionToken: optionString(options, "SessionToken", "sessionToken") || undefined
+                    };
+                }
+                return new SQSClient(config);
+            })();
+        }
+        return this.clientPromise;
+    }
+}
 class PushDiffusionEndpointAdapter extends CallbackAdapter {
     async produce(payload) {
         return super.produce(payload);
@@ -1711,6 +1898,8 @@ export class EndpointAdapterFactory {
                 return new RedisStreamsEndpointAdapter(normalized);
             case "AzureEventHubs":
                 return new AzureEventHubsEndpointAdapter(normalized);
+            case "Sqs":
+                return new SqsEndpointAdapter(normalized);
             case "PushDiffusion":
                 return new PushDiffusionEndpointAdapter(normalized);
             case "DelegateStream":
@@ -1838,6 +2027,28 @@ const AZURE_EVENT_HUBS_ENDPOINT_FLAT_KEYS = [
     "StartFromEarliest",
     "startFromEarliest"
 ];
+const SQS_ENDPOINT_FLAT_KEYS = [
+    "QueueUrl",
+    "queueUrl",
+    "Region",
+    "region",
+    "ServiceUrl",
+    "serviceUrl",
+    "AccessKeyId",
+    "accessKeyId",
+    "SecretAccessKey",
+    "secretAccessKey",
+    "SessionToken",
+    "sessionToken",
+    "WaitTimeSeconds",
+    "waitTimeSeconds",
+    "MaxNumberOfMessages",
+    "maxNumberOfMessages",
+    "VisibilityTimeoutSeconds",
+    "visibilityTimeoutSeconds",
+    "DeleteAfterConsume",
+    "deleteAfterConsume"
+];
 const PUSH_DIFFUSION_ENDPOINT_FLAT_KEYS = [
     "ServerUrl",
     "serverUrl",
@@ -1898,6 +2109,7 @@ function normalizeEndpointDefinition(endpoint) {
         nats: normalizeProtocolOptions(pickEndpointTransportRecord(raw, kind, "Nats", ["nats", "Nats"], NATS_ENDPOINT_FLAT_KEYS)),
         redisStreams: normalizeProtocolOptions(pickEndpointTransportRecord(raw, kind, "RedisStreams", ["redisStreams", "RedisStreams"], REDIS_STREAMS_ENDPOINT_FLAT_KEYS)),
         azureEventHubs: normalizeProtocolOptions(pickEndpointTransportRecord(raw, kind, "AzureEventHubs", ["azureEventHubs", "AzureEventHubs"], AZURE_EVENT_HUBS_ENDPOINT_FLAT_KEYS)),
+        sqs: normalizeProtocolOptions(pickEndpointTransportRecord(raw, kind, "Sqs", ["sqs", "Sqs"], SQS_ENDPOINT_FLAT_KEYS)),
         pushDiffusion: normalizeProtocolOptions(pickEndpointTransportRecord(raw, kind, "PushDiffusion", ["pushDiffusion", "PushDiffusion"], PUSH_DIFFUSION_ENDPOINT_FLAT_KEYS)),
         delegate: normalizeDelegateEndpointOptions(pickEndpointTransportRecord(raw, kind, "DelegateStream", ["delegate", "Delegate", "DelegateStream"], DELEGATE_STREAM_ENDPOINT_FLAT_KEYS))
     };
@@ -1955,6 +2167,22 @@ function resolveEndpointKind(raw) {
     ])) {
         return "AzureEventHubs";
     }
+    if (Object.keys(pickEndpointRecord(raw, "sqs", "Sqs")).length || hasAnyEndpointField(raw, [
+        "QueueUrl",
+        "queueUrl",
+        "ServiceUrl",
+        "serviceUrl",
+        "WaitTimeSeconds",
+        "waitTimeSeconds",
+        "MaxNumberOfMessages",
+        "maxNumberOfMessages",
+        "VisibilityTimeoutSeconds",
+        "visibilityTimeoutSeconds",
+        "DeleteAfterConsume",
+        "deleteAfterConsume"
+    ])) {
+        return "Sqs";
+    }
     if (Object.keys(pickEndpointRecord(raw, "pushDiffusion", "PushDiffusion")).length || hasAnyEndpointField(raw, [
         "TopicPath",
         "topicPath",
@@ -2236,6 +2464,9 @@ function validateEndpointDefinition(endpoint) {
         case "AzureEventHubs":
             validateAzureEventHubsEndpoint(endpoint, mode, hasModeDelegate);
             return;
+        case "Sqs":
+            validateSqsEndpoint(endpoint, mode, hasModeDelegate);
+            return;
         case "PushDiffusion":
             validatePushDiffusionEndpoint(endpoint, mode);
             return;
@@ -2457,6 +2688,32 @@ function validateAzureEventHubsEndpoint(endpoint, mode, hasModeDelegate) {
         throw new RangeError("PartitionCount must be zero or greater when configured.");
     }
 }
+function validateSqsEndpoint(endpoint, mode, hasModeDelegate) {
+    const options = endpoint.sqs;
+    if ((!options || typeof options !== "object") && !hasModeDelegate) {
+        throw new Error(`Sqs endpoint in ${mode} mode requires sqs options or delegate callback.`);
+    }
+    if (!options || typeof options !== "object") {
+        return;
+    }
+    requireNonEmptyString(optionString(options, "QueueUrl", "queueUrl"), "QueueUrl must be provided for AWS SQS endpoint.");
+    requireNonEmptyString(optionString(options, "Region", "region"), "Region must be provided for AWS SQS endpoint.");
+    if (optionString(options, "AccessKeyId", "accessKeyId") && !optionString(options, "SecretAccessKey", "secretAccessKey")) {
+        throw new Error("SecretAccessKey must be provided when AccessKeyId is configured for AWS SQS endpoint.");
+    }
+    const waitTimeSeconds = optionNumber(options, "WaitTimeSeconds", "waitTimeSeconds");
+    if (waitTimeSeconds < 0 || waitTimeSeconds > 20) {
+        throw new RangeError("WaitTimeSeconds must be between 0 and 20 for AWS SQS endpoint.");
+    }
+    const maxNumberOfMessages = optionNumber(options, "MaxNumberOfMessages", "maxNumberOfMessages") || 1;
+    if (maxNumberOfMessages <= 0 || maxNumberOfMessages > 10) {
+        throw new RangeError("MaxNumberOfMessages must be between 1 and 10 for AWS SQS endpoint.");
+    }
+    const visibilityTimeoutSeconds = optionNumber(options, "VisibilityTimeoutSeconds", "visibilityTimeoutSeconds");
+    if (visibilityTimeoutSeconds < 0) {
+        throw new RangeError("VisibilityTimeoutSeconds must be zero or greater when configured.");
+    }
+}
 function validatePushDiffusionEndpoint(endpoint, mode) {
     const options = endpoint.pushDiffusion;
     if (!options || typeof options !== "object") {
@@ -2821,6 +3078,12 @@ function optionNumber(options, ...keys) {
     }
     return 0;
 }
+function hasOptionValue(options, ...keys) {
+    return keys.some((key) => {
+        const value = options[key];
+        return value !== undefined && value !== null && (!(typeof value === "string") || value.trim() !== "");
+    });
+}
 function optionBoolean(options, fallback, ...keys) {
     for (const key of keys) {
         const value = options[key];
@@ -3704,6 +3967,29 @@ function createRedisStreamPayload(fields, endpoint) {
     }
     return createBrokerPayload(headers, body, endpoint, contentType);
 }
+function toSqsMessageAttributes(headers, contentType) {
+    const attributes = {};
+    for (const [key, value] of Object.entries(headers)) {
+        attributes[key] = { DataType: "String", StringValue: String(value ?? "") };
+    }
+    if (contentType) {
+        attributes["content-type"] = { DataType: "String", StringValue: contentType };
+    }
+    return attributes;
+}
+function fromSqsMessageAttributes(attributes) {
+    const headers = {};
+    let contentType;
+    for (const [key, value] of Object.entries(attributes ?? {})) {
+        const text = String(value?.StringValue ?? "");
+        if (key.toLowerCase() === "content-type") {
+            contentType = text;
+            continue;
+        }
+        headers[key] = text;
+    }
+    return { headers, contentType };
+}
 function payloadBodyAsUtf8(body) {
     if (body instanceof Uint8Array) {
         return new TextDecoder().decode(body);
@@ -3738,6 +4024,9 @@ export const __loadstrikeTestExports = {
     RedisStreamsEndpointAdapter,
     RedisStreamsEndpointDefinition,
     RedisStreamsEndpointDefinitionModel,
+    SqsEndpointAdapter,
+    SqsEndpointDefinition,
+    SqsEndpointDefinitionModel,
     bufferToUint8Array,
     applyHttpAuthHeaders,
     buildHttpRequestBody,
@@ -3772,6 +4061,11 @@ export const __loadstrikeTestExports = {
     shouldUseConfluentKafkaClient,
     toHeaderRecord,
     toKafkaHeadersWithContentType,
+    toSqsMessageAttributes,
+    fromSqsMessageAttributes,
+    setSqsClientFactoryForTests: (factory) => {
+        sqsClientFactoryForTests = factory;
+    },
     validateHttpEndpoint,
     validateTrackingSelectorPath
 };

package/dist/types/autopilot-contracts.d.ts

@@ -13,6 +13,8 @@ export interface LoadStrikeAutopilotOptions {
     AllowedReplayHosts?: string[];
     BaseUrlRewrite?: string;
     TrackingSelector?: string;
+    RunnerKey?: string;
+    LicenseValidationTimeoutSeconds?: number;
     SecretBindings?: LoadStrikeAutopilotSecretBinding[];
     EndpointBindings?: LoadStrikeAutopilotEndpointBinding[];
 }

package/dist/types/autopilot.d.ts

@@ -37,7 +37,10 @@ export declare class LoadStrikeAutopilotResult implements LoadStrikeAutopilotRes
     BuildScenario(): LoadStrikeScenario;
 }
 export declare class LoadStrikeAutopilot {
-    static generate(request: LoadStrikeAutopilotRequest): LoadStrikeAutopilotResult;
-    static Generate(request: LoadStrikeAutopilotRequest): LoadStrikeAutopilotResult;
+    static generate(request: LoadStrikeAutopilotRequest): Promise<LoadStrikeAutopilotResult>;
+    static Generate(request: LoadStrikeAutopilotRequest): Promise<LoadStrikeAutopilotResult>;
 }
+export declare const __private: {
+    setAutopilotLicenseValidationBypassForTests(value: boolean): void;
+};
 export {};

package/dist/types/contracts.d.ts

@@ -108,6 +108,7 @@ export interface LoadStrikeEndpointSpec {
     Nats?: LoadStrikeNatsEndpointOptions;
     RedisStreams?: LoadStrikeRedisStreamsEndpointOptions;
     AzureEventHubs?: LoadStrikeAzureEventHubsEndpointOptions;
+    Sqs?: LoadStrikeSqsEndpointOptions;
     DelegateStream?: LoadStrikeDelegateEndpointOptions;
     PushDiffusion?: LoadStrikePushDiffusionEndpointOptions;
 }
@@ -203,6 +204,18 @@ export interface LoadStrikeAzureEventHubsEndpointOptions {
     PartitionKey?: string;
     PartitionCount?: number;
 }
+export interface LoadStrikeSqsEndpointOptions {
+    QueueUrl?: string;
+    Region?: string;
+    ServiceUrl?: string;
+    AccessKeyId?: string;
+    SecretAccessKey?: string;
+    SessionToken?: string;
+    WaitTimeSeconds?: number;
+    MaxNumberOfMessages?: number;
+    VisibilityTimeoutSeconds?: number;
+    DeleteAfterConsume?: boolean;
+}
 export interface LoadStrikeDelegateEndpointOptions {
     ProduceCallbackUrl?: string;
     ConsumeCallbackUrl?: string;

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-export type { LoadStrikeDateValue, LoadStrikeObject, LoadStrikeRunContext as LoadStrikeContractRunContext, LoadStrikeScenarioSpec, LoadStrikeLoadSimulationSpec, LoadStrikeThresholdSpec, LoadStrikeTrackingConfigurationSpec, LoadStrikeCorrelationStoreSpec, LoadStrikeRedisCorrelationStoreSpec, LoadStrikeEndpointSpec, LoadStrikeHttpEndpointOptions, LoadStrikeHttpAuthOptions, LoadStrikeHttpOAuth2ClientCredentialsOptions, LoadStrikeKafkaEndpointOptions, LoadStrikeKafkaSaslOptions, LoadStrikeRabbitMqEndpointOptions, LoadStrikeNatsEndpointOptions, LoadStrikeRedisStreamsEndpointOptions, LoadStrikeAzureEventHubsEndpointOptions, LoadStrikeDelegateEndpointOptions, LoadStrikePushDiffusionEndpointOptions, LoadStrikeReportingSinkSpec, LoadStrikeInfluxDbSinkOptions, LoadStrikeTimescaleDbSinkOptions, LoadStrikeGrafanaLokiSinkOptions, LoadStrikeDatadogSinkOptions, LoadStrikeSplunkSinkOptions, LoadStrikeOtelCollectorSinkOptions, LoadStrikeWorkerPluginSpec, LoadStrikeRunRequest, LoadStrikeRunResponse, LoadStrikeNodeStatsDto, LoadStrikeNodeInfoDto, LoadStrikeTestInfoDto, LoadStrikeScenarioStatsDto, LoadStrikeStepStatsDto, LoadStrikeMeasurementStatsDto, LoadStrikeRequestStatsDto, LoadStrikeLatencyStatsDto, LoadStrikeDataTransferStatsDto, LoadStrikeStatusCodeStatsDto, LoadStrikeMetricStatsDto, LoadStrikeCounterStatsDto, LoadStrikeGaugeStatsDto, LoadStrikeThresholdResultDto, LoadStrikePluginDataDto, LoadStrikePluginDataTableDto, LoadStrikePayloadDto, LoadStrikeProducedMessageRequestDto, LoadStrikeProducedMessageResultDto, LoadStrikeConsumedMessageDto } from "./contracts.js";
+export type { LoadStrikeDateValue, LoadStrikeObject, LoadStrikeRunContext as LoadStrikeContractRunContext, LoadStrikeScenarioSpec, LoadStrikeLoadSimulationSpec, LoadStrikeThresholdSpec, LoadStrikeTrackingConfigurationSpec, LoadStrikeCorrelationStoreSpec, LoadStrikeRedisCorrelationStoreSpec, LoadStrikeEndpointSpec, LoadStrikeHttpEndpointOptions, LoadStrikeHttpAuthOptions, LoadStrikeHttpOAuth2ClientCredentialsOptions, LoadStrikeKafkaEndpointOptions, LoadStrikeKafkaSaslOptions, LoadStrikeRabbitMqEndpointOptions, LoadStrikeNatsEndpointOptions, LoadStrikeRedisStreamsEndpointOptions, LoadStrikeAzureEventHubsEndpointOptions, LoadStrikeSqsEndpointOptions, LoadStrikeDelegateEndpointOptions, LoadStrikePushDiffusionEndpointOptions, LoadStrikeReportingSinkSpec, LoadStrikeInfluxDbSinkOptions, LoadStrikeTimescaleDbSinkOptions, LoadStrikeGrafanaLokiSinkOptions, LoadStrikeDatadogSinkOptions, LoadStrikeSplunkSinkOptions, LoadStrikeOtelCollectorSinkOptions, LoadStrikeWorkerPluginSpec, LoadStrikeRunRequest, LoadStrikeRunResponse, LoadStrikeNodeStatsDto, LoadStrikeNodeInfoDto, LoadStrikeTestInfoDto, LoadStrikeScenarioStatsDto, LoadStrikeStepStatsDto, LoadStrikeMeasurementStatsDto, LoadStrikeRequestStatsDto, LoadStrikeLatencyStatsDto, LoadStrikeDataTransferStatsDto, LoadStrikeStatusCodeStatsDto, LoadStrikeMetricStatsDto, LoadStrikeCounterStatsDto, LoadStrikeGaugeStatsDto, LoadStrikeThresholdResultDto, LoadStrikePluginDataDto, LoadStrikePluginDataTableDto, LoadStrikePayloadDto, LoadStrikeProducedMessageRequestDto, LoadStrikeProducedMessageResultDto, LoadStrikeConsumedMessageDto } from "./contracts.js";
 export { LoadStrikeAutopilot, LoadStrikeAutopilotResult } from "./autopilot.js";
 export type { LoadStrikeAutopilotEndpoint, LoadStrikeAutopilotEndpointBinding, LoadStrikeAutopilotLoadSimulationSuggestion, LoadStrikeAutopilotMessageSample, LoadStrikeAutopilotOptions, LoadStrikeAutopilotPlan, LoadStrikeAutopilotPreviewReport, LoadStrikeAutopilotReadinessFailure, LoadStrikeAutopilotRedaction, LoadStrikeAutopilotRequest, LoadStrikeAutopilotResultShape, LoadStrikeAutopilotScenarioPlan, LoadStrikeAutopilotSecretBinding, LoadStrikeAutopilotThresholdSuggestion, LoadStrikeAutopilotTrackingSelectorSuggestion } from "./autopilot-contracts.js";
 export { LoadStrikeAutopilotReadiness } from "./autopilot-contracts.js";
@@ -6,7 +6,7 @@ export { CrossPlatformScenarioConfigurator, ScenarioTrackingExtensions, LoadStri
 export type { ILoadStrikeReportingSink, ILoadStrikeWorkerPlugin, LoadStrikeRunResult, LoadStrikeReportingSink, LoadStrikeRuntimePolicy, LoadStrikeRunnerOptions, LoadStrikeRunContext as LoadStrikeRuntimeContext, LoadStrikeRunContext, LoadStrikeBaseContext, LoadStrikeCounterStats, LoadStrikeDataTransferStats, LoadStrikeGaugeStats, LoadStrikeLogger, LoadStrikeLoadSimulationStats, LoadStrikeMeasurementStats, LoadStrikeMetricStats, LoadStrikeNodeInfo, LoadStrikeMetricValue, LoadStrikeRandom, LoadStrikeReply, LoadStrikeLatencyCount, LoadStrikeLatencyStats, LoadStrikeLoadSimulation, LoadStrikeScenarioInfo, LoadStrikeScenarioInitContext, LoadStrikeScenarioPartition, LoadStrikeScenarioStartInfo, LoadStrikeScenarioContext, LoadStrikeScenarioStats, LoadStrikeTestInfo, LoadStrikeScenarioRuntime, LoadStrikeSessionStartInfo, LoadStrikeSinkSession, LoadStrikeSinkError, LoadStrikeStatusCodeStats, LoadStrikeThresholdResult, LoadStrikeThresholdPredicateContext, LoadStrikeStepReply, LoadStrikeStepStats, LoadStrikeStepRuntime, LoadStrikeThresholdOptions, LoadStrikeRequestStats, LoadStrikeWorkerPlugin } from "./runtime.js";
 export { CorrelationStoreConfiguration, CrossPlatformTrackingRuntime, InMemoryCorrelationStore, RedisCorrelationStoreOptions, RedisCorrelationStore, TrackingPayloadBuilder, TrackingFieldSelector } from "./correlation.js";
 export type { CorrelationEntry, DestinationConsumeResult, GatheredRow, CorrelationStoreKind, CorrelationRuntimeOptions, CorrelationRuntimePlugin, CorrelationRuntimeStats, CorrelationStore, SourceProduceResult, TrackingFieldLocation, TrackingPayload } from "./correlation.js";
-export { EndpointAdapterFactory, LOADSTRIKE_TRACE_ID_HEADER, LOADSTRIKE_TRACE_ID_TRACKING_FIELD, TrafficEndpointDefinition, HttpEndpointDefinition, KafkaEndpointDefinition, KafkaSaslOptions, RabbitMqEndpointDefinition, NatsEndpointDefinition, RedisStreamsEndpointDefinition, AzureEventHubsEndpointDefinition, DelegateStreamEndpointDefinition, PushDiffusionEndpointDefinition, HttpOAuth2ClientCredentialsOptions, HttpAuthOptions } from "./transports.js";
-export type { EndpointAdapter, EndpointDefinition, EndpointDefinitionInput, EndpointKind, EndpointMode, DotNetDelegateEndpointOptions, DotNetEndpointDefinition, DotNetHttpAuthOptions, DotNetHttpEndpointOptions, DotNetHttpOAuth2ClientCredentialsOptions, HttpAuthMode, HttpAuthType, HttpRequestBodyType, HttpResponseSource, HttpTrackingPayloadSource, KafkaSaslMechanismType, KafkaSecurityProtocolType, HttpEndpointOptions, KafkaEndpointOptions, RabbitMqEndpointOptions, NatsEndpointOptions, RedisStreamsEndpointOptions, AzureEventHubsEndpointOptions, PushDiffusionEndpointOptions, TrackingFieldSelectorInput, TrackingRunMode, TrafficEndpointKind, TrafficEndpointMode, ProducedMessageRequest, ProducedMessageResult, ConsumedMessage, DelegateConsumeAsync, DelegateConsumeStreamHandler, DelegateEndpointOptions } from "./transports.js";
+export { LOADSTRIKE_TRACE_ID_HEADER, LOADSTRIKE_TRACE_ID_TRACKING_FIELD, TrafficEndpointDefinition, HttpEndpointDefinition, KafkaEndpointDefinition, KafkaSaslOptions, RabbitMqEndpointDefinition, NatsEndpointDefinition, RedisStreamsEndpointDefinition, AzureEventHubsEndpointDefinition, SqsEndpointDefinition, DelegateStreamEndpointDefinition, PushDiffusionEndpointDefinition, HttpOAuth2ClientCredentialsOptions, HttpAuthOptions } from "./transports.js";
+export type { EndpointAdapter, EndpointDefinition, EndpointDefinitionInput, EndpointKind, EndpointMode, DotNetDelegateEndpointOptions, DotNetEndpointDefinition, DotNetHttpAuthOptions, DotNetHttpEndpointOptions, DotNetHttpOAuth2ClientCredentialsOptions, HttpAuthMode, HttpAuthType, HttpRequestBodyType, HttpResponseSource, HttpTrackingPayloadSource, KafkaSaslMechanismType, KafkaSecurityProtocolType, HttpEndpointOptions, KafkaEndpointOptions, RabbitMqEndpointOptions, NatsEndpointOptions, RedisStreamsEndpointOptions, AzureEventHubsEndpointOptions, SqsEndpointOptions, PushDiffusionEndpointOptions, TrackingFieldSelectorInput, TrackingRunMode, TrafficEndpointKind, TrafficEndpointMode, ProducedMessageRequest, ProducedMessageResult, ConsumedMessage, DelegateConsumeAsync, DelegateConsumeStreamHandler, DelegateEndpointOptions } from "./transports.js";
 export { DatadogReportingSink, DatadogReportingSinkOptions, GrafanaLokiReportingSink, GrafanaLokiReportingSinkOptions, InfluxDbReportingSink, InfluxDbReportingSinkOptions, OtelCollectorReportingSink, OtelCollectorReportingSinkOptions, SplunkReportingSink, SplunkReportingSinkOptions, TimescaleDbReportingSink, TimescaleDbReportingSinkOptions } from "./sinks.js";
 export type { DatadogSinkOptions, GrafanaLokiSinkOptions, InfluxDbSinkOptions, OtelCollectorSinkOptions, SplunkSinkOptions, TimescaleDbSinkOptions } from "./sinks.js";

package/dist/types/transports.d.ts

@@ -1,7 +1,7 @@
 import { TrackingFieldSelector, type TrackingPayload } from "./correlation.js";
 export declare const LOADSTRIKE_TRACE_ID_HEADER = "loadstrike-trace-id";
 export declare const LOADSTRIKE_TRACE_ID_TRACKING_FIELD = "header:loadstrike-trace-id";
-export type EndpointKind = "Http" | "Kafka" | "RabbitMq" | "Nats" | "RedisStreams" | "AzureEventHubs" | "PushDiffusion" | "DelegateStream";
+export type EndpointKind = "Http" | "Kafka" | "RabbitMq" | "Nats" | "RedisStreams" | "AzureEventHubs" | "Sqs" | "PushDiffusion" | "DelegateStream";
 export type EndpointMode = "Produce" | "Consume";
 export type HttpAuthMode = "None" | "Basic" | "Bearer" | "OAuth2ClientCredentials";
 export type HttpAuthType = HttpAuthMode;
@@ -228,6 +228,29 @@ export interface AzureEventHubsEndpointOptions {
     startFromEarliest?: boolean;
     [key: string]: unknown;
 }
+export interface SqsEndpointOptions {
+    QueueUrl?: string;
+    queueUrl?: string;
+    Region?: string;
+    region?: string;
+    ServiceUrl?: string;
+    serviceUrl?: string;
+    AccessKeyId?: string;
+    accessKeyId?: string;
+    SecretAccessKey?: string;
+    secretAccessKey?: string;
+    SessionToken?: string;
+    sessionToken?: string;
+    WaitTimeSeconds?: number;
+    waitTimeSeconds?: number;
+    MaxNumberOfMessages?: number;
+    maxNumberOfMessages?: number;
+    VisibilityTimeoutSeconds?: number;
+    visibilityTimeoutSeconds?: number;
+    DeleteAfterConsume?: boolean;
+    deleteAfterConsume?: boolean;
+    [key: string]: unknown;
+}
 export interface PushDiffusionEndpointOptions {
     ServerUrl?: string;
     serverUrl?: string;
@@ -322,6 +345,8 @@ export interface EndpointDefinition {
     redisStreams?: RedisStreamsEndpointOptions;
     AzureEventHubs?: AzureEventHubsEndpointOptions;
     azureEventHubs?: AzureEventHubsEndpointOptions;
+    Sqs?: SqsEndpointOptions;
+    sqs?: SqsEndpointOptions;
     PushDiffusion?: PushDiffusionEndpointOptions;
     pushDiffusion?: PushDiffusionEndpointOptions;
     Delegate?: DelegateEndpointOptions;
@@ -394,6 +419,7 @@ export interface DotNetEndpointDefinition {
     Nats?: NatsEndpointOptions;
     RedisStreams?: RedisStreamsEndpointOptions;
     AzureEventHubs?: AzureEventHubsEndpointOptions;
+    Sqs?: SqsEndpointOptions;
     PushDiffusion?: PushDiffusionEndpointOptions;
     Delegate?: DotNetDelegateEndpointOptions;
     DelegateStream?: DotNetDelegateEndpointOptions;
@@ -528,6 +554,30 @@ export interface AzureEventHubsEndpointDefinition extends TrafficEndpointDefinit
     StartFromEarliest?: boolean;
     startFromEarliest?: boolean;
 }
+export interface SqsEndpointDefinition extends TrafficEndpointDefinition {
+    Kind?: "Sqs";
+    kind?: "Sqs";
+    QueueUrl?: string;
+    queueUrl?: string;
+    Region?: string;
+    region?: string;
+    ServiceUrl?: string;
+    serviceUrl?: string;
+    AccessKeyId?: string;
+    accessKeyId?: string;
+    SecretAccessKey?: string;
+    secretAccessKey?: string;
+    SessionToken?: string;
+    sessionToken?: string;
+    WaitTimeSeconds?: number;
+    waitTimeSeconds?: number;
+    MaxNumberOfMessages?: number;
+    maxNumberOfMessages?: number;
+    VisibilityTimeoutSeconds?: number;
+    visibilityTimeoutSeconds?: number;
+    DeleteAfterConsume?: boolean;
+    deleteAfterConsume?: boolean;
+}
 export interface DelegateStreamEndpointDefinition extends TrafficEndpointDefinition {
     Kind?: "DelegateStream";
     kind?: "DelegateStream";
@@ -570,6 +620,7 @@ type RabbitMqEndpointDefinitionInit = Partial<RabbitMqEndpointDefinition>;
 type NatsEndpointDefinitionInit = Partial<NatsEndpointDefinition>;
 type RedisStreamsEndpointDefinitionInit = Partial<RedisStreamsEndpointDefinition>;
 type AzureEventHubsEndpointDefinitionInit = Partial<AzureEventHubsEndpointDefinition>;
+type SqsEndpointDefinitionInit = Partial<SqsEndpointDefinition>;
 type DelegateStreamEndpointDefinitionInit = Partial<DelegateStreamEndpointDefinition>;
 type PushDiffusionEndpointDefinitionInit = Partial<PushDiffusionEndpointDefinition>;
 declare abstract class TrafficEndpointDefinitionModel {
@@ -711,6 +762,21 @@ declare class AzureEventHubsEndpointDefinitionModel extends TrafficEndpointDefin
     constructor(initial?: AzureEventHubsEndpointDefinitionInit);
     Validate(): void;
 }
+declare class SqsEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
+    readonly Kind: "Sqs";
+    QueueUrl: string;
+    Region: string;
+    ServiceUrl?: string;
+    AccessKeyId?: string;
+    SecretAccessKey?: string;
+    SessionToken?: string;
+    WaitTimeSeconds: number;
+    MaxNumberOfMessages: number;
+    VisibilityTimeoutSeconds?: number;
+    DeleteAfterConsume: boolean;
+    constructor(initial?: SqsEndpointDefinitionInit);
+    Validate(): void;
+}
 declare class DelegateStreamEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
     readonly Kind: "DelegateStream";
     Produce?: (payload: TrackingPayload) => Promise<TrackingPayload | null> | TrackingPayload | null;
@@ -740,12 +806,13 @@ export declare const RabbitMqEndpointDefinition: typeof RabbitMqEndpointDefiniti
 export declare const NatsEndpointDefinition: typeof NatsEndpointDefinitionModel;
 export declare const RedisStreamsEndpointDefinition: typeof RedisStreamsEndpointDefinitionModel;
 export declare const AzureEventHubsEndpointDefinition: typeof AzureEventHubsEndpointDefinitionModel;
+export declare const SqsEndpointDefinition: typeof SqsEndpointDefinitionModel;
 export declare const DelegateStreamEndpointDefinition: typeof DelegateStreamEndpointDefinitionModel;
 export declare const PushDiffusionEndpointDefinition: typeof PushDiffusionEndpointDefinitionModel;
 export declare const HttpOAuth2ClientCredentialsOptions: typeof HttpOAuth2ClientCredentialsOptionsModel;
 export declare const HttpAuthOptions: typeof HttpAuthOptionsModel;
 export declare const KafkaSaslOptions: typeof KafkaSaslOptionsModel;
-export type EndpointDefinitionInput = EndpointDefinition | DotNetEndpointDefinition | HttpEndpointDefinition | KafkaEndpointDefinition | RabbitMqEndpointDefinition | NatsEndpointDefinition | RedisStreamsEndpointDefinition | AzureEventHubsEndpointDefinition | DelegateStreamEndpointDefinition | PushDiffusionEndpointDefinition;
+export type EndpointDefinitionInput = EndpointDefinition | DotNetEndpointDefinition | HttpEndpointDefinition | KafkaEndpointDefinition | RabbitMqEndpointDefinition | NatsEndpointDefinition | RedisStreamsEndpointDefinition | AzureEventHubsEndpointDefinition | SqsEndpointDefinition | DelegateStreamEndpointDefinition | PushDiffusionEndpointDefinition;
 export interface EndpointAdapter {
     initialize?(): Promise<void>;
     produce(payload?: TrackingPayload): Promise<TrackingPayload | null>;
@@ -794,6 +861,18 @@ declare class AzureEventHubsEndpointAdapter extends CallbackAdapter {
     private getConsumer;
     private ensureSubscriptionStarted;
 }
+type SqsClientLike = {
+    send(command: unknown): Promise<unknown>;
+    destroy?: () => void;
+};
+declare let sqsClientFactoryForTests: ((endpoint: EndpointDefinition) => SqsClientLike | Promise<SqsClientLike>) | null;
+declare class SqsEndpointAdapter extends CallbackAdapter {
+    private clientPromise;
+    produce(payload?: TrackingPayload): Promise<TrackingPayload | null>;
+    consume(): Promise<TrackingPayload | null>;
+    dispose(): Promise<void>;
+    private getClient;
+}
 export declare class EndpointAdapterFactory {
     static create(endpoint: EndpointDefinitionInput): EndpointAdapter;
 }
@@ -834,6 +913,16 @@ declare function readFirstRedisStreamEntry(value: unknown): {
     fields: Record<string, Uint8Array>;
 } | null;
 declare function createRedisStreamPayload(fields: Record<string, Uint8Array>, endpoint: EndpointDefinition): TrackingPayload;
+declare function toSqsMessageAttributes(headers: Record<string, string>, contentType?: string): Record<string, {
+    DataType: string;
+    StringValue: string;
+}>;
+declare function fromSqsMessageAttributes(attributes: Record<string, {
+    StringValue?: string;
+} | undefined> | undefined): {
+    headers: Record<string, string>;
+    contentType?: string;
+};
 declare function payloadBodyAsUtf8(body: unknown): string;
 export declare const __loadstrikeTestExports: {
     AzureEventHubsEndpointAdapter: typeof AzureEventHubsEndpointAdapter;
@@ -852,6 +941,9 @@ export declare const __loadstrikeTestExports: {
     RedisStreamsEndpointAdapter: typeof RedisStreamsEndpointAdapter;
     RedisStreamsEndpointDefinition: typeof RedisStreamsEndpointDefinitionModel;
     RedisStreamsEndpointDefinitionModel: typeof RedisStreamsEndpointDefinitionModel;
+    SqsEndpointAdapter: typeof SqsEndpointAdapter;
+    SqsEndpointDefinition: typeof SqsEndpointDefinitionModel;
+    SqsEndpointDefinitionModel: typeof SqsEndpointDefinitionModel;
     bufferToUint8Array: typeof bufferToUint8Array;
     applyHttpAuthHeaders: typeof applyHttpAuthHeaders;
     buildHttpRequestBody: typeof buildHttpRequestBody;
@@ -886,6 +978,9 @@ export declare const __loadstrikeTestExports: {
     shouldUseConfluentKafkaClient: typeof shouldUseConfluentKafkaClient;
     toHeaderRecord: typeof toHeaderRecord;
     toKafkaHeadersWithContentType: typeof toKafkaHeadersWithContentType;
+    toSqsMessageAttributes: typeof toSqsMessageAttributes;
+    fromSqsMessageAttributes: typeof fromSqsMessageAttributes;
+    setSqsClientFactoryForTests: (factory: typeof sqsClientFactoryForTests) => void;
     validateHttpEndpoint: typeof validateHttpEndpoint;
     validateTrackingSelectorPath: typeof validateTrackingSelectorPath;
 };