@loadstrike/loadstrike-sdk 1.0.27101 → 1.0.29201

package/dist/esm/transports.js

@@ -285,6 +285,127 @@ class PushDiffusionEndpointDefinitionModel extends TrafficEndpointDefinitionMode
         }
     }
 }
+export const GrpcMethodTypes = {
+    Unary: "Unary",
+    ServerStreaming: "ServerStreaming",
+    ClientStreaming: "ClientStreaming",
+    BidirectionalStreaming: "BidirectionalStreaming"
+};
+export class GrpcNativeClientOptions {
+    constructor(initial = {}) {
+        this.UseReflection = false;
+        this.UseTls = true;
+        this.AllowUntrustedCertificates = false;
+        this.DeadlineSeconds = 30;
+        this.Metadata = {};
+        this.RequestPayloadJsonStream = [];
+        const raw = asRecordOrEmpty(initial);
+        this.ProtoFilePath = pickOptionalEndpointString(raw, "ProtoFilePath", "protoFilePath");
+        this.DescriptorSetPath = pickOptionalEndpointString(raw, "DescriptorSetPath", "descriptorSetPath");
+        this.UseReflection = pickEndpointBoolean(raw, "UseReflection", "useReflection") ?? false;
+        this.UseTls = pickEndpointBoolean(raw, "UseTls", "useTls") ?? true;
+        this.AllowUntrustedCertificates = pickEndpointBoolean(raw, "AllowUntrustedCertificates", "allowUntrustedCertificates") ?? false;
+        const deadlineMs = pickOptionalEndpointNumber(raw, "DeadlineMs", "deadlineMs");
+        const deadlineSeconds = pickOptionalEndpointNumber(raw, "DeadlineSeconds", "deadlineSeconds", "Deadline", "deadline");
+        this.DeadlineSeconds = deadlineMs != null ? deadlineMs / 1000 : (deadlineSeconds ?? 30);
+        this.Metadata = pickEndpointStringRecord(raw, "Metadata", "metadata");
+        this.RequestPayloadJson = pickOptionalEndpointString(raw, "RequestPayloadJson", "requestPayloadJson");
+        this.RequestPayloadJsonStream = pickEndpointStringArray(raw, "RequestPayloadJsonStream", "requestPayloadJsonStream") ?? [];
+    }
+    Validate() {
+        this.validate();
+    }
+    validate() {
+        if (this.DeadlineSeconds <= 0) {
+            throw new RangeError("Deadline must be greater than zero.");
+        }
+    }
+}
+export const GrpcStatusMapper = {
+    fromStatusCode(statusCode) {
+        const names = {
+            0: "OK",
+            1: "CANCELLED",
+            2: "UNKNOWN",
+            3: "INVALID_ARGUMENT",
+            4: "DEADLINE_EXCEEDED",
+            5: "NOT_FOUND",
+            6: "ALREADY_EXISTS",
+            7: "PERMISSION_DENIED",
+            8: "RESOURCE_EXHAUSTED",
+            9: "FAILED_PRECONDITION",
+            10: "ABORTED",
+            11: "OUT_OF_RANGE",
+            12: "UNIMPLEMENTED",
+            13: "INTERNAL",
+            14: "UNAVAILABLE",
+            15: "DATA_LOSS",
+            16: "UNAUTHENTICATED"
+        };
+        const normalized = Number.isFinite(statusCode) ? Math.trunc(statusCode) : 2;
+        const statusName = names[normalized] ?? "UNKNOWN";
+        return {
+            statusCode: normalized,
+            StatusCode: normalized,
+            statusName,
+            StatusName: statusName,
+            isSuccess: normalized === 0,
+            IsSuccess: normalized === 0
+        };
+    },
+    FromStatusCode(statusCode) {
+        return this.fromStatusCode(statusCode);
+    }
+};
+export class ProtocolMetricSnapshot {
+    constructor(initial = {}) {
+        this.protocol = "";
+        this.Protocol = "";
+        this.requests = 0;
+        this.Requests = 0;
+        this.messagesSent = 0;
+        this.MessagesSent = 0;
+        this.messagesReceived = 0;
+        this.MessagesReceived = 0;
+        this.latencyMs = 0;
+        this.LatencyMs = 0;
+        this.streamDurationMs = 0;
+        this.StreamDurationMs = 0;
+        this.bytesSent = 0;
+        this.BytesSent = 0;
+        this.bytesReceived = 0;
+        this.BytesReceived = 0;
+        this.reconnects = 0;
+        this.Reconnects = 0;
+        this.errors = 0;
+        this.Errors = 0;
+        this.status = "";
+        this.Status = "";
+        const raw = asRecordOrEmpty(initial);
+        this.protocol = pickOptionalEndpointString(raw, "protocol", "Protocol") ?? "";
+        this.Protocol = this.protocol;
+        this.requests = pickOptionalEndpointNumber(raw, "requests", "Requests") ?? 0;
+        this.Requests = this.requests;
+        this.messagesSent = pickOptionalEndpointNumber(raw, "messagesSent", "MessagesSent") ?? 0;
+        this.MessagesSent = this.messagesSent;
+        this.messagesReceived = pickOptionalEndpointNumber(raw, "messagesReceived", "MessagesReceived") ?? 0;
+        this.MessagesReceived = this.messagesReceived;
+        this.latencyMs = pickOptionalEndpointNumber(raw, "latencyMs", "LatencyMs") ?? 0;
+        this.LatencyMs = this.latencyMs;
+        this.streamDurationMs = pickOptionalEndpointNumber(raw, "streamDurationMs", "StreamDurationMs") ?? 0;
+        this.StreamDurationMs = this.streamDurationMs;
+        this.bytesSent = pickOptionalEndpointNumber(raw, "bytesSent", "BytesSent") ?? 0;
+        this.BytesSent = this.bytesSent;
+        this.bytesReceived = pickOptionalEndpointNumber(raw, "bytesReceived", "BytesReceived") ?? 0;
+        this.BytesReceived = this.bytesReceived;
+        this.reconnects = pickOptionalEndpointNumber(raw, "reconnects", "Reconnects") ?? 0;
+        this.Reconnects = this.reconnects;
+        this.errors = pickOptionalEndpointNumber(raw, "errors", "Errors") ?? 0;
+        this.Errors = this.errors;
+        this.status = pickOptionalEndpointString(raw, "status", "Status") ?? "";
+        this.Status = this.status;
+    }
+}
 class GrpcEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
     constructor(initial) {
         super(initial);
@@ -307,14 +428,155 @@ class GrpcEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
         if (this.DeadlineSeconds <= 0) {
             throw new RangeError("Deadline must be greater than zero.");
         }
-        if (this.Mode === "Produce" && typeof this.ProduceAsync !== "function") {
+        this.NativeClient?.validate();
+        if (this.Mode === "Produce" && typeof this.ProduceAsync !== "function" && !this.NativeClient) {
             throw new Error("ProduceAsync delegate must be provided when endpoint mode is Produce.");
         }
-        if (this.Mode === "Consume" && typeof this.ConsumeAsync !== "function") {
+        if (this.Mode === "Consume" && typeof this.ConsumeAsync !== "function" && !this.NativeClient) {
             throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
         }
     }
 }
+export class WebSocketReconnectPolicy {
+    constructor(initial = {}) {
+        this.MaxAttempts = 0;
+        this.maxAttempts = 0;
+        this.DelaySeconds = 1;
+        this.delaySeconds = 1;
+        const raw = asRecordOrEmpty(initial);
+        this.MaxAttempts = Math.trunc(pickOptionalEndpointNumber(raw, "MaxAttempts", "maxAttempts") ?? 0);
+        this.maxAttempts = this.MaxAttempts;
+        const delayMs = pickOptionalEndpointNumber(raw, "DelayMs", "delayMs");
+        this.DelaySeconds = delayMs != null
+            ? delayMs / 1000
+            : (pickOptionalEndpointNumber(raw, "DelaySeconds", "delaySeconds", "Delay", "delay") ?? 1);
+        this.delaySeconds = this.DelaySeconds;
+    }
+    Validate() {
+        this.validate();
+    }
+    validate() {
+        if (this.MaxAttempts < 0) {
+            throw new RangeError("MaxAttempts cannot be negative.");
+        }
+        if (this.DelaySeconds < 0) {
+            throw new RangeError("Delay cannot be negative.");
+        }
+    }
+}
+export class WebSocketMessageSpec {
+    constructor(initial = {}) {
+        this.Kind = "Text";
+        this.kind = "Text";
+        const raw = asRecordOrEmpty(initial);
+        this.Kind = pickOptionalEndpointString(raw, "Kind", "kind") ?? "Text";
+        this.kind = this.Kind;
+        this.TextPayload = pickOptionalEndpointString(raw, "TextPayload", "textPayload");
+        this.textPayload = this.TextPayload;
+        const binary = pickEndpointValue(raw, "BinaryPayload", "binaryPayload");
+        if (binary instanceof Uint8Array) {
+            this.BinaryPayload = binary;
+        }
+        else if (Array.isArray(binary)) {
+            this.BinaryPayload = Uint8Array.from(binary.map((value) => Number(value) & 0xff));
+        }
+        this.binaryPayload = this.BinaryPayload;
+    }
+    static Text(payload) {
+        return new WebSocketMessageSpec({ Kind: "Text", TextPayload: payload });
+    }
+    static Binary(payload) {
+        return new WebSocketMessageSpec({ Kind: "Binary", BinaryPayload: payload });
+    }
+    Validate() {
+        this.validate();
+    }
+    validate() {
+        if (this.Kind.toLowerCase() === "text" && this.TextPayload == null) {
+            throw new Error("Text WebSocket messages require TextPayload.");
+        }
+        if (this.Kind.toLowerCase() === "binary" && this.BinaryPayload == null) {
+            throw new Error("Binary WebSocket messages require BinaryPayload.");
+        }
+    }
+}
+export class WebSocketExpectedMessage {
+    constructor(initial = {}) {
+        this.TimeoutSeconds = 30;
+        this.timeoutSeconds = 30;
+        const raw = asRecordOrEmpty(initial);
+        this.ContainsText = pickOptionalEndpointString(raw, "ContainsText", "containsText");
+        this.containsText = this.ContainsText;
+        const bytes = pickEndpointValue(raw, "ContainsBytes", "containsBytes");
+        if (bytes instanceof Uint8Array) {
+            this.ContainsBytes = bytes;
+        }
+        else if (Array.isArray(bytes)) {
+            this.ContainsBytes = Uint8Array.from(bytes.map((value) => Number(value) & 0xff));
+        }
+        this.containsBytes = this.ContainsBytes;
+        const timeoutMs = pickOptionalEndpointNumber(raw, "TimeoutMs", "timeoutMs");
+        this.TimeoutSeconds = timeoutMs != null
+            ? timeoutMs / 1000
+            : (pickOptionalEndpointNumber(raw, "TimeoutSeconds", "timeoutSeconds", "Timeout", "timeout") ?? 30);
+        this.timeoutSeconds = this.TimeoutSeconds;
+    }
+    Validate() {
+        this.validate();
+    }
+    validate() {
+        if (this.TimeoutSeconds <= 0) {
+            throw new RangeError("Timeout must be greater than zero.");
+        }
+    }
+}
+export class WebSocketNativeClientOptions {
+    constructor(initial = {}) {
+        this.Headers = {};
+        this.headers = {};
+        this.Cookies = [];
+        this.cookies = [];
+        this.Reconnect = new WebSocketReconnectPolicy();
+        this.reconnect = this.Reconnect;
+        this.Messages = [];
+        this.messages = [];
+        this.ExpectedMessages = [];
+        this.expectedMessages = [];
+        const raw = asRecordOrEmpty(initial);
+        this.Headers = pickEndpointStringRecord(raw, "Headers", "headers");
+        this.headers = this.Headers;
+        this.Cookies = pickEndpointStringArray(raw, "Cookies", "cookies") ?? [];
+        this.cookies = this.Cookies;
+        const pingMs = pickOptionalEndpointNumber(raw, "PingIntervalMs", "pingIntervalMs");
+        const pingSeconds = pickOptionalEndpointNumber(raw, "PingIntervalSeconds", "pingIntervalSeconds", "PingInterval", "pingInterval");
+        this.PingIntervalSeconds = pingMs != null ? pingMs / 1000 : pingSeconds;
+        this.pingIntervalSeconds = this.PingIntervalSeconds;
+        const reconnect = pickEndpointValue(raw, "Reconnect", "reconnect");
+        this.Reconnect = reconnect instanceof WebSocketReconnectPolicy
+            ? reconnect
+            : new WebSocketReconnectPolicy(asRecordOrEmpty(reconnect));
+        this.reconnect = this.Reconnect;
+        this.Messages = normalizeWebSocketMessages(pickEndpointValue(raw, "Messages", "messages"));
+        this.messages = this.Messages;
+        this.ExpectedMessages = normalizeWebSocketExpectedMessages(pickEndpointValue(raw, "ExpectedMessages", "expectedMessages"));
+        this.expectedMessages = this.ExpectedMessages;
+    }
+    Validate() {
+        this.validate();
+    }
+    validate() {
+        if (this.PingIntervalSeconds != null && this.PingIntervalSeconds <= 0) {
+            throw new RangeError("PingInterval must be greater than zero.");
+        }
+        this.Reconnect.validate();
+        for (const message of this.Messages) {
+            message.validate();
+        }
+        for (const expected of this.ExpectedMessages) {
+            expected.validate();
+        }
+    }
+}
 class WebSocketEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
     constructor(initial) {
         super(initial);
@@ -345,10 +607,11 @@ class WebSocketEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
         if (this.CloseTimeoutSeconds <= 0) {
             throw new RangeError("CloseTimeout must be greater than zero.");
         }
-        if (this.Mode === "Produce" && typeof this.ProduceAsync !== "function") {
+        this.NativeClient?.validate();
+        if (this.Mode === "Produce" && typeof this.ProduceAsync !== "function" && !this.NativeClient) {
             throw new Error("ProduceAsync delegate must be provided when endpoint mode is Produce.");
         }
-        if (this.Mode === "Consume" && typeof this.ConsumeAsync !== "function") {
+        if (this.Mode === "Consume" && typeof this.ConsumeAsync !== "function" && !this.NativeClient) {
             throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
         }
     }
@@ -862,6 +1125,12 @@ function initializeGrpcEndpointDefinitionModel(target, initial) {
     if (hasAnyEndpointField(raw, ["Metadata", "metadata"])) {
         target.Metadata = pickEndpointStringRecord(raw, "Metadata", "metadata");
     }
+    if (hasAnyEndpointField(raw, ["NativeClient", "nativeClient"])) {
+        const nativeClient = pickEndpointValue(raw, "NativeClient", "nativeClient");
+        target.NativeClient = nativeClient instanceof GrpcNativeClientOptions
+            ? nativeClient
+            : new GrpcNativeClientOptions(asRecordOrEmpty(nativeClient));
+    }
 }
 function initializeWebSocketEndpointDefinitionModel(target, initial) {
     const raw = asRecordOrEmpty(initial);
@@ -908,6 +1177,12 @@ function initializeWebSocketEndpointDefinitionModel(target, initial) {
     if (hasAnyEndpointField(raw, ["ConnectionMetadata", "connectionMetadata"])) {
         target.ConnectionMetadata = pickEndpointStringRecord(raw, "ConnectionMetadata", "connectionMetadata");
     }
+    if (hasAnyEndpointField(raw, ["NativeClient", "nativeClient"])) {
+        const nativeClient = pickEndpointValue(raw, "NativeClient", "nativeClient");
+        target.NativeClient = nativeClient instanceof WebSocketNativeClientOptions
+            ? nativeClient
+            : new WebSocketNativeClientOptions(asRecordOrEmpty(nativeClient));
+    }
 }
 function validateTrafficEndpointDefinitionModel(target) {
     requireNonEmptyString(target.Name, "Endpoint name must be provided.");
@@ -2248,7 +2523,9 @@ const DELEGATE_STREAM_ENDPOINT_FLAT_KEYS = [
     "ConsumeAsync",
     "consumeAsync",
     "ConnectionMetadata",
-    "connectionMetadata"
+    "connectionMetadata",
+    "NativeClient",
+    "nativeClient"
 ];
 const GRPC_ENDPOINT_FLAT_KEYS = [
     "Target",
@@ -2276,7 +2553,9 @@ const GRPC_ENDPOINT_FLAT_KEYS = [
     "ConsumeAsync",
     "consumeAsync",
     "ConnectionMetadata",
-    "connectionMetadata"
+    "connectionMetadata",
+    "NativeClient",
+    "nativeClient"
 ];
 const WEB_SOCKET_ENDPOINT_FLAT_KEYS = [
     "Url",
@@ -2436,7 +2715,9 @@ function resolveEndpointKind(raw) {
         "MethodName",
         "methodName",
         "MethodType",
-        "methodType"
+        "methodType",
+        "NativeClient",
+        "nativeClient"
     ])) {
         return "Grpc";
     }
@@ -2446,7 +2727,9 @@ function resolveEndpointKind(raw) {
         "ConnectTimeoutSeconds",
         "connectTimeoutSeconds",
         "CloseTimeoutSeconds",
-        "closeTimeoutSeconds"
+        "closeTimeoutSeconds",
+        "NativeClient",
+        "nativeClient"
     ])) {
         return "WebSocket";
     }
@@ -2580,6 +2863,22 @@ function normalizeDelegateEndpointOptions(options) {
 function normalizeProtocolOptions(options) {
     return Object.keys(options).length ? options : undefined;
 }
+function normalizeWebSocketMessages(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.map((entry) => entry instanceof WebSocketMessageSpec
+        ? entry
+        : new WebSocketMessageSpec(asRecordOrEmpty(entry)));
+}
+function normalizeWebSocketExpectedMessages(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.map((entry) => entry instanceof WebSocketExpectedMessage
+        ? entry
+        : new WebSocketExpectedMessage(asRecordOrEmpty(entry)));
+}
 function pickEndpointValue(record, ...keys) {
     return pickProtocolValue(record, ...keys);
 }
@@ -2817,10 +3116,14 @@ function validateGrpcEndpoint(endpoint, mode) {
         || (hasOptionValue(options, "DeadlineSeconds", "deadlineSeconds", "Deadline", "deadline") && deadlineSeconds <= 0)) {
         throw new RangeError("Deadline must be greater than zero.");
     }
-    if (mode === "Produce" && !resolveStructuredProduceDelegate(endpoint) && !resolveProduceDelegate(endpoint)) {
+    const nativeClient = pickEndpointValue(options, "NativeClient", "nativeClient");
+    if (nativeClient != null) {
+        new GrpcNativeClientOptions(asRecordOrEmpty(nativeClient)).validate();
+    }
+    if (mode === "Produce" && !resolveStructuredProduceDelegate(endpoint) && !resolveProduceDelegate(endpoint) && nativeClient == null) {
         throw new Error("ProduceAsync delegate must be provided when endpoint mode is Produce.");
     }
-    if (mode === "Consume" && !resolveStructuredConsumeDelegate(endpoint) && !resolveStructuredConsumeStreamDelegate(endpoint) && !resolveConsumeDelegate(endpoint)) {
+    if (mode === "Consume" && !resolveStructuredConsumeDelegate(endpoint) && !resolveStructuredConsumeStreamDelegate(endpoint) && !resolveConsumeDelegate(endpoint) && nativeClient == null) {
         throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
     }
 }
@@ -2849,10 +3152,14 @@ function validateWebSocketEndpoint(endpoint, mode) {
         || (hasOptionValue(options, "CloseTimeoutSeconds", "closeTimeoutSeconds", "CloseTimeout", "closeTimeout") && closeSeconds <= 0)) {
         throw new RangeError("CloseTimeout must be greater than zero.");
     }
-    if (mode === "Produce" && !resolveStructuredProduceDelegate(endpoint) && !resolveProduceDelegate(endpoint)) {
+    const nativeClient = pickEndpointValue(options, "NativeClient", "nativeClient");
+    if (nativeClient != null) {
+        new WebSocketNativeClientOptions(asRecordOrEmpty(nativeClient)).validate();
+    }
+    if (mode === "Produce" && !resolveStructuredProduceDelegate(endpoint) && !resolveProduceDelegate(endpoint) && nativeClient == null) {
         throw new Error("ProduceAsync delegate must be provided when endpoint mode is Produce.");
     }
-    if (mode === "Consume" && !resolveStructuredConsumeDelegate(endpoint) && !resolveStructuredConsumeStreamDelegate(endpoint) && !resolveConsumeDelegate(endpoint)) {
+    if (mode === "Consume" && !resolveStructuredConsumeDelegate(endpoint) && !resolveStructuredConsumeStreamDelegate(endpoint) && !resolveConsumeDelegate(endpoint) && nativeClient == null) {
         throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
     }
 }

package/dist/types/contracts.d.ts

@@ -3,6 +3,7 @@ export type LoadStrikeDateValue = string | Date;
 export interface LoadStrikeRunRequest {
     Context?: LoadStrikeRunContext | Record<string, unknown>;
     Scenarios?: Array<LoadStrikeScenarioSpec | Record<string, unknown>>;
+    ScenarioSourceAnalysis?: Array<LoadStrikeScenarioSourceAnalysisSpec | Record<string, unknown>>;
     RunArgs?: string[];
 }
 export interface LoadStrikeRunContext {
@@ -45,6 +46,17 @@ export interface LoadStrikeScenarioSpec {
     LoadSimulations?: LoadStrikeLoadSimulationSpec[];
     Thresholds?: Array<LoadStrikeThresholdSpec | Record<string, unknown>>;
     Tracking?: LoadStrikeTrackingConfigurationSpec | Record<string, unknown>;
+    ScenarioSourceAnalysis?: LoadStrikeScenarioSourceAnalysisSpec | Record<string, unknown>;
+}
+export interface LoadStrikeScenarioSourceAnalysisSpec {
+    ScenarioName: string;
+    Language: string;
+    AnalyzerVersion: string;
+    ScenarioBlockLineCount: number;
+    LocalMethodLineCount: number;
+    TotalCountedLineCount: number;
+    IgnoredExternalCallCount: number;
+    Warnings?: string[];
 }
 export interface LoadStrikeLoadSimulationSpec {
     Kind: string;

package/dist/types/index.d.ts

@@ -2,11 +2,11 @@ export type { LoadStrikeDateValue, LoadStrikeObject, LoadStrikeRunContext as Loa
 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";
-export { CrossPlatformScenarioConfigurator, ScenarioTrackingExtensions, LoadStrikeContext, LoadStrikeAccessibility, LoadStrikeBrowserWebVitals, LoadStrikePluginData, LoadStrikePluginDataTable, LoadStrikeNodeType, LoadStrikeReportFormat, LoadStrikeResponse, LoadStrikeLogLevel, LoadStrikeScenarioOperation, LoadStrikeOperationType, LoadStrikeRunner, LoadStrikeScenario, LoadStrikeScenarioShare, LoadStrikeSimulation, LoadStrikeTrafficMix, CrossPlatformTrackingConfiguration, LoadStrikeMetric, LoadStrikeCounter, LoadStrikeGauge, LoadStrikeStep, LoadStrikeThreshold } from "./runtime.js";
-export type { ILoadStrikeReportingSink, ILoadStrikeWorkerPlugin, LoadStrikeRunResult, LoadStrikeReportingSink, LoadStrikeRuntimePolicy, LoadStrikeRunnerOptions, LoadStrikeRunContext as LoadStrikeRuntimeContext, LoadStrikeRunContext, LoadStrikeAccessibilityOptions, LoadStrikeAccessibilityViolation, LoadStrikeAccessibilityResult, LoadStrikeAccessibilityCheckContext, LoadStrikeBrowserWebVitalsOptions, LoadStrikeBrowserWebVitalsResult, LoadStrikeBrowserWebVitalsContext, 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 { CrossPlatformScenarioConfigurator, ScenarioTrackingExtensions, LoadStrikeContext, LoadStrikeAccessibility, LoadStrikeAccessibilityAdapters, LoadStrikeAccessibilityBaseline, LoadStrikeAccessibilityCiGate, LoadStrikeAccessibilityScanner, LoadStrikeBrowserWebVitals, LoadStrikeBrowserWebVitalsCollector, LoadStrikePluginData, LoadStrikePluginDataTable, LoadStrikeNodeType, LoadStrikeReportFormat, LoadStrikeResponse, LoadStrikeLogLevel, LoadStrikeScenarioOperation, LoadStrikeOperationType, LoadStrikeRunner, LoadStrikeScenario, LoadStrikeScenarioShare, LoadStrikeSimulation, LoadStrikeTrafficMix, CrossPlatformTrackingConfiguration, LoadStrikeMetric, LoadStrikeCounter, LoadStrikeGauge, LoadStrikeStep, LoadStrikeThreshold } from "./runtime.js";
+export type { ILoadStrikeReportingSink, ILoadStrikeWorkerPlugin, LoadStrikeRunResult, LoadStrikeReportingSink, LoadStrikeRuntimePolicy, LoadStrikeRunnerOptions, LoadStrikeRunContext as LoadStrikeRuntimeContext, LoadStrikeRunContext, LoadStrikeAccessibilityOptions, LoadStrikeAccessibilityBaselineOutcome, LoadStrikeAccessibilityCiGateOutcome, LoadStrikeAccessibilityViolation, LoadStrikeKeyboardFocusResult, LoadStrikeAccessibilityResult, LoadStrikeAccessibilityCheckContext, LoadStrikeBrowserWebVitalsOptions, LoadStrikeBrowserWebVitalsResult, LoadStrikeBrowserWebVitalsContext, 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 { LOADSTRIKE_TRACE_ID_HEADER, LOADSTRIKE_TRACE_ID_TRACKING_FIELD, TrafficEndpointDefinition, HttpEndpointDefinition, KafkaEndpointDefinition, KafkaSaslOptions, RabbitMqEndpointDefinition, NatsEndpointDefinition, RedisStreamsEndpointDefinition, AzureEventHubsEndpointDefinition, SqsEndpointDefinition, DelegateStreamEndpointDefinition, PushDiffusionEndpointDefinition, GrpcEndpointDefinition, WebSocketEndpointDefinition, HttpOAuth2ClientCredentialsOptions, HttpAuthOptions } from "./transports.js";
+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, GrafanaLokiReportingSink, GrafanaLokiReportingSinkOptions, InfluxDbReportingSink, InfluxDbReportingSinkOptions, OtelCollectorReportingSink, OtelCollectorReportingSinkOptions, PortalReportingSink, SplunkReportingSink, SplunkReportingSinkOptions, TimescaleDbReportingSink, TimescaleDbReportingSinkOptions } from "./sinks.js";
-export type { DatadogSinkOptions, GrafanaLokiSinkOptions, InfluxDbSinkOptions, OtelCollectorSinkOptions, PortalReportingSinkOptionsInput, SplunkSinkOptions, TimescaleDbSinkOptions } from "./sinks.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";

package/dist/types/runtime.d.ts

@@ -697,6 +697,18 @@ export interface LoadStrikeAccessibilityViolation {
 export interface LoadStrikeAccessibilityResult {
     url?: string;
     violations?: LoadStrikeAccessibilityViolation[];
+    keyboardFocus?: LoadStrikeKeyboardFocusResult;
+    totalViolations?: number;
+    criticalViolations?: number;
+    seriousViolations?: number;
+    moderateViolations?: number;
+    minorViolations?: number;
+}
+export interface LoadStrikeKeyboardFocusResult {
+    tabbableElementCount?: number;
+    visibleFocusFailures?: number;
+    missingSkipLinkCount?: number;
+    focusOrder?: string[];
 }
 export interface LoadStrikeAccessibilityCheckContext {
     options: LoadStrikeAccessibilityOptions;
@@ -1523,6 +1535,60 @@ export declare class LoadStrikeContext {
      */
     withRegisteredScenarios(...scenarios: LoadStrikeScenario[]): LoadStrikeContext;
 }
+export declare class LoadStrikeAccessibilityBaseline {
+    readonly allowedRuleIds: string[];
+    readonly AllowedRuleIds: string[];
+    readonly maxNewViolations: number;
+    readonly MaxNewViolations: number;
+    constructor(initial?: Record<string, unknown>);
+    compare(result: LoadStrikeAccessibilityResult): LoadStrikeAccessibilityBaselineOutcome;
+    Compare(result: LoadStrikeAccessibilityResult): LoadStrikeAccessibilityBaselineOutcome;
+}
+export interface LoadStrikeAccessibilityBaselineOutcome {
+    passed: boolean;
+    Passed: boolean;
+    newViolationCount: number;
+    NewViolationCount: number;
+    newRuleIds: string[];
+    NewRuleIds: string[];
+}
+export declare class LoadStrikeAccessibilityCiGate {
+    readonly maxViolations?: number;
+    readonly MaxViolations?: number;
+    readonly maxCriticalViolations?: number;
+    readonly MaxCriticalViolations?: number;
+    readonly maxSeriousViolations?: number;
+    readonly MaxSeriousViolations?: number;
+    readonly baseline?: LoadStrikeAccessibilityBaseline;
+    readonly Baseline?: LoadStrikeAccessibilityBaseline;
+    constructor(initial?: Record<string, unknown>);
+    evaluate(result: LoadStrikeAccessibilityResult): LoadStrikeAccessibilityCiGateOutcome;
+    Evaluate(result: LoadStrikeAccessibilityResult): LoadStrikeAccessibilityCiGateOutcome;
+}
+export interface LoadStrikeAccessibilityCiGateOutcome {
+    passed: boolean;
+    Passed: boolean;
+    reasons: string[];
+    Reasons: string[];
+}
+export declare class LoadStrikeAccessibilityScanner {
+    static scanHtml(options: LoadStrikeAccessibilityOptions, html: string): LoadStrikeAccessibilityResult;
+    static ScanHtml(options: LoadStrikeAccessibilityOptions, html: string): LoadStrikeAccessibilityResult;
+}
+export declare class LoadStrikeAccessibilityAdapters {
+    static fromPlaywrightPageAsync(options: LoadStrikeAccessibilityOptions, page: unknown): Promise<LoadStrikeAccessibilityResult>;
+    static FromPlaywrightPageAsync(options: LoadStrikeAccessibilityOptions, page: unknown): Promise<LoadStrikeAccessibilityResult>;
+    static fromSeleniumDriver(options: LoadStrikeAccessibilityOptions, driver: unknown): LoadStrikeAccessibilityResult;
+    static FromSeleniumDriver(options: LoadStrikeAccessibilityOptions, driver: unknown): LoadStrikeAccessibilityResult;
+}
+export declare class LoadStrikeBrowserWebVitalsCollector {
+    static fromPerformanceSnapshot(options: LoadStrikeBrowserWebVitalsOptions, snapshot: unknown): LoadStrikeBrowserWebVitalsResult;
+    static FromPerformanceSnapshot(options: LoadStrikeBrowserWebVitalsOptions, snapshot: unknown): LoadStrikeBrowserWebVitalsResult;
+    static fromPlaywrightPageAsync(options: LoadStrikeBrowserWebVitalsOptions, page: unknown): Promise<LoadStrikeBrowserWebVitalsResult>;
+    static FromPlaywrightPageAsync(options: LoadStrikeBrowserWebVitalsOptions, page: unknown): Promise<LoadStrikeBrowserWebVitalsResult>;
+    static fromSeleniumDriver(options: LoadStrikeBrowserWebVitalsOptions, driver: unknown): LoadStrikeBrowserWebVitalsResult;
+    static FromSeleniumDriver(options: LoadStrikeBrowserWebVitalsOptions, driver: unknown): LoadStrikeBrowserWebVitalsResult;
+}
 export declare class LoadStrikeAccessibility {
     static createScenario(name: string, options: LoadStrikeAccessibilityOptions, check: (context: LoadStrikeAccessibilityCheckContext) => Promise<LoadStrikeAccessibilityResult> | LoadStrikeAccessibilityResult): LoadStrikeScenario;
     static CreateScenario(name: string, options: LoadStrikeAccessibilityOptions, check: (context: LoadStrikeAccessibilityCheckContext) => Promise<LoadStrikeAccessibilityResult> | LoadStrikeAccessibilityResult): LoadStrikeScenario;
@@ -1662,6 +1728,7 @@ export declare class LoadStrikeScenario {
      */
     shouldRestartIterationOnFail(): boolean;
     __loadStrikeInternalLicenseFeatures(): string[];
+    __loadStrikeScenarioSourceAnalysis(): Record<string, unknown>;
     __loadStrikeWithInternalLicenseFeatures(...features: string[]): LoadStrikeScenario;
     invokeInit(context: LoadStrikeScenarioInitContext): Promise<void>;
     invokeClean(context: LoadStrikeScenarioInitContext): Promise<void>;