@loadstrike/loadstrike-sdk 1.0.26901 → 1.0.27301

package/dist/esm/transports.js

@@ -285,6 +285,337 @@ 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);
+        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.");
+        }
+        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" && !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);
+        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.");
+        }
+        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" && !this.NativeClient) {
+            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 +626,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 +1077,113 @@ 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");
+    }
+    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);
+    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");
+    }
+    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.");
     if (target.Mode !== "Produce" && target.Mode !== "Consume") {
@@ -1878,6 +2318,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 +2348,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 ?? "")}.`);
         }
@@ -2066,6 +2514,66 @@ const PUSH_DIFFUSION_ENDPOINT_FLAT_KEYS = [
     "subscribeAsync"
 ];
 const DELEGATE_STREAM_ENDPOINT_FLAT_KEYS = [
+    "Produce",
+    "produce",
+    "Consume",
+    "consume",
+    "ProduceAsync",
+    "produceAsync",
+    "ConsumeAsync",
+    "consumeAsync",
+    "ConnectionMetadata",
+    "connectionMetadata",
+    "NativeClient",
+    "nativeClient"
+];
+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",
+    "NativeClient",
+    "nativeClient"
+];
+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",
@@ -2111,7 +2619,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 +2707,32 @@ function resolveEndpointKind(raw) {
     ])) {
         return "PushDiffusion";
     }
+    if (Object.keys(pickEndpointRecord(raw, "grpc", "Grpc")).length || hasAnyEndpointField(raw, [
+        "Target",
+        "target",
+        "ServiceName",
+        "serviceName",
+        "MethodName",
+        "methodName",
+        "MethodType",
+        "methodType",
+        "NativeClient",
+        "nativeClient"
+    ])) {
+        return "Grpc";
+    }
+    if (Object.keys(pickEndpointRecord(raw, "webSocket", "WebSocket")).length || hasAnyEndpointField(raw, [
+        "Subprotocols",
+        "subprotocols",
+        "ConnectTimeoutSeconds",
+        "connectTimeoutSeconds",
+        "CloseTimeoutSeconds",
+        "closeTimeoutSeconds",
+        "NativeClient",
+        "nativeClient"
+    ])) {
+        return "WebSocket";
+    }
     if (Object.keys(pickEndpointRecord(raw, "delegate", "Delegate", "DelegateStream")).length || hasAnyEndpointField(raw, [
         "Produce",
         "produce",
@@ -2327,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);
 }
@@ -2440,10 +2992,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 +3023,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 +3104,65 @@ 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.");
+    }
+    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) && nativeClient == null) {
+        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.");
+    }
+    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) && nativeClient == null) {
+        throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
+    }
+}
 function validateHttpAuthOptions(options) {
     const auth = options.auth;
     if (!auth) {
@@ -3190,6 +3805,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 +4027,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 +4048,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) {