@loadstrike/loadstrike-sdk 1.0.26701 → 1.0.27101

package/dist/esm/transports.js

@@ -285,6 +285,74 @@ class PushDiffusionEndpointDefinitionModel extends TrafficEndpointDefinitionMode
         }
     }
 }
+class GrpcEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
+    constructor(initial) {
+        super(initial);
+        this.Kind = "Grpc";
+        this.Target = "";
+        this.ServiceName = "";
+        this.MethodName = "";
+        this.MethodType = "Unary";
+        this.DeadlineSeconds = 30;
+        this.ConnectionMetadata = {};
+        this.Metadata = {};
+        initializeGrpcEndpointDefinitionModel(this, initial);
+    }
+    Validate() {
+        super.Validate();
+        requireNonEmptyString(this.Target, "Target must be provided for gRPC endpoint definitions.");
+        requireNonEmptyString(this.ServiceName, "ServiceName must be provided for gRPC endpoint definitions.");
+        requireNonEmptyString(this.MethodName, "MethodName must be provided for gRPC endpoint definitions.");
+        requireNonEmptyString(this.MethodType, "MethodType must be provided for gRPC endpoint definitions.");
+        if (this.DeadlineSeconds <= 0) {
+            throw new RangeError("Deadline must be greater than zero.");
+        }
+        if (this.Mode === "Produce" && typeof this.ProduceAsync !== "function") {
+            throw new Error("ProduceAsync delegate must be provided when endpoint mode is Produce.");
+        }
+        if (this.Mode === "Consume" && typeof this.ConsumeAsync !== "function") {
+            throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
+        }
+    }
+}
+class WebSocketEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
+    constructor(initial) {
+        super(initial);
+        this.Kind = "WebSocket";
+        this.Url = "";
+        this.Subprotocols = [];
+        this.ConnectTimeoutSeconds = 30;
+        this.CloseTimeoutSeconds = 5;
+        this.ConnectionMetadata = {};
+        initializeWebSocketEndpointDefinitionModel(this, initial);
+    }
+    Validate() {
+        super.Validate();
+        const url = requireNonEmptyString(this.Url, "Url must be provided for WebSocket endpoint definitions.");
+        let parsed;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            throw new Error("Url must be an absolute ws:// or wss:// URI.");
+        }
+        if (parsed.protocol !== "ws:" && parsed.protocol !== "wss:") {
+            throw new Error("Url must be an absolute ws:// or wss:// URI.");
+        }
+        if (this.ConnectTimeoutSeconds <= 0) {
+            throw new RangeError("ConnectTimeout must be greater than zero.");
+        }
+        if (this.CloseTimeoutSeconds <= 0) {
+            throw new RangeError("CloseTimeout must be greater than zero.");
+        }
+        if (this.Mode === "Produce" && typeof this.ProduceAsync !== "function") {
+            throw new Error("ProduceAsync delegate must be provided when endpoint mode is Produce.");
+        }
+        if (this.Mode === "Consume" && typeof this.ConsumeAsync !== "function") {
+            throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
+        }
+    }
+}
 export const TrafficEndpointDefinition = TrafficEndpointDefinitionModel;
 export const HttpEndpointDefinition = HttpEndpointDefinitionModel;
 export const KafkaEndpointDefinition = KafkaEndpointDefinitionModel;
@@ -295,6 +363,8 @@ export const AzureEventHubsEndpointDefinition = AzureEventHubsEndpointDefinition
 export const SqsEndpointDefinition = SqsEndpointDefinitionModel;
 export const DelegateStreamEndpointDefinition = DelegateStreamEndpointDefinitionModel;
 export const PushDiffusionEndpointDefinition = PushDiffusionEndpointDefinitionModel;
+export const GrpcEndpointDefinition = GrpcEndpointDefinitionModel;
+export const WebSocketEndpointDefinition = WebSocketEndpointDefinitionModel;
 export const HttpOAuth2ClientCredentialsOptions = HttpOAuth2ClientCredentialsOptionsModel;
 export const HttpAuthOptions = HttpAuthOptionsModel;
 export const KafkaSaslOptions = KafkaSaslOptionsModel;
@@ -744,6 +814,101 @@ function initializePushDiffusionEndpointDefinitionModel(target, initial) {
         target.SubscribeAsync = subscribeAsync;
     }
 }
+function initializeGrpcEndpointDefinitionModel(target, initial) {
+    const raw = asRecordOrEmpty(initial);
+    const targetUrl = pickOptionalEndpointString(raw, "Target", "target");
+    if (targetUrl) {
+        target.Target = targetUrl;
+    }
+    const serviceName = pickOptionalEndpointString(raw, "ServiceName", "serviceName");
+    if (serviceName) {
+        target.ServiceName = serviceName;
+    }
+    const methodName = pickOptionalEndpointString(raw, "MethodName", "methodName");
+    if (methodName) {
+        target.MethodName = methodName;
+    }
+    const methodType = pickOptionalEndpointString(raw, "MethodType", "methodType");
+    if (methodType) {
+        target.MethodType = methodType;
+    }
+    const deadlineMs = pickOptionalEndpointNumber(raw, "DeadlineMs", "deadlineMs");
+    const deadlineSeconds = pickOptionalEndpointNumber(raw, "DeadlineSeconds", "deadlineSeconds", "Deadline", "deadline");
+    if (deadlineMs != null) {
+        target.DeadlineSeconds = deadlineMs / 1000;
+    }
+    else if (deadlineSeconds != null) {
+        target.DeadlineSeconds = deadlineSeconds;
+    }
+    const produce = pickEndpointFunction(raw, "Produce", "produce");
+    if (produce) {
+        target.Produce = produce;
+    }
+    const consume = pickEndpointFunction(raw, "Consume", "consume");
+    if (consume) {
+        target.Consume = consume;
+    }
+    const produceAsync = pickEndpointFunction(raw, "ProduceAsync", "produceAsync");
+    if (produceAsync) {
+        target.ProduceAsync = produceAsync;
+    }
+    const consumeAsync = pickEndpointFunction(raw, "ConsumeAsync", "consumeAsync");
+    if (consumeAsync) {
+        target.ConsumeAsync = consumeAsync;
+    }
+    if (hasAnyEndpointField(raw, ["ConnectionMetadata", "connectionMetadata"])) {
+        target.ConnectionMetadata = pickEndpointStringRecord(raw, "ConnectionMetadata", "connectionMetadata");
+    }
+    if (hasAnyEndpointField(raw, ["Metadata", "metadata"])) {
+        target.Metadata = pickEndpointStringRecord(raw, "Metadata", "metadata");
+    }
+}
+function initializeWebSocketEndpointDefinitionModel(target, initial) {
+    const raw = asRecordOrEmpty(initial);
+    const url = pickOptionalEndpointString(raw, "Url", "url");
+    if (url) {
+        target.Url = url;
+    }
+    const subprotocols = pickEndpointStringArray(raw, "Subprotocols", "subprotocols");
+    if (subprotocols) {
+        target.Subprotocols = subprotocols;
+    }
+    const connectMs = pickOptionalEndpointNumber(raw, "ConnectTimeoutMs", "connectTimeoutMs");
+    const connectSeconds = pickOptionalEndpointNumber(raw, "ConnectTimeoutSeconds", "connectTimeoutSeconds", "ConnectTimeout", "connectTimeout");
+    if (connectMs != null) {
+        target.ConnectTimeoutSeconds = connectMs / 1000;
+    }
+    else if (connectSeconds != null) {
+        target.ConnectTimeoutSeconds = connectSeconds;
+    }
+    const closeMs = pickOptionalEndpointNumber(raw, "CloseTimeoutMs", "closeTimeoutMs");
+    const closeSeconds = pickOptionalEndpointNumber(raw, "CloseTimeoutSeconds", "closeTimeoutSeconds", "CloseTimeout", "closeTimeout");
+    if (closeMs != null) {
+        target.CloseTimeoutSeconds = closeMs / 1000;
+    }
+    else if (closeSeconds != null) {
+        target.CloseTimeoutSeconds = closeSeconds;
+    }
+    const produce = pickEndpointFunction(raw, "Produce", "produce");
+    if (produce) {
+        target.Produce = produce;
+    }
+    const consume = pickEndpointFunction(raw, "Consume", "consume");
+    if (consume) {
+        target.Consume = consume;
+    }
+    const produceAsync = pickEndpointFunction(raw, "ProduceAsync", "produceAsync");
+    if (produceAsync) {
+        target.ProduceAsync = produceAsync;
+    }
+    const consumeAsync = pickEndpointFunction(raw, "ConsumeAsync", "consumeAsync");
+    if (consumeAsync) {
+        target.ConsumeAsync = consumeAsync;
+    }
+    if (hasAnyEndpointField(raw, ["ConnectionMetadata", "connectionMetadata"])) {
+        target.ConnectionMetadata = pickEndpointStringRecord(raw, "ConnectionMetadata", "connectionMetadata");
+    }
+}
 function validateTrafficEndpointDefinitionModel(target) {
     requireNonEmptyString(target.Name, "Endpoint name must be provided.");
     if (target.Mode !== "Produce" && target.Mode !== "Consume") {
@@ -1878,6 +2043,10 @@ class PushDiffusionEndpointAdapter extends CallbackAdapter {
 }
 class DelegateStreamEndpointAdapter extends CallbackAdapter {
 }
+class GrpcEndpointAdapter extends CallbackAdapter {
+}
+class WebSocketEndpointAdapter extends CallbackAdapter {
+}
 export class EndpointAdapterFactory {
     static create(endpoint) {
         if (endpoint instanceof TrafficEndpointDefinitionModel) {
@@ -1904,6 +2073,10 @@ export class EndpointAdapterFactory {
                 return new PushDiffusionEndpointAdapter(normalized);
             case "DelegateStream":
                 return new DelegateStreamEndpointAdapter(normalized);
+            case "Grpc":
+                return new GrpcEndpointAdapter(normalized);
+            case "WebSocket":
+                return new WebSocketEndpointAdapter(normalized);
             default:
                 throw new Error(`Unsupported endpoint kind: ${String(normalized?.kind ?? "")}.`);
         }
@@ -2077,6 +2250,62 @@ const DELEGATE_STREAM_ENDPOINT_FLAT_KEYS = [
     "ConnectionMetadata",
     "connectionMetadata"
 ];
+const GRPC_ENDPOINT_FLAT_KEYS = [
+    "Target",
+    "target",
+    "ServiceName",
+    "serviceName",
+    "MethodName",
+    "methodName",
+    "MethodType",
+    "methodType",
+    "Deadline",
+    "deadline",
+    "DeadlineSeconds",
+    "deadlineSeconds",
+    "DeadlineMs",
+    "deadlineMs",
+    "Metadata",
+    "metadata",
+    "Produce",
+    "produce",
+    "Consume",
+    "consume",
+    "ProduceAsync",
+    "produceAsync",
+    "ConsumeAsync",
+    "consumeAsync",
+    "ConnectionMetadata",
+    "connectionMetadata"
+];
+const WEB_SOCKET_ENDPOINT_FLAT_KEYS = [
+    "Url",
+    "url",
+    "Subprotocols",
+    "subprotocols",
+    "ConnectTimeout",
+    "connectTimeout",
+    "ConnectTimeoutSeconds",
+    "connectTimeoutSeconds",
+    "ConnectTimeoutMs",
+    "connectTimeoutMs",
+    "CloseTimeout",
+    "closeTimeout",
+    "CloseTimeoutSeconds",
+    "closeTimeoutSeconds",
+    "CloseTimeoutMs",
+    "closeTimeoutMs",
+    "Produce",
+    "produce",
+    "Consume",
+    "consume",
+    "ProduceAsync",
+    "produceAsync",
+    "ConsumeAsync",
+    "consumeAsync",
+    "ConnectionMetadata",
+    "connectionMetadata"
+];
 function normalizeEndpointDefinition(endpoint) {
     if (!endpoint || typeof endpoint !== "object") {
         return endpoint;
@@ -2111,7 +2340,9 @@ function normalizeEndpointDefinition(endpoint) {
         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))
+        delegate: normalizeDelegateEndpointOptions(pickEndpointTransportRecord(raw, kind, "DelegateStream", ["delegate", "Delegate", "DelegateStream"], DELEGATE_STREAM_ENDPOINT_FLAT_KEYS)),
+        grpc: normalizeProtocolOptions(pickEndpointTransportRecord(raw, kind, "Grpc", ["grpc", "Grpc"], GRPC_ENDPOINT_FLAT_KEYS)),
+        webSocket: normalizeProtocolOptions(pickEndpointTransportRecord(raw, kind, "WebSocket", ["webSocket", "WebSocket"], WEB_SOCKET_ENDPOINT_FLAT_KEYS))
     };
 }
 function resolveEndpointKind(raw) {
@@ -2197,6 +2428,28 @@ function resolveEndpointKind(raw) {
     ])) {
         return "PushDiffusion";
     }
+    if (Object.keys(pickEndpointRecord(raw, "grpc", "Grpc")).length || hasAnyEndpointField(raw, [
+        "Target",
+        "target",
+        "ServiceName",
+        "serviceName",
+        "MethodName",
+        "methodName",
+        "MethodType",
+        "methodType"
+    ])) {
+        return "Grpc";
+    }
+    if (Object.keys(pickEndpointRecord(raw, "webSocket", "WebSocket")).length || hasAnyEndpointField(raw, [
+        "Subprotocols",
+        "subprotocols",
+        "ConnectTimeoutSeconds",
+        "connectTimeoutSeconds",
+        "CloseTimeoutSeconds",
+        "closeTimeoutSeconds"
+    ])) {
+        return "WebSocket";
+    }
     if (Object.keys(pickEndpointRecord(raw, "delegate", "Delegate", "DelegateStream")).length || hasAnyEndpointField(raw, [
         "Produce",
         "produce",
@@ -2440,10 +2693,8 @@ function validateEndpointDefinition(endpoint) {
     if (mode !== "Produce" && mode !== "Consume") {
         throw new Error(`Unsupported endpoint mode: ${mode}.`);
     }
-    const hasProduceDelegate = typeof endpoint.delegate?.produce === "function"
-        || typeof endpoint.delegate?.produceAsync === "function";
-    const hasConsumeDelegate = typeof endpoint.delegate?.consume === "function"
-        || typeof endpoint.delegate?.consumeAsync === "function";
+    const hasProduceDelegate = Boolean(resolveProduceDelegate(endpoint) || resolveStructuredProduceDelegate(endpoint));
+    const hasConsumeDelegate = Boolean(resolveConsumeDelegate(endpoint) || resolveStructuredConsumeDelegate(endpoint) || resolveStructuredConsumeStreamDelegate(endpoint));
     const hasModeDelegate = mode === "Produce" ? hasProduceDelegate : hasConsumeDelegate;
     switch (kind) {
         case "Http":
@@ -2473,6 +2724,12 @@ function validateEndpointDefinition(endpoint) {
         case "DelegateStream":
             validateDelegateStreamEndpoint(endpoint, mode);
             return;
+        case "Grpc":
+            validateGrpcEndpoint(endpoint, mode);
+            return;
+        case "WebSocket":
+            validateWebSocketEndpoint(endpoint, mode);
+            return;
         default:
             throw new Error(`Unsupported endpoint kind: ${kind}.`);
     }
@@ -2548,6 +2805,57 @@ function validateDelegateStreamEndpoint(endpoint, mode) {
         throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
     }
 }
+function validateGrpcEndpoint(endpoint, mode) {
+    const options = asRecordOrEmpty(endpoint.grpc);
+    requireNonEmptyString(optionString(options, "Target", "target"), "Target must be provided for gRPC endpoint definitions.");
+    requireNonEmptyString(optionString(options, "ServiceName", "serviceName"), "ServiceName must be provided for gRPC endpoint definitions.");
+    requireNonEmptyString(optionString(options, "MethodName", "methodName"), "MethodName must be provided for gRPC endpoint definitions.");
+    requireNonEmptyString(optionString(options, "MethodType", "methodType") || "Unary", "MethodType must be provided for gRPC endpoint definitions.");
+    const deadlineMs = optionNumber(options, "DeadlineMs", "deadlineMs");
+    const deadlineSeconds = optionNumber(options, "DeadlineSeconds", "deadlineSeconds", "Deadline", "deadline");
+    if ((hasOptionValue(options, "DeadlineMs", "deadlineMs") && deadlineMs <= 0)
+        || (hasOptionValue(options, "DeadlineSeconds", "deadlineSeconds", "Deadline", "deadline") && deadlineSeconds <= 0)) {
+        throw new RangeError("Deadline must be greater than zero.");
+    }
+    if (mode === "Produce" && !resolveStructuredProduceDelegate(endpoint) && !resolveProduceDelegate(endpoint)) {
+        throw new Error("ProduceAsync delegate must be provided when endpoint mode is Produce.");
+    }
+    if (mode === "Consume" && !resolveStructuredConsumeDelegate(endpoint) && !resolveStructuredConsumeStreamDelegate(endpoint) && !resolveConsumeDelegate(endpoint)) {
+        throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
+    }
+}
+function validateWebSocketEndpoint(endpoint, mode) {
+    const options = asRecordOrEmpty(endpoint.webSocket);
+    const url = requireNonEmptyString(optionString(options, "Url", "url"), "Url must be provided for WebSocket endpoint definitions.");
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new Error("Url must be an absolute ws:// or wss:// URI.");
+    }
+    if (parsed.protocol !== "ws:" && parsed.protocol !== "wss:") {
+        throw new Error("Url must be an absolute ws:// or wss:// URI.");
+    }
+    const connectMs = optionNumber(options, "ConnectTimeoutMs", "connectTimeoutMs");
+    const connectSeconds = optionNumber(options, "ConnectTimeoutSeconds", "connectTimeoutSeconds", "ConnectTimeout", "connectTimeout");
+    const closeMs = optionNumber(options, "CloseTimeoutMs", "closeTimeoutMs");
+    const closeSeconds = optionNumber(options, "CloseTimeoutSeconds", "closeTimeoutSeconds", "CloseTimeout", "closeTimeout");
+    if ((hasOptionValue(options, "ConnectTimeoutMs", "connectTimeoutMs") && connectMs <= 0)
+        || (hasOptionValue(options, "ConnectTimeoutSeconds", "connectTimeoutSeconds", "ConnectTimeout", "connectTimeout") && connectSeconds <= 0)) {
+        throw new RangeError("ConnectTimeout must be greater than zero.");
+    }
+    if ((hasOptionValue(options, "CloseTimeoutMs", "closeTimeoutMs") && closeMs <= 0)
+        || (hasOptionValue(options, "CloseTimeoutSeconds", "closeTimeoutSeconds", "CloseTimeout", "closeTimeout") && closeSeconds <= 0)) {
+        throw new RangeError("CloseTimeout must be greater than zero.");
+    }
+    if (mode === "Produce" && !resolveStructuredProduceDelegate(endpoint) && !resolveProduceDelegate(endpoint)) {
+        throw new Error("ProduceAsync delegate must be provided when endpoint mode is Produce.");
+    }
+    if (mode === "Consume" && !resolveStructuredConsumeDelegate(endpoint) && !resolveStructuredConsumeStreamDelegate(endpoint) && !resolveConsumeDelegate(endpoint)) {
+        throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
+    }
+}
 function validateHttpAuthOptions(options) {
     const auth = options.auth;
     if (!auth) {
@@ -3190,6 +3498,10 @@ function createDelegateRequestEndpointView(endpoint) {
             return new AzureEventHubsEndpointDefinition(endpoint);
         case "PushDiffusion":
             return new PushDiffusionEndpointDefinition(endpoint);
+        case "Grpc":
+            return new GrpcEndpointDefinition(endpoint);
+        case "WebSocket":
+            return new WebSocketEndpointDefinition(endpoint);
         default:
             return new DelegateStreamEndpointDefinition(endpoint);
     }
@@ -3408,12 +3720,20 @@ function parseBodyObject(body) {
 function resolveStructuredProduceDelegate(endpoint) {
     return endpoint.delegate?.produceAsync
         ?? endpoint.pushDiffusion?.PublishAsync
-        ?? endpoint.pushDiffusion?.publishAsync;
+        ?? endpoint.pushDiffusion?.publishAsync
+        ?? endpoint.grpc?.ProduceAsync
+        ?? endpoint.grpc?.produceAsync
+        ?? endpoint.webSocket?.ProduceAsync
+        ?? endpoint.webSocket?.produceAsync;
 }
 function resolveStructuredConsumeDelegate(endpoint) {
     const delegate = endpoint.delegate?.consumeAsync
         ?? endpoint.pushDiffusion?.SubscribeAsync
-        ?? endpoint.pushDiffusion?.subscribeAsync;
+        ?? endpoint.pushDiffusion?.subscribeAsync
+        ?? endpoint.grpc?.ConsumeAsync
+        ?? endpoint.grpc?.consumeAsync
+        ?? endpoint.webSocket?.ConsumeAsync
+        ?? endpoint.webSocket?.consumeAsync;
     return typeof delegate === "function" && delegate.length === 0
         ? delegate
         : undefined;
@@ -3421,22 +3741,36 @@ function resolveStructuredConsumeDelegate(endpoint) {
 function resolveStructuredConsumeStreamDelegate(endpoint) {
     const delegate = endpoint.delegate?.consumeAsync
         ?? endpoint.pushDiffusion?.SubscribeAsync
-        ?? endpoint.pushDiffusion?.subscribeAsync;
+        ?? endpoint.pushDiffusion?.subscribeAsync
+        ?? endpoint.grpc?.ConsumeAsync
+        ?? endpoint.grpc?.consumeAsync
+        ?? endpoint.webSocket?.ConsumeAsync
+        ?? endpoint.webSocket?.consumeAsync;
     return typeof delegate === "function" && delegate.length > 0
         ? delegate
         : undefined;
 }
 function resolveProduceDelegate(endpoint) {
-    return endpoint.delegate?.produce;
+    return endpoint.delegate?.produce
+        ?? endpoint.grpc?.Produce
+        ?? endpoint.grpc?.produce
+        ?? endpoint.webSocket?.Produce
+        ?? endpoint.webSocket?.produce;
 }
 function resolveConsumeDelegate(endpoint) {
-    return endpoint.delegate?.consume;
+    return endpoint.delegate?.consume
+        ?? endpoint.grpc?.Consume
+        ?? endpoint.grpc?.consume
+        ?? endpoint.webSocket?.Consume
+        ?? endpoint.webSocket?.consume;
 }
 function resolveConnectionMetadata(endpoint) {
     return {
         ...(endpoint.connectionMetadata ?? {}),
         ...(endpoint.delegate?.connectionMetadata ?? {}),
-        ...toStringRecord(endpoint.pushDiffusion?.ConnectionProperties ?? endpoint.pushDiffusion?.connectionProperties)
+        ...toStringRecord(endpoint.pushDiffusion?.ConnectionProperties ?? endpoint.pushDiffusion?.connectionProperties),
+        ...toStringRecord(endpoint.grpc?.ConnectionMetadata ?? endpoint.grpc?.connectionMetadata),
+        ...toStringRecord(endpoint.webSocket?.ConnectionMetadata ?? endpoint.webSocket?.connectionMetadata)
     };
 }
 function isStructuredProduceResult(value) {

package/dist/types/contracts.d.ts

@@ -111,6 +111,8 @@ export interface LoadStrikeEndpointSpec {
     Sqs?: LoadStrikeSqsEndpointOptions;
     DelegateStream?: LoadStrikeDelegateEndpointOptions;
     PushDiffusion?: LoadStrikePushDiffusionEndpointOptions;
+    Grpc?: LoadStrikeGrpcEndpointOptions;
+    WebSocket?: LoadStrikeWebSocketEndpointOptions;
 }
 export interface LoadStrikeHttpEndpointOptions {
     Url?: string;
@@ -230,6 +232,22 @@ export interface LoadStrikePushDiffusionEndpointOptions {
     PublishCallbackUrl?: string;
     SubscribeCallbackUrl?: string;
 }
+export interface LoadStrikeGrpcEndpointOptions {
+    Target?: string;
+    ServiceName?: string;
+    MethodName?: string;
+    MethodType?: string;
+    DeadlineSeconds?: number;
+    Metadata?: Record<string, string>;
+    ConnectionMetadata?: Record<string, string>;
+}
+export interface LoadStrikeWebSocketEndpointOptions {
+    Url?: string;
+    Subprotocols?: string[];
+    ConnectTimeoutSeconds?: number;
+    CloseTimeoutSeconds?: number;
+    ConnectionMetadata?: Record<string, string>;
+}
 export interface LoadStrikeReportingSinkSpec {
     Kind: string;
     InfluxDb?: LoadStrikeInfluxDbSinkOptions;

package/dist/types/index.d.ts

@@ -1,12 +1,12 @@
-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 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, LoadStrikeGrpcEndpointOptions, LoadStrikeWebSocketEndpointOptions, 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";
-export { CrossPlatformScenarioConfigurator, ScenarioTrackingExtensions, LoadStrikeContext, LoadStrikePluginData, LoadStrikePluginDataTable, LoadStrikeNodeType, LoadStrikeReportFormat, LoadStrikeResponse, LoadStrikeLogLevel, LoadStrikeScenarioOperation, LoadStrikeOperationType, LoadStrikeRunner, LoadStrikeScenario, LoadStrikeSimulation, CrossPlatformTrackingConfiguration, LoadStrikeMetric, LoadStrikeCounter, LoadStrikeGauge, LoadStrikeStep, LoadStrikeThreshold } from "./runtime.js";
-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 { 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 { 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, 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 { 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 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";

package/dist/types/local.d.ts

@@ -21,9 +21,8 @@ export interface LicenseValidationSession {
     heartbeatTimer?: ReturnType<typeof setInterval>;
 }
 export declare class LoadStrikeLocalClient {
-    private readonly licensingApiBaseUrl;
+    #private;
     private readonly licenseValidationTimeoutMs;
-    private readonly signingKeyCache;
     /**
      * Exposes the public constructor operation.
      * Use this when the surrounding wrapper type makes this operation the clearest way to express your intent.