@loadstrike/loadstrike-sdk 0.1.0

package/dist/esm/transports.js

@@ -0,0 +1,3658 @@
+import { randomUUID } from "node:crypto";
+import { TrackingFieldSelector } from "./correlation.js";
+class TrafficEndpointDefinitionModel {
+    get JsonSerializerSettings() {
+        return this.JsonSettings;
+    }
+    set JsonSerializerSettings(value) {
+        this.JsonSettings = value;
+    }
+    constructor(initial) {
+        this.Mode = "Produce";
+        this.Name = "";
+        this.TrackingField = "";
+        this.AutoGenerateTrackingIdWhenMissing = true;
+        this.PollInterval = 0.25;
+        this.MessageHeaders = {};
+        if (new.target === TrafficEndpointDefinitionModel) {
+            throw new TypeError("TrafficEndpointDefinition is abstract and cannot be instantiated directly.");
+        }
+        initializeTrafficEndpointDefinitionModel(this, initial);
+    }
+    Validate() {
+        validateTrafficEndpointDefinitionModel(this);
+    }
+}
+class HttpOAuth2ClientCredentialsOptionsModel {
+    constructor(initial) {
+        this.TokenEndpoint = "";
+        this.ClientId = "";
+        this.ClientSecret = "";
+        this.Scopes = [];
+        this.AdditionalFormFields = {};
+        initializeHttpOAuth2ClientCredentialsOptionsModel(this, initial);
+    }
+    Validate() {
+        validateHttpOAuth2ClientCredentialsOptionsModel(this);
+    }
+}
+class HttpAuthOptionsModel {
+    constructor(initial) {
+        this.Type = "None";
+        this.AdditionalFormFields = {};
+        initializeHttpAuthOptionsModel(this, initial);
+    }
+    Validate() {
+        validateHttpAuthOptionsModel(this);
+    }
+}
+class KafkaSaslOptionsModel {
+    constructor(initial) {
+        this.Mechanism = "Plain";
+        this.AdditionalSettings = {};
+        initializeKafkaSaslOptionsModel(this, initial);
+    }
+    Validate() {
+        validateKafkaSaslOptionsModel(this);
+    }
+}
+class HttpEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
+    constructor(initial) {
+        super(initial);
+        this.Kind = "Http";
+        this.Url = "";
+        this.Method = "GET";
+        this.BodyType = "Json";
+        this.TrackingPayloadSource = "Request";
+        this.ConsumeJsonArrayResponse = false;
+        this.RequestTimeout = 30;
+        this.Auth = new HttpAuthOptionsModel();
+        this.TokenRequestHeaders = {};
+        initializeHttpEndpointDefinitionModel(this, initial);
+    }
+    Validate() {
+        super.Validate();
+        const url = requireNonEmptyString(this.Url, "Url must be provided for HTTP endpoint.");
+        try {
+            new URL(url);
+        }
+        catch {
+            throw new Error("Url must be an absolute URI for HTTP endpoint.");
+        }
+        if (this.RequestTimeout <= 0) {
+            throw new RangeError("RequestTimeout must be greater than zero.");
+        }
+        toHttpAuthOptionsModel(this.Auth).Validate();
+    }
+}
+class KafkaEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
+    constructor(initial) {
+        super(initial);
+        this.Kind = "Kafka";
+        this.BootstrapServers = "";
+        this.Topic = "";
+        this.SecurityProtocol = "Plaintext";
+        this.ConfluentSettings = {};
+        this.StartFromEarliest = true;
+        initializeKafkaEndpointDefinitionModel(this, initial);
+    }
+    Validate() {
+        super.Validate();
+        requireNonEmptyString(this.BootstrapServers, "BootstrapServers must be provided for Kafka endpoint.");
+        requireNonEmptyString(this.Topic, "Topic must be provided for Kafka endpoint.");
+        if (this.Mode === "Consume" && !String(this.ConsumerGroupId ?? "").trim()) {
+            throw new Error("ConsumerGroupId must be provided when Kafka endpoint mode is Consume.");
+        }
+        const securityProtocol = normalizeToken(this.SecurityProtocol);
+        if (securityProtocol === "saslplaintext" || securityProtocol === "saslssl") {
+            if (!this.Sasl) {
+                throw new Error("Sasl options must be provided for SASL Kafka security protocol.");
+            }
+            toKafkaSaslOptionsModel(this.Sasl).Validate();
+        }
+    }
+}
+class RabbitMqEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
+    constructor(initial) {
+        super(initial);
+        this.Kind = "RabbitMq";
+        this.HostName = "";
+        this.Port = 5672;
+        this.VirtualHost = "/";
+        this.UserName = "";
+        this.Password = "";
+        this.Exchange = "";
+        this.RoutingKey = "";
+        this.QueueName = "";
+        this.Durable = true;
+        this.AutoAck = false;
+        this.UseSsl = false;
+        this.ClientProperties = {};
+        initializeRabbitMqEndpointDefinitionModel(this, initial);
+    }
+    Validate() {
+        super.Validate();
+        requireNonEmptyString(this.HostName, "HostName must be provided for RabbitMQ endpoint.");
+        if (this.Port <= 0) {
+            throw new RangeError("Port must be greater than zero.");
+        }
+        requireNonEmptyString(this.UserName, "UserName must be provided for RabbitMQ endpoint.");
+        if (this.Password == null) {
+            throw new Error("Password must be provided for RabbitMQ endpoint.");
+        }
+        if (this.Mode === "Produce" && !String(this.RoutingKey).trim() && !String(this.QueueName).trim()) {
+            throw new Error("Either RoutingKey or QueueName must be provided for RabbitMQ producer endpoint.");
+        }
+        if (this.Mode === "Consume" && !String(this.QueueName).trim()) {
+            throw new Error("QueueName must be provided for RabbitMQ consumer endpoint.");
+        }
+    }
+}
+class NatsEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
+    constructor(initial) {
+        super(initial);
+        this.Kind = "Nats";
+        this.ServerUrl = "";
+        this.Subject = "";
+        this.MaxReconnectAttempts = 60;
+        initializeNatsEndpointDefinitionModel(this, initial);
+    }
+    Validate() {
+        super.Validate();
+        requireNonEmptyString(this.ServerUrl, "ServerUrl must be provided for NATS endpoint.");
+        requireNonEmptyString(this.Subject, "Subject must be provided for NATS endpoint.");
+        if (String(this.UserName ?? "").trim() && this.Password == null) {
+            throw new Error("Password must be provided when UserName is configured for NATS endpoint.");
+        }
+        if (this.MaxReconnectAttempts < 0) {
+            throw new RangeError("MaxReconnectAttempts must be zero or greater.");
+        }
+    }
+}
+class RedisStreamsEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
+    constructor(initial) {
+        super(initial);
+        this.Kind = "RedisStreams";
+        this.ConnectionString = "";
+        this.StreamKey = "";
+        this.StartFromEarliest = true;
+        this.ReadCount = 50;
+        initializeRedisStreamsEndpointDefinitionModel(this, initial);
+    }
+    Validate() {
+        super.Validate();
+        requireNonEmptyString(this.ConnectionString, "ConnectionString must be provided for Redis Streams endpoint.");
+        requireNonEmptyString(this.StreamKey, "StreamKey must be provided for Redis Streams endpoint.");
+        if (this.Mode === "Consume" && !String(this.ConsumerGroup ?? "").trim()) {
+            throw new Error("ConsumerGroup must be provided when Redis Streams endpoint mode is Consume.");
+        }
+        if (this.Mode === "Consume" && !String(this.ConsumerName ?? "").trim()) {
+            throw new Error("ConsumerName must be provided when Redis Streams endpoint mode is Consume.");
+        }
+        if (this.ReadCount <= 0) {
+            throw new RangeError("ReadCount must be greater than zero.");
+        }
+        if (this.MaxLength != null && this.MaxLength <= 0) {
+            throw new RangeError("MaxLength must be greater than zero when configured.");
+        }
+    }
+}
+class AzureEventHubsEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
+    constructor(initial) {
+        super(initial);
+        this.Kind = "AzureEventHubs";
+        this.ConnectionString = "";
+        this.EventHubName = "";
+        this.ConsumerGroup = "$Default";
+        this.StartFromEarliest = false;
+        initializeAzureEventHubsEndpointDefinitionModel(this, initial);
+    }
+    Validate() {
+        super.Validate();
+        requireNonEmptyString(this.ConnectionString, "ConnectionString must be provided for Azure Event Hubs endpoint.");
+        requireNonEmptyString(this.EventHubName, "EventHubName must be provided for Azure Event Hubs endpoint.");
+    }
+}
+class DelegateStreamEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
+    constructor(initial) {
+        super(initial);
+        this.Kind = "DelegateStream";
+        this.ConnectionMetadata = {};
+        initializeDelegateStreamEndpointDefinitionModel(this, initial);
+    }
+    Validate() {
+        super.Validate();
+        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 PushDiffusionEndpointDefinitionModel extends TrafficEndpointDefinitionModel {
+    constructor(initial) {
+        super(initial);
+        this.Kind = "PushDiffusion";
+        this.ServerUrl = "";
+        this.TopicPath = "";
+        this.ConnectionProperties = {};
+        initializePushDiffusionEndpointDefinitionModel(this, initial);
+    }
+    Validate() {
+        super.Validate();
+        requireNonEmptyString(this.ServerUrl, "ServerUrl must be provided for Push Diffusion endpoint.");
+        requireNonEmptyString(this.TopicPath, "TopicPath must be provided for Push Diffusion endpoint.");
+        if (this.Mode === "Produce" && typeof this.PublishAsync !== "function") {
+            throw new Error("PublishAsync delegate must be provided for Push Diffusion producer endpoint.");
+        }
+        if (this.Mode === "Consume" && typeof this.SubscribeAsync !== "function") {
+            throw new Error("SubscribeAsync delegate must be provided for Push Diffusion consumer endpoint.");
+        }
+    }
+}
+export const TrafficEndpointDefinition = TrafficEndpointDefinitionModel;
+export const HttpEndpointDefinition = HttpEndpointDefinitionModel;
+export const KafkaEndpointDefinition = KafkaEndpointDefinitionModel;
+export const RabbitMqEndpointDefinition = RabbitMqEndpointDefinitionModel;
+export const NatsEndpointDefinition = NatsEndpointDefinitionModel;
+export const RedisStreamsEndpointDefinition = RedisStreamsEndpointDefinitionModel;
+export const AzureEventHubsEndpointDefinition = AzureEventHubsEndpointDefinitionModel;
+export const DelegateStreamEndpointDefinition = DelegateStreamEndpointDefinitionModel;
+export const PushDiffusionEndpointDefinition = PushDiffusionEndpointDefinitionModel;
+export const HttpOAuth2ClientCredentialsOptions = HttpOAuth2ClientCredentialsOptionsModel;
+export const HttpAuthOptions = HttpAuthOptionsModel;
+export const KafkaSaslOptions = KafkaSaslOptionsModel;
+function initializeTrafficEndpointDefinitionModel(target, initial) {
+    const raw = asRecordOrEmpty(initial);
+    const mode = pickOptionalEndpointString(raw, "Mode", "mode");
+    if (mode) {
+        target.Mode = mode;
+    }
+    const name = pickOptionalEndpointString(raw, "Name", "name");
+    if (name) {
+        target.Name = name;
+    }
+    const trackingField = pickOptionalTrackingFieldSelectorString(raw, "TrackingField", "trackingField");
+    if (trackingField != null) {
+        target.TrackingField = trackingField;
+    }
+    if (hasAnyEndpointField(raw, ["GatherByField", "gatherByField"])) {
+        target.GatherByField = pickOptionalTrackingFieldSelectorString(raw, "GatherByField", "gatherByField");
+    }
+    const autoGenerate = pickEndpointBoolean(raw, "AutoGenerateTrackingIdWhenMissing", "autoGenerateTrackingIdWhenMissing");
+    if (autoGenerate != null) {
+        target.AutoGenerateTrackingIdWhenMissing = autoGenerate;
+    }
+    const pollInterval = pickOptionalEndpointNumber(raw, "PollInterval", "pollInterval");
+    const pollIntervalMs = pickOptionalEndpointNumber(raw, "PollIntervalMs", "pollIntervalMs");
+    const pollIntervalSeconds = pickOptionalEndpointNumber(raw, "PollIntervalSeconds", "pollIntervalSeconds");
+    if (pollIntervalMs != null) {
+        target.PollInterval = pollIntervalMs / 1000;
+    }
+    else if (pollIntervalSeconds != null) {
+        target.PollInterval = pollIntervalSeconds;
+    }
+    else if (pollInterval != null) {
+        target.PollInterval = pollInterval;
+    }
+    if (hasAnyEndpointField(raw, ["MessageHeaders", "messageHeaders"])) {
+        target.MessageHeaders = pickEndpointStringRecord(raw, "MessageHeaders", "messageHeaders");
+    }
+    if (hasAnyEndpointField(raw, ["MessagePayload", "messagePayload"])) {
+        target.MessagePayload = pickEndpointValue(raw, "MessagePayload", "messagePayload");
+    }
+    if (hasAnyEndpointField(raw, ["MessagePayloadType", "messagePayloadType"])) {
+        target.MessagePayloadType = pickOptionalEndpointString(raw, "MessagePayloadType", "messagePayloadType");
+    }
+    if (hasAnyEndpointField(raw, ["JsonSettings", "jsonSettings", "JsonSerializerSettings", "jsonSerializerSettings"])) {
+        target.JsonSettings = pickEndpointRecord(raw, "JsonSettings", "jsonSettings", "JsonSerializerSettings", "jsonSerializerSettings");
+    }
+    if (hasAnyEndpointField(raw, ["JsonConvertSettings", "jsonConvertSettings"])) {
+        target.JsonConvertSettings = pickEndpointRecord(raw, "JsonConvertSettings", "jsonConvertSettings");
+    }
+    if (hasAnyEndpointField(raw, ["ContentType", "contentType"])) {
+        target.ContentType = pickOptionalEndpointString(raw, "ContentType", "contentType");
+    }
+}
+function initializeHttpOAuth2ClientCredentialsOptionsModel(target, initial) {
+    const raw = asRecordOrEmpty(initial);
+    const tokenEndpoint = pickOptionalEndpointString(raw, "TokenEndpoint", "tokenEndpoint", "TokenUrl", "tokenUrl");
+    if (tokenEndpoint) {
+        target.TokenEndpoint = tokenEndpoint;
+    }
+    const clientId = pickOptionalEndpointString(raw, "ClientId", "clientId");
+    if (clientId) {
+        target.ClientId = clientId;
+    }
+    const clientSecret = pickOptionalEndpointString(raw, "ClientSecret", "clientSecret");
+    if (clientSecret) {
+        target.ClientSecret = clientSecret;
+    }
+    const scopes = pickEndpointStringArray(raw, "Scopes", "scopes");
+    if (scopes) {
+        target.Scopes = scopes;
+    }
+    if (hasAnyEndpointField(raw, ["AdditionalFormFields", "additionalFormFields"])) {
+        target.AdditionalFormFields = pickEndpointStringRecord(raw, "AdditionalFormFields", "additionalFormFields");
+    }
+}
+function initializeHttpAuthOptionsModel(target, initial) {
+    const raw = asRecordOrEmpty(initial);
+    const type = pickOptionalEndpointString(raw, "Type", "type", "Mode", "mode");
+    if (type) {
+        target.Type = type;
+    }
+    if (hasAnyEndpointField(raw, ["Username", "username"])) {
+        target.Username = pickOptionalEndpointString(raw, "Username", "username");
+    }
+    if (hasAnyEndpointField(raw, ["Password", "password"])) {
+        target.Password = pickOptionalEndpointStringAllowEmpty(raw, "Password", "password");
+    }
+    if (hasAnyEndpointField(raw, ["BearerToken", "bearerToken"])) {
+        target.BearerToken = pickOptionalEndpointString(raw, "BearerToken", "bearerToken");
+    }
+    if (hasAnyEndpointField(raw, ["TokenUrl", "tokenUrl"])) {
+        target.TokenUrl = pickOptionalEndpointString(raw, "TokenUrl", "tokenUrl");
+    }
+    if (hasAnyEndpointField(raw, ["ClientId", "clientId"])) {
+        target.ClientId = pickOptionalEndpointString(raw, "ClientId", "clientId");
+    }
+    if (hasAnyEndpointField(raw, ["ClientSecret", "clientSecret"])) {
+        target.ClientSecret = pickOptionalEndpointString(raw, "ClientSecret", "clientSecret");
+    }
+    if (hasAnyEndpointField(raw, ["Scope", "scope"])) {
+        target.Scope = pickOptionalEndpointString(raw, "Scope", "scope");
+    }
+    const scopes = pickEndpointStringArray(raw, "Scopes", "scopes");
+    if (scopes) {
+        target.Scopes = scopes;
+    }
+    if (hasAnyEndpointField(raw, ["Audience", "audience"])) {
+        target.Audience = pickOptionalEndpointString(raw, "Audience", "audience");
+    }
+    if (hasAnyEndpointField(raw, ["TokenHeaderName", "tokenHeaderName"])) {
+        target.TokenHeaderName = pickOptionalEndpointString(raw, "TokenHeaderName", "tokenHeaderName");
+    }
+    if (hasAnyEndpointField(raw, ["AdditionalFormFields", "additionalFormFields"])) {
+        target.AdditionalFormFields = pickEndpointStringRecord(raw, "AdditionalFormFields", "additionalFormFields");
+    }
+    if (hasAnyEndpointField(raw, ["OAuth2ClientCredentials", "oauth2ClientCredentials"])) {
+        target.OAuth2ClientCredentials = toHttpOAuth2ClientCredentialsOptionsModel(pickEndpointRecord(raw, "OAuth2ClientCredentials", "oauth2ClientCredentials"));
+    }
+}
+function initializeKafkaSaslOptionsModel(target, initial) {
+    const raw = asRecordOrEmpty(initial);
+    const mechanism = pickOptionalEndpointString(raw, "Mechanism", "mechanism");
+    if (mechanism) {
+        target.Mechanism = mechanism;
+    }
+    if (hasAnyEndpointField(raw, ["Username", "username"])) {
+        target.Username = pickOptionalEndpointString(raw, "Username", "username");
+    }
+    if (hasAnyEndpointField(raw, ["Password", "password"])) {
+        target.Password = pickOptionalEndpointStringAllowEmpty(raw, "Password", "password");
+    }
+    if (hasAnyEndpointField(raw, ["OAuthBearerTokenEndpointUrl", "oauthBearerTokenEndpointUrl", "TokenEndpoint", "tokenEndpoint"])) {
+        const tokenEndpoint = pickOptionalEndpointString(raw, "OAuthBearerTokenEndpointUrl", "oauthBearerTokenEndpointUrl", "TokenEndpoint", "tokenEndpoint");
+        target.OAuthBearerTokenEndpointUrl = tokenEndpoint;
+        target.TokenEndpoint = tokenEndpoint;
+    }
+    if (hasAnyEndpointField(raw, ["AccessToken", "accessToken"])) {
+        target.AccessToken = pickOptionalEndpointString(raw, "AccessToken", "accessToken");
+    }
+    if (hasAnyEndpointField(raw, ["OAuthBearerToken", "oauthBearerToken"])) {
+        target.OAuthBearerToken = pickOptionalEndpointString(raw, "OAuthBearerToken", "oauthBearerToken");
+    }
+    if (hasAnyEndpointField(raw, ["AdditionalSettings", "additionalSettings"])) {
+        target.AdditionalSettings = pickEndpointStringRecord(raw, "AdditionalSettings", "additionalSettings");
+    }
+}
+function initializeHttpEndpointDefinitionModel(target, initial) {
+    const raw = asRecordOrEmpty(initial);
+    const url = pickOptionalEndpointString(raw, "Url", "url");
+    if (url) {
+        target.Url = url;
+    }
+    const method = pickOptionalEndpointString(raw, "Method", "method");
+    if (method) {
+        target.Method = method;
+    }
+    const consumePoll = pickEndpointFunction(raw, "ConsumePoll", "consumePoll");
+    if (consumePoll) {
+        target.ConsumePoll = consumePoll;
+    }
+    const bodyType = pickOptionalEndpointString(raw, "BodyType", "bodyType");
+    if (bodyType) {
+        target.BodyType = bodyType;
+    }
+    const responseSource = pickOptionalEndpointString(raw, "ResponseSource", "responseSource");
+    if (responseSource) {
+        target.ResponseSource = responseSource;
+    }
+    const trackingPayloadSource = pickOptionalEndpointString(raw, "TrackingPayloadSource", "trackingPayloadSource");
+    if (trackingPayloadSource) {
+        target.TrackingPayloadSource = canonicalizeHttpTrackingPayloadSource(trackingPayloadSource);
+        if (!responseSource) {
+            const inferredResponseSource = inferLegacyHttpResponseSource(trackingPayloadSource);
+            if (inferredResponseSource) {
+                target.ResponseSource = inferredResponseSource;
+            }
+        }
+    }
+    if (hasAnyEndpointField(raw, ["ConsumeArrayPath", "consumeArrayPath"])) {
+        target.ConsumeArrayPath = pickOptionalEndpointString(raw, "ConsumeArrayPath", "consumeArrayPath");
+    }
+    const consumeJsonArrayResponse = pickEndpointBoolean(raw, "ConsumeJsonArrayResponse", "consumeJsonArrayResponse");
+    if (consumeJsonArrayResponse != null) {
+        target.ConsumeJsonArrayResponse = consumeJsonArrayResponse;
+    }
+    const requestTimeout = pickOptionalEndpointNumber(raw, "RequestTimeout", "requestTimeout", "RequestTimeoutSeconds", "requestTimeoutSeconds");
+    if (requestTimeout != null) {
+        target.RequestTimeout = requestTimeout;
+    }
+    if (hasAnyEndpointField(raw, ["Auth", "auth"])) {
+        target.Auth = toHttpAuthOptionsModel(pickEndpointRecord(raw, "Auth", "auth"));
+    }
+    if (hasAnyEndpointField(raw, ["TokenRequestHeaders", "tokenRequestHeaders"])) {
+        target.TokenRequestHeaders = pickEndpointStringRecord(raw, "TokenRequestHeaders", "tokenRequestHeaders");
+    }
+}
+function initializeKafkaEndpointDefinitionModel(target, initial) {
+    const raw = asRecordOrEmpty(initial);
+    const bootstrapServers = pickOptionalEndpointString(raw, "BootstrapServers", "bootstrapServers");
+    if (bootstrapServers) {
+        target.BootstrapServers = bootstrapServers;
+    }
+    const topic = pickOptionalEndpointString(raw, "Topic", "topic");
+    if (topic) {
+        target.Topic = topic;
+    }
+    if (hasAnyEndpointField(raw, ["ConsumerGroupId", "consumerGroupId"])) {
+        target.ConsumerGroupId = pickOptionalEndpointString(raw, "ConsumerGroupId", "consumerGroupId");
+    }
+    const securityProtocol = pickOptionalEndpointString(raw, "SecurityProtocol", "securityProtocol");
+    if (securityProtocol) {
+        target.SecurityProtocol = securityProtocol;
+    }
+    if (hasAnyEndpointField(raw, ["Sasl", "sasl"])) {
+        target.Sasl = toKafkaSaslOptionsModel(pickEndpointRecord(raw, "Sasl", "sasl"));
+    }
+    if (hasAnyEndpointField(raw, ["ConfluentSettings", "confluentSettings"])) {
+        target.ConfluentSettings = pickEndpointStringRecord(raw, "ConfluentSettings", "confluentSettings");
+    }
+    const startFromEarliest = pickEndpointBoolean(raw, "StartFromEarliest", "startFromEarliest");
+    if (startFromEarliest != null) {
+        target.StartFromEarliest = startFromEarliest;
+    }
+}
+function initializeRabbitMqEndpointDefinitionModel(target, initial) {
+    const raw = asRecordOrEmpty(initial);
+    const hostName = pickOptionalEndpointString(raw, "HostName", "hostName");
+    if (hostName) {
+        target.HostName = hostName;
+    }
+    const port = pickOptionalEndpointNumber(raw, "Port", "port");
+    if (port != null) {
+        target.Port = port;
+    }
+    const virtualHost = pickOptionalEndpointString(raw, "VirtualHost", "virtualHost");
+    if (virtualHost) {
+        target.VirtualHost = virtualHost;
+    }
+    const userName = pickOptionalEndpointString(raw, "UserName", "userName");
+    if (userName) {
+        target.UserName = userName;
+    }
+    if (hasAnyEndpointField(raw, ["Password", "password"])) {
+        target.Password = pickOptionalEndpointStringAllowEmpty(raw, "Password", "password") ?? "";
+    }
+    const exchange = pickOptionalEndpointString(raw, "Exchange", "exchange");
+    if (exchange) {
+        target.Exchange = exchange;
+    }
+    const routingKey = pickOptionalEndpointString(raw, "RoutingKey", "routingKey");
+    if (routingKey) {
+        target.RoutingKey = routingKey;
+    }
+    const queueName = pickOptionalEndpointString(raw, "QueueName", "queueName");
+    if (queueName) {
+        target.QueueName = queueName;
+    }
+    const durable = pickEndpointBoolean(raw, "Durable", "durable");
+    if (durable != null) {
+        target.Durable = durable;
+    }
+    const autoAck = pickEndpointBoolean(raw, "AutoAck", "autoAck");
+    if (autoAck != null) {
+        target.AutoAck = autoAck;
+    }
+    const useSsl = pickEndpointBoolean(raw, "UseSsl", "useSsl");
+    if (useSsl != null) {
+        target.UseSsl = useSsl;
+    }
+    if (hasAnyEndpointField(raw, ["ClientProperties", "clientProperties"])) {
+        target.ClientProperties = pickEndpointStringRecord(raw, "ClientProperties", "clientProperties");
+    }
+}
+function initializeNatsEndpointDefinitionModel(target, initial) {
+    const raw = asRecordOrEmpty(initial);
+    const serverUrl = pickOptionalEndpointString(raw, "ServerUrl", "serverUrl");
+    if (serverUrl) {
+        target.ServerUrl = serverUrl;
+    }
+    const subject = pickOptionalEndpointString(raw, "Subject", "subject");
+    if (subject) {
+        target.Subject = subject;
+    }
+    if (hasAnyEndpointField(raw, ["QueueGroup", "queueGroup"])) {
+        target.QueueGroup = pickOptionalEndpointString(raw, "QueueGroup", "queueGroup");
+    }
+    if (hasAnyEndpointField(raw, ["UserName", "userName"])) {
+        target.UserName = pickOptionalEndpointString(raw, "UserName", "userName");
+    }
+    if (hasAnyEndpointField(raw, ["Password", "password"])) {
+        target.Password = pickOptionalEndpointStringAllowEmpty(raw, "Password", "password");
+    }
+    if (hasAnyEndpointField(raw, ["Token", "token"])) {
+        target.Token = pickOptionalEndpointString(raw, "Token", "token");
+    }
+    if (hasAnyEndpointField(raw, ["ConnectionName", "connectionName"])) {
+        target.ConnectionName = pickOptionalEndpointString(raw, "ConnectionName", "connectionName");
+    }
+    const maxReconnectAttempts = pickOptionalEndpointNumber(raw, "MaxReconnectAttempts", "maxReconnectAttempts");
+    if (maxReconnectAttempts != null) {
+        target.MaxReconnectAttempts = maxReconnectAttempts;
+    }
+}
+function initializeRedisStreamsEndpointDefinitionModel(target, initial) {
+    const raw = asRecordOrEmpty(initial);
+    const connectionString = pickOptionalEndpointString(raw, "ConnectionString", "connectionString");
+    if (connectionString) {
+        target.ConnectionString = connectionString;
+    }
+    const streamKey = pickOptionalEndpointString(raw, "StreamKey", "streamKey");
+    if (streamKey) {
+        target.StreamKey = streamKey;
+    }
+    if (hasAnyEndpointField(raw, ["ConsumerGroup", "consumerGroup"])) {
+        target.ConsumerGroup = pickOptionalEndpointString(raw, "ConsumerGroup", "consumerGroup");
+    }
+    if (hasAnyEndpointField(raw, ["ConsumerName", "consumerName"])) {
+        target.ConsumerName = pickOptionalEndpointString(raw, "ConsumerName", "consumerName");
+    }
+    const startFromEarliest = pickEndpointBoolean(raw, "StartFromEarliest", "startFromEarliest");
+    if (startFromEarliest != null) {
+        target.StartFromEarliest = startFromEarliest;
+    }
+    const readCount = pickOptionalEndpointNumber(raw, "ReadCount", "readCount");
+    if (readCount != null) {
+        target.ReadCount = readCount;
+    }
+    if (hasAnyEndpointField(raw, ["MaxLength", "maxLength"])) {
+        target.MaxLength = pickOptionalEndpointNumber(raw, "MaxLength", "maxLength");
+    }
+}
+function initializeAzureEventHubsEndpointDefinitionModel(target, initial) {
+    const raw = asRecordOrEmpty(initial);
+    const connectionString = pickOptionalEndpointString(raw, "ConnectionString", "connectionString");
+    if (connectionString) {
+        target.ConnectionString = connectionString;
+    }
+    const eventHubName = pickOptionalEndpointString(raw, "EventHubName", "eventHubName");
+    if (eventHubName) {
+        target.EventHubName = eventHubName;
+    }
+    const consumerGroup = pickOptionalEndpointString(raw, "ConsumerGroup", "consumerGroup");
+    if (consumerGroup) {
+        target.ConsumerGroup = consumerGroup;
+    }
+    const startFromEarliest = pickEndpointBoolean(raw, "StartFromEarliest", "startFromEarliest");
+    if (startFromEarliest != null) {
+        target.StartFromEarliest = startFromEarliest;
+    }
+    if (hasAnyEndpointField(raw, ["PartitionId", "partitionId"])) {
+        target.PartitionId = pickOptionalEndpointString(raw, "PartitionId", "partitionId");
+    }
+}
+function initializeDelegateStreamEndpointDefinitionModel(target, initial) {
+    const raw = asRecordOrEmpty(initial);
+    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 initializePushDiffusionEndpointDefinitionModel(target, initial) {
+    const raw = asRecordOrEmpty(initial);
+    const serverUrl = pickOptionalEndpointString(raw, "ServerUrl", "serverUrl");
+    if (serverUrl) {
+        target.ServerUrl = serverUrl;
+    }
+    const topicPath = pickOptionalEndpointString(raw, "TopicPath", "topicPath");
+    if (topicPath) {
+        target.TopicPath = topicPath;
+    }
+    if (hasAnyEndpointField(raw, ["Principal", "principal"])) {
+        target.Principal = pickOptionalEndpointString(raw, "Principal", "principal");
+    }
+    if (hasAnyEndpointField(raw, ["Password", "password"])) {
+        target.Password = pickOptionalEndpointStringAllowEmpty(raw, "Password", "password");
+    }
+    if (hasAnyEndpointField(raw, ["ConnectionProperties", "connectionProperties"])) {
+        target.ConnectionProperties = pickEndpointStringRecord(raw, "ConnectionProperties", "connectionProperties");
+    }
+    const publishAsync = pickEndpointFunction(raw, "PublishAsync", "publishAsync");
+    if (publishAsync) {
+        target.PublishAsync = publishAsync;
+    }
+    const subscribeAsync = pickEndpointFunction(raw, "SubscribeAsync", "subscribeAsync");
+    if (subscribeAsync) {
+        target.SubscribeAsync = subscribeAsync;
+    }
+}
+function validateTrafficEndpointDefinitionModel(target) {
+    requireNonEmptyString(target.Name, "Endpoint name must be provided.");
+    if (target.Mode !== "Produce" && target.Mode !== "Consume") {
+        throw new Error(`Unsupported endpoint mode: ${String(target.Mode)}.`);
+    }
+    if (!String(target.TrackingField ?? "").trim()) {
+        throw new Error("TrackingField must be provided.");
+    }
+    validateTrackingSelectorPath(String(target.TrackingField ?? ""), "TrackingField");
+    if (target.GatherByField != null) {
+        validateTrackingSelectorPath(String(target.GatherByField), "GatherByField");
+    }
+    if (target.PollInterval <= 0) {
+        throw new RangeError("PollInterval must be greater than zero.");
+    }
+}
+function validateHttpOAuth2ClientCredentialsOptionsModel(target) {
+    requireNonEmptyString(target.TokenEndpoint, "TokenEndpoint must be provided for OAuth2 client credentials flow.");
+    requireNonEmptyString(target.ClientId, "ClientId must be provided for OAuth2 client credentials flow.");
+    requireNonEmptyString(target.ClientSecret, "ClientSecret must be provided for OAuth2 client credentials flow.");
+}
+function validateHttpAuthOptionsModel(target) {
+    switch (normalizeToken(target.Type)) {
+        case "none":
+            return;
+        case "basic":
+            if (!String(target.Username ?? "").trim()) {
+                throw new Error("Username must be provided for basic auth.");
+            }
+            if (target.Password == null) {
+                throw new Error("Password must be provided for basic auth.");
+            }
+            return;
+        case "bearer":
+            if (!String(target.BearerToken ?? "").trim()) {
+                throw new Error("BearerToken must be provided for bearer auth.");
+            }
+            return;
+        case "oauth2clientcredentials":
+            if (!target.OAuth2ClientCredentials) {
+                throw new Error("OAuth2ClientCredentials must be provided for OAuth2 client-credentials auth.");
+            }
+            toHttpOAuth2ClientCredentialsOptionsModel(target.OAuth2ClientCredentials).Validate();
+            return;
+        default:
+            throw new RangeError("Unsupported HTTP auth type.");
+    }
+}
+function validateKafkaSaslOptionsModel(target) {
+    switch (normalizeToken(target.Mechanism)) {
+        case "oauthbearer":
+            if (!String(target.OAuthBearerTokenEndpointUrl ?? "").trim()) {
+                throw new Error("OAuthBearerTokenEndpointUrl must be provided when SASL mechanism is OAuthBearer.");
+            }
+            return;
+        default:
+            if (!String(target.Username ?? "").trim()) {
+                throw new Error("Username must be provided for SASL authentication.");
+            }
+            if (target.Password == null) {
+                throw new Error("Password must be provided for SASL authentication.");
+            }
+    }
+}
+function toHttpOAuth2ClientCredentialsOptionsModel(value) {
+    return value instanceof HttpOAuth2ClientCredentialsOptionsModel
+        ? value
+        : new HttpOAuth2ClientCredentialsOptionsModel(value);
+}
+function toHttpAuthOptionsModel(value) {
+    return value instanceof HttpAuthOptionsModel ? value : new HttpAuthOptionsModel(value);
+}
+function toKafkaSaslOptionsModel(value) {
+    return value instanceof KafkaSaslOptionsModel ? value : new KafkaSaslOptionsModel(value);
+}
+const protocolBus = new class InMemoryProtocolBus {
+    constructor() {
+        this.kafkaTopics = new Map();
+        this.kafkaOffsets = new Map();
+        this.rabbitQueues = new Map();
+        this.natsSubjects = new Map();
+        this.natsOffsets = new Map();
+        this.redisStreams = new Map();
+        this.redisGroupOffsets = new Map();
+        this.redisCounters = new Map();
+        this.eventHubs = new Map();
+        this.eventHubOffsets = new Map();
+        this.pushTopics = new Map();
+        this.pushOffsets = new Map();
+    }
+    reset() {
+        this.kafkaTopics.clear();
+        this.kafkaOffsets.clear();
+        this.rabbitQueues.clear();
+        this.natsSubjects.clear();
+        this.natsOffsets.clear();
+        this.redisStreams.clear();
+        this.redisGroupOffsets.clear();
+        this.redisCounters.clear();
+        this.eventHubs.clear();
+        this.eventHubOffsets.clear();
+        this.pushTopics.clear();
+        this.pushOffsets.clear();
+    }
+    produceKafka(endpoint, payload) {
+        const options = endpoint.kafka ?? {};
+        const topic = optionString(options, "Topic", "topic") || endpoint.name;
+        const topicRows = this.kafkaTopics.get(topic) ?? [];
+        topicRows.push({ payload: clonePayload(payload), timestampMs: Date.now() });
+        this.kafkaTopics.set(topic, topicRows);
+        return clonePayload(payload);
+    }
+    consumeKafka(endpoint) {
+        const options = endpoint.kafka ?? {};
+        const topic = optionString(options, "Topic", "topic") || endpoint.name;
+        const topicRows = this.kafkaTopics.get(topic) ?? [];
+        const groupId = optionString(options, "ConsumerGroupId", "consumerGroupId")
+            || `${endpoint.name}-group`;
+        const startFromEarliest = optionBoolean(options, true, "StartFromEarliest", "startFromEarliest");
+        const cursorKey = `${topic}|${groupId}`;
+        let offset = this.kafkaOffsets.get(cursorKey);
+        if (offset == null) {
+            offset = startFromEarliest ? 0 : topicRows.length;
+        }
+        if (offset >= topicRows.length) {
+            this.kafkaOffsets.set(cursorKey, offset);
+            return null;
+        }
+        const next = topicRows[offset];
+        this.kafkaOffsets.set(cursorKey, offset + 1);
+        return clonePayload(next.payload);
+    }
+    produceRabbit(endpoint, payload) {
+        const options = endpoint.rabbitMq ?? {};
+        const queueName = optionString(options, "QueueName", "queueName")
+            || optionString(options, "RoutingKey", "routingKey")
+            || endpoint.name;
+        const queue = this.rabbitQueues.get(queueName) ?? [];
+        queue.push({ payload: clonePayload(payload), timestampMs: Date.now() });
+        this.rabbitQueues.set(queueName, queue);
+        return clonePayload(payload);
+    }
+    consumeRabbit(endpoint) {
+        const options = endpoint.rabbitMq ?? {};
+        const queueName = optionString(options, "QueueName", "queueName")
+            || optionString(options, "RoutingKey", "routingKey")
+            || endpoint.name;
+        const queue = this.rabbitQueues.get(queueName) ?? [];
+        if (!queue.length) {
+            return null;
+        }
+        const next = queue.shift() ?? null;
+        this.rabbitQueues.set(queueName, queue);
+        return next ? clonePayload(next.payload) : null;
+    }
+    produceNats(endpoint, payload) {
+        const options = endpoint.nats ?? {};
+        const subject = optionString(options, "Subject", "subject") || endpoint.name;
+        const rows = this.natsSubjects.get(subject) ?? [];
+        rows.push({ payload: clonePayload(payload), timestampMs: Date.now() });
+        this.natsSubjects.set(subject, rows);
+        return clonePayload(payload);
+    }
+    consumeNats(endpoint) {
+        const options = endpoint.nats ?? {};
+        const subject = optionString(options, "Subject", "subject") || endpoint.name;
+        const rows = this.natsSubjects.get(subject) ?? [];
+        const queueGroup = optionString(options, "QueueGroup", "queueGroup");
+        const startFromEarliest = optionBoolean(options, true, "StartFromEarliest", "startFromEarliest");
+        const cursorKey = queueGroup
+            ? `queue:${subject}:${queueGroup}`
+            : `sub:${subject}:${endpoint.name}`;
+        let offset = this.natsOffsets.get(cursorKey);
+        if (offset == null) {
+            offset = startFromEarliest ? 0 : rows.length;
+        }
+        if (offset >= rows.length) {
+            this.natsOffsets.set(cursorKey, offset);
+            return null;
+        }
+        const next = rows[offset];
+        this.natsOffsets.set(cursorKey, offset + 1);
+        return clonePayload(next.payload);
+    }
+    produceRedis(endpoint, payload) {
+        const options = endpoint.redisStreams ?? {};
+        const streamKey = optionString(options, "StreamKey", "streamKey") || endpoint.name;
+        const rows = this.redisStreams.get(streamKey) ?? [];
+        const counter = (this.redisCounters.get(streamKey) ?? 0) + 1;
+        this.redisCounters.set(streamKey, counter);
+        const id = `${Date.now()}-${counter}`;
+        rows.push({ id, payload: clonePayload(payload), timestampMs: Date.now() });
+        const maxLength = optionNumber(options, "MaxLength", "maxLength");
+        if (maxLength > 0 && rows.length > maxLength) {
+            rows.splice(0, rows.length - Math.trunc(maxLength));
+        }
+        this.redisStreams.set(streamKey, rows);
+        const withId = clonePayload(payload);
+        withId.headers = {
+            ...(withId.headers ?? {}),
+            "x-stream-id": id
+        };
+        return withId;
+    }
+    consumeRedis(endpoint) {
+        const options = endpoint.redisStreams ?? {};
+        const streamKey = optionString(options, "StreamKey", "streamKey") || endpoint.name;
+        const rows = this.redisStreams.get(streamKey) ?? [];
+        const consumerGroup = optionString(options, "ConsumerGroup", "consumerGroup")
+            || `${endpoint.name}-group`;
+        const startFromEarliest = optionBoolean(options, true, "StartFromEarliest", "startFromEarliest");
+        const cursorKey = `${streamKey}|${consumerGroup}`;
+        let offset = this.redisGroupOffsets.get(cursorKey);
+        if (offset == null) {
+            offset = startFromEarliest ? 0 : rows.length;
+        }
+        if (offset >= rows.length) {
+            this.redisGroupOffsets.set(cursorKey, offset);
+            return null;
+        }
+        const next = rows[offset];
+        this.redisGroupOffsets.set(cursorKey, offset + 1);
+        const payload = clonePayload(next.payload);
+        payload.headers = {
+            ...(payload.headers ?? {}),
+            "x-stream-id": next.id
+        };
+        return payload;
+    }
+    produceEventHub(endpoint, payload) {
+        const options = endpoint.azureEventHubs ?? {};
+        const hubName = optionString(options, "EventHubName", "eventHubName") || endpoint.name;
+        const partitionId = optionString(options, "PartitionId", "partitionId")
+            || partitionFromKey(optionString(options, "PartitionKey", "partitionKey"), optionNumber(options, "PartitionCount", "partitionCount") || 4);
+        const rows = this.eventHubs.get(hubName) ?? [];
+        rows.push({
+            partitionId,
+            payload: clonePayload(payload),
+            timestampMs: Date.now()
+        });
+        this.eventHubs.set(hubName, rows);
+        return clonePayload(payload);
+    }
+    consumeEventHub(endpoint) {
+        const options = endpoint.azureEventHubs ?? {};
+        const hubName = optionString(options, "EventHubName", "eventHubName") || endpoint.name;
+        const rows = this.eventHubs.get(hubName) ?? [];
+        const consumerGroup = optionString(options, "ConsumerGroup", "consumerGroup") || "$Default";
+        const partitionFilter = optionString(options, "PartitionId", "partitionId") || "*";
+        const startFromEarliest = optionBoolean(options, false, "StartFromEarliest", "startFromEarliest");
+        const cursorKey = `${hubName}|${consumerGroup}|${partitionFilter}`;
+        let offset = this.eventHubOffsets.get(cursorKey);
+        if (offset == null) {
+            offset = startFromEarliest ? 0 : rows.length;
+        }
+        for (let i = offset; i < rows.length; i += 1) {
+            const row = rows[i];
+            if (partitionFilter !== "*" && row.partitionId !== partitionFilter) {
+                continue;
+            }
+            this.eventHubOffsets.set(cursorKey, i + 1);
+            return clonePayload(row.payload);
+        }
+        this.eventHubOffsets.set(cursorKey, rows.length);
+        return null;
+    }
+    producePush(endpoint, payload) {
+        const options = endpoint.pushDiffusion ?? {};
+        const topic = optionString(options, "TopicPath", "topicPath")
+            || optionString(options, "Channel", "channel")
+            || endpoint.name;
+        const rows = this.pushTopics.get(topic) ?? [];
+        rows.push({ payload: clonePayload(payload), timestampMs: Date.now() });
+        this.pushTopics.set(topic, rows);
+        return clonePayload(payload);
+    }
+    consumePush(endpoint) {
+        const options = endpoint.pushDiffusion ?? {};
+        const topic = optionString(options, "TopicPath", "topicPath")
+            || optionString(options, "Channel", "channel")
+            || endpoint.name;
+        const rows = this.pushTopics.get(topic) ?? [];
+        const subscriberId = optionString(options, "SubscriberId", "subscriberId") || endpoint.name;
+        const startFromEarliest = optionBoolean(options, true, "StartFromEarliest", "startFromEarliest");
+        const cursorKey = `${topic}|${subscriberId}`;
+        let offset = this.pushOffsets.get(cursorKey);
+        if (offset == null) {
+            offset = startFromEarliest ? 0 : rows.length;
+        }
+        if (offset >= rows.length) {
+            this.pushOffsets.set(cursorKey, offset);
+            return null;
+        }
+        const next = rows[offset];
+        this.pushOffsets.set(cursorKey, offset + 1);
+        return clonePayload(next.payload);
+    }
+}();
+class CallbackAdapter {
+    constructor(endpoint) {
+        this.consumeQueue = [];
+        this.consumeStreamStarted = false;
+        this.endpoint = endpoint;
+    }
+    async produce(payload) {
+        if (this.endpoint.mode !== "Produce") {
+            return null;
+        }
+        const resolved = prepareProducedPayload(this.endpoint, payload);
+        const structuredDelegate = resolveStructuredProduceDelegate(this.endpoint);
+        if (structuredDelegate) {
+            return await invokeStructuredProduceDelegate(this.endpoint, resolved, structuredDelegate);
+        }
+        const delegate = resolveProduceDelegate(this.endpoint);
+        if (delegate) {
+            const next = await delegate(clonePayload(resolved));
+            return next == null ? null : normalizeTrackingPayload(next);
+        }
+        return clonePayload(resolved);
+    }
+    async consume() {
+        if (this.endpoint.mode !== "Consume") {
+            return null;
+        }
+        if (this.consumeQueue.length > 0) {
+            return this.consumeQueue.shift() ?? null;
+        }
+        const structuredDelegate = resolveStructuredConsumeDelegate(this.endpoint);
+        if (structuredDelegate) {
+            const next = await structuredDelegate();
+            return normalizeConsumedDelegatePayload(next);
+        }
+        const streamDelegate = resolveStructuredConsumeStreamDelegate(this.endpoint);
+        if (streamDelegate) {
+            this.ensureConsumeStreamStarted(streamDelegate);
+            return this.consumeQueue.shift() ?? null;
+        }
+        const delegate = resolveConsumeDelegate(this.endpoint);
+        if (delegate) {
+            const next = await delegate();
+            return next == null ? null : normalizeTrackingPayload(next);
+        }
+        return this.defaultPayload();
+    }
+    async dispose() { }
+    defaultPayload() {
+        return createDefaultPayload(this.endpoint);
+    }
+    ensureConsumeStreamStarted(streamDelegate) {
+        if (this.consumeStreamStarted) {
+            return;
+        }
+        this.consumeStreamStarted = true;
+        void Promise.resolve(streamDelegate(async (message) => {
+            const normalized = normalizeConsumedDelegatePayload(message);
+            if (normalized) {
+                this.consumeQueue.push(normalized);
+            }
+        })).catch(() => {
+            // Consume stream failures are best-effort at the adapter surface.
+        });
+    }
+}
+class HttpEndpointAdapter extends CallbackAdapter {
+    constructor() {
+        super(...arguments);
+        this.httpConsumeQueue = [];
+        this.oauthToken = null;
+    }
+    async produce(payload) {
+        if (this.endpoint.mode !== "Produce") {
+            return null;
+        }
+        const resolved = payload ?? this.defaultPayload();
+        const httpOptions = this.endpoint.http;
+        if (!httpOptions?.url) {
+            return super.produce(resolved);
+        }
+        const method = httpOptions.method ?? "GET";
+        const resolvedContentType = resolveHttpContentType(this.endpoint.contentType, httpOptions.bodyType);
+        const headers = {
+            ...(resolved.headers ?? {}),
+            "Content-Type": resolvedContentType
+        };
+        await applyHttpAuthHeaders(headers, httpOptions, async () => this.resolveOAuthToken(httpOptions));
+        const body = buildHttpRequestBody(resolved.body, httpOptions.bodyType ?? "Json", headers["Content-Type"] ?? resolvedContentType);
+        const produceTimeout = createTimeoutSignal(httpOptions.requestTimeoutSeconds);
+        const response = await fetch(httpOptions.url, {
+            method,
+            headers,
+            body: body,
+            signal: produceTimeout.signal
+        }).finally(() => produceTimeout.clear());
+        if (!response.ok) {
+            throw new Error(`HTTP adapter request failed with status ${response.status}.`);
+        }
+        const responseClone = response.clone();
+        let result = await buildHttpProduceResult(resolved, response, httpOptions.responseSource);
+        if (canonicalizeHttpTrackingPayloadSource(String(httpOptions.trackingPayloadSource ?? "Request")) === "Response" &&
+            !extractTrackingValue(result, this.endpoint.trackingField)) {
+            result = await buildHttpProduceResult(resolved, responseClone, "ResponseBody");
+        }
+        return result;
+    }
+    async consume() {
+        if (this.endpoint.mode !== "Consume") {
+            return null;
+        }
+        const httpOptions = this.endpoint.http;
+        if (this.httpConsumeQueue.length > 0) {
+            return this.httpConsumeQueue.shift() ?? null;
+        }
+        if (httpOptions?.consumePoll) {
+            return await httpOptions.consumePoll();
+        }
+        if (!httpOptions?.url) {
+            return super.consume();
+        }
+        const method = httpOptions.method ?? "GET";
+        const headers = {};
+        await applyHttpAuthHeaders(headers, httpOptions, async () => this.resolveOAuthToken(httpOptions));
+        const consumeTimeout = createTimeoutSignal(httpOptions.requestTimeoutSeconds);
+        const response = await fetch(httpOptions.url, {
+            method,
+            headers,
+            signal: consumeTimeout.signal
+        }).finally(() => consumeTimeout.clear());
+        if (!response.ok) {
+            return null;
+        }
+        const rawText = await response.text();
+        const parsed = parseMaybeJson(rawText);
+        const consumeArrayPath = httpOptions.consumeArrayPath
+            ?? (httpOptions.consumeJsonArrayResponse ? "$" : undefined);
+        const rows = normalizeConsumedPayloadRows(parsed, consumeArrayPath);
+        if (!rows.length) {
+            return null;
+        }
+        this.httpConsumeQueue.push(...rows.slice(1));
+        return rows[0];
+    }
+    async resolveOAuthToken(httpOptions) {
+        const auth = httpOptions.auth;
+        const mode = normalizeToken(auth?.mode ?? auth?.type ?? "None");
+        if (mode !== "oauth2clientcredentials") {
+            return "";
+        }
+        const now = Date.now();
+        if (this.oauthToken && this.oauthToken.expiresAtMs > now + 5000) {
+            return this.oauthToken.value;
+        }
+        const oauthOptions = auth?.oauth2ClientCredentials;
+        const tokenUrl = requireNonEmptyString(auth?.tokenUrl ?? oauthOptions?.tokenEndpoint, "Http auth tokenUrl is required for OAuth2 client credentials.");
+        const clientId = requireNonEmptyString(auth?.clientId ?? oauthOptions?.clientId, "Http auth clientId is required for OAuth2 client credentials.");
+        const clientSecret = requireNonEmptyString(auth?.clientSecret ?? oauthOptions?.clientSecret, "Http auth clientSecret is required for OAuth2 client credentials.");
+        const body = new URLSearchParams();
+        body.set("grant_type", "client_credentials");
+        body.set("client_id", clientId);
+        body.set("client_secret", clientSecret);
+        const scopes = Array.isArray(oauthOptions?.scopes)
+            ? oauthOptions.scopes.map((x) => String(x).trim()).filter((x) => x.length > 0)
+            : Array.isArray(auth?.scopes)
+                ? auth.scopes.map((x) => String(x).trim()).filter((x) => x.length > 0)
+                : [];
+        const scopeText = typeof auth?.scope === "string" && auth.scope.trim()
+            ? auth.scope.trim()
+            : (scopes.length ? scopes.join(" ") : "");
+        if (scopeText) {
+            body.set("scope", scopeText);
+        }
+        if (typeof auth?.audience === "string" && auth.audience.trim()) {
+            body.set("audience", auth.audience.trim());
+        }
+        for (const [key, value] of Object.entries({
+            ...(auth?.additionalFormFields ?? {}),
+            ...(oauthOptions?.additionalFormFields ?? {})
+        })) {
+            if (key.trim() && typeof value === "string") {
+                body.set(key.trim(), value);
+            }
+        }
+        const headers = {
+            "Content-Type": "application/x-www-form-urlencoded"
+        };
+        for (const [key, value] of Object.entries(httpOptions.tokenRequestHeaders ?? {})) {
+            if (key.trim() && typeof value === "string") {
+                headers[key] = value;
+            }
+        }
+        const tokenTimeout = createTimeoutSignal(httpOptions.requestTimeoutSeconds);
+        const response = await fetch(tokenUrl, {
+            method: "POST",
+            headers,
+            body: body.toString(),
+            signal: tokenTimeout.signal
+        }).finally(() => tokenTimeout.clear());
+        if (!response.ok) {
+            throw new Error(`OAuth2 token request failed with status ${response.status}.`);
+        }
+        const payload = parseMaybeJson(await response.text());
+        if (!isRecord(payload)) {
+            throw new Error("OAuth2 token response payload was not a JSON object.");
+        }
+        const accessToken = requireNonEmptyString(payload.access_token, "OAuth2 token response did not contain access_token.");
+        const expiresInSeconds = optionNumber(payload, "expires_in", "expiresIn", "ExpiresIn");
+        this.oauthToken = {
+            value: accessToken,
+            expiresAtMs: now + (Math.max(expiresInSeconds, 1) * 1000)
+        };
+        return accessToken;
+    }
+}
+class KafkaEndpointAdapter extends CallbackAdapter {
+    constructor() {
+        super(...arguments);
+        this.producerPromise = null;
+        this.consumerPromise = null;
+        this.consumerStartPromise = null;
+        this.queue = [];
+    }
+    async produce(payload) {
+        if (resolveProduceDelegate(this.endpoint)) {
+            return super.produce(payload);
+        }
+        if (this.endpoint.mode !== "Produce") {
+            return null;
+        }
+        const producer = await this.getProducer();
+        const options = this.endpoint.kafka ?? {};
+        const resolved = prepareProducedPayload(this.endpoint, payload);
+        const wire = toWirePayload(resolved, this.endpoint);
+        await producer.send({
+            topic: optionString(options, "Topic", "topic"),
+            messages: [
+                {
+                    value: Buffer.from(wire.body),
+                    headers: toKafkaHeadersWithContentType(wire.headers, wire.contentType)
+                }
+            ]
+        });
+        return clonePayload(resolved);
+    }
+    async consume() {
+        if (resolveConsumeDelegate(this.endpoint)) {
+            return super.consume();
+        }
+        if (this.endpoint.mode !== "Consume") {
+            return null;
+        }
+        await this.ensureConsumerStarted();
+        return this.queue.shift() ?? null;
+    }
+    async dispose() {
+        const consumer = await this.consumerPromise?.catch(() => null);
+        const producer = await this.producerPromise?.catch(() => null);
+        await consumer?.disconnect?.().catch(() => { });
+        await producer?.disconnect?.().catch(() => { });
+    }
+    async getProducer() {
+        if (!this.producerPromise) {
+            this.producerPromise = (async () => {
+                const kafka = await createKafkaClient(this.endpoint);
+                const producer = kafka.producer();
+                await producer.connect();
+                return producer;
+            })();
+        }
+        return this.producerPromise;
+    }
+    async ensureConsumerStarted() {
+        if (!this.consumerStartPromise) {
+            this.consumerStartPromise = (async () => {
+                const options = this.endpoint.kafka ?? {};
+                const useConfluentClient = shouldUseConfluentKafkaClient(this.endpoint);
+                const kafka = await createKafkaClient(this.endpoint);
+                const consumer = kafka.consumer(buildKafkaConsumerOptions(this.endpoint));
+                await consumer.connect();
+                if (useConfluentClient) {
+                    await consumer.subscribe({
+                        topics: [optionString(options, "Topic", "topic")]
+                    });
+                }
+                else {
+                    await consumer.subscribe({
+                        topic: optionString(options, "Topic", "topic"),
+                        fromBeginning: optionBoolean(options, true, "StartFromEarliest", "startFromEarliest")
+                    });
+                }
+                await consumer.run({
+                    eachMessage: async ({ message }) => {
+                        this.queue.push(createBrokerPayload(fromKafkaHeaders(message.headers), bufferToUint8Array(message.value), this.endpoint, headerValue(message.headers, "content-type")));
+                    }
+                });
+                this.consumerPromise = Promise.resolve(consumer);
+            })();
+        }
+        await this.consumerStartPromise;
+    }
+}
+class RabbitMqEndpointAdapter extends CallbackAdapter {
+    constructor() {
+        super(...arguments);
+        this.connectionPromise = null;
+        this.channelPromise = null;
+    }
+    async produce(payload) {
+        if (resolveProduceDelegate(this.endpoint)) {
+            return super.produce(payload);
+        }
+        if (this.endpoint.mode !== "Produce") {
+            return null;
+        }
+        const options = this.endpoint.rabbitMq ?? {};
+        const channel = await this.getChannel();
+        const resolved = prepareProducedPayload(this.endpoint, payload);
+        const wire = toWirePayload(resolved, this.endpoint);
+        const queueName = optionString(options, "QueueName", "queueName");
+        const routingKey = optionString(options, "RoutingKey", "routingKey") || queueName;
+        const exchange = optionString(options, "Exchange", "exchange");
+        if (queueName) {
+            await channel.assertQueue(queueName, {
+                durable: optionBoolean(options, true, "Durable", "durable"),
+                autoDelete: false,
+                exclusive: false
+            });
+        }
+        channel.publish(exchange || "", routingKey, Buffer.from(wire.body), {
+            persistent: optionBoolean(options, true, "Durable", "durable"),
+            contentType: wire.contentType,
+            headers: { ...wire.headers }
+        });
+        return clonePayload(resolved);
+    }
+    async consume() {
+        if (resolveConsumeDelegate(this.endpoint)) {
+            return super.consume();
+        }
+        if (this.endpoint.mode !== "Consume") {
+            return null;
+        }
+        const channel = await this.getChannel();
+        const options = this.endpoint.rabbitMq ?? {};
+        const queueName = optionString(options, "QueueName", "queueName");
+        const autoAck = optionBoolean(options, false, "AutoAck", "autoAck");
+        const message = await channel.get(queueName, { noAck: autoAck });
+        if (!message) {
+            return null;
+        }
+        if (!autoAck) {
+            channel.ack(message);
+        }
+        return createBrokerPayload(toHeaderRecord(message.properties?.headers), bufferToUint8Array(message.content), this.endpoint, typeof message.properties?.contentType === "string" ? message.properties.contentType : undefined);
+    }
+    async dispose() {
+        const channel = await this.channelPromise?.catch(() => null);
+        const connection = await this.connectionPromise?.catch(() => null);
+        await channel?.close?.().catch(() => { });
+        await connection?.close?.().catch(() => { });
+    }
+    async getChannel() {
+        if (!this.channelPromise) {
+            this.channelPromise = (async () => {
+                const amqplib = await import("amqplib");
+                const options = this.endpoint.rabbitMq ?? {};
+                const connection = await amqplib.default.connect({
+                    protocol: optionBoolean(options, false, "UseSsl", "useSsl") ? "amqps" : "amqp",
+                    hostname: optionString(options, "HostName", "hostName"),
+                    port: optionNumber(options, "Port", "port") || 5672,
+                    username: optionString(options, "UserName", "userName"),
+                    password: optionString(options, "Password", "password"),
+                    vhost: optionString(options, "VirtualHost", "virtualHost") || "/",
+                    clientProperties: toStringRecord(pickProtocolValue(options, "ClientProperties", "clientProperties"))
+                });
+                this.connectionPromise = Promise.resolve(connection);
+                const channel = await connection.createChannel();
+                const queueName = optionString(options, "QueueName", "queueName");
+                if (queueName) {
+                    await channel.assertQueue(queueName, {
+                        durable: optionBoolean(options, true, "Durable", "durable"),
+                        autoDelete: false,
+                        exclusive: false
+                    });
+                }
+                return channel;
+            })();
+        }
+        return this.channelPromise;
+    }
+}
+class NatsEndpointAdapter extends CallbackAdapter {
+    constructor() {
+        super(...arguments);
+        this.connectionPromise = null;
+        this.subscriptionPromise = null;
+        this.subscription = null;
+        this.queue = [];
+    }
+    async produce(payload) {
+        if (resolveProduceDelegate(this.endpoint)) {
+            return super.produce(payload);
+        }
+        if (this.endpoint.mode !== "Produce") {
+            return null;
+        }
+        const connection = await this.getConnection();
+        const options = this.endpoint.nats ?? {};
+        const resolved = prepareProducedPayload(this.endpoint, payload);
+        const wire = toWirePayload(resolved, this.endpoint);
+        const subject = optionString(options, "Subject", "subject");
+        const headers = await createNatsHeaders(wire.headers, wire.contentType);
+        connection.publish(subject, Buffer.from(wire.body), headers ? { headers } : undefined);
+        await connection.flush();
+        return clonePayload(resolved);
+    }
+    async consume() {
+        if (resolveConsumeDelegate(this.endpoint)) {
+            return super.consume();
+        }
+        if (this.endpoint.mode !== "Consume") {
+            return null;
+        }
+        await this.ensureSubscriptionStarted();
+        return this.queue.shift() ?? null;
+    }
+    async dispose() {
+        this.subscription?.unsubscribe?.();
+        const connection = await this.connectionPromise?.catch(() => null);
+        await connection?.drain?.().catch(() => { });
+        await connection?.close?.().catch(() => { });
+    }
+    async getConnection() {
+        if (!this.connectionPromise) {
+            this.connectionPromise = (async () => {
+                const { connect } = await import("nats");
+                const options = this.endpoint.nats ?? {};
+                return connect({
+                    servers: optionString(options, "ServerUrl", "serverUrl"),
+                    user: optionString(options, "UserName", "userName") || undefined,
+                    pass: optionString(options, "Password", "password") || undefined,
+                    token: optionString(options, "Token", "token") || undefined,
+                    name: optionString(options, "ConnectionName", "connectionName") || this.endpoint.name,
+                    maxReconnectAttempts: optionNumber(options, "MaxReconnectAttempts", "maxReconnectAttempts") || 60
+                });
+            })();
+        }
+        return this.connectionPromise;
+    }
+    async ensureSubscriptionStarted() {
+        if (!this.subscriptionPromise) {
+            this.subscriptionPromise = (async () => {
+                const connection = await this.getConnection();
+                const options = this.endpoint.nats ?? {};
+                const subject = optionString(options, "Subject", "subject");
+                const queueGroup = optionString(options, "QueueGroup", "queueGroup") || undefined;
+                this.subscription = connection.subscribe(subject, queueGroup ? { queue: queueGroup } : undefined);
+                await connection.flush();
+                void (async () => {
+                    for await (const message of this.subscription) {
+                        this.queue.push(createBrokerPayload(toHeaderRecord(message.headers), bufferToUint8Array(message.data), this.endpoint, toHeaderRecord(message.headers)["content-type"]));
+                    }
+                })();
+            })();
+        }
+        await this.subscriptionPromise;
+    }
+}
+class RedisStreamsEndpointAdapter extends CallbackAdapter {
+    constructor() {
+        super(...arguments);
+        this.clientPromise = null;
+        this.groupReady = false;
+    }
+    async produce(payload) {
+        if (resolveProduceDelegate(this.endpoint)) {
+            return super.produce(payload);
+        }
+        if (this.endpoint.mode !== "Produce") {
+            return null;
+        }
+        const client = await this.getClient();
+        const options = this.endpoint.redisStreams ?? {};
+        const resolved = prepareProducedPayload(this.endpoint, payload);
+        const wire = toWirePayload(resolved, this.endpoint);
+        const streamKey = optionString(options, "StreamKey", "streamKey");
+        const args = ["XADD", streamKey];
+        const maxLength = optionNumber(options, "MaxLength", "maxLength");
+        if (maxLength > 0) {
+            args.push("MAXLEN", "~", String(Math.trunc(maxLength)));
+        }
+        args.push("*", "body", Buffer.from(wire.body));
+        if (wire.contentType) {
+            args.push("content-type", wire.contentType);
+        }
+        for (const [key, value] of Object.entries(wire.headers)) {
+            args.push(`header:${key}`, value);
+        }
+        await client.sendCommand(args);
+        return clonePayload(resolved);
+    }
+    async consume() {
+        if (resolveConsumeDelegate(this.endpoint)) {
+            return super.consume();
+        }
+        if (this.endpoint.mode !== "Consume") {
+            return null;
+        }
+        const client = await this.getClient();
+        const options = this.endpoint.redisStreams ?? {};
+        await this.ensureConsumerGroup();
+        const streamKey = optionString(options, "StreamKey", "streamKey");
+        const consumerGroup = optionString(options, "ConsumerGroup", "consumerGroup");
+        const consumerName = optionString(options, "ConsumerName", "consumerName");
+        const readCount = optionNumber(options, "ReadCount", "readCount") || 50;
+        const blockMs = Math.max(this.endpoint.pollIntervalMs ?? 250, 1);
+        const { commandOptions } = await import("redis");
+        const rows = await client.sendCommand(commandOptions({ returnBuffers: true }), [
+            "XREADGROUP",
+            "GROUP",
+            consumerGroup,
+            consumerName,
+            "COUNT",
+            String(Math.trunc(readCount)),
+            "BLOCK",
+            String(Math.trunc(blockMs)),
+            "STREAMS",
+            streamKey,
+            ">"
+        ]);
+        const entry = readFirstRedisStreamEntry(rows);
+        if (!entry) {
+            return null;
+        }
+        await client.sendCommand(["XACK", streamKey, consumerGroup, entry.id]);
+        const payload = createRedisStreamPayload(entry.fields, this.endpoint);
+        payload.headers = {
+            ...(payload.headers ?? {}),
+            "x-stream-id": entry.id
+        };
+        return payload;
+    }
+    async dispose() {
+        const client = await this.clientPromise?.catch(() => null);
+        await client?.quit?.().catch(async () => {
+            await client?.disconnect?.().catch(() => { });
+        });
+    }
+    async getClient() {
+        if (!this.clientPromise) {
+            this.clientPromise = (async () => {
+                const { createClient } = await import("redis");
+                const options = this.endpoint.redisStreams ?? {};
+                const client = createClient({
+                    url: optionString(options, "ConnectionString", "connectionString")
+                });
+                client.on?.("error", () => { });
+                await client.connect();
+                return client;
+            })();
+        }
+        return this.clientPromise;
+    }
+    async ensureConsumerGroup() {
+        if (this.groupReady) {
+            return;
+        }
+        const client = await this.getClient();
+        const options = this.endpoint.redisStreams ?? {};
+        const streamKey = optionString(options, "StreamKey", "streamKey");
+        const consumerGroup = optionString(options, "ConsumerGroup", "consumerGroup");
+        const startPosition = optionBoolean(options, true, "StartFromEarliest", "startFromEarliest") ? "0-0" : "$";
+        try {
+            await client.sendCommand(["XGROUP", "CREATE", streamKey, consumerGroup, startPosition, "MKSTREAM"]);
+        }
+        catch (error) {
+            if (!String(error ?? "").toUpperCase().includes("BUSYGROUP")) {
+                throw error;
+            }
+        }
+        this.groupReady = true;
+    }
+}
+class AzureEventHubsEndpointAdapter extends CallbackAdapter {
+    constructor() {
+        super(...arguments);
+        this.producerPromise = null;
+        this.consumerPromise = null;
+        this.subscriptionPromise = null;
+        this.subscription = null;
+        this.queue = [];
+    }
+    async produce(payload) {
+        if (resolveProduceDelegate(this.endpoint)) {
+            return super.produce(payload);
+        }
+        if (this.endpoint.mode !== "Produce") {
+            return null;
+        }
+        const producer = await this.getProducer();
+        const options = this.endpoint.azureEventHubs ?? {};
+        const resolved = prepareProducedPayload(this.endpoint, payload);
+        const wire = toWirePayload(resolved, this.endpoint);
+        const batch = await producer.createBatch();
+        const eventData = {
+            body: Buffer.from(wire.body),
+            contentType: wire.contentType,
+            properties: { ...wire.headers }
+        };
+        const partitionId = optionString(options, "PartitionId", "partitionId");
+        if (partitionId) {
+            eventData.partitionId = partitionId;
+        }
+        if (!batch.tryAdd(eventData)) {
+            throw new Error("Azure Event Hubs payload is too large for a single batch.");
+        }
+        await producer.sendBatch(batch);
+        return clonePayload(resolved);
+    }
+    async consume() {
+        if (resolveConsumeDelegate(this.endpoint)) {
+            return super.consume();
+        }
+        if (this.endpoint.mode !== "Consume") {
+            return null;
+        }
+        await this.ensureSubscriptionStarted();
+        return this.queue.shift() ?? null;
+    }
+    async dispose() {
+        await this.subscription?.close?.().catch(() => { });
+        const consumer = await this.consumerPromise?.catch(() => null);
+        const producer = await this.producerPromise?.catch(() => null);
+        await consumer?.close?.().catch(() => { });
+        await producer?.close?.().catch(() => { });
+    }
+    async getProducer() {
+        if (!this.producerPromise) {
+            this.producerPromise = (async () => {
+                const { EventHubProducerClient } = await import("@azure/event-hubs");
+                const options = this.endpoint.azureEventHubs ?? {};
+                return new EventHubProducerClient(optionString(options, "ConnectionString", "connectionString"), optionString(options, "EventHubName", "eventHubName"));
+            })();
+        }
+        return this.producerPromise;
+    }
+    async getConsumer() {
+        if (!this.consumerPromise) {
+            this.consumerPromise = (async () => {
+                const { EventHubConsumerClient } = await import("@azure/event-hubs");
+                const options = this.endpoint.azureEventHubs ?? {};
+                return new EventHubConsumerClient(optionString(options, "ConsumerGroup", "consumerGroup") || "$Default", optionString(options, "ConnectionString", "connectionString"), optionString(options, "EventHubName", "eventHubName"));
+            })();
+        }
+        return this.consumerPromise;
+    }
+    async ensureSubscriptionStarted() {
+        if (!this.subscriptionPromise) {
+            this.subscriptionPromise = (async () => {
+                const consumer = await this.getConsumer();
+                const options = this.endpoint.azureEventHubs ?? {};
+                const startPosition = optionBoolean(options, false, "StartFromEarliest", "startFromEarliest")
+                    ? { enqueuedOn: new Date(0) }
+                    : { latest: true };
+                const partitionId = optionString(options, "PartitionId", "partitionId");
+                this.subscription = consumer.subscribe(partitionId ? {
+                    processEvents: async (events) => {
+                        for (const event of events) {
+                            this.queue.push(createBrokerPayload(toHeaderRecord(event.properties), bufferToUint8Array(event.body), this.endpoint, typeof event.contentType === "string" ? event.contentType : undefined));
+                        }
+                    },
+                    processError: async () => { }
+                } : {
+                    processEvents: async (events) => {
+                        for (const event of events) {
+                            this.queue.push(createBrokerPayload(toHeaderRecord(event.properties), bufferToUint8Array(event.body), this.endpoint, typeof event.contentType === "string" ? event.contentType : undefined));
+                        }
+                    },
+                    processError: async () => { }
+                }, partitionId ? { startPosition, partitionId } : { startPosition });
+            })();
+        }
+        await this.subscriptionPromise;
+    }
+}
+class PushDiffusionEndpointAdapter extends CallbackAdapter {
+    async produce(payload) {
+        return super.produce(payload);
+    }
+    async consume() {
+        return super.consume();
+    }
+}
+class DelegateStreamEndpointAdapter extends CallbackAdapter {
+}
+export class EndpointAdapterFactory {
+    static create(endpoint) {
+        if (endpoint instanceof TrafficEndpointDefinitionModel) {
+            endpoint.Validate();
+        }
+        const normalized = normalizeEndpointDefinition(endpoint);
+        validateEndpointDefinition(normalized);
+        switch (normalized.kind) {
+            case "Http":
+                return new HttpEndpointAdapter(normalized);
+            case "Kafka":
+                return new KafkaEndpointAdapter(normalized);
+            case "RabbitMq":
+                return new RabbitMqEndpointAdapter(normalized);
+            case "Nats":
+                return new NatsEndpointAdapter(normalized);
+            case "RedisStreams":
+                return new RedisStreamsEndpointAdapter(normalized);
+            case "AzureEventHubs":
+                return new AzureEventHubsEndpointAdapter(normalized);
+            case "PushDiffusion":
+                return new PushDiffusionEndpointAdapter(normalized);
+            case "DelegateStream":
+                return new DelegateStreamEndpointAdapter(normalized);
+            default:
+                throw new Error(`Unsupported endpoint kind: ${String(normalized?.kind ?? "")}.`);
+        }
+    }
+}
+const HTTP_ENDPOINT_FLAT_KEYS = [
+    "Url",
+    "url",
+    "Method",
+    "method",
+    "ConsumePoll",
+    "consumePoll",
+    "BodyType",
+    "bodyType",
+    "ResponseSource",
+    "responseSource",
+    "TrackingPayloadSource",
+    "trackingPayloadSource",
+    "ConsumeArrayPath",
+    "consumeArrayPath",
+    "ConsumeJsonArrayResponse",
+    "consumeJsonArrayResponse",
+    "RequestTimeout",
+    "requestTimeout",
+    "RequestTimeoutSeconds",
+    "requestTimeoutSeconds",
+    "Auth",
+    "auth",
+    "TokenRequestHeaders",
+    "tokenRequestHeaders"
+];
+const KAFKA_ENDPOINT_FLAT_KEYS = [
+    "BootstrapServers",
+    "bootstrapServers",
+    "Topic",
+    "topic",
+    "ConsumerGroupId",
+    "consumerGroupId",
+    "SecurityProtocol",
+    "securityProtocol",
+    "Sasl",
+    "sasl",
+    "ConfluentSettings",
+    "confluentSettings",
+    "StartFromEarliest",
+    "startFromEarliest"
+];
+const RABBITMQ_ENDPOINT_FLAT_KEYS = [
+    "HostName",
+    "hostName",
+    "Port",
+    "port",
+    "VirtualHost",
+    "virtualHost",
+    "UserName",
+    "userName",
+    "Password",
+    "password",
+    "Exchange",
+    "exchange",
+    "QueueName",
+    "queueName",
+    "RoutingKey",
+    "routingKey",
+    "Durable",
+    "durable",
+    "AutoAck",
+    "autoAck",
+    "UseSsl",
+    "useSsl",
+    "ClientProperties",
+    "clientProperties"
+];
+const NATS_ENDPOINT_FLAT_KEYS = [
+    "ServerUrl",
+    "serverUrl",
+    "Subject",
+    "subject",
+    "QueueGroup",
+    "queueGroup",
+    "UserName",
+    "userName",
+    "Password",
+    "password",
+    "Token",
+    "token",
+    "ConnectionName",
+    "connectionName",
+    "MaxReconnectAttempts",
+    "maxReconnectAttempts"
+];
+const REDIS_STREAMS_ENDPOINT_FLAT_KEYS = [
+    "ConnectionString",
+    "connectionString",
+    "StreamKey",
+    "streamKey",
+    "ConsumerGroup",
+    "consumerGroup",
+    "ConsumerName",
+    "consumerName",
+    "StartFromEarliest",
+    "startFromEarliest",
+    "ReadCount",
+    "readCount",
+    "MaxLength",
+    "maxLength"
+];
+const AZURE_EVENT_HUBS_ENDPOINT_FLAT_KEYS = [
+    "ConnectionString",
+    "connectionString",
+    "EventHubName",
+    "eventHubName",
+    "ConsumerGroup",
+    "consumerGroup",
+    "PartitionId",
+    "partitionId",
+    "StartFromEarliest",
+    "startFromEarliest"
+];
+const PUSH_DIFFUSION_ENDPOINT_FLAT_KEYS = [
+    "ServerUrl",
+    "serverUrl",
+    "TopicPath",
+    "topicPath",
+    "Principal",
+    "principal",
+    "Password",
+    "password",
+    "ConnectionProperties",
+    "connectionProperties",
+    "PublishAsync",
+    "publishAsync",
+    "SubscribeAsync",
+    "subscribeAsync"
+];
+const DELEGATE_STREAM_ENDPOINT_FLAT_KEYS = [
+    "Produce",
+    "produce",
+    "Consume",
+    "consume",
+    "ProduceAsync",
+    "produceAsync",
+    "ConsumeAsync",
+    "consumeAsync",
+    "ConnectionMetadata",
+    "connectionMetadata"
+];
+function normalizeEndpointDefinition(endpoint) {
+    if (!endpoint || typeof endpoint !== "object") {
+        return endpoint;
+    }
+    const raw = endpoint;
+    const kind = resolveEndpointKind(raw);
+    const pollInterval = pickOptionalEndpointNumber(raw, "PollInterval", "pollInterval");
+    const pollIntervalMs = pickOptionalEndpointNumber(raw, "PollIntervalMs", "pollIntervalMs");
+    const pollIntervalSeconds = pickOptionalEndpointNumber(raw, "PollIntervalSeconds", "pollIntervalSeconds");
+    return {
+        kind: (kind ?? pickEndpointString(raw, "kind", "Kind")),
+        mode: pickEndpointString(raw, "mode", "Mode"),
+        name: pickEndpointString(raw, "name", "Name"),
+        trackingField: pickTrackingFieldSelectorString(raw, "trackingField", "TrackingField"),
+        gatherByField: pickOptionalTrackingFieldSelectorString(raw, "gatherByField", "GatherByField"),
+        autoGenerateTrackingIdWhenMissing: pickEndpointBoolean(raw, "autoGenerateTrackingIdWhenMissing", "AutoGenerateTrackingIdWhenMissing"),
+        pollIntervalMs: pollIntervalMs ?? (pollIntervalSeconds != null
+            ? pollIntervalSeconds * 1000
+            : (pollInterval != null ? pollInterval * 1000 : undefined)),
+        messageHeaders: pickEndpointStringRecord(raw, "messageHeaders", "MessageHeaders"),
+        messagePayload: pickEndpointValue(raw, "messagePayload", "MessagePayload"),
+        messagePayloadType: pickOptionalEndpointString(raw, "messagePayloadType", "MessagePayloadType"),
+        jsonSerializerSettings: pickEndpointRecord(raw, "jsonSerializerSettings", "JsonSettings", "JsonSerializerSettings"),
+        jsonConvertSettings: pickEndpointRecord(raw, "jsonConvertSettings", "JsonConvertSettings"),
+        contentType: pickOptionalEndpointString(raw, "contentType", "ContentType"),
+        connectionMetadata: pickEndpointStringRecord(raw, "connectionMetadata", "ConnectionMetadata"),
+        http: normalizeHttpEndpointOptions(pickEndpointTransportRecord(raw, kind, "Http", ["http", "Http"], HTTP_ENDPOINT_FLAT_KEYS)),
+        kafka: normalizeProtocolOptions(pickEndpointTransportRecord(raw, kind, "Kafka", ["kafka", "Kafka"], KAFKA_ENDPOINT_FLAT_KEYS)),
+        rabbitMq: normalizeProtocolOptions(pickEndpointTransportRecord(raw, kind, "RabbitMq", ["rabbitMq", "RabbitMq"], RABBITMQ_ENDPOINT_FLAT_KEYS)),
+        nats: normalizeProtocolOptions(pickEndpointTransportRecord(raw, kind, "Nats", ["nats", "Nats"], NATS_ENDPOINT_FLAT_KEYS)),
+        redisStreams: normalizeProtocolOptions(pickEndpointTransportRecord(raw, kind, "RedisStreams", ["redisStreams", "RedisStreams"], REDIS_STREAMS_ENDPOINT_FLAT_KEYS)),
+        azureEventHubs: normalizeProtocolOptions(pickEndpointTransportRecord(raw, kind, "AzureEventHubs", ["azureEventHubs", "AzureEventHubs"], AZURE_EVENT_HUBS_ENDPOINT_FLAT_KEYS)),
+        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))
+    };
+}
+function resolveEndpointKind(raw) {
+    const explicitKind = pickOptionalEndpointString(raw, "kind", "Kind");
+    if (explicitKind) {
+        return explicitKind;
+    }
+    if (Object.keys(pickEndpointRecord(raw, "http", "Http")).length || hasAnyEndpointField(raw, ["Url", "url"])) {
+        return "Http";
+    }
+    if (Object.keys(pickEndpointRecord(raw, "kafka", "Kafka")).length || hasAnyEndpointField(raw, ["BootstrapServers", "bootstrapServers", "Topic", "topic"])) {
+        return "Kafka";
+    }
+    if (Object.keys(pickEndpointRecord(raw, "rabbitMq", "RabbitMq")).length || hasAnyEndpointField(raw, [
+        "HostName",
+        "hostName",
+        "VirtualHost",
+        "virtualHost",
+        "Exchange",
+        "exchange",
+        "QueueName",
+        "queueName",
+        "RoutingKey",
+        "routingKey",
+        "UseSsl",
+        "useSsl",
+        "ClientProperties",
+        "clientProperties"
+    ])) {
+        return "RabbitMq";
+    }
+    if (Object.keys(pickEndpointRecord(raw, "redisStreams", "RedisStreams")).length || hasAnyEndpointField(raw, [
+        "StreamKey",
+        "streamKey",
+        "ConsumerName",
+        "consumerName",
+        "ReadCount",
+        "readCount",
+        "MaxLength",
+        "maxLength"
+    ])) {
+        return "RedisStreams";
+    }
+    if (Object.keys(pickEndpointRecord(raw, "azureEventHubs", "AzureEventHubs")).length || hasAnyEndpointField(raw, [
+        "EventHubName",
+        "eventHubName",
+        "PartitionId",
+        "partitionId"
+    ])) {
+        return "AzureEventHubs";
+    }
+    if (Object.keys(pickEndpointRecord(raw, "pushDiffusion", "PushDiffusion")).length || hasAnyEndpointField(raw, [
+        "TopicPath",
+        "topicPath",
+        "ConnectionProperties",
+        "connectionProperties",
+        "PublishAsync",
+        "publishAsync",
+        "SubscribeAsync",
+        "subscribeAsync",
+        "Principal",
+        "principal"
+    ])) {
+        return "PushDiffusion";
+    }
+    if (Object.keys(pickEndpointRecord(raw, "delegate", "Delegate", "DelegateStream")).length || hasAnyEndpointField(raw, [
+        "Produce",
+        "produce",
+        "Consume",
+        "consume",
+        "ProduceAsync",
+        "produceAsync",
+        "ConsumeAsync",
+        "consumeAsync",
+        "ConnectionMetadata",
+        "connectionMetadata"
+    ])) {
+        return "DelegateStream";
+    }
+    if (Object.keys(pickEndpointRecord(raw, "nats", "Nats")).length || hasAnyEndpointField(raw, [
+        "Subject",
+        "subject",
+        "QueueGroup",
+        "queueGroup",
+        "Token",
+        "token",
+        "ConnectionName",
+        "connectionName",
+        "MaxReconnectAttempts",
+        "maxReconnectAttempts"
+    ])) {
+        return "Nats";
+    }
+    return undefined;
+}
+function pickEndpointTransportRecord(raw, resolvedKind, expectedKind, nestedKeys, flatKeys) {
+    const nested = pickEndpointRecord(raw, ...nestedKeys);
+    if (Object.keys(nested).length) {
+        return nested;
+    }
+    if (resolvedKind !== expectedKind) {
+        return {};
+    }
+    return pickFlatEndpointRecord(raw, flatKeys);
+}
+function pickFlatEndpointRecord(raw, keys) {
+    const result = {};
+    for (const key of keys) {
+        if (key in raw) {
+            result[key] = raw[key];
+        }
+    }
+    return result;
+}
+function hasAnyEndpointField(raw, keys) {
+    return keys.some((key) => key in raw);
+}
+function normalizeHttpEndpointOptions(options) {
+    if (!Object.keys(options).length) {
+        return undefined;
+    }
+    return {
+        url: pickOptionalEndpointString(options, "url", "Url") ?? "",
+        method: pickOptionalEndpointString(options, "method", "Method") ?? "GET",
+        consumePoll: pickEndpointFunction(options, "consumePoll", "ConsumePoll"),
+        bodyType: pickOptionalEndpointString(options, "bodyType", "BodyType") ?? "Json",
+        responseSource: (() => {
+            const explicitResponseSource = pickOptionalEndpointString(options, "responseSource", "ResponseSource");
+            if (explicitResponseSource) {
+                return explicitResponseSource;
+            }
+            const rawTrackingPayloadSource = pickOptionalEndpointString(options, "TrackingPayloadSource", "trackingPayloadSource");
+            return inferLegacyHttpResponseSource(rawTrackingPayloadSource);
+        })(),
+        trackingPayloadSource: (() => {
+            const rawTrackingPayloadSource = pickOptionalEndpointString(options, "TrackingPayloadSource", "trackingPayloadSource");
+            return rawTrackingPayloadSource
+                ? canonicalizeHttpTrackingPayloadSource(rawTrackingPayloadSource)
+                : undefined;
+        })(),
+        consumeArrayPath: pickOptionalEndpointString(options, "consumeArrayPath", "ConsumeArrayPath"),
+        consumeJsonArrayResponse: pickEndpointBoolean(options, "consumeJsonArrayResponse", "ConsumeJsonArrayResponse"),
+        requestTimeoutSeconds: pickOptionalEndpointNumber(options, "requestTimeoutSeconds", "RequestTimeoutSeconds", "requestTimeout", "RequestTimeout") ?? 30,
+        auth: normalizeHttpAuthOptions(pickEndpointRecord(options, "auth", "Auth")),
+        tokenRequestHeaders: pickEndpointStringRecord(options, "tokenRequestHeaders", "TokenRequestHeaders")
+    };
+}
+function normalizeHttpAuthOptions(options) {
+    if (!Object.keys(options).length) {
+        return undefined;
+    }
+    return {
+        mode: pickOptionalEndpointString(options, "mode", "Mode"),
+        type: pickOptionalEndpointString(options, "type", "Type"),
+        username: pickOptionalEndpointString(options, "username", "Username"),
+        password: pickOptionalEndpointStringAllowEmpty(options, "password", "Password"),
+        bearerToken: pickOptionalEndpointString(options, "bearerToken", "BearerToken"),
+        tokenUrl: pickOptionalEndpointString(options, "tokenUrl", "TokenUrl"),
+        clientId: pickOptionalEndpointString(options, "clientId", "ClientId"),
+        clientSecret: pickOptionalEndpointString(options, "clientSecret", "ClientSecret"),
+        scope: pickOptionalEndpointString(options, "scope", "Scope"),
+        scopes: pickEndpointStringArray(options, "scopes", "Scopes"),
+        audience: pickOptionalEndpointString(options, "audience", "Audience"),
+        tokenHeaderName: pickOptionalEndpointString(options, "tokenHeaderName", "TokenHeaderName"),
+        additionalFormFields: pickEndpointStringRecord(options, "additionalFormFields", "AdditionalFormFields"),
+        oauth2ClientCredentials: normalizeOAuth2ClientCredentialsOptions(pickEndpointRecord(options, "oauth2ClientCredentials", "OAuth2ClientCredentials"))
+    };
+}
+function normalizeOAuth2ClientCredentialsOptions(options) {
+    if (!Object.keys(options).length) {
+        return undefined;
+    }
+    return {
+        tokenEndpoint: pickOptionalEndpointString(options, "tokenEndpoint", "TokenEndpoint"),
+        clientId: pickOptionalEndpointString(options, "clientId", "ClientId"),
+        clientSecret: pickOptionalEndpointString(options, "clientSecret", "ClientSecret"),
+        scopes: pickEndpointStringArray(options, "scopes", "Scopes"),
+        additionalFormFields: pickEndpointStringRecord(options, "additionalFormFields", "AdditionalFormFields")
+    };
+}
+function normalizeDelegateEndpointOptions(options) {
+    if (!Object.keys(options).length) {
+        return undefined;
+    }
+    return {
+        produce: pickEndpointFunction(options, "produce", "Produce"),
+        consume: pickEndpointFunction(options, "consume", "Consume"),
+        produceAsync: pickEndpointFunction(options, "produceAsync", "ProduceAsync"),
+        consumeAsync: pickEndpointFunction(options, "consumeAsync", "ConsumeAsync"),
+        connectionMetadata: pickEndpointStringRecord(options, "connectionMetadata", "ConnectionMetadata")
+    };
+}
+function normalizeProtocolOptions(options) {
+    return Object.keys(options).length ? options : undefined;
+}
+function pickEndpointValue(record, ...keys) {
+    return pickProtocolValue(record, ...keys);
+}
+function pickEndpointString(record, ...keys) {
+    return optionString(record, ...keys);
+}
+function pickOptionalEndpointString(record, ...keys) {
+    const value = optionString(record, ...keys).trim();
+    return value ? value : undefined;
+}
+function pickOptionalEndpointStringAllowEmpty(record, ...keys) {
+    const value = pickEndpointValue(record, ...keys);
+    return typeof value === "string" ? value.trim() : undefined;
+}
+function pickTrackingFieldSelectorString(record, ...keys) {
+    const value = pickEndpointValue(record, ...keys);
+    const normalized = normalizeTrackingFieldSelectorInput(value, keys[0] ?? "TrackingField");
+    return normalized ?? "";
+}
+function pickOptionalTrackingFieldSelectorString(record, ...keys) {
+    const value = pickEndpointValue(record, ...keys);
+    return normalizeTrackingFieldSelectorInput(value, keys[0] ?? "TrackingField");
+}
+function pickEndpointBoolean(record, ...keys) {
+    const value = pickEndpointValue(record, ...keys);
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "number") {
+        return value !== 0;
+    }
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "true" || normalized === "1" || normalized === "yes") {
+            return true;
+        }
+        if (normalized === "false" || normalized === "0" || normalized === "no") {
+            return false;
+        }
+    }
+    return undefined;
+}
+function pickOptionalEndpointNumber(record, ...keys) {
+    const value = pickEndpointValue(record, ...keys);
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function pickEndpointRecord(record, ...keys) {
+    return asRecordOrEmpty(pickEndpointValue(record, ...keys));
+}
+function pickEndpointStringRecord(record, ...keys) {
+    const value = pickEndpointValue(record, ...keys);
+    return value == null ? {} : toStringRecord(value);
+}
+function pickEndpointStringArray(record, ...keys) {
+    const value = pickEndpointValue(record, ...keys);
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const values = value
+        .map((entry) => String(entry ?? "").trim())
+        .filter((entry) => entry.length > 0);
+    return values.length ? values : undefined;
+}
+function pickEndpointFunction(record, ...keys) {
+    const value = pickEndpointValue(record, ...keys);
+    return typeof value === "function" ? value : undefined;
+}
+function normalizeTrackingFieldSelectorInput(value, fieldName) {
+    if (value == null) {
+        return undefined;
+    }
+    if (typeof value === "string") {
+        return value.trim();
+    }
+    if (value instanceof TrackingFieldSelector) {
+        return value.toString();
+    }
+    if (typeof value === "object") {
+        const raw = value;
+        const location = raw.Location ?? raw.location ?? raw.Kind ?? raw.kind;
+        if (location != null || raw.Path != null || raw.path != null) {
+            return new TrackingFieldSelector(location, String(raw.Path ?? raw.path ?? "")).toString();
+        }
+    }
+    throw new TypeError(`${fieldName} must be provided as a string or TrackingFieldSelector.`);
+}
+function validateEndpointDefinition(endpoint) {
+    if (!endpoint || typeof endpoint !== "object") {
+        throw new Error("Endpoint definition must be provided.");
+    }
+    const kind = requireNonEmptyString(endpoint.kind, "Endpoint kind must be provided.");
+    const mode = requireNonEmptyString(endpoint.mode, "Endpoint mode must be provided.");
+    requireNonEmptyString(endpoint.name, "Endpoint name must be provided.");
+    requireNonEmptyString(endpoint.trackingField, "Endpoint trackingField must be provided.");
+    validateTrackingSelectorPath(endpoint.trackingField, "TrackingField");
+    if (endpoint.gatherByField != null) {
+        validateTrackingSelectorPath(String(endpoint.gatherByField), "GatherByField");
+    }
+    if (endpoint.pollIntervalMs != null && endpoint.pollIntervalMs <= 0) {
+        throw new RangeError("PollInterval must be greater than zero.");
+    }
+    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 hasModeDelegate = mode === "Produce" ? hasProduceDelegate : hasConsumeDelegate;
+    switch (kind) {
+        case "Http":
+            validateHttpEndpoint(endpoint, mode, hasModeDelegate);
+            return;
+        case "Kafka":
+            validateKafkaEndpoint(endpoint, mode, hasModeDelegate);
+            return;
+        case "RabbitMq":
+            validateRabbitMqEndpoint(endpoint, mode, hasModeDelegate);
+            return;
+        case "Nats":
+            validateNatsEndpoint(endpoint, mode, hasModeDelegate);
+            return;
+        case "RedisStreams":
+            validateRedisStreamsEndpoint(endpoint, mode, hasModeDelegate);
+            return;
+        case "AzureEventHubs":
+            validateAzureEventHubsEndpoint(endpoint, mode, hasModeDelegate);
+            return;
+        case "PushDiffusion":
+            validatePushDiffusionEndpoint(endpoint, mode);
+            return;
+        case "DelegateStream":
+            validateDelegateStreamEndpoint(endpoint, mode);
+            return;
+        default:
+            throw new Error(`Unsupported endpoint kind: ${kind}.`);
+    }
+}
+function validateTrackingSelectorPath(expression, fieldName) {
+    const normalized = String(expression ?? "").trim();
+    if (!normalized) {
+        if (fieldName === "TrackingField") {
+            throw new Error("TrackingField must be provided.");
+        }
+        throw new Error("GatherByField path must be provided when GatherByField is configured.");
+    }
+    const separatorIndex = normalized.indexOf(":");
+    if (separatorIndex >= 0) {
+        const location = normalized.slice(0, separatorIndex).trim().toLowerCase();
+        const path = normalized.slice(separatorIndex + 1).trim();
+        if ((location === "header" || location === "json") && !path) {
+            throw new Error(`${fieldName} path must be provided when ${fieldName} is configured.`);
+        }
+    }
+}
+function validateHttpEndpoint(endpoint, mode, hasModeDelegate) {
+    const options = endpoint.http;
+    if (!options && !hasModeDelegate) {
+        throw new Error(`Http endpoint in ${mode} mode requires http options or delegate callback.`);
+    }
+    if (options) {
+        const bodyType = canonicalizeHttpBodyType(String(options.bodyType ?? "Json"));
+        if (!["Json", "PlainText", "Xml", "FormUrlEncoded", "Binary"].includes(bodyType)) {
+            throw new Error(`Unsupported Http bodyType: ${String(options.bodyType ?? "")}.`);
+        }
+        const responseSource = canonicalizeHttpResponseSource(String(options.responseSource ?? "None"));
+        if (!["None", "ResponseBody", "ResponseHeaders", "ResponseStatusCode"].includes(responseSource)) {
+            throw new Error(`Unsupported Http responseSource: ${String(options.responseSource ?? "")}.`);
+        }
+        const trackingPayloadSource = canonicalizeHttpTrackingPayloadSource(String(options.trackingPayloadSource ?? "Request"));
+        if (!["Request", "Response"].includes(trackingPayloadSource)) {
+            throw new Error(`Unsupported Http trackingPayloadSource: ${String(options.trackingPayloadSource ?? "")}.`);
+        }
+        options.bodyType = bodyType;
+        options.responseSource = responseSource;
+        options.trackingPayloadSource = trackingPayloadSource;
+        if (options.url && String(options.url).trim()) {
+            try {
+                new URL(String(options.url).trim());
+            }
+            catch {
+                throw new Error("Url must be an absolute URI for HTTP endpoint.");
+            }
+        }
+        if (options.requestTimeoutSeconds != null && options.requestTimeoutSeconds <= 0) {
+            throw new RangeError("RequestTimeout must be greater than zero.");
+        }
+        validateHttpAuthOptions(options);
+    }
+    if (mode === "Produce" && !hasModeDelegate) {
+        if (!options?.url || !String(options.url).trim()) {
+            throw new Error("Url must be provided for HTTP endpoint.");
+        }
+    }
+    else if (mode === "Consume" && !hasModeDelegate) {
+        if (!options?.url || !String(options.url).trim()) {
+            throw new Error("Url must be provided for HTTP endpoint.");
+        }
+    }
+}
+function validateDelegateStreamEndpoint(endpoint, mode) {
+    const delegate = endpoint.delegate;
+    if (mode === "Produce" && typeof delegate?.produce !== "function" && typeof delegate?.produceAsync !== "function") {
+        throw new Error("ProduceAsync delegate must be provided when endpoint mode is Produce.");
+    }
+    if (mode === "Consume" && typeof delegate?.consume !== "function" && typeof delegate?.consumeAsync !== "function") {
+        throw new Error("ConsumeAsync delegate must be provided when endpoint mode is Consume.");
+    }
+}
+function validateHttpAuthOptions(options) {
+    const auth = options.auth;
+    if (!auth) {
+        return;
+    }
+    const mode = normalizeToken(auth.mode ?? auth.type ?? "None");
+    const oauthOptions = auth.oauth2ClientCredentials;
+    switch (mode) {
+        case "none":
+            return;
+        case "basic":
+            requireNonEmptyString(auth.username, "Username must be provided for basic auth.");
+            if ((auth.password ?? null) == null) {
+                throw new Error("Password must be provided for basic auth.");
+            }
+            return;
+        case "bearer":
+            requireNonEmptyString(auth.bearerToken, "BearerToken must be provided for bearer auth.");
+            return;
+        case "oauth2clientcredentials":
+            requireNonEmptyString(auth.tokenUrl ?? oauthOptions?.tokenEndpoint, "TokenEndpoint must be provided for OAuth2 client credentials flow.");
+            requireNonEmptyString(auth.clientId ?? oauthOptions?.clientId, "ClientId must be provided for OAuth2 client credentials flow.");
+            requireNonEmptyString(auth.clientSecret ?? oauthOptions?.clientSecret, "ClientSecret must be provided for OAuth2 client credentials flow.");
+            return;
+        default:
+            throw new RangeError("Unsupported HTTP auth type.");
+    }
+}
+function validateKafkaEndpoint(endpoint, mode, hasModeDelegate) {
+    const options = endpoint.kafka;
+    if ((!options || typeof options !== "object") && !hasModeDelegate) {
+        throw new Error(`Kafka endpoint in ${mode} mode requires kafka options or delegate callback.`);
+    }
+    if (!options || typeof options !== "object") {
+        return;
+    }
+    requireNonEmptyString(optionString(options, "BootstrapServers", "bootstrapServers"), "BootstrapServers must be provided for Kafka endpoint.");
+    requireNonEmptyString(optionString(options, "Topic", "topic"), "Topic must be provided for Kafka endpoint.");
+    if (!hasModeDelegate && mode === "Consume") {
+        requireNonEmptyString(optionString(options, "ConsumerGroupId", "consumerGroupId"), "ConsumerGroupId must be provided when Kafka endpoint mode is Consume.");
+    }
+    const securityProtocol = optionString(options, "SecurityProtocol", "securityProtocol") || "Plaintext";
+    if (/^sasl/i.test(securityProtocol)) {
+        const sasl = asRecordOrEmpty(pickProtocolValue(options, "Sasl", "sasl"));
+        validateKafkaSaslOptions(sasl);
+    }
+}
+function validateKafkaSaslOptions(options) {
+    const mechanism = optionString(options, "Mechanism", "mechanism") || "Plain";
+    if (mechanism.toLowerCase() === "oauthbearer") {
+        requireNonEmptyString(optionString(options, "OAuthBearerTokenEndpointUrl", "oauthBearerTokenEndpointUrl", "TokenEndpoint", "tokenEndpoint") || optionString(asRecordOrEmpty(pickProtocolValue(options, "AdditionalSettings", "additionalSettings")), "TokenEndpoint", "tokenEndpoint"), "OAuthBearerTokenEndpointUrl must be provided when SASL mechanism is OAuthBearer.");
+        return;
+    }
+    requireNonEmptyString(optionString(options, "Username", "username"), "Username must be provided for SASL authentication.");
+    if (pickProtocolValue(options, "Password", "password") == null) {
+        throw new Error("Password must be provided for SASL authentication.");
+    }
+}
+function validateRabbitMqEndpoint(endpoint, mode, hasModeDelegate) {
+    const options = endpoint.rabbitMq;
+    if ((!options || typeof options !== "object") && !hasModeDelegate) {
+        throw new Error(`RabbitMq endpoint in ${mode} mode requires rabbitMq options or delegate callback.`);
+    }
+    if (!options || typeof options !== "object") {
+        return;
+    }
+    requireNonEmptyString(optionString(options, "HostName", "hostName"), "HostName must be provided for RabbitMQ endpoint.");
+    const port = optionNumber(options, "Port", "port") || 5672;
+    if (port <= 0) {
+        throw new RangeError("Port must be greater than zero.");
+    }
+    requireNonEmptyString(optionString(options, "UserName", "userName"), "UserName must be provided for RabbitMQ endpoint.");
+    if (pickProtocolValue(options, "Password", "password") == null) {
+        throw new Error("Password must be provided for RabbitMQ endpoint.");
+    }
+    const routingKey = optionString(options, "RoutingKey", "routingKey");
+    const queueName = optionString(options, "QueueName", "queueName");
+    if (!hasModeDelegate && mode === "Produce" && !routingKey && !queueName) {
+        throw new Error("Either RoutingKey or QueueName must be provided for RabbitMQ producer endpoint.");
+    }
+    if (!hasModeDelegate && mode === "Consume" && !queueName) {
+        throw new Error("QueueName must be provided for RabbitMQ consumer endpoint.");
+    }
+}
+function validateNatsEndpoint(endpoint, mode, hasModeDelegate) {
+    const options = endpoint.nats;
+    if ((!options || typeof options !== "object") && !hasModeDelegate) {
+        throw new Error(`Nats endpoint in ${mode} mode requires nats options or delegate callback.`);
+    }
+    if (!options || typeof options !== "object") {
+        return;
+    }
+    requireNonEmptyString(optionString(options, "ServerUrl", "serverUrl"), "ServerUrl must be provided for NATS endpoint.");
+    requireNonEmptyString(optionString(options, "Subject", "subject"), "Subject must be provided for NATS endpoint.");
+    if (optionString(options, "UserName", "userName") && pickProtocolValue(options, "Password", "password") == null) {
+        throw new Error("Password must be provided when UserName is configured for NATS endpoint.");
+    }
+    const reconnect = optionNumber(options, "MaxReconnectAttempts", "maxReconnectAttempts");
+    if (reconnect < 0) {
+        throw new RangeError("MaxReconnectAttempts must be zero or greater.");
+    }
+}
+function validateRedisStreamsEndpoint(endpoint, mode, hasModeDelegate) {
+    const options = endpoint.redisStreams;
+    if ((!options || typeof options !== "object") && !hasModeDelegate) {
+        throw new Error(`RedisStreams endpoint in ${mode} mode requires redisStreams options or delegate callback.`);
+    }
+    if (!options || typeof options !== "object") {
+        return;
+    }
+    requireNonEmptyString(optionString(options, "ConnectionString", "connectionString"), "ConnectionString must be provided for Redis Streams endpoint.");
+    requireNonEmptyString(optionString(options, "StreamKey", "streamKey"), "StreamKey must be provided for Redis Streams endpoint.");
+    if (!hasModeDelegate && mode === "Consume") {
+        requireNonEmptyString(optionString(options, "ConsumerGroup", "consumerGroup"), "ConsumerGroup must be provided when Redis Streams endpoint mode is Consume.");
+        requireNonEmptyString(optionString(options, "ConsumerName", "consumerName"), "ConsumerName must be provided when Redis Streams endpoint mode is Consume.");
+    }
+    const readCount = optionNumber(options, "ReadCount", "readCount");
+    if (readCount !== 0 && readCount <= 0) {
+        throw new RangeError("ReadCount must be greater than zero.");
+    }
+    const maxLength = optionNumber(options, "MaxLength", "maxLength");
+    if (maxLength !== 0 && maxLength <= 0) {
+        throw new RangeError("MaxLength must be greater than zero when configured.");
+    }
+}
+function validateAzureEventHubsEndpoint(endpoint, mode, hasModeDelegate) {
+    const options = endpoint.azureEventHubs;
+    if ((!options || typeof options !== "object") && !hasModeDelegate) {
+        throw new Error(`AzureEventHubs endpoint in ${mode} mode requires azureEventHubs options or delegate callback.`);
+    }
+    if (!options || typeof options !== "object") {
+        return;
+    }
+    requireNonEmptyString(optionString(options, "ConnectionString", "connectionString"), "ConnectionString must be provided for Azure Event Hubs endpoint.");
+    requireNonEmptyString(optionString(options, "EventHubName", "eventHubName"), "EventHubName must be provided for Azure Event Hubs endpoint.");
+}
+function validatePushDiffusionEndpoint(endpoint, mode) {
+    const options = endpoint.pushDiffusion;
+    if (!options || typeof options !== "object") {
+        throw new Error(`PushDiffusion endpoint in ${mode} mode requires pushDiffusion options.`);
+    }
+    requireNonEmptyString(optionString(options, "ServerUrl", "serverUrl"), "ServerUrl must be provided for Push Diffusion endpoint.");
+    requireNonEmptyString(optionString(options, "TopicPath", "topicPath"), "TopicPath must be provided for Push Diffusion endpoint.");
+    if (mode === "Produce" && !resolveStructuredProduceDelegate(endpoint) && !resolveProduceDelegate(endpoint)) {
+        throw new Error("PublishAsync delegate must be provided for Push Diffusion producer endpoint.");
+    }
+    if (mode === "Consume"
+        && !resolveStructuredConsumeDelegate(endpoint)
+        && !resolveStructuredConsumeStreamDelegate(endpoint)
+        && !resolveConsumeDelegate(endpoint)) {
+        throw new Error("SubscribeAsync delegate must be provided for Push Diffusion consumer endpoint.");
+    }
+}
+async function applyHttpAuthHeaders(headers, options, resolveOAuthToken) {
+    const auth = options.auth;
+    if (!auth) {
+        return;
+    }
+    const headerName = auth.tokenHeaderName?.trim() || "Authorization";
+    const mode = normalizeToken(auth.mode ?? auth.type ?? "None");
+    if (mode === "basic") {
+        const username = requireNonEmptyString(auth.username, "Http Basic auth requires username.");
+        if (auth.password == null) {
+            throw new Error("Http Basic auth requires password.");
+        }
+        headers[headerName] = `Basic ${Buffer.from(`${username}:${String(auth.password)}`).toString("base64")}`;
+    }
+    else if (mode === "bearer") {
+        headers[headerName] = `Bearer ${requireNonEmptyString(auth.bearerToken, "Http Bearer auth requires bearerToken.")}`;
+    }
+    else if (mode === "oauth2clientcredentials") {
+        headers[headerName] = `Bearer ${await resolveOAuthToken()}`;
+    }
+}
+function buildHttpRequestBody(body, bodyType, contentType) {
+    if (body == null) {
+        return undefined;
+    }
+    if (body instanceof Uint8Array) {
+        return new Uint8Array(body);
+    }
+    if (body instanceof ArrayBuffer) {
+        return body;
+    }
+    const normalized = normalizeToken(canonicalizeHttpBodyType(String(bodyType)));
+    if (normalized === "plaintext" || normalized === "text" || normalized === "xml") {
+        return String(body);
+    }
+    if (normalized === "binary") {
+        return new TextEncoder().encode(String(body));
+    }
+    if (normalized === "formurlencoded") {
+        if (isRecord(body)) {
+            const form = new URLSearchParams();
+            for (const [key, value] of Object.entries(body)) {
+                form.set(String(key), value == null ? "" : String(value));
+            }
+            return form.toString();
+        }
+        return String(body);
+    }
+    if (typeof body === "string" && !isLikelyJsonContentType(contentType)) {
+        return body;
+    }
+    return JSON.stringify(body);
+}
+async function buildHttpProduceResult(requestPayload, response, responseSource) {
+    const mode = normalizeToken(canonicalizeHttpResponseSource(String(responseSource ?? "None")));
+    if (mode === "none") {
+        return requestPayload;
+    }
+    if (mode === "responseheaders") {
+        return attachPayloadHelpers({
+            headers: {
+                ...(requestPayload.headers ?? {}),
+                ...headersToRecord(response.headers)
+            },
+            body: requestPayload.body,
+            producedUtc: requestPayload.producedUtc,
+            contentType: requestPayload.contentType,
+            messagePayloadType: requestPayload.messagePayloadType,
+            jsonSettings: requestPayload.jsonSettings,
+            jsonConvertSettings: requestPayload.jsonConvertSettings
+        });
+    }
+    if (mode === "responsestatuscode") {
+        return attachPayloadHelpers({
+            headers: { ...(requestPayload.headers ?? {}) },
+            body: {
+                statusCode: response.status,
+                statusText: response.statusText
+            },
+            producedUtc: requestPayload.producedUtc,
+            contentType: requestPayload.contentType,
+            messagePayloadType: requestPayload.messagePayloadType,
+            jsonSettings: requestPayload.jsonSettings,
+            jsonConvertSettings: requestPayload.jsonConvertSettings
+        });
+    }
+    const raw = await response.text();
+    return attachPayloadHelpers({
+        headers: {
+            ...(requestPayload.headers ?? {}),
+            ...headersToRecord(response.headers)
+        },
+        body: parseMaybeJson(raw),
+        producedUtc: requestPayload.producedUtc,
+        contentType: response.headers.get("content-type") ?? requestPayload.contentType,
+        messagePayloadType: requestPayload.messagePayloadType,
+        jsonSettings: requestPayload.jsonSettings,
+        jsonConvertSettings: requestPayload.jsonConvertSettings
+    });
+}
+function buildProducedMessageRequest(endpoint, payload) {
+    const clonedPayload = clonePayload(payload);
+    const request = attachPayloadHelpers(clonePayload(clonedPayload));
+    request.endpoint = endpoint;
+    request.payload = attachPayloadHelpers(clonePayload(clonedPayload));
+    request.trackingId = extractTrackingValue(clonedPayload, endpoint.trackingField) ?? "";
+    request.connectionMetadata = resolveConnectionMetadata(endpoint);
+    return attachStructuredProducedMessageRequestAliases(request, endpoint);
+}
+async function invokeStructuredProduceDelegate(endpoint, payload, delegate) {
+    const request = buildProducedMessageRequest(endpoint, payload);
+    const callbackResult = await delegate(request);
+    return normalizeStructuredProduceResult(endpoint, payload, callbackResult, request.trackingId);
+}
+function normalizeStructuredProduceResult(endpoint, requestPayload, callbackResult, requestTrackingId) {
+    if (callbackResult == null) {
+        throw new Error("Structured producer returned null result.");
+    }
+    if (isStructuredProduceResult(callbackResult)) {
+        const structured = callbackResult;
+        const isSuccess = structured.isSuccess ?? structured.IsSuccess;
+        const timestampUtc = (structured.timestampUtc ?? structured.TimestampUtc);
+        const timestampUtcMs = (structured.timestampUtcMs ?? structured.TimestampUtcMs);
+        if (isSuccess === false) {
+            throw new Error(String(structured.errorMessage ?? structured.ErrorMessage ?? "").trim()
+                || "Structured producer reported failure.");
+        }
+        const payload = normalizeTrackingPayload(structured.responsePayload
+            ?? structured.ResponsePayload
+            ?? requestPayload);
+        payload.producedUtc = payload.producedUtc ?? normalizeDelegateTimestamp(timestampUtc, timestampUtcMs);
+        if (requestTrackingId && !extractTrackingValue(payload, endpoint.trackingField)) {
+            injectTrackingValue(payload, endpoint.trackingField, requestTrackingId);
+        }
+        return payload;
+    }
+    const payload = normalizeTrackingPayload(callbackResult);
+    payload.producedUtc = payload.producedUtc ?? normalizeDelegateTimestamp();
+    if (requestTrackingId && !extractTrackingValue(payload, endpoint.trackingField)) {
+        injectTrackingValue(payload, endpoint.trackingField, requestTrackingId);
+    }
+    return payload;
+}
+function normalizeConsumedDelegatePayload(message) {
+    if (message == null) {
+        return null;
+    }
+    if (isStructuredConsumedMessage(message)) {
+        const structured = message;
+        const timestampUtc = (structured.timestampUtc ?? structured.TimestampUtc);
+        const timestampUtcMs = (structured.timestampUtcMs ?? structured.TimestampUtcMs);
+        const payload = normalizeTrackingPayload(structured.payload
+            ?? structured.Payload
+            ?? structured);
+        payload.producedUtc = payload.producedUtc ?? normalizeDelegateTimestamp(timestampUtc, timestampUtcMs);
+        return payload;
+    }
+    return normalizeTrackingPayload(message);
+}
+function normalizeDelegateTimestamp(value, valueMs) {
+    if (typeof valueMs === "number" && Number.isFinite(valueMs)) {
+        return new Date(valueMs).toISOString();
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return new Date(value).toISOString();
+    }
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Date.parse(value);
+        return Number.isFinite(parsed) ? new Date(parsed).toISOString() : value.trim();
+    }
+    return new Date().toISOString();
+}
+function normalizeConsumedPayloadRows(value, arrayPath) {
+    const selected = extractJsonPath(value, arrayPath);
+    if (Array.isArray(selected)) {
+        return selected.map((entry) => normalizeTrackingPayload(entry));
+    }
+    if (selected == null) {
+        return [];
+    }
+    return [normalizeTrackingPayload(selected)];
+}
+function normalizeTrackingPayload(value) {
+    if (isRecord(value) && ("headers" in value || "body" in value || "Headers" in value || "Body" in value)) {
+        const headers = toStringRecord(value.headers ?? value.Headers);
+        const jsonSettings = value.jsonSettings ?? value.JsonSettings;
+        const jsonConvertSettings = value.jsonConvertSettings ?? value.JsonConvertSettings;
+        return attachPayloadHelpers({
+            headers,
+            body: cloneBody(value.body ?? value.Body),
+            producedUtc: typeof (value.producedUtc ?? value.ProducedUtc) === "string"
+                ? String(value.producedUtc ?? value.ProducedUtc)
+                : undefined,
+            contentType: typeof (value.contentType ?? value.ContentType) === "string"
+                ? String(value.contentType ?? value.ContentType)
+                : undefined,
+            messagePayloadType: typeof (value.messagePayloadType ?? value.MessagePayloadType) === "string"
+                ? String(value.messagePayloadType ?? value.MessagePayloadType)
+                : undefined,
+            jsonSettings: isRecord(jsonSettings) ? { ...jsonSettings } : undefined,
+            jsonConvertSettings: isRecord(jsonConvertSettings) ? { ...jsonConvertSettings } : undefined
+        });
+    }
+    return attachPayloadHelpers({
+        headers: {},
+        body: cloneBody(value),
+        producedUtc: undefined
+    });
+}
+function extractJsonPath(value, arrayPath) {
+    if (!arrayPath || !arrayPath.trim()) {
+        return value;
+    }
+    let current = value;
+    const normalized = arrayPath.trim().replace(/^\$\./, "").replace(/^\$/, "");
+    if (!normalized) {
+        return value;
+    }
+    const tokens = normalized.replace(/\[(\d+)\]/g, ".$1").split(".").filter((x) => x.length > 0);
+    for (const token of tokens) {
+        if (current == null) {
+            return null;
+        }
+        if (Array.isArray(current)) {
+            const index = Number(token);
+            if (!Number.isInteger(index) || index < 0 || index >= current.length) {
+                return null;
+            }
+            current = current[index];
+            continue;
+        }
+        if (!isRecord(current) || !(token in current)) {
+            return null;
+        }
+        current = current[token];
+    }
+    return current;
+}
+function parseMaybeJson(value) {
+    const text = value.trim();
+    if (!text) {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return value;
+    }
+}
+function headersToRecord(value) {
+    const headers = {};
+    value.forEach((headerValue, key) => {
+        headers[key] = headerValue;
+    });
+    return headers;
+}
+function toStringRecord(value) {
+    if (!isRecord(value)) {
+        return {};
+    }
+    const mapped = {};
+    for (const [key, row] of Object.entries(value)) {
+        mapped[key] = row == null ? "" : String(row);
+    }
+    return mapped;
+}
+function isLikelyJsonContentType(contentType) {
+    return contentType.toLowerCase().includes("json");
+}
+function normalizeToken(value) {
+    return String(value ?? "").trim().toLowerCase();
+}
+function createTimeoutSignal(timeoutSeconds) {
+    const timeoutMs = Number(timeoutSeconds ?? 0);
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        return { signal: undefined, clear: () => undefined };
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), Math.trunc(timeoutMs * 1000));
+    return {
+        signal: controller.signal,
+        clear: () => clearTimeout(timer)
+    };
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function requireNonEmptyString(value, message) {
+    if (typeof value === "string" && value.trim()) {
+        return value.trim();
+    }
+    throw new Error(message);
+}
+function clonePayload(payload) {
+    return attachPayloadHelpers({
+        headers: { ...(payload.headers ?? {}) },
+        body: cloneBody(payload.body),
+        producedUtc: payload.producedUtc,
+        contentType: payload.contentType,
+        messagePayloadType: payload.messagePayloadType,
+        jsonSettings: isRecord(payload.jsonSettings) ? { ...payload.jsonSettings } : undefined,
+        jsonConvertSettings: isRecord(payload.jsonConvertSettings) ? { ...payload.jsonConvertSettings } : undefined
+    });
+}
+function cloneBody(value) {
+    if (value == null) {
+        return value;
+    }
+    if (value instanceof Uint8Array) {
+        return new Uint8Array(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((x) => cloneBody(x));
+    }
+    if (typeof value === "object") {
+        return { ...value };
+    }
+    return value;
+}
+function optionString(options, ...keys) {
+    for (const key of keys) {
+        const value = options[key];
+        if (typeof value === "string" && value.trim()) {
+            return value.trim();
+        }
+    }
+    return "";
+}
+function optionNumber(options, ...keys) {
+    for (const key of keys) {
+        const value = options[key];
+        if (typeof value === "number" && Number.isFinite(value)) {
+            return value;
+        }
+        if (typeof value === "string" && value.trim()) {
+            const parsed = Number(value);
+            if (Number.isFinite(parsed)) {
+                return parsed;
+            }
+        }
+    }
+    return 0;
+}
+function optionBoolean(options, fallback, ...keys) {
+    for (const key of keys) {
+        const value = options[key];
+        if (typeof value === "boolean") {
+            return value;
+        }
+        if (typeof value === "number") {
+            return value !== 0;
+        }
+        if (typeof value === "string" && value.trim()) {
+            const normalized = value.trim().toLowerCase();
+            if (normalized === "true" || normalized === "1" || normalized === "yes") {
+                return true;
+            }
+            if (normalized === "false" || normalized === "0" || normalized === "no") {
+                return false;
+            }
+        }
+    }
+    return fallback;
+}
+function partitionFromKey(value, partitionCount) {
+    if (!value) {
+        return "0";
+    }
+    const count = Math.max(Math.trunc(partitionCount), 1);
+    let hash = 0;
+    for (let i = 0; i < value.length; i += 1) {
+        hash = ((hash << 5) - hash) + value.charCodeAt(i);
+        hash |= 0;
+    }
+    const normalized = Math.abs(hash) % count;
+    return String(normalized);
+}
+function attachPayloadHelpers(payload) {
+    const target = {
+        ...payload,
+        getBodyAsUtf8: () => payloadBodyAsUtf8(target.body)
+    };
+    return attachDotNetTrackingPayloadAliases(target);
+}
+function attachDotNetTrackingPayloadAliases(payload) {
+    const target = payload;
+    definePascalCaseAlias(target, "Headers", () => target.headers, (value) => { target.headers = toStringRecord(value); });
+    definePascalCaseAlias(target, "Body", () => target.body, (value) => { target.body = cloneBody(value); });
+    definePascalCaseAlias(target, "ProducedUtc", () => target.producedUtc, (value) => {
+        target.producedUtc = typeof value === "string" ? value : undefined;
+    });
+    definePascalCaseAlias(target, "ConsumedUtc", () => target.consumedUtc, (value) => {
+        target.consumedUtc = typeof value === "string" ? value : undefined;
+    });
+    definePascalCaseAlias(target, "ContentType", () => target.contentType, (value) => {
+        target.contentType = typeof value === "string" ? value : undefined;
+    });
+    definePascalCaseAlias(target, "MessagePayloadType", () => target.messagePayloadType, (value) => {
+        target.messagePayloadType = typeof value === "string" ? value : undefined;
+    });
+    definePascalCaseAlias(target, "JsonSettings", () => target.jsonSettings, (value) => {
+        target.jsonSettings = isRecord(value) ? { ...value } : undefined;
+    });
+    definePascalCaseAlias(target, "JsonConvertSettings", () => target.jsonConvertSettings, (value) => {
+        target.jsonConvertSettings = isRecord(value) ? { ...value } : undefined;
+    });
+    definePascalCaseAlias(target, "GetBodyAsUtf8", () => target.getBodyAsUtf8);
+    return payload;
+}
+function attachStructuredProducedMessageRequestAliases(request, endpoint) {
+    const target = request;
+    const endpointView = createDelegateRequestEndpointView(endpoint);
+    definePascalCaseAlias(target, "Endpoint", () => endpointView);
+    definePascalCaseAlias(target, "Payload", () => target.payload);
+    definePascalCaseAlias(target, "TrackingId", () => target.trackingId, (value) => {
+        target.trackingId = String(value ?? "");
+    });
+    definePascalCaseAlias(target, "ConnectionMetadata", () => target.connectionMetadata, (value) => {
+        target.connectionMetadata = toStringRecord(value);
+    });
+    return request;
+}
+function createDelegateRequestEndpointView(endpoint) {
+    switch (endpoint.kind) {
+        case "Http":
+            return new HttpEndpointDefinition(endpoint);
+        case "Kafka":
+            return new KafkaEndpointDefinition(endpoint);
+        case "RabbitMq":
+            return new RabbitMqEndpointDefinition(endpoint);
+        case "Nats":
+            return new NatsEndpointDefinition(endpoint);
+        case "RedisStreams":
+            return new RedisStreamsEndpointDefinition(endpoint);
+        case "AzureEventHubs":
+            return new AzureEventHubsEndpointDefinition(endpoint);
+        case "PushDiffusion":
+            return new PushDiffusionEndpointDefinition(endpoint);
+        default:
+            return new DelegateStreamEndpointDefinition(endpoint);
+    }
+}
+function definePascalCaseAlias(target, key, getter, setter) {
+    if (Object.getOwnPropertyDescriptor(target, key)) {
+        return;
+    }
+    Object.defineProperty(target, key, {
+        configurable: true,
+        enumerable: true,
+        get: getter,
+        set: setter
+    });
+}
+function createDefaultPayload(endpoint) {
+    const contentType = endpoint.contentType
+        ?? (endpoint.messagePayload != null ? "application/json" : undefined);
+    return attachPayloadHelpers({
+        headers: { ...(endpoint.messageHeaders ?? {}) },
+        body: cloneBody(endpoint.messagePayload),
+        contentType,
+        messagePayloadType: endpoint.messagePayloadType,
+        jsonSettings: endpoint.jsonSerializerSettings ? { ...endpoint.jsonSerializerSettings } : undefined,
+        jsonConvertSettings: endpoint.jsonConvertSettings ? { ...endpoint.jsonConvertSettings } : undefined
+    });
+}
+function prepareProducedPayload(endpoint, payload) {
+    const base = payload
+        ? attachPayloadHelpers({
+            headers: {
+                ...(endpoint.messageHeaders ?? {}),
+                ...(payload.headers ?? {})
+            },
+            body: payload.body ?? cloneBody(endpoint.messagePayload),
+            producedUtc: payload.producedUtc,
+            contentType: payload.contentType ?? endpoint.contentType ?? (payload.body != null || endpoint.messagePayload != null ? "application/json" : undefined),
+            messagePayloadType: payload.messagePayloadType ?? endpoint.messagePayloadType,
+            jsonSettings: payload.jsonSettings ?? endpoint.jsonSerializerSettings,
+            jsonConvertSettings: payload.jsonConvertSettings ?? endpoint.jsonConvertSettings
+        })
+        : createDefaultPayload(endpoint);
+    const trackingId = extractTrackingValue(base, endpoint.trackingField);
+    if (trackingId) {
+        return base;
+    }
+    if (endpoint.autoGenerateTrackingIdWhenMissing === false) {
+        throw new Error(`Tracking id could not be extracted using selector \`${endpoint.trackingField}\` and AutoGenerateTrackingIdWhenMissing is disabled for endpoint \`${endpoint.name}\`.`);
+    }
+    const generated = randomUUID().replace(/-/g, "");
+    if (!injectTrackingValue(base, endpoint.trackingField, generated)) {
+        throw new Error(`Tracking id could not be injected using selector \`${endpoint.trackingField}\` for endpoint \`${endpoint.name}\`. Verify the selector and payload shape.`);
+    }
+    return base;
+}
+function toWirePayload(payload, endpoint) {
+    return {
+        headers: { ...(payload.headers ?? {}) },
+        body: serializePayloadBody(payload.body, payload.contentType ?? endpoint.contentType),
+        contentType: payload.contentType ?? endpoint.contentType
+    };
+}
+function serializePayloadBody(body, contentType) {
+    if (body == null) {
+        return new Uint8Array();
+    }
+    if (body instanceof Uint8Array) {
+        return new Uint8Array(body);
+    }
+    if (body instanceof ArrayBuffer) {
+        return new Uint8Array(body);
+    }
+    if (typeof body === "string") {
+        if (isLikelyJsonContentType(contentType ?? "")) {
+            try {
+                JSON.parse(body);
+                return new TextEncoder().encode(body);
+            }
+            catch {
+                return new TextEncoder().encode(JSON.stringify(body));
+            }
+        }
+        return new TextEncoder().encode(body);
+    }
+    return new TextEncoder().encode(JSON.stringify(body));
+}
+function createBrokerPayload(headers, body, endpoint, contentType) {
+    const normalizedHeaders = { ...headers };
+    const resolvedContentType = contentType ?? normalizedHeaders["content-type"] ?? endpoint.contentType;
+    return attachPayloadHelpers({
+        headers: normalizedHeaders,
+        body: deserializeBrokerPayloadBody(body, resolvedContentType, endpoint.messagePayloadType),
+        contentType: resolvedContentType,
+        messagePayloadType: endpoint.messagePayloadType,
+        jsonSettings: endpoint.jsonSerializerSettings ? { ...endpoint.jsonSerializerSettings } : undefined,
+        jsonConvertSettings: endpoint.jsonConvertSettings ? { ...endpoint.jsonConvertSettings } : undefined
+    });
+}
+function deserializeBrokerPayloadBody(body, contentType, messagePayloadType) {
+    if (!body.length) {
+        return null;
+    }
+    const payloadType = String(messagePayloadType ?? "").trim().toLowerCase();
+    if (payloadType === "binary") {
+        return new Uint8Array(body);
+    }
+    const text = new TextDecoder().decode(body);
+    if (payloadType === "json" || isLikelyJsonContentType(contentType ?? "")) {
+        return parseMaybeJson(text);
+    }
+    if (payloadType) {
+        return text;
+    }
+    if (typeof contentType === "string" && contentType.trim()) {
+        return text;
+    }
+    return new Uint8Array(body);
+}
+function extractTrackingValue(payload, selector) {
+    const normalized = selector.trim().toLowerCase();
+    if (normalized.startsWith("header:")) {
+        const headerName = selector.slice("header:".length).trim().toLowerCase();
+        for (const [key, value] of Object.entries(payload.headers ?? {})) {
+            const resolved = String(value ?? "").trim();
+            if (key.toLowerCase() === headerName && resolved) {
+                return resolved;
+            }
+        }
+        return null;
+    }
+    if (normalized.startsWith("json:")) {
+        const body = parseBodyObject(payload.body);
+        if (!body) {
+            return null;
+        }
+        let current = body;
+        for (const segment of selector.slice("json:".length).trim().replace(/^\$\./, "").split(".").filter(Boolean)) {
+            if (!isRecord(current)) {
+                return null;
+            }
+            current = current[segment];
+        }
+        return current == null ? null : String(current);
+    }
+    return null;
+}
+function injectTrackingValue(payload, selector, value) {
+    const normalized = selector.trim().toLowerCase();
+    if (normalized.startsWith("header:")) {
+        const headerName = selector.slice("header:".length).trim();
+        if (!headerName) {
+            return false;
+        }
+        payload.headers = {
+            ...(payload.headers ?? {}),
+            [headerName]: value
+        };
+        return true;
+    }
+    if (normalized.startsWith("json:")) {
+        const path = selector.slice("json:".length).trim().replace(/^\$\./, "");
+        payload.body = setJsonBodyValue(payload.body, path, value);
+        if (!payload.contentType) {
+            payload.contentType = "application/json";
+        }
+        return true;
+    }
+    return false;
+}
+function setJsonBodyValue(body, path, value) {
+    const target = parseBodyObject(body) ?? {};
+    const clone = cloneBody(target);
+    const segments = path.split(".").filter(Boolean);
+    if (!segments.length) {
+        return clone;
+    }
+    let current = clone;
+    for (let i = 0; i < segments.length - 1; i += 1) {
+        const segment = segments[i];
+        const next = current[segment];
+        if (!isRecord(next)) {
+            current[segment] = {};
+        }
+        current = current[segment];
+    }
+    current[segments[segments.length - 1]] = value;
+    return clone;
+}
+function parseBodyObject(body) {
+    if (body instanceof Uint8Array) {
+        return parseBodyObject(new TextDecoder().decode(body));
+    }
+    if (isRecord(body)) {
+        return body;
+    }
+    if (typeof body !== "string" || !body.trim()) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(body);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveStructuredProduceDelegate(endpoint) {
+    return endpoint.delegate?.produceAsync
+        ?? endpoint.pushDiffusion?.PublishAsync
+        ?? endpoint.pushDiffusion?.publishAsync;
+}
+function resolveStructuredConsumeDelegate(endpoint) {
+    const delegate = endpoint.delegate?.consumeAsync
+        ?? endpoint.pushDiffusion?.SubscribeAsync
+        ?? endpoint.pushDiffusion?.subscribeAsync;
+    return typeof delegate === "function" && delegate.length === 0
+        ? delegate
+        : undefined;
+}
+function resolveStructuredConsumeStreamDelegate(endpoint) {
+    const delegate = endpoint.delegate?.consumeAsync
+        ?? endpoint.pushDiffusion?.SubscribeAsync
+        ?? endpoint.pushDiffusion?.subscribeAsync;
+    return typeof delegate === "function" && delegate.length > 0
+        ? delegate
+        : undefined;
+}
+function resolveProduceDelegate(endpoint) {
+    return endpoint.delegate?.produce;
+}
+function resolveConsumeDelegate(endpoint) {
+    return endpoint.delegate?.consume;
+}
+function resolveConnectionMetadata(endpoint) {
+    return {
+        ...(endpoint.connectionMetadata ?? {}),
+        ...(endpoint.delegate?.connectionMetadata ?? {}),
+        ...toStringRecord(endpoint.pushDiffusion?.ConnectionProperties ?? endpoint.pushDiffusion?.connectionProperties)
+    };
+}
+function isStructuredProduceResult(value) {
+    return isRecord(value) && ("isSuccess" in value
+        || "IsSuccess" in value
+        || "errorMessage" in value
+        || "ErrorMessage" in value
+        || "responsePayload" in value
+        || "ResponsePayload" in value
+        || "timestampUtc" in value
+        || "TimestampUtc" in value
+        || "timestampUtcMs" in value
+        || "TimestampUtcMs" in value);
+}
+function isStructuredConsumedMessage(value) {
+    return isRecord(value) && ("payload" in value
+        || "Payload" in value
+        || "timestampUtc" in value
+        || "TimestampUtc" in value
+        || "timestampUtcMs" in value
+        || "TimestampUtcMs" in value);
+}
+function resolveHttpContentType(configuredContentType, bodyType) {
+    if (typeof configuredContentType === "string" && configuredContentType.trim()) {
+        return configuredContentType.trim();
+    }
+    switch (canonicalizeHttpBodyType(String(bodyType ?? "Json"))) {
+        case "PlainText":
+            return "text/plain";
+        case "Xml":
+            return "application/xml";
+        case "FormUrlEncoded":
+            return "application/x-www-form-urlencoded";
+        case "Binary":
+            return "application/octet-stream";
+        default:
+            return "application/json";
+    }
+}
+function canonicalizeHttpBodyType(value) {
+    const normalized = normalizeToken(value).replace(/_/g, "");
+    switch (normalized) {
+        case "":
+        case "json":
+            return "Json";
+        case "text":
+        case "plaintext":
+            return "PlainText";
+        case "xml":
+            return "Xml";
+        case "form":
+        case "formurlencoded":
+            return "FormUrlEncoded";
+        case "binary":
+            return "Binary";
+        default:
+            return value;
+    }
+}
+function canonicalizeHttpResponseSource(value) {
+    const normalized = normalizeToken(value).replace(/_/g, "");
+    switch (normalized) {
+        case "":
+        case "none":
+        case "request":
+            return "None";
+        case "response":
+        case "body":
+        case "responsebody":
+            return "ResponseBody";
+        case "headers":
+        case "responseheaders":
+            return "ResponseHeaders";
+        case "status":
+        case "statuscode":
+        case "responsestatuscode":
+            return "ResponseStatusCode";
+        default:
+            return value;
+    }
+}
+function canonicalizeHttpTrackingPayloadSource(value) {
+    const normalized = normalizeToken(value).replace(/_/g, "");
+    switch (normalized) {
+        case "":
+        case "request":
+            return "Request";
+        case "response":
+        case "body":
+        case "responsebody":
+        case "headers":
+        case "responseheaders":
+        case "status":
+        case "statuscode":
+        case "responsestatuscode":
+            return "Response";
+        default:
+            return value;
+    }
+}
+function inferLegacyHttpResponseSource(value) {
+    const normalized = normalizeToken(String(value ?? "")).replace(/_/g, "");
+    switch (normalized) {
+        case "body":
+        case "responsebody":
+            return "ResponseBody";
+        case "headers":
+        case "responseheaders":
+            return "ResponseHeaders";
+        case "status":
+        case "statuscode":
+        case "responsestatuscode":
+            return "ResponseStatusCode";
+        default:
+            return undefined;
+    }
+}
+function asRecordOrEmpty(value) {
+    return isRecord(value) ? value : {};
+}
+function pickProtocolValue(options, ...keys) {
+    for (const key of keys) {
+        if (key in options) {
+            return options[key];
+        }
+    }
+    return undefined;
+}
+function buildKafkaClientOptions(endpoint) {
+    const options = endpoint.kafka ?? {};
+    const securityProtocol = (optionString(options, "SecurityProtocol", "securityProtocol") || "Plaintext").toLowerCase();
+    const bootstrapServers = optionString(options, "BootstrapServers", "bootstrapServers")
+        .split(",")
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0);
+    const clientOptions = {
+        clientId: `${endpoint.name}-${randomUUID().slice(0, 8)}`,
+        brokers: bootstrapServers,
+        ssl: securityProtocol === "ssl" || securityProtocol === "saslssl"
+    };
+    if (securityProtocol === "saslplaintext" || securityProtocol === "saslssl") {
+        const saslOptions = asRecordOrEmpty(pickProtocolValue(options, "Sasl", "sasl"));
+        const mechanism = (optionString(saslOptions, "Mechanism", "mechanism") || "Plain").toLowerCase();
+        if (mechanism === "oauthbearer") {
+            clientOptions.sasl = {
+                mechanism: "oauthbearer",
+                oauthBearerProvider: async () => ({
+                    value: await resolveKafkaOAuthBearerToken(saslOptions)
+                })
+            };
+        }
+        else {
+            clientOptions.sasl = {
+                mechanism: mapKafkaSaslMechanism(mechanism),
+                username: optionString(saslOptions, "Username", "username"),
+                password: optionString(saslOptions, "Password", "password")
+            };
+        }
+    }
+    return clientOptions;
+}
+async function createKafkaClient(endpoint) {
+    if (shouldUseConfluentKafkaClient(endpoint)) {
+        const { KafkaJS } = await import("@confluentinc/kafka-javascript");
+        return new KafkaJS.Kafka(buildConfluentKafkaClientOptions(endpoint));
+    }
+    const { Kafka } = await import("kafkajs");
+    return new Kafka(buildKafkaClientOptions(endpoint));
+}
+function buildKafkaConsumerOptions(endpoint) {
+    const options = endpoint.kafka ?? {};
+    const groupId = optionString(options, "ConsumerGroupId", "consumerGroupId");
+    const fromBeginning = optionBoolean(options, true, "StartFromEarliest", "startFromEarliest");
+    if (shouldUseConfluentKafkaClient(endpoint)) {
+        return {
+            "group.id": groupId,
+            "auto.offset.reset": fromBeginning ? "earliest" : "latest",
+            "enable.auto.commit": true
+        };
+    }
+    return { groupId };
+}
+function shouldUseConfluentKafkaClient(endpoint) {
+    const options = endpoint.kafka ?? {};
+    const securityProtocol = (optionString(options, "SecurityProtocol", "securityProtocol") || "Plaintext").toLowerCase();
+    if (securityProtocol !== "saslplaintext" && securityProtocol !== "saslssl") {
+        return Object.keys(toStringRecord(pickProtocolValue(options, "ConfluentSettings", "confluentSettings"))).length > 0;
+    }
+    const saslOptions = asRecordOrEmpty(pickProtocolValue(options, "Sasl", "sasl"));
+    const mechanism = (optionString(saslOptions, "Mechanism", "mechanism") || "Plain").toLowerCase();
+    const confluentSettings = toStringRecord(pickProtocolValue(options, "ConfluentSettings", "confluentSettings"));
+    const additionalSettings = toStringRecord(pickProtocolValue(saslOptions, "AdditionalSettings", "additionalSettings"));
+    const hasDirectOAuthToken = mechanism === "oauthbearer" && Boolean(optionString(saslOptions, "AccessToken", "accessToken", "OAuthBearerToken", "oauthBearerToken"));
+    return mechanism === "gssapi"
+        || Object.keys(confluentSettings).length > 0
+        || (Object.keys(additionalSettings).length > 0 && !hasDirectOAuthToken);
+}
+function buildConfluentKafkaClientOptions(endpoint) {
+    const options = endpoint.kafka ?? {};
+    const securityProtocol = optionString(options, "SecurityProtocol", "securityProtocol") || "Plaintext";
+    const base = {
+        "bootstrap.servers": optionString(options, "BootstrapServers", "bootstrapServers"),
+        "client.id": `${endpoint.name}-${randomUUID().slice(0, 8)}`,
+        "security.protocol": mapConfluentKafkaSecurityProtocol(securityProtocol)
+    };
+    if (/^sasl/i.test(securityProtocol)) {
+        const saslOptions = asRecordOrEmpty(pickProtocolValue(options, "Sasl", "sasl"));
+        const mechanism = optionString(saslOptions, "Mechanism", "mechanism") || "Plain";
+        const additionalSettings = toStringRecord(pickProtocolValue(saslOptions, "AdditionalSettings", "additionalSettings"));
+        base["sasl.mechanism"] = mapConfluentKafkaSaslMechanism(mechanism);
+        if (mechanism.toLowerCase() === "oauthbearer") {
+            const tokenEndpoint = optionString(saslOptions, "OAuthBearerTokenEndpointUrl", "oauthBearerTokenEndpointUrl", "TokenEndpoint", "tokenEndpoint") || optionString(additionalSettings, "TokenEndpoint", "tokenEndpoint");
+            if (tokenEndpoint) {
+                base["sasl.oauthbearer.method"] = "oidc";
+                base["sasl.oauthbearer.token.endpoint.url"] = tokenEndpoint;
+            }
+            const clientId = optionString(additionalSettings, "ClientId", "clientId");
+            if (clientId) {
+                base["sasl.oauthbearer.client.id"] = clientId;
+            }
+            const clientSecret = optionString(additionalSettings, "ClientSecret", "clientSecret");
+            if (clientSecret) {
+                base["sasl.oauthbearer.client.secret"] = clientSecret;
+            }
+            const scope = optionString(additionalSettings, "Scope", "scope");
+            if (scope) {
+                base["sasl.oauthbearer.scope"] = scope;
+            }
+            const grantType = optionString(additionalSettings, "GrantType", "grantType");
+            if (grantType) {
+                base["sasl.oauthbearer.grant.type"] = grantType;
+            }
+            const extensions = optionString(additionalSettings, "Extensions", "extensions");
+            if (extensions) {
+                base["sasl.oauthbearer.extensions"] = extensions;
+            }
+        }
+        else {
+            base["sasl.username"] = optionString(saslOptions, "Username", "username");
+            base["sasl.password"] = optionString(saslOptions, "Password", "password");
+        }
+        for (const [key, value] of Object.entries(additionalSettings)) {
+            if (key === "ClientId"
+                || key === "clientId"
+                || key === "ClientSecret"
+                || key === "clientSecret"
+                || key === "Scope"
+                || key === "scope"
+                || key === "GrantType"
+                || key === "grantType"
+                || key === "Extensions"
+                || key === "extensions"
+                || key === "TokenEndpoint"
+                || key === "tokenEndpoint") {
+                continue;
+            }
+            base[key] = value;
+        }
+    }
+    for (const [key, value] of Object.entries(toStringRecord(pickProtocolValue(options, "ConfluentSettings", "confluentSettings")))) {
+        base[key] = value;
+    }
+    return base;
+}
+async function resolveKafkaOAuthBearerToken(options) {
+    const directToken = optionString(options, "AccessToken", "accessToken", "OAuthBearerToken", "oauthBearerToken");
+    if (directToken) {
+        return directToken;
+    }
+    const additional = asRecordOrEmpty(pickProtocolValue(options, "AdditionalSettings", "additionalSettings"));
+    const tokenEndpoint = optionString(options, "OAuthBearerTokenEndpointUrl", "oauthBearerTokenEndpointUrl", "TokenEndpoint", "tokenEndpoint") || optionString(additional, "TokenEndpoint", "tokenEndpoint");
+    const clientId = optionString(additional, "ClientId", "clientId");
+    const clientSecret = optionString(additional, "ClientSecret", "clientSecret");
+    if (!tokenEndpoint || !clientId || !clientSecret) {
+        throw new Error("Kafka OAuthBearer requires a direct access token or token endpoint with client credentials.");
+    }
+    const form = new URLSearchParams();
+    form.set("grant_type", "client_credentials");
+    form.set("client_id", clientId);
+    form.set("client_secret", clientSecret);
+    const scope = optionString(additional, "Scope", "scope");
+    if (scope) {
+        form.set("scope", scope);
+    }
+    const response = await fetch(tokenEndpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: form.toString()
+    });
+    if (!response.ok) {
+        throw new Error(`Kafka OAuthBearer token request failed with status ${response.status}.`);
+    }
+    const payload = parseMaybeJson(await response.text());
+    if (!isRecord(payload) || !payload.access_token) {
+        throw new Error("Kafka OAuthBearer token response did not contain access_token.");
+    }
+    return String(payload.access_token);
+}
+function mapKafkaSaslMechanism(mechanism) {
+    switch (mechanism) {
+        case "plain":
+            return "plain";
+        case "scramsha256":
+        case "scram-sha-256":
+            return "scram-sha-256";
+        case "scramsha512":
+        case "scram-sha-512":
+            return "scram-sha-512";
+        default:
+            throw new Error(`Unsupported Kafka SASL mechanism: ${mechanism}.`);
+    }
+}
+function mapConfluentKafkaSecurityProtocol(protocol) {
+    switch (protocol.toLowerCase()) {
+        case "plaintext":
+            return "plaintext";
+        case "ssl":
+            return "ssl";
+        case "saslplaintext":
+        case "sasl_plaintext":
+        case "sasl-plaintext":
+            return "sasl_plaintext";
+        case "saslssl":
+        case "sasl_ssl":
+        case "sasl-ssl":
+            return "sasl_ssl";
+        default:
+            throw new Error(`Unsupported Kafka security protocol: ${protocol}.`);
+    }
+}
+function mapConfluentKafkaSaslMechanism(mechanism) {
+    switch (mechanism.toLowerCase()) {
+        case "plain":
+            return "PLAIN";
+        case "scramsha256":
+        case "scram-sha-256":
+            return "SCRAM-SHA-256";
+        case "scramsha512":
+        case "scram-sha-512":
+            return "SCRAM-SHA-512";
+        case "gssapi":
+            return "GSSAPI";
+        case "oauthbearer":
+            return "OAUTHBEARER";
+        default:
+            throw new Error(`Unsupported Kafka SASL mechanism: ${mechanism}.`);
+    }
+}
+function toKafkaHeadersWithContentType(headers, contentType) {
+    const resolvedHeaders = { ...headers };
+    if (contentType) {
+        resolvedHeaders["content-type"] = contentType;
+    }
+    return toKafkaHeaders(resolvedHeaders);
+}
+function toKafkaHeaders(headers) {
+    return Object.fromEntries(Object.entries(headers).map(([key, value]) => [key, Buffer.from(String(value ?? ""), "utf8")]));
+}
+function fromKafkaHeaders(headers) {
+    const result = {};
+    for (const [key, value] of Object.entries(headers ?? {})) {
+        if (value == null) {
+            result[key] = "";
+            continue;
+        }
+        if (Array.isArray(value)) {
+            const last = value[value.length - 1];
+            result[key] = last == null
+                ? ""
+                : typeof last === "string"
+                    ? last
+                    : Buffer.from(last).toString("utf8");
+            continue;
+        }
+        if (typeof value === "string") {
+            result[key] = value;
+            continue;
+        }
+        result[key] = Buffer.from(value).toString("utf8");
+    }
+    return result;
+}
+function headerValue(headers, expected) {
+    const normalized = expected.toLowerCase();
+    for (const [key, value] of Object.entries(headers ?? {})) {
+        if (key.toLowerCase() !== normalized) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            const last = value[value.length - 1];
+            if (typeof last === "string") {
+                return last;
+            }
+            if (last != null) {
+                return Buffer.from(last).toString("utf8");
+            }
+            return undefined;
+        }
+        if (typeof value === "string") {
+            return value;
+        }
+        if (value != null) {
+            return Buffer.from(value).toString("utf8");
+        }
+    }
+    return undefined;
+}
+async function createNatsHeaders(headers, contentType) {
+    const entries = Object.entries(headers);
+    if (!entries.length && !contentType) {
+        return null;
+    }
+    const { headers: createHeaders } = await import("nats");
+    const natsHeaders = createHeaders();
+    for (const [key, value] of entries) {
+        natsHeaders.set(key, value);
+    }
+    if (contentType) {
+        natsHeaders.set("content-type", contentType);
+    }
+    return natsHeaders;
+}
+function toHeaderRecord(value) {
+    if (!value) {
+        return {};
+    }
+    if (typeof value.entries === "function") {
+        const result = {};
+        for (const [key, entry] of value.entries()) {
+            if (Array.isArray(entry)) {
+                result[key] = String(entry[0] ?? "");
+            }
+            else {
+                result[key] = String(entry ?? "");
+            }
+        }
+        return result;
+    }
+    if (typeof value.keys === "function"
+        && typeof value.get === "function") {
+        const result = {};
+        for (const key of value.keys()) {
+            const entry = value.get(key);
+            if (Array.isArray(entry)) {
+                result[key] = String(entry[0] ?? "");
+            }
+            else {
+                result[key] = String(entry ?? "");
+            }
+        }
+        return result;
+    }
+    if (typeof value.forEach === "function") {
+        const result = {};
+        value.forEach((entry, key) => {
+            if (Array.isArray(entry)) {
+                result[key] = String(entry[0] ?? "");
+            }
+            else {
+                result[key] = String(entry ?? "");
+            }
+        });
+        return result;
+    }
+    if (isRecord(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => {
+            if (entry instanceof Uint8Array || entry instanceof Buffer) {
+                return [key, Buffer.from(entry).toString("utf8")];
+            }
+            return [key, String(entry ?? "")];
+        }));
+    }
+    return {};
+}
+function bufferToUint8Array(value) {
+    if (value instanceof Uint8Array) {
+        return new Uint8Array(value);
+    }
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) {
+        return Uint8Array.from(value);
+    }
+    if (value instanceof ArrayBuffer) {
+        return new Uint8Array(value);
+    }
+    if (value == null) {
+        return new Uint8Array();
+    }
+    return new TextEncoder().encode(String(value));
+}
+function readFirstRedisStreamEntry(value) {
+    if (!Array.isArray(value) || value.length === 0) {
+        return null;
+    }
+    const stream = value[0];
+    if (!Array.isArray(stream) || stream.length < 2 || !Array.isArray(stream[1]) || stream[1].length === 0) {
+        return null;
+    }
+    const message = stream[1][0];
+    if (!Array.isArray(message) || message.length < 2 || !Array.isArray(message[1])) {
+        return null;
+    }
+    const id = Buffer.from(message[0]).toString("utf8");
+    const fieldEntries = message[1];
+    const fields = {};
+    for (let index = 0; index < fieldEntries.length; index += 2) {
+        const key = Buffer.from(fieldEntries[index]).toString("utf8");
+        const raw = fieldEntries[index + 1];
+        fields[key] = bufferToUint8Array(raw);
+    }
+    return { id, fields };
+}
+function createRedisStreamPayload(fields, endpoint) {
+    const headers = {};
+    let body = new Uint8Array(0);
+    let contentType;
+    for (const [key, value] of Object.entries(fields)) {
+        if (key.toLowerCase() === "body") {
+            body = bufferToUint8Array(value);
+            continue;
+        }
+        if (key.toLowerCase() === "content-type") {
+            contentType = Buffer.from(value).toString("utf8");
+            continue;
+        }
+        if (key.toLowerCase().startsWith("header:")) {
+            headers[key.slice("header:".length)] = Buffer.from(value).toString("utf8");
+        }
+    }
+    return createBrokerPayload(headers, body, endpoint, contentType);
+}
+function payloadBodyAsUtf8(body) {
+    if (body instanceof Uint8Array) {
+        return new TextDecoder().decode(body);
+    }
+    if (typeof body === "string") {
+        return body;
+    }
+    if (body == null) {
+        return "";
+    }
+    try {
+        return JSON.stringify(body);
+    }
+    catch {
+        return String(body);
+    }
+}