@loadstrike/loadstrike-sdk 1.0.31601 → 1.0.33601

package/dist/types/contracts.d.ts

@@ -259,6 +259,7 @@ export interface LoadStrikeWebSocketEndpointOptions {
     ConnectTimeoutSeconds?: number;
     CloseTimeoutSeconds?: number;
     ConnectionMetadata?: Record<string, string>;
+    NativeClient?: Record<string, unknown>;
 }
 export interface LoadStrikeReportingSinkSpec {
     Kind: string;

package/dist/types/index.d.ts

@@ -11,4 +11,4 @@ export type { CorrelationEntry, DestinationConsumeResult, GatheredRow, Correlati
 export { LOADSTRIKE_TRACE_ID_HEADER, LOADSTRIKE_TRACE_ID_TRACKING_FIELD, TrafficEndpointDefinition, HttpEndpointDefinition, KafkaEndpointDefinition, KafkaSaslOptions, RabbitMqEndpointDefinition, NatsEndpointDefinition, RedisStreamsEndpointDefinition, AzureEventHubsEndpointDefinition, SqsEndpointDefinition, DelegateStreamEndpointDefinition, PushDiffusionEndpointDefinition, GrpcEndpointDefinition, GrpcMethodTypes, GrpcNativeClientOptions, GrpcStatusMapper, ProtocolMetricSnapshot, WebSocketEndpointDefinition, WebSocketExpectedMessage, WebSocketMessageSpec, WebSocketNativeClientOptions, WebSocketReconnectPolicy, 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, GrpcEndpointOptions, WebSocketEndpointOptions, GrpcEndpointDefinition as GrpcEndpointDefinitionShape, WebSocketEndpointDefinition as WebSocketEndpointDefinitionShape, TrackingFieldSelectorInput, TrackingRunMode, TrafficEndpointKind, TrafficEndpointMode, ProducedMessageRequest, ProducedMessageResult, ConsumedMessage, DelegateConsumeAsync, DelegateConsumeStreamHandler, DelegateEndpointOptions } from "./transports.js";
 export { DatadogReportingSink, DatadogReportingSinkOptions, DogStatsDReportingSink, CloudWatchReportingSink, DynatraceReportingSink, ElasticsearchReportingSink, GrafanaLokiReportingSink, GrafanaLokiReportingSinkOptions, GenericWebhookReportingSink, InfluxDbReportingSink, InfluxDbReportingSinkOptions, JsonlFileReportingSink, KafkaReportingSink, NetdataStatsDReportingSink, NewRelicReportingSink, OtelCollectorReportingSink, OtelCollectorReportingSinkOptions, OpenSearchReportingSink, PortalReportingSink, PrometheusRemoteWriteReportingSink, SplunkReportingSink, SplunkReportingSinkOptions, StatsDReportingSink, TimescaleDbReportingSink, TimescaleDbReportingSinkOptions } from "./sinks.js";
-export type { DatadogSinkOptions, ExpandedSinkOptionsInput, GrafanaLokiSinkOptions, InfluxDbSinkOptions, JsonlFileReportingSinkOptionsInput, KafkaReportingSinkOptionsInput, OtelCollectorSinkOptions, PortalReportingSinkOptionsInput, SplunkSinkOptions, StatsDReportingSinkOptionsInput, TimescaleDbSinkOptions } from "./sinks.js";
+export type { CloudWatchReportingSinkOptionsInput, DatadogSinkOptions, DynatraceReportingSinkOptionsInput, ElasticsearchReportingSinkOptionsInput, ExpandedSinkOptionsInput, GrafanaLokiSinkOptions, InfluxDbSinkOptions, JsonlFileReportingSinkOptionsInput, KafkaReportingSinkOptionsInput, NewRelicReportingSinkOptionsInput, OpenSearchReportingSinkOptionsInput, OtelCollectorSinkOptions, PortalReportingSinkOptionsInput, PrometheusRemoteWriteReportingSinkOptionsInput, SplunkSinkOptions, StatsDReportingSinkOptionsInput, TimescaleDbSinkOptions } from "./sinks.js";

package/dist/types/internal/prometheus-remote-write.d.ts

@@ -0,0 +1,2 @@
+import { type EncodedProtocolPayload, type ProtocolMetricPoint } from "./vendor-metric-payloads.js";
+export declare function encodePrometheusRemoteWrite(points: readonly ProtocolMetricPoint[], staticLabels?: Readonly<Record<string, string>>): EncodedProtocolPayload;

package/dist/types/internal/reporting-sink-http-error.d.ts

@@ -0,0 +1,6 @@
+export declare class ReportingSinkHttpError extends Error {
+    readonly status: number;
+    readonly statusText: string;
+    readonly requestId: string;
+    constructor(sinkName: string, status: number, statusText: string, requestId: string);
+}

package/dist/types/internal/vendor-metric-payloads.d.ts

@@ -0,0 +1,48 @@
+export type ProtocolMetricKind = "count" | "gauge";
+export interface ProtocolMetricPoint {
+    metricName: string;
+    metricKind: ProtocolMetricKind;
+    occurredUtc: Date;
+    value: number;
+    unitOfMeasure?: string;
+    scenario: string;
+    status: string;
+    runId?: string;
+    intervalMs?: number | bigint;
+}
+export interface EncodedProtocolPayload {
+    contentType: string;
+    body: Uint8Array;
+}
+export interface CloudWatchDimension {
+    Name: string;
+    Value: string;
+}
+export interface CloudWatchMetricDatum {
+    MetricName: string;
+    Dimensions: CloudWatchDimension[];
+    Value: number;
+    Unit?: string;
+    Timestamp: Date;
+}
+export interface CloudWatchPutMetricData {
+    Namespace: string;
+    MetricData: CloudWatchMetricDatum[];
+}
+type ProtocolSink = "prometheus" | "cloudwatch" | "dynatrace" | "newrelic";
+export interface PreparedProtocolMetricPoint {
+    metricName: string;
+    metricKind: ProtocolMetricKind;
+    occurredUtc: Date;
+    value: number;
+    unitOfMeasure?: string;
+    intervalMs?: bigint;
+    attributes: Array<readonly [string, string]>;
+}
+export declare function createCloudWatchMetricData(namespace: string, points: readonly ProtocolMetricPoint[], staticDimensions?: Readonly<Record<string, string>>): CloudWatchPutMetricData;
+export declare function encodeDynatraceMetrics(points: readonly ProtocolMetricPoint[], staticDimensions?: Readonly<Record<string, string>>): EncodedProtocolPayload;
+export declare function encodeDynatraceMetricBatches(points: readonly ProtocolMetricPoint[], staticDimensions?: Readonly<Record<string, string>>, maximumBodyBytesExclusive?: number): EncodedProtocolPayload[];
+export declare function encodeNewRelicMetricBatch(points: readonly ProtocolMetricPoint[], staticAttributes?: Readonly<Record<string, string>>): EncodedProtocolPayload;
+export declare function encodeNewRelicMetricBatches(points: readonly ProtocolMetricPoint[], staticAttributes?: Readonly<Record<string, string>>, maximumBodyBytesExclusive?: number): EncodedProtocolPayload[];
+export declare function prepareProtocolMetricPoints(sink: ProtocolSink, points: readonly ProtocolMetricPoint[], staticAttributes?: Readonly<Record<string, string>>): PreparedProtocolMetricPoint[];
+export {};

package/dist/types/local.d.ts

@@ -43,9 +43,6 @@ export declare class LoadStrikeLocalClient {
     private getLicensingRequest;
 }
 declare function sanitizeRequest(request: LoadStrikeRunRequest): LoadStrikeRunRequest;
-declare function normalizeLicensingApiBaseUrl(value: string | undefined): string;
-declare function resolveLicensingApiBaseUrl(): string;
-declare function setDevelopmentLicensingApiBaseUrlOverride(value: string | undefined): void;
 declare function normalizeTimeoutMs(value: number | undefined): number;
 declare function collectRequestedFeatures(request: LoadStrikeRunRequest): string[];
 declare function mapEnvironmentClassification(value: string): number;
@@ -146,8 +143,6 @@ export declare const __loadstrikeTestExports: {
     mapEnvironmentClassification: typeof mapEnvironmentClassification;
     mapEndpointSpec: typeof mapEndpointSpec;
     normalizeEndpointPayloadValue: typeof normalizeEndpointPayloadValue;
-    normalizeLicensingApiBaseUrl: typeof normalizeLicensingApiBaseUrl;
-    resolveLicensingApiBaseUrl: typeof resolveLicensingApiBaseUrl;
     normalizeNodeType: typeof normalizeNodeType;
     normalizePayload: typeof normalizePayload;
     normalizeStringArray: typeof normalizeStringArray;
@@ -166,7 +161,6 @@ export declare const __loadstrikeTestExports: {
     sanitizeLooseJson: typeof sanitizeLooseJson;
     sanitizeRequest: typeof sanitizeRequest;
     setJsonPathValue: typeof setJsonPathValue;
-    setDevelopmentLicensingApiBaseUrlOverride: typeof setDevelopmentLicensingApiBaseUrlOverride;
     sleep: typeof sleep;
     stringOrDefault: typeof stringOrDefault;
     toBoolean: typeof toBoolean;

package/dist/types/reporting-containment.d.ts

@@ -0,0 +1,2 @@
+export declare function assertNoUnsupportedReportingInfraConfig(infraConfig: unknown, sinks?: readonly unknown[]): void;
+export declare function assertNoUnsupportedReportingSinkGraph(sinks: readonly unknown[]): void;

package/dist/types/runtime.d.ts

@@ -2514,6 +2514,7 @@ declare class ManagedScenarioTrackingRuntime {
     dispose(): Promise<void>;
     private executeSourceOnly;
     private observeExistingTraffic;
+    private interruptEndpointAdapters;
     private consumeSourceLoop;
     private consumeDestinationLoop;
     private runTimeoutSweepLoop;

package/dist/types/sinks.d.ts

@@ -1,5 +1,8 @@
 import type { ILoadStrikeReportingSink, LoadStrikeBaseContext, LoadStrikeMetricStats, LoadStrikeMetricValue, LoadStrikeNodeInfo, LoadStrikePluginData, LoadStrikeReportingSink, LoadStrikeRunResult, LoadStrikeScenarioStats, LoadStrikeSessionStartInfo, LoadStrikeSinkError, LoadStrikeStepStats, LoadStrikeTestInfo, LoadStrikeThresholdResult } from "./runtime.js";
 import { type LoadStrikeIterationObservationBatchV1, type LoadStrikeIterationObservationStreamCompletionV1 } from "./iteration-observations.js";
+import { type ProtocolMetricPoint } from "./internal/vendor-metric-payloads.js";
+declare const SEND_DIRECT_VENDOR_PROTOCOL_POINTS: unique symbol;
+declare const CLONE_DIRECT_VENDOR_FOR_RUN: unique symbol;
 interface LoadStrikeNodeStats {
     startedUtc: string;
     completedUtc: string;
@@ -489,7 +492,7 @@ export declare class PortalReportingSink implements LoadStrikeReportingSink {
     private persistObservationPayload;
     private currentRunToken;
 }
-export declare function cloneReportingSinkForRun(sink: LoadStrikeReportingSink): LoadStrikeReportingSink;
+export declare function cloneReportingSinkForRun(sink: LoadStrikeReportingSink, infraConfig?: Record<string, unknown>, environment?: Readonly<Record<string, string | undefined>>): LoadStrikeReportingSink;
 export declare class InfluxDbReportingSink implements LoadStrikeReportingSink {
     readonly sinkName = "influxdb";
     readonly SinkName = "influxdb";
@@ -680,6 +683,8 @@ export declare class OtelCollectorReportingSink implements LoadStrikeReportingSi
     private persistEvents;
 }
 export interface ExpandedSinkOptionsInput {
+    ConfigurationSectionPath?: string;
+    configurationSectionPath?: string;
     BaseUrl?: string;
     baseUrl?: string;
     EndpointPath?: string;
@@ -695,6 +700,20 @@ export interface ExpandedSinkOptionsInput {
     FetchImpl?: SinkFetch;
     fetchImpl?: SinkFetch;
 }
+export interface ElasticsearchReportingSinkOptionsInput extends ExpandedSinkOptionsInput {
+    IndexName?: string;
+    indexName?: string;
+    ApiKey?: string;
+    apiKey?: string;
+}
+export interface OpenSearchReportingSinkOptionsInput extends ExpandedSinkOptionsInput {
+    IndexName?: string;
+    indexName?: string;
+    Username?: string;
+    username?: string;
+    Password?: string;
+    password?: string;
+}
 declare abstract class ExpandedEventReportingSink implements LoadStrikeReportingSink {
     readonly SinkName: string;
     readonly sinkName: string;
@@ -729,38 +748,128 @@ declare abstract class ExpandedEventReportingSink implements LoadStrikeReporting
 declare class ExpandedHttpJsonReportingSink extends ExpandedEventReportingSink {
     private readonly fetchImpl;
     private readonly baseUrl;
+    private readonly exactUrl;
     private readonly endpointPath;
     private readonly headers;
     private readonly staticTags;
     private readonly timeoutMs;
-    constructor(sinkName: string, licenseFeature: string, defaultEndpointPath: string, options?: ExpandedSinkOptionsInput);
+    constructor(sinkName: string, licenseFeature: string, defaultEndpointPath: string, options?: ExpandedSinkOptionsInput, bindingOptions?: ExpandedSinkOptionsInput);
     init(context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>): void;
     protected persistEvents(events: ReportingSinkEvent[]): Promise<void>;
     saveIterationBatch(batch: LoadStrikeIterationObservationBatchV1): Promise<void>;
     completeIterationObservationStream(completion: LoadStrikeIterationObservationStreamCompletionV1): Promise<void>;
     protected persistCanonicalGzipPayload(payload: unknown): Promise<void>;
+    private requestUrl;
 }
-export declare class PrometheusRemoteWriteReportingSink extends ExpandedHttpJsonReportingSink {
-    readonly iterationObservationShapeLimited = true;
-    constructor(options?: ExpandedSinkOptionsInput);
+interface DirectVendorMetricSinkOptionsInput extends ExpandedSinkOptionsInput {
+    RunId?: string;
+    runId?: string;
+    ReportingIntervalSeconds?: number;
+    reportingIntervalSeconds?: number;
 }
-export declare class CloudWatchReportingSink extends ExpandedHttpJsonReportingSink {
-    readonly iterationObservationShapeLimited = true;
-    constructor(options?: ExpandedSinkOptionsInput);
+export interface PrometheusRemoteWriteReportingSinkOptionsInput extends DirectVendorMetricSinkOptionsInput {
+    BearerToken?: string;
+    bearerToken?: string;
+}
+export interface CloudWatchReportingSinkOptionsInput extends DirectVendorMetricSinkOptionsInput {
+    Namespace?: string;
+    namespace?: string;
+    Region?: string;
+    region?: string;
+    AccessKeyId?: string;
+    accessKeyId?: string;
+    SecretAccessKey?: string;
+    secretAccessKey?: string;
+    SessionToken?: string;
+    sessionToken?: string;
+    EndpointUrl?: string;
+    endpointUrl?: string;
+}
+export interface DynatraceReportingSinkOptionsInput extends DirectVendorMetricSinkOptionsInput {
+    ApiToken?: string;
+    apiToken?: string;
 }
-export declare class DynatraceReportingSink extends ExpandedHttpJsonReportingSink {
+export interface NewRelicReportingSinkOptionsInput extends DirectVendorMetricSinkOptionsInput {
+    LicenseKey?: string;
+    licenseKey?: string;
+    ApiKey?: string;
+    apiKey?: string;
+}
+declare abstract class DirectVendorMetricReportingSink extends ExpandedEventReportingSink {
     readonly iterationObservationShapeLimited = true;
-    constructor(options?: ExpandedSinkOptionsInput);
+    protected readonly fetchImpl: SinkFetch;
+    protected readonly baseUrl: string;
+    protected readonly endpointPath: string;
+    protected readonly headers: Record<string, string>;
+    protected readonly staticTags: Record<string, string>;
+    protected readonly timeoutMs: number;
+    private readonly configuredRunId;
+    private readonly requireBaseUrl;
+    private configuredFirstIntervalMs;
+    private runStartedUtc;
+    private previousCounts;
+    private previousCountTimes;
+    private stateGeneration;
+    private stateQueue;
+    protected constructor(sinkName: string, licenseFeature: string, defaultEndpointPath: string, options: DirectVendorMetricSinkOptionsInput, requireBaseUrl?: boolean);
+    init(context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>): void;
+    start(session: LoadStrikeSessionStartInfo): void;
+    stop(): void;
+    protected persistEvents(events: ReportingSinkEvent[]): Promise<void>;
+    protected abstract [SEND_DIRECT_VENDOR_PROTOCOL_POINTS](points: readonly ProtocolMetricPoint[]): Promise<void>;
+    abstract [CLONE_DIRECT_VENDOR_FOR_RUN](): DirectVendorMetricReportingSink;
+    private prepareStatefulPoints;
+}
+export declare class PrometheusRemoteWriteReportingSink extends DirectVendorMetricReportingSink {
+    private readonly bearerToken;
+    private readonly cloneOptions;
+    constructor(options?: PrometheusRemoteWriteReportingSinkOptionsInput);
+    [CLONE_DIRECT_VENDOR_FOR_RUN](): PrometheusRemoteWriteReportingSink;
+    protected [SEND_DIRECT_VENDOR_PROTOCOL_POINTS](points: readonly ProtocolMetricPoint[]): Promise<void>;
+}
+export declare class CloudWatchReportingSink extends DirectVendorMetricReportingSink {
+    private readonly namespace;
+    private readonly region;
+    private readonly accessKeyId;
+    private readonly secretAccessKey;
+    private readonly sessionToken;
+    private readonly cloneOptions;
+    private cloudWatchClient;
+    constructor(options?: CloudWatchReportingSinkOptionsInput);
+    [CLONE_DIRECT_VENDOR_FOR_RUN](): CloudWatchReportingSink;
+    init(context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>): void;
+    Dispose(): void;
+    protected [SEND_DIRECT_VENDOR_PROTOCOL_POINTS](points: readonly ProtocolMetricPoint[]): Promise<void>;
+}
+export declare class DynatraceReportingSink extends DirectVendorMetricReportingSink {
+    private readonly apiToken;
+    private readonly cloneOptions;
+    constructor(options?: DynatraceReportingSinkOptionsInput);
+    [CLONE_DIRECT_VENDOR_FOR_RUN](): DynatraceReportingSink;
+    init(context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>): void;
+    protected [SEND_DIRECT_VENDOR_PROTOCOL_POINTS](points: readonly ProtocolMetricPoint[]): Promise<void>;
+}
+export declare class NewRelicReportingSink extends DirectVendorMetricReportingSink {
+    private readonly licenseKey;
+    private readonly cloneOptions;
+    constructor(options?: NewRelicReportingSinkOptionsInput);
+    [CLONE_DIRECT_VENDOR_FOR_RUN](): NewRelicReportingSink;
+    init(context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>): void;
+    protected [SEND_DIRECT_VENDOR_PROTOCOL_POINTS](points: readonly ProtocolMetricPoint[]): Promise<void>;
 }
 export declare class ElasticsearchReportingSink extends ExpandedHttpJsonReportingSink {
-    constructor(options?: ExpandedSinkOptionsInput);
+    private readonly indexName;
+    private readonly usesIndexName;
+    constructor(options?: ElasticsearchReportingSinkOptionsInput);
+    init(context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>): void;
 }
 export declare class OpenSearchReportingSink extends ExpandedHttpJsonReportingSink {
-    constructor(options?: ExpandedSinkOptionsInput);
-}
-export declare class NewRelicReportingSink extends ExpandedHttpJsonReportingSink {
-    readonly iterationObservationShapeLimited = true;
-    constructor(options?: ExpandedSinkOptionsInput);
+    private readonly indexName;
+    private readonly usesIndexName;
+    private readonly username;
+    private readonly password;
+    constructor(options?: OpenSearchReportingSinkOptionsInput);
+    init(context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>): void;
 }
 export declare class GenericWebhookReportingSink extends ExpandedHttpJsonReportingSink {
     protected preservesRawIterationObservations: boolean;
@@ -771,6 +880,8 @@ export declare class GenericWebhookReportingSink extends ExpandedHttpJsonReporti
     CompleteIterationObservationStream(completion: LoadStrikeIterationObservationStreamCompletionV1): Promise<void>;
 }
 export interface KafkaReportingSinkOptionsInput {
+    ConfigurationSectionPath?: string;
+    configurationSectionPath?: string;
     Topic?: string;
     topic?: string;
     BootstrapServers?: string;
@@ -782,15 +893,19 @@ export interface KafkaReportingSinkOptionsInput {
 }
 export declare class KafkaReportingSink extends ExpandedEventReportingSink {
     private readonly topic;
+    private readonly bootstrapServers;
     private readonly staticTags;
     private readonly publishAsync?;
     constructor(options?: KafkaReportingSinkOptionsInput);
+    init(context: LoadStrikeBaseContext, infraConfig: Record<string, unknown>): void;
     saveIterationBatch(batch: LoadStrikeIterationObservationBatchV1): Promise<void>;
     completeIterationObservationStream(completion: LoadStrikeIterationObservationStreamCompletionV1): Promise<void>;
     protected persistEvents(events: ReportingSinkEvent[]): Promise<void>;
     private publishCanonicalValue;
 }
 export interface StatsDReportingSinkOptionsInput {
+    ConfigurationSectionPath?: string;
+    configurationSectionPath?: string;
     Prefix?: string;
     prefix?: string;
     Host?: string;
@@ -827,6 +942,8 @@ export declare class NetdataStatsDReportingSink extends StatsDReportingSinkBase
     constructor(options?: StatsDReportingSinkOptionsInput);
 }
 export interface JsonlFileReportingSinkOptionsInput {
+    ConfigurationSectionPath?: string;
+    configurationSectionPath?: string;
     FilePath?: string;
     filePath?: string;
     StaticTags?: Record<string, string>;
@@ -886,7 +1003,7 @@ declare function cloneSessionStartInfo(session: LoadStrikeSessionStartInfo): Loa
 declare function cloneMetricStats(metrics: LoadStrikeMetricStats): LoadStrikeMetricStats;
 declare function cloneScenarioStats(value: LoadStrikeScenarioStats): LoadStrikeScenarioStats;
 declare function cloneNodeStats(result: LoadStrikeNodeStats): LoadStrikeNodeStats;
-declare function postWithTimeout(fetchImpl: SinkFetch, url: string, init: RequestInit, timeoutMs: number, sinkName: string): Promise<string>;
+declare function postWithTimeout(fetchImpl: SinkFetch, url: string, init: RequestInit, timeoutMs: number, sinkName: string, ignoreSuccessfulResponseBody?: boolean): Promise<string>;
 export declare const __loadstrikeTestExports: {
     GrafanaLokiReportingSink: typeof GrafanaLokiReportingSink;
     InfluxDbReportingSink: typeof InfluxDbReportingSink;

package/dist/types/transports.d.ts

@@ -1009,6 +1009,7 @@ export interface EndpointAdapter {
     initialize?(): Promise<void>;
     produce(payload?: TrackingPayload): Promise<TrackingPayload | null>;
     consume(): Promise<TrackingPayload | null>;
+    interrupt?(): void;
     dispose?(): Promise<void>;
 }
 declare class CallbackAdapter implements EndpointAdapter {
@@ -1068,6 +1069,7 @@ declare class SqsEndpointAdapter extends CallbackAdapter {
 export declare class EndpointAdapterFactory {
     static create(endpoint: EndpointDefinitionInput): EndpointAdapter;
 }
+export declare function validateNativeEndpointExecutionSupport(endpoint: EndpointDefinitionInput): void;
 declare function validateTrackingSelectorPath(expression: string, fieldName: "TrackingField" | "GatherByField"): void;
 declare function validateHttpEndpoint(endpoint: EndpointDefinition, mode: EndpointMode, hasModeDelegate: boolean): void;
 declare function applyHttpAuthHeaders(headers: Record<string, string>, options: HttpEndpointOptions, resolveOAuthToken: () => Promise<string>): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loadstrike/loadstrike-sdk",
-  "version": "1.0.31601",
+  "version": "1.0.33601",
   "description": "TypeScript and JavaScript SDK for in-process load execution, traffic correlation, and reporting.",
   "keywords": [
     "load-testing",
@@ -61,6 +61,7 @@
     "test:broker": "node --test --test-concurrency=1 tests/broker-integration.test.mjs tests/broker-distributed.test.mjs"
   },
   "dependencies": {
+    "@aws-sdk/client-cloudwatch": "^3.1045.0",
     "@aws-sdk/client-sqs": "^3.1045.0",
     "@azure/event-hubs": "^5.12.2",
     "@confluentinc/kafka-javascript": "^1.8.2",
@@ -68,7 +69,10 @@
     "amqplib": "^0.10.9",
     "nats": "^2.29.3",
     "pg": "^8.20.0",
-    "redis": "^4.7.1"
+    "protobufjs": "^8.7.1",
+    "redis": "^4.7.1",
+    "snappyjs": "^0.7.0",
+    "ws": "^8.21.1"
   },
   "publishConfig": {
     "access": "public"
@@ -76,12 +80,14 @@
   "devDependencies": {
     "@types/amqplib": "^0.10.7",
     "@types/node": "^20.19.37",
+    "@types/snappyjs": "^0.7.1",
+    "@types/ws": "^8.18.1",
     "c8": "^11.0.0",
     "rimraf": "^6.0.1",
     "typescript": "^5.9.2"
   },
   "overrides": {
-    "brace-expansion": "5.0.8",
+    "brace-expansion": "5.0.9",
     "tar": "7.5.21"
   }
 }

package/dist/cjs/internal-build.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BLACKBOX_LICENSING_API_BASE_URL_TOKEN = void 0;
-exports.BLACKBOX_LICENSING_API_BASE_URL_TOKEN = "";

package/dist/esm/internal-build.js

@@ -1 +0,0 @@
-export const BLACKBOX_LICENSING_API_BASE_URL_TOKEN = "";

package/dist/types/internal-build.d.ts

@@ -1 +0,0 @@
-export declare const BLACKBOX_LICENSING_API_BASE_URL_TOKEN = "";