@aws-sdk/client-kafkaconnect 3.927.0 → 3.929.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,8 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -91,6 +90,7 @@ class KafkaConnectClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -110,12 +110,12 @@ class KafkaConnectClient extends smithyClient.Client {
     }
 }
 
-class KafkaConnectServiceException extends smithyClient.ServiceException {
+let KafkaConnectServiceException$1 = class KafkaConnectServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, KafkaConnectServiceException.prototype);
     }
-}
+};
 
 const ConnectorOperationStepState = {
     CANCELLED: "CANCELLED",
@@ -177,7 +177,7 @@ const WorkerConfigurationState = {
     ACTIVE: "ACTIVE",
     DELETING: "DELETING",
 };
-class BadRequestException extends KafkaConnectServiceException {
+let BadRequestException$1 = class BadRequestException extends KafkaConnectServiceException$1 {
     name = "BadRequestException";
     $fault = "client";
     constructor(opts) {
@@ -188,8 +188,8 @@ class BadRequestException extends KafkaConnectServiceException {
         });
         Object.setPrototypeOf(this, BadRequestException.prototype);
     }
-}
-class ConflictException extends KafkaConnectServiceException {
+};
+let ConflictException$1 = class ConflictException extends KafkaConnectServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     constructor(opts) {
@@ -200,8 +200,8 @@ class ConflictException extends KafkaConnectServiceException {
         });
         Object.setPrototypeOf(this, ConflictException.prototype);
     }
-}
-class ForbiddenException extends KafkaConnectServiceException {
+};
+let ForbiddenException$1 = class ForbiddenException extends KafkaConnectServiceException$1 {
     name = "ForbiddenException";
     $fault = "client";
     constructor(opts) {
@@ -212,8 +212,8 @@ class ForbiddenException extends KafkaConnectServiceException {
         });
         Object.setPrototypeOf(this, ForbiddenException.prototype);
     }
-}
-class InternalServerErrorException extends KafkaConnectServiceException {
+};
+let InternalServerErrorException$1 = class InternalServerErrorException extends KafkaConnectServiceException$1 {
     name = "InternalServerErrorException";
     $fault = "server";
     constructor(opts) {
@@ -224,8 +224,8 @@ class InternalServerErrorException extends KafkaConnectServiceException {
         });
         Object.setPrototypeOf(this, InternalServerErrorException.prototype);
     }
-}
-class NotFoundException extends KafkaConnectServiceException {
+};
+let NotFoundException$1 = class NotFoundException extends KafkaConnectServiceException$1 {
     name = "NotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -236,8 +236,8 @@ class NotFoundException extends KafkaConnectServiceException {
         });
         Object.setPrototypeOf(this, NotFoundException.prototype);
     }
-}
-class ServiceUnavailableException extends KafkaConnectServiceException {
+};
+let ServiceUnavailableException$1 = class ServiceUnavailableException extends KafkaConnectServiceException$1 {
     name = "ServiceUnavailableException";
     $fault = "server";
     constructor(opts) {
@@ -248,8 +248,8 @@ class ServiceUnavailableException extends KafkaConnectServiceException {
         });
         Object.setPrototypeOf(this, ServiceUnavailableException.prototype);
     }
-}
-class TooManyRequestsException extends KafkaConnectServiceException {
+};
+let TooManyRequestsException$1 = class TooManyRequestsException extends KafkaConnectServiceException$1 {
     name = "TooManyRequestsException";
     $fault = "client";
     constructor(opts) {
@@ -260,8 +260,8 @@ class TooManyRequestsException extends KafkaConnectServiceException {
         });
         Object.setPrototypeOf(this, TooManyRequestsException.prototype);
     }
-}
-class UnauthorizedException extends KafkaConnectServiceException {
+};
+let UnauthorizedException$1 = class UnauthorizedException extends KafkaConnectServiceException$1 {
     name = "UnauthorizedException";
     $fault = "client";
     constructor(opts) {
@@ -272,845 +272,1030 @@ class UnauthorizedException extends KafkaConnectServiceException {
         });
         Object.setPrototypeOf(this, UnauthorizedException.prototype);
     }
-}
-const CreateConnectorRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.connectorConfiguration && { connectorConfiguration: smithyClient.SENSITIVE_STRING }),
-});
-const CreateWorkerConfigurationRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.propertiesFileContent && { propertiesFileContent: smithyClient.SENSITIVE_STRING }),
-});
-const DescribeConnectorResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.connectorConfiguration && { connectorConfiguration: smithyClient.SENSITIVE_STRING }),
-});
-const DescribeConnectorOperationResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.originConnectorConfiguration && { originConnectorConfiguration: smithyClient.SENSITIVE_STRING }),
-    ...(obj.targetConnectorConfiguration && { targetConnectorConfiguration: smithyClient.SENSITIVE_STRING }),
-});
-const WorkerConfigurationRevisionDescriptionFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.propertiesFileContent && { propertiesFileContent: smithyClient.SENSITIVE_STRING }),
-});
-const DescribeWorkerConfigurationResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.latestRevision && {
-        latestRevision: WorkerConfigurationRevisionDescriptionFilterSensitiveLog(obj.latestRevision),
-    }),
-});
-const UpdateConnectorRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.connectorConfiguration && { connectorConfiguration: smithyClient.SENSITIVE_STRING }),
-});
-
-const se_CreateConnectorCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/connectors");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        capacity: (_) => smithyClient._json(_),
-        connectorConfiguration: (_) => smithyClient._json(_),
-        connectorDescription: [],
-        connectorName: [],
-        kafkaCluster: (_) => smithyClient._json(_),
-        kafkaClusterClientAuthentication: (_) => smithyClient._json(_),
-        kafkaClusterEncryptionInTransit: (_) => smithyClient._json(_),
-        kafkaConnectVersion: [],
-        logDelivery: (_) => smithyClient._json(_),
-        plugins: (_) => smithyClient._json(_),
-        serviceExecutionRoleArn: [],
-        tags: (_) => smithyClient._json(_),
-        workerConfiguration: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateCustomPluginCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/custom-plugins");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        contentType: [],
-        description: [],
-        location: (_) => smithyClient._json(_),
-        name: [],
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_CreateWorkerConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/worker-configurations");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        description: [],
-        name: [],
-        propertiesFileContent: [],
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteConnectorCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/connectors/{connectorArn}");
-    b.p("connectorArn", () => input.connectorArn, "{connectorArn}", false);
-    const query = smithyClient.map({
-        [_cV]: [, input[_cV]],
-    });
-    let body;
-    b.m("DELETE").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_DeleteCustomPluginCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/custom-plugins/{customPluginArn}");
-    b.p("customPluginArn", () => input.customPluginArn, "{customPluginArn}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteWorkerConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/worker-configurations/{workerConfigurationArn}");
-    b.p("workerConfigurationArn", () => input.workerConfigurationArn, "{workerConfigurationArn}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeConnectorCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/connectors/{connectorArn}");
-    b.p("connectorArn", () => input.connectorArn, "{connectorArn}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeConnectorOperationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/connectorOperations/{connectorOperationArn}");
-    b.p("connectorOperationArn", () => input.connectorOperationArn, "{connectorOperationArn}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeCustomPluginCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/custom-plugins/{customPluginArn}");
-    b.p("customPluginArn", () => input.customPluginArn, "{customPluginArn}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeWorkerConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/worker-configurations/{workerConfigurationArn}");
-    b.p("workerConfigurationArn", () => input.workerConfigurationArn, "{workerConfigurationArn}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_ListConnectorOperationsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/connectors/{connectorArn}/operations");
-    b.p("connectorArn", () => input.connectorArn, "{connectorArn}", false);
-    const query = smithyClient.map({
-        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
-        [_nT]: [, input[_nT]],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListConnectorsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/connectors");
-    const query = smithyClient.map({
-        [_cNP]: [, input[_cNP]],
-        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
-        [_nT]: [, input[_nT]],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListCustomPluginsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/custom-plugins");
-    const query = smithyClient.map({
-        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
-        [_nT]: [, input[_nT]],
-        [_nP]: [, input[_nP]],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_ListWorkerConfigurationsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/worker-configurations");
-    const query = smithyClient.map({
-        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
-        [_nT]: [, input[_nT]],
-        [_nP]: [, input[_nP]],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_TagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        tags: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/v1/tags/{resourceArn}");
-    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
-    const query = smithyClient.map({
-        [_tK]: [smithyClient.expectNonNull(input.tagKeys, `tagKeys`) != null, () => input[_tK] || []],
-    });
-    let body;
-    b.m("DELETE").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_UpdateConnectorCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/v1/connectors/{connectorArn}");
-    b.p("connectorArn", () => input.connectorArn, "{connectorArn}", false);
-    const query = smithyClient.map({
-        [_cV]: [, smithyClient.expectNonNull(input[_cV], `currentVersion`)],
-    });
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        capacity: (_) => smithyClient._json(_),
-        connectorConfiguration: (_) => smithyClient._json(_),
-    }));
-    b.m("PUT").h(headers).q(query).b(body);
-    return b.build();
-};
-const de_CreateConnectorCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        connectorArn: smithyClient.expectString,
-        connectorName: smithyClient.expectString,
-        connectorState: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateCustomPluginCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        customPluginArn: smithyClient.expectString,
-        customPluginState: smithyClient.expectString,
-        name: smithyClient.expectString,
-        revision: smithyClient.expectLong,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CreateWorkerConfigurationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        latestRevision: (_) => de_WorkerConfigurationRevisionSummary(_),
-        name: smithyClient.expectString,
-        workerConfigurationArn: smithyClient.expectString,
-        workerConfigurationState: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteConnectorCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        connectorArn: smithyClient.expectString,
-        connectorState: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteCustomPluginCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        customPluginArn: smithyClient.expectString,
-        customPluginState: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteWorkerConfigurationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        workerConfigurationArn: smithyClient.expectString,
-        workerConfigurationState: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeConnectorCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        capacity: smithyClient._json,
-        connectorArn: smithyClient.expectString,
-        connectorConfiguration: smithyClient._json,
-        connectorDescription: smithyClient.expectString,
-        connectorName: smithyClient.expectString,
-        connectorState: smithyClient.expectString,
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        currentVersion: smithyClient.expectString,
-        kafkaCluster: smithyClient._json,
-        kafkaClusterClientAuthentication: smithyClient._json,
-        kafkaClusterEncryptionInTransit: smithyClient._json,
-        kafkaConnectVersion: smithyClient.expectString,
-        logDelivery: smithyClient._json,
-        plugins: smithyClient._json,
-        serviceExecutionRoleArn: smithyClient.expectString,
-        stateDescription: smithyClient._json,
-        workerConfiguration: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
 };
-const de_DescribeConnectorOperationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        connectorArn: smithyClient.expectString,
-        connectorOperationArn: smithyClient.expectString,
-        connectorOperationState: smithyClient.expectString,
-        connectorOperationType: smithyClient.expectString,
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        endTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        errorInfo: smithyClient._json,
-        operationSteps: smithyClient._json,
-        originConnectorConfiguration: smithyClient._json,
-        originWorkerSetting: smithyClient._json,
-        targetConnectorConfiguration: smithyClient._json,
-        targetWorkerSetting: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeCustomPluginCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        customPluginArn: smithyClient.expectString,
-        customPluginState: smithyClient.expectString,
-        description: smithyClient.expectString,
-        latestRevision: (_) => de_CustomPluginRevisionSummary(_),
-        name: smithyClient.expectString,
-        stateDescription: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeWorkerConfigurationCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        description: smithyClient.expectString,
-        latestRevision: (_) => de_WorkerConfigurationRevisionDescription(_),
-        name: smithyClient.expectString,
-        workerConfigurationArn: smithyClient.expectString,
-        workerConfigurationState: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListConnectorOperationsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        connectorOperations: (_) => de___listOfConnectorOperationSummary(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListConnectorsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        connectors: (_) => de___listOfConnectorSummary(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListCustomPluginsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        customPlugins: (_) => de___listOfCustomPluginSummary(_),
-        nextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        tags: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListWorkerConfigurationsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        nextToken: smithyClient.expectString,
-        workerConfigurations: (_) => de___listOfWorkerConfigurationSummary(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UpdateConnectorCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        connectorArn: smithyClient.expectString,
-        connectorOperationArn: smithyClient.expectString,
-        connectorState: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "BadRequestException":
-        case "com.amazonaws.kafkaconnect#BadRequestException":
-            throw await de_BadRequestExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.kafkaconnect#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "ForbiddenException":
-        case "com.amazonaws.kafkaconnect#ForbiddenException":
-            throw await de_ForbiddenExceptionRes(parsedOutput);
-        case "InternalServerErrorException":
-        case "com.amazonaws.kafkaconnect#InternalServerErrorException":
-            throw await de_InternalServerErrorExceptionRes(parsedOutput);
-        case "NotFoundException":
-        case "com.amazonaws.kafkaconnect#NotFoundException":
-            throw await de_NotFoundExceptionRes(parsedOutput);
-        case "ServiceUnavailableException":
-        case "com.amazonaws.kafkaconnect#ServiceUnavailableException":
-            throw await de_ServiceUnavailableExceptionRes(parsedOutput);
-        case "TooManyRequestsException":
-        case "com.amazonaws.kafkaconnect#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput);
-        case "UnauthorizedException":
-        case "com.amazonaws.kafkaconnect#UnauthorizedException":
-            throw await de_UnauthorizedExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(KafkaConnectServiceException);
-const de_BadRequestExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new BadRequestException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConflictExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ForbiddenExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ForbiddenException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalServerErrorExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalServerErrorException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_NotFoundExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new NotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ServiceUnavailableException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_TooManyRequestsExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new TooManyRequestsException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_UnauthorizedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new UnauthorizedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de___listOfConnectorOperationSummary = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ConnectorOperationSummary(entry);
-    });
-    return retVal;
-};
-const de___listOfConnectorSummary = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ConnectorSummary(entry);
-    });
-    return retVal;
-};
-const de___listOfCustomPluginSummary = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_CustomPluginSummary(entry);
-    });
-    return retVal;
-};
-const de___listOfWorkerConfigurationSummary = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_WorkerConfigurationSummary(entry);
-    });
-    return retVal;
-};
-const de_ConnectorOperationSummary = (output, context) => {
-    return smithyClient.take(output, {
-        connectorOperationArn: smithyClient.expectString,
-        connectorOperationState: smithyClient.expectString,
-        connectorOperationType: smithyClient.expectString,
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        endTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-    });
-};
-const de_ConnectorSummary = (output, context) => {
-    return smithyClient.take(output, {
-        capacity: smithyClient._json,
-        connectorArn: smithyClient.expectString,
-        connectorDescription: smithyClient.expectString,
-        connectorName: smithyClient.expectString,
-        connectorState: smithyClient.expectString,
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        currentVersion: smithyClient.expectString,
-        kafkaCluster: smithyClient._json,
-        kafkaClusterClientAuthentication: smithyClient._json,
-        kafkaClusterEncryptionInTransit: smithyClient._json,
-        kafkaConnectVersion: smithyClient.expectString,
-        logDelivery: smithyClient._json,
-        plugins: smithyClient._json,
-        serviceExecutionRoleArn: smithyClient.expectString,
-        workerConfiguration: smithyClient._json,
-    });
-};
-const de_CustomPluginRevisionSummary = (output, context) => {
-    return smithyClient.take(output, {
-        contentType: smithyClient.expectString,
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        description: smithyClient.expectString,
-        fileDescription: smithyClient._json,
-        location: smithyClient._json,
-        revision: smithyClient.expectLong,
-    });
-};
-const de_CustomPluginSummary = (output, context) => {
-    return smithyClient.take(output, {
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        customPluginArn: smithyClient.expectString,
-        customPluginState: smithyClient.expectString,
-        description: smithyClient.expectString,
-        latestRevision: (_) => de_CustomPluginRevisionSummary(_),
-        name: smithyClient.expectString,
-    });
-};
-const de_WorkerConfigurationRevisionDescription = (output, context) => {
-    return smithyClient.take(output, {
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        description: smithyClient.expectString,
-        propertiesFileContent: smithyClient.expectString,
-        revision: smithyClient.expectLong,
-    });
-};
-const de_WorkerConfigurationRevisionSummary = (output, context) => {
-    return smithyClient.take(output, {
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        description: smithyClient.expectString,
-        revision: smithyClient.expectLong,
-    });
-};
-const de_WorkerConfigurationSummary = (output, context) => {
-    return smithyClient.take(output, {
-        creationTime: (_) => smithyClient.expectNonNull(smithyClient.parseRfc3339DateTimeWithOffset(_)),
-        description: smithyClient.expectString,
-        latestRevision: (_) => de_WorkerConfigurationRevisionSummary(_),
-        name: smithyClient.expectString,
-        workerConfigurationArn: smithyClient.expectString,
-        workerConfigurationState: smithyClient.expectString,
-    });
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
+
+const _AKC = "ApacheKafkaCluster";
+const _AKCD = "ApacheKafkaClusterDescription";
+const _AS = "AutoScaling";
+const _ASD = "AutoScalingDescription";
+const _ASU = "AutoScalingUpdate";
+const _BRE = "BadRequestException";
+const _C = "Capacity";
+const _CC = "ConnectorConfiguration";
+const _CCP = "CreateCustomPlugin";
+const _CCPR = "CreateCustomPluginRequest";
+const _CCPRr = "CreateCustomPluginResponse";
+const _CCR = "CreateConnectorRequest";
+const _CCRr = "CreateConnectorResponse";
+const _CCU = "ConnectorConfigurationUpdate";
+const _CCr = "CreateConnector";
+const _CD = "CapacityDescription";
+const _CE = "ConflictException";
+const _COS = "ConnectorOperationStep";
+const _COSo = "ConnectorOperationSummary";
+const _CP = "CustomPlugin";
+const _CPD = "CustomPluginDescription";
+const _CPFD = "CustomPluginFileDescription";
+const _CPL = "CustomPluginLocation";
+const _CPLD = "CustomPluginLocationDescription";
+const _CPRS = "CustomPluginRevisionSummary";
+const _CPS = "CustomPluginSummary";
+const _CS = "ConnectorSummary";
+const _CU = "CapacityUpdate";
+const _CWC = "CreateWorkerConfiguration";
+const _CWCR = "CreateWorkerConfigurationRequest";
+const _CWCRr = "CreateWorkerConfigurationResponse";
+const _CWLLD = "CloudWatchLogsLogDelivery";
+const _CWLLDD = "CloudWatchLogsLogDeliveryDescription";
+const _DC = "DeleteConnector";
+const _DCO = "DescribeConnectorOperation";
+const _DCOR = "DescribeConnectorOperationRequest";
+const _DCORe = "DescribeConnectorOperationResponse";
+const _DCP = "DeleteCustomPlugin";
+const _DCPR = "DeleteCustomPluginRequest";
+const _DCPRe = "DeleteCustomPluginResponse";
+const _DCPRes = "DescribeCustomPluginRequest";
+const _DCPResc = "DescribeCustomPluginResponse";
+const _DCPe = "DescribeCustomPlugin";
+const _DCR = "DeleteConnectorRequest";
+const _DCRe = "DeleteConnectorResponse";
+const _DCRes = "DescribeConnectorRequest";
+const _DCResc = "DescribeConnectorResponse";
+const _DCe = "DescribeConnector";
+const _DWC = "DeleteWorkerConfiguration";
+const _DWCR = "DeleteWorkerConfigurationRequest";
+const _DWCRe = "DeleteWorkerConfigurationResponse";
+const _DWCRes = "DescribeWorkerConfigurationRequest";
+const _DWCResc = "DescribeWorkerConfigurationResponse";
+const _DWCe = "DescribeWorkerConfiguration";
+const _FE = "ForbiddenException";
+const _FLD = "FirehoseLogDelivery";
+const _FLDD = "FirehoseLogDeliveryDescription";
+const _ISEE = "InternalServerErrorException";
+const _KC = "KafkaCluster";
+const _KCCA = "KafkaClusterClientAuthentication";
+const _KCCAD = "KafkaClusterClientAuthenticationDescription";
+const _KCD = "KafkaClusterDescription";
+const _KCEIT = "KafkaClusterEncryptionInTransit";
+const _KCEITD = "KafkaClusterEncryptionInTransitDescription";
+const _LC = "ListConnectors";
+const _LCO = "ListConnectorOperations";
+const _LCOR = "ListConnectorOperationsRequest";
+const _LCORi = "ListConnectorOperationsResponse";
+const _LCP = "ListCustomPlugins";
+const _LCPR = "ListCustomPluginsRequest";
+const _LCPRi = "ListCustomPluginsResponse";
+const _LCR = "ListConnectorsRequest";
+const _LCRi = "ListConnectorsResponse";
+const _LD = "LogDelivery";
+const _LDD = "LogDeliveryDescription";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _LWC = "ListWorkerConfigurations";
+const _LWCR = "ListWorkerConfigurationsRequest";
+const _LWCRi = "ListWorkerConfigurationsResponse";
+const _NFE = "NotFoundException";
+const _P = "Plugin";
+const _PC = "ProvisionedCapacity";
+const _PCD = "ProvisionedCapacityDescription";
+const _PCU = "ProvisionedCapacityUpdate";
+const _PD = "PluginDescription";
+const _SD = "StateDescription";
+const _SIP = "ScaleInPolicy";
+const _SIPD = "ScaleInPolicyDescription";
+const _SIPU = "ScaleInPolicyUpdate";
+const _SL = "S3Location";
+const _SLD = "S3LocationDescription";
+const _SLDD = "S3LogDeliveryDescription";
+const _SLDo = "S3LogDelivery";
+const _SOP = "ScaleOutPolicy";
+const _SOPD = "ScaleOutPolicyDescription";
+const _SOPU = "ScaleOutPolicyUpdate";
+const _SUE = "ServiceUnavailableException";
+const _TMRE = "TooManyRequestsException";
+const _TR = "TagResource";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _UC = "UpdateConnector";
+const _UCR = "UpdateConnectorRequest";
+const _UCRp = "UpdateConnectorResponse";
+const _UE = "UnauthorizedException";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _V = "Vpc";
+const _VD = "VpcDescription";
+const _WC = "WorkerConfiguration";
+const _WCD = "WorkerConfigurationDescription";
+const _WCRD = "WorkerConfigurationRevisionDescription";
+const _WCRS = "WorkerConfigurationRevisionSummary";
+const _WCS = "WorkerConfigurationSummary";
+const _WLD = "WorkerLogDelivery";
+const _WLDD = "WorkerLogDeliveryDescription";
+const _WS = "WorkerSetting";
+const _aKC = "apacheKafkaCluster";
+const _aS = "autoScaling";
+const _aT = "authenticationType";
+const _b = "bucket";
+const _bA = "bucketArn";
+const _bS = "bootstrapServers";
+const _c = "client";
+const _cA = "connectorArn";
+const _cC = "connectorConfiguration";
+const _cD = "connectorDescription";
+const _cN = "connectorName";
 const _cNP = "connectorNamePrefix";
+const _cO = "connectorOperations";
+const _cOA = "connectorOperationArn";
+const _cOS = "connectorOperationState";
+const _cOT = "connectorOperationType";
+const _cP = "customPlugins";
+const _cPA = "customPluginArn";
+const _cPS = "customPluginState";
+const _cPu = "customPlugin";
+const _cS = "connectorState";
+const _cT = "creationTime";
+const _cTo = "contentType";
+const _cUP = "cpuUtilizationPercentage";
 const _cV = "currentVersion";
+const _cWL = "cloudWatchLogs";
+const _ca = "capacity";
+const _co = "connectors";
+const _cod = "code";
+const _d = "description";
+const _dS = "deliveryStream";
+const _e = "error";
+const _eI = "errorInfo";
+const _eT = "endTime";
+const _eTn = "encryptionType";
+const _en = "enabled";
+const _f = "firehose";
+const _fD = "fileDescription";
+const _fK = "fileKey";
+const _fM = "fileMd5";
+const _fS = "fileSize";
+const _h = "http";
+const _hE = "httpError";
+const _hQ = "httpQuery";
+const _kC = "kafkaCluster";
+const _kCCA = "kafkaClusterClientAuthentication";
+const _kCEIT = "kafkaClusterEncryptionInTransit";
+const _kCV = "kafkaConnectVersion";
+const _l = "location";
+const _lD = "logDelivery";
+const _lG = "logGroup";
+const _lOCOS = "__listOfConnectorOperationStep";
+const _lOCOSi = "__listOfConnectorOperationSummary";
+const _lOCPS = "__listOfCustomPluginSummary";
+const _lOCS = "__listOfConnectorSummary";
+const _lOP = "__listOfPlugin";
+const _lOPD = "__listOfPluginDescription";
+const _lOWCS = "__listOfWorkerConfigurationSummary";
+const _lR = "latestRevision";
+const _m = "message";
+const _mC = "mcuCount";
 const _mR = "maxResults";
+const _mWC = "maxWorkerCount";
+const _mWCi = "minWorkerCount";
+const _n = "name";
 const _nP = "namePrefix";
 const _nT = "nextToken";
+const _oCC = "originConnectorConfiguration";
+const _oS = "operationSteps";
+const _oV = "objectVersion";
+const _oWS = "originWorkerSetting";
+const _p = "plugins";
+const _pC = "provisionedCapacity";
+const _pFC = "propertiesFileContent";
+const _pr = "prefix";
+const _r = "revision";
+const _rA = "resourceArn";
+const _s = "server";
+const _sD = "stateDescription";
+const _sERA = "serviceExecutionRoleArn";
+const _sG = "securityGroups";
+const _sIP = "scaleInPolicy";
+const _sL = "s3Location";
+const _sOP = "scaleOutPolicy";
+const _sS = "__sensitiveString";
+const _sSt = "stepState";
+const _sT = "stepType";
+const _s_ = "s3";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.kafkaconnect";
+const _su = "subnets";
+const _t = "tags";
+const _tCC = "targetConnectorConfiguration";
 const _tK = "tagKeys";
+const _tWS = "targetWorkerSetting";
+const _v = "vpc";
+const _wC = "workerConfiguration";
+const _wCA = "workerConfigurationArn";
+const _wCS = "workerConfigurationState";
+const _wCo = "workerConfigurations";
+const _wCor = "workerCount";
+const _wLD = "workerLogDelivery";
+const n0 = "com.amazonaws.kafkaconnect";
+var __sensitiveString = [0, n0, _sS, 8, 0];
+var ApacheKafkaCluster = [3, n0, _AKC, 0, [_bS, _v], [0, () => Vpc]];
+var ApacheKafkaClusterDescription = [
+    3,
+    n0,
+    _AKCD,
+    0,
+    [_bS, _v],
+    [0, () => VpcDescription],
+];
+var AutoScaling = [
+    3,
+    n0,
+    _AS,
+    0,
+    [_mWC, _mC, _mWCi, _sIP, _sOP],
+    [1, 1, 1, () => ScaleInPolicy, () => ScaleOutPolicy],
+];
+var AutoScalingDescription = [
+    3,
+    n0,
+    _ASD,
+    0,
+    [_mWC, _mC, _mWCi, _sIP, _sOP],
+    [1, 1, 1, () => ScaleInPolicyDescription, () => ScaleOutPolicyDescription],
+];
+var AutoScalingUpdate = [
+    3,
+    n0,
+    _ASU,
+    0,
+    [_mWC, _mC, _mWCi, _sIP, _sOP],
+    [1, 1, 1, () => ScaleInPolicyUpdate, () => ScaleOutPolicyUpdate],
+];
+var BadRequestException = [
+    -3,
+    n0,
+    _BRE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(BadRequestException, BadRequestException$1);
+var Capacity = [3, n0, _C, 0, [_aS, _pC], [() => AutoScaling, () => ProvisionedCapacity]];
+var CapacityDescription = [
+    3,
+    n0,
+    _CD,
+    0,
+    [_aS, _pC],
+    [() => AutoScalingDescription, () => ProvisionedCapacityDescription],
+];
+var CapacityUpdate = [
+    3,
+    n0,
+    _CU,
+    0,
+    [_aS, _pC],
+    [() => AutoScalingUpdate, () => ProvisionedCapacityUpdate],
+];
+var CloudWatchLogsLogDelivery = [3, n0, _CWLLD, 0, [_en, _lG], [2, 0]];
+var CloudWatchLogsLogDeliveryDescription = [3, n0, _CWLLDD, 0, [_en, _lG], [2, 0]];
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var ConnectorOperationStep = [3, n0, _COS, 0, [_sT, _sSt], [0, 0]];
+var ConnectorOperationSummary = [
+    3,
+    n0,
+    _COSo,
+    0,
+    [_cOA, _cOT, _cOS, _cT, _eT],
+    [0, 0, 0, 5, 5],
+];
+var ConnectorSummary = [
+    3,
+    n0,
+    _CS,
+    0,
+    [_ca, _cA, _cD, _cN, _cS, _cT, _cV, _kC, _kCCA, _kCEIT, _kCV, _lD, _p, _sERA, _wC],
+    [
+        () => CapacityDescription,
+        0,
+        0,
+        0,
+        0,
+        5,
+        0,
+        () => KafkaClusterDescription,
+        () => KafkaClusterClientAuthenticationDescription,
+        () => KafkaClusterEncryptionInTransitDescription,
+        0,
+        () => LogDeliveryDescription,
+        () => __listOfPluginDescription,
+        0,
+        () => WorkerConfigurationDescription,
+    ],
+];
+var CreateConnectorRequest = [
+    3,
+    n0,
+    _CCR,
+    0,
+    [_ca, _cC, _cD, _cN, _kC, _kCCA, _kCEIT, _kCV, _lD, _p, _sERA, _wC, _t],
+    [
+        () => Capacity,
+        [() => ConnectorConfiguration, 0],
+        0,
+        0,
+        () => KafkaCluster,
+        () => KafkaClusterClientAuthentication,
+        () => KafkaClusterEncryptionInTransit,
+        0,
+        () => LogDelivery,
+        () => __listOfPlugin,
+        0,
+        () => WorkerConfiguration,
+        128 | 0,
+    ],
+];
+var CreateConnectorResponse = [3, n0, _CCRr, 0, [_cA, _cN, _cS], [0, 0, 0]];
+var CreateCustomPluginRequest = [
+    3,
+    n0,
+    _CCPR,
+    0,
+    [_cTo, _d, _l, _n, _t],
+    [0, 0, () => CustomPluginLocation, 0, 128 | 0],
+];
+var CreateCustomPluginResponse = [3, n0, _CCPRr, 0, [_cPA, _cPS, _n, _r], [0, 0, 0, 1]];
+var CreateWorkerConfigurationRequest = [
+    3,
+    n0,
+    _CWCR,
+    0,
+    [_d, _n, _pFC, _t],
+    [0, 0, [() => __sensitiveString, 0], 128 | 0],
+];
+var CreateWorkerConfigurationResponse = [
+    3,
+    n0,
+    _CWCRr,
+    0,
+    [_cT, _lR, _n, _wCA, _wCS],
+    [5, () => WorkerConfigurationRevisionSummary, 0, 0, 0],
+];
+var CustomPlugin = [3, n0, _CP, 0, [_cPA, _r], [0, 1]];
+var CustomPluginDescription = [3, n0, _CPD, 0, [_cPA, _r], [0, 1]];
+var CustomPluginFileDescription = [3, n0, _CPFD, 0, [_fM, _fS], [0, 1]];
+var CustomPluginLocation = [3, n0, _CPL, 0, [_sL], [() => S3Location]];
+var CustomPluginLocationDescription = [
+    3,
+    n0,
+    _CPLD,
+    0,
+    [_sL],
+    [() => S3LocationDescription],
+];
+var CustomPluginRevisionSummary = [
+    3,
+    n0,
+    _CPRS,
+    0,
+    [_cTo, _cT, _d, _fD, _l, _r],
+    [0, 5, 0, () => CustomPluginFileDescription, () => CustomPluginLocationDescription, 1],
+];
+var CustomPluginSummary = [
+    3,
+    n0,
+    _CPS,
+    0,
+    [_cT, _cPA, _cPS, _d, _lR, _n],
+    [5, 0, 0, 0, () => CustomPluginRevisionSummary, 0],
+];
+var DeleteConnectorRequest = [
+    3,
+    n0,
+    _DCR,
+    0,
+    [_cA, _cV],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _cV,
+            },
+        ],
+    ],
+];
+var DeleteConnectorResponse = [3, n0, _DCRe, 0, [_cA, _cS], [0, 0]];
+var DeleteCustomPluginRequest = [3, n0, _DCPR, 0, [_cPA], [[0, 1]]];
+var DeleteCustomPluginResponse = [3, n0, _DCPRe, 0, [_cPA, _cPS], [0, 0]];
+var DeleteWorkerConfigurationRequest = [3, n0, _DWCR, 0, [_wCA], [[0, 1]]];
+var DeleteWorkerConfigurationResponse = [3, n0, _DWCRe, 0, [_wCA, _wCS], [0, 0]];
+var DescribeConnectorOperationRequest = [3, n0, _DCOR, 0, [_cOA], [[0, 1]]];
+var DescribeConnectorOperationResponse = [
+    3,
+    n0,
+    _DCORe,
+    0,
+    [_cA, _cOA, _cOS, _cOT, _oS, _oWS, _oCC, _tWS, _tCC, _eI, _cT, _eT],
+    [
+        0,
+        0,
+        0,
+        0,
+        () => __listOfConnectorOperationStep,
+        () => WorkerSetting,
+        [() => ConnectorConfiguration, 0],
+        () => WorkerSetting,
+        [() => ConnectorConfiguration, 0],
+        () => StateDescription,
+        5,
+        5,
+    ],
+];
+var DescribeConnectorRequest = [3, n0, _DCRes, 0, [_cA], [[0, 1]]];
+var DescribeConnectorResponse = [
+    3,
+    n0,
+    _DCResc,
+    0,
+    [_ca, _cA, _cC, _cD, _cN, _cS, _cT, _cV, _kC, _kCCA, _kCEIT, _kCV, _lD, _p, _sERA, _wC, _sD],
+    [
+        () => CapacityDescription,
+        0,
+        [() => ConnectorConfiguration, 0],
+        0,
+        0,
+        0,
+        5,
+        0,
+        () => KafkaClusterDescription,
+        () => KafkaClusterClientAuthenticationDescription,
+        () => KafkaClusterEncryptionInTransitDescription,
+        0,
+        () => LogDeliveryDescription,
+        () => __listOfPluginDescription,
+        0,
+        () => WorkerConfigurationDescription,
+        () => StateDescription,
+    ],
+];
+var DescribeCustomPluginRequest = [3, n0, _DCPRes, 0, [_cPA], [[0, 1]]];
+var DescribeCustomPluginResponse = [
+    3,
+    n0,
+    _DCPResc,
+    0,
+    [_cT, _cPA, _cPS, _d, _lR, _n, _sD],
+    [5, 0, 0, 0, () => CustomPluginRevisionSummary, 0, () => StateDescription],
+];
+var DescribeWorkerConfigurationRequest = [3, n0, _DWCRes, 0, [_wCA], [[0, 1]]];
+var DescribeWorkerConfigurationResponse = [
+    3,
+    n0,
+    _DWCResc,
+    0,
+    [_cT, _d, _lR, _n, _wCA, _wCS],
+    [5, 0, [() => WorkerConfigurationRevisionDescription, 0], 0, 0, 0],
+];
+var FirehoseLogDelivery = [3, n0, _FLD, 0, [_dS, _en], [0, 2]];
+var FirehoseLogDeliveryDescription = [3, n0, _FLDD, 0, [_dS, _en], [0, 2]];
+var ForbiddenException = [
+    -3,
+    n0,
+    _FE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ForbiddenException, ForbiddenException$1);
+var InternalServerErrorException = [
+    -3,
+    n0,
+    _ISEE,
+    {
+        [_e]: _s,
+        [_hE]: 500,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerErrorException, InternalServerErrorException$1);
+var KafkaCluster = [3, n0, _KC, 0, [_aKC], [() => ApacheKafkaCluster]];
+var KafkaClusterClientAuthentication = [3, n0, _KCCA, 0, [_aT], [0]];
+var KafkaClusterClientAuthenticationDescription = [3, n0, _KCCAD, 0, [_aT], [0]];
+var KafkaClusterDescription = [
+    3,
+    n0,
+    _KCD,
+    0,
+    [_aKC],
+    [() => ApacheKafkaClusterDescription],
+];
+var KafkaClusterEncryptionInTransit = [3, n0, _KCEIT, 0, [_eTn], [0]];
+var KafkaClusterEncryptionInTransitDescription = [3, n0, _KCEITD, 0, [_eTn], [0]];
+var ListConnectorOperationsRequest = [
+    3,
+    n0,
+    _LCOR,
+    0,
+    [_cA, _mR, _nT],
+    [
+        [0, 1],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+    ],
+];
+var ListConnectorOperationsResponse = [
+    3,
+    n0,
+    _LCORi,
+    0,
+    [_cO, _nT],
+    [() => __listOfConnectorOperationSummary, 0],
+];
+var ListConnectorsRequest = [
+    3,
+    n0,
+    _LCR,
+    0,
+    [_cNP, _mR, _nT],
+    [
+        [
+            0,
+            {
+                [_hQ]: _cNP,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+    ],
+];
+var ListConnectorsResponse = [
+    3,
+    n0,
+    _LCRi,
+    0,
+    [_co, _nT],
+    [() => __listOfConnectorSummary, 0],
+];
+var ListCustomPluginsRequest = [
+    3,
+    n0,
+    _LCPR,
+    0,
+    [_mR, _nT, _nP],
+    [
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _nP,
+            },
+        ],
+    ],
+];
+var ListCustomPluginsResponse = [
+    3,
+    n0,
+    _LCPRi,
+    0,
+    [_cP, _nT],
+    [() => __listOfCustomPluginSummary, 0],
+];
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_rA], [[0, 1]]];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_t], [128 | 0]];
+var ListWorkerConfigurationsRequest = [
+    3,
+    n0,
+    _LWCR,
+    0,
+    [_mR, _nT, _nP],
+    [
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _nP,
+            },
+        ],
+    ],
+];
+var ListWorkerConfigurationsResponse = [
+    3,
+    n0,
+    _LWCRi,
+    0,
+    [_nT, _wCo],
+    [0, () => __listOfWorkerConfigurationSummary],
+];
+var LogDelivery = [3, n0, _LD, 0, [_wLD], [() => WorkerLogDelivery]];
+var LogDeliveryDescription = [
+    3,
+    n0,
+    _LDD,
+    0,
+    [_wLD],
+    [() => WorkerLogDeliveryDescription],
+];
+var NotFoundException = [
+    -3,
+    n0,
+    _NFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(NotFoundException, NotFoundException$1);
+var Plugin = [3, n0, _P, 0, [_cPu], [() => CustomPlugin]];
+var PluginDescription = [3, n0, _PD, 0, [_cPu], [() => CustomPluginDescription]];
+var ProvisionedCapacity = [3, n0, _PC, 0, [_mC, _wCor], [1, 1]];
+var ProvisionedCapacityDescription = [3, n0, _PCD, 0, [_mC, _wCor], [1, 1]];
+var ProvisionedCapacityUpdate = [3, n0, _PCU, 0, [_mC, _wCor], [1, 1]];
+var S3Location = [3, n0, _SL, 0, [_bA, _fK, _oV], [0, 0, 0]];
+var S3LocationDescription = [3, n0, _SLD, 0, [_bA, _fK, _oV], [0, 0, 0]];
+var S3LogDelivery = [3, n0, _SLDo, 0, [_b, _en, _pr], [0, 2, 0]];
+var S3LogDeliveryDescription = [3, n0, _SLDD, 0, [_b, _en, _pr], [0, 2, 0]];
+var ScaleInPolicy = [3, n0, _SIP, 0, [_cUP], [1]];
+var ScaleInPolicyDescription = [3, n0, _SIPD, 0, [_cUP], [1]];
+var ScaleInPolicyUpdate = [3, n0, _SIPU, 0, [_cUP], [1]];
+var ScaleOutPolicy = [3, n0, _SOP, 0, [_cUP], [1]];
+var ScaleOutPolicyDescription = [3, n0, _SOPD, 0, [_cUP], [1]];
+var ScaleOutPolicyUpdate = [3, n0, _SOPU, 0, [_cUP], [1]];
+var ServiceUnavailableException = [
+    -3,
+    n0,
+    _SUE,
+    {
+        [_e]: _s,
+        [_hE]: 503,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceUnavailableException, ServiceUnavailableException$1);
+var StateDescription = [3, n0, _SD, 0, [_cod, _m], [0, 0]];
+var TagResourceRequest = [3, n0, _TRR, 0, [_rA, _t], [[0, 1], 128 | 0]];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var TooManyRequestsException = [
+    -3,
+    n0,
+    _TMRE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(TooManyRequestsException, TooManyRequestsException$1);
+var UnauthorizedException = [
+    -3,
+    n0,
+    _UE,
+    {
+        [_e]: _c,
+        [_hE]: 401,
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(UnauthorizedException, UnauthorizedException$1);
+var UntagResourceRequest = [
+    3,
+    n0,
+    _URR,
+    0,
+    [_rA, _tK],
+    [
+        [0, 1],
+        [
+            64 | 0,
+            {
+                [_hQ]: _tK,
+            },
+        ],
+    ],
+];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var UpdateConnectorRequest = [
+    3,
+    n0,
+    _UCR,
+    0,
+    [_ca, _cC, _cA, _cV],
+    [
+        () => CapacityUpdate,
+        [() => ConnectorConfigurationUpdate, 0],
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _cV,
+            },
+        ],
+    ],
+];
+var UpdateConnectorResponse = [3, n0, _UCRp, 0, [_cA, _cS, _cOA], [0, 0, 0]];
+var Vpc = [3, n0, _V, 0, [_sG, _su], [64 | 0, 64 | 0]];
+var VpcDescription = [3, n0, _VD, 0, [_sG, _su], [64 | 0, 64 | 0]];
+var WorkerConfiguration = [3, n0, _WC, 0, [_r, _wCA], [1, 0]];
+var WorkerConfigurationDescription = [3, n0, _WCD, 0, [_r, _wCA], [1, 0]];
+var WorkerConfigurationRevisionDescription = [
+    3,
+    n0,
+    _WCRD,
+    0,
+    [_cT, _d, _pFC, _r],
+    [5, 0, [() => __sensitiveString, 0], 1],
+];
+var WorkerConfigurationRevisionSummary = [3, n0, _WCRS, 0, [_cT, _d, _r], [5, 0, 1]];
+var WorkerConfigurationSummary = [
+    3,
+    n0,
+    _WCS,
+    0,
+    [_cT, _d, _lR, _n, _wCA, _wCS],
+    [5, 0, () => WorkerConfigurationRevisionSummary, 0, 0, 0],
+];
+var WorkerLogDelivery = [
+    3,
+    n0,
+    _WLD,
+    0,
+    [_cWL, _f, _s_],
+    [() => CloudWatchLogsLogDelivery, () => FirehoseLogDelivery, () => S3LogDelivery],
+];
+var WorkerLogDeliveryDescription = [
+    3,
+    n0,
+    _WLDD,
+    0,
+    [_cWL, _f, _s_],
+    [() => CloudWatchLogsLogDeliveryDescription, () => FirehoseLogDeliveryDescription, () => S3LogDeliveryDescription],
+];
+var WorkerSetting = [3, n0, _WS, 0, [_ca], [() => CapacityDescription]];
+var KafkaConnectServiceException = [-3, _sm, "KafkaConnectServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(KafkaConnectServiceException, KafkaConnectServiceException$1);
+var __listOfConnectorOperationStep = [1, n0, _lOCOS, 0, () => ConnectorOperationStep];
+var __listOfConnectorOperationSummary = [1, n0, _lOCOSi, 0, () => ConnectorOperationSummary];
+var __listOfConnectorSummary = [1, n0, _lOCS, 0, () => ConnectorSummary];
+var __listOfCustomPluginSummary = [1, n0, _lOCPS, 0, () => CustomPluginSummary];
+var __listOfPlugin = [1, n0, _lOP, 0, () => Plugin];
+var __listOfPluginDescription = [1, n0, _lOPD, 0, () => PluginDescription];
+var __listOfWorkerConfigurationSummary = [1, n0, _lOWCS, 0, () => WorkerConfigurationSummary];
+var ConnectorConfiguration = [2, n0, _CC, 8, 0, 0];
+var ConnectorConfigurationUpdate = [2, n0, _CCU, 8, 0, 0];
+var CreateConnector = [
+    9,
+    n0,
+    _CCr,
+    {
+        [_h]: ["POST", "/v1/connectors", 200],
+    },
+    () => CreateConnectorRequest,
+    () => CreateConnectorResponse,
+];
+var CreateCustomPlugin = [
+    9,
+    n0,
+    _CCP,
+    {
+        [_h]: ["POST", "/v1/custom-plugins", 200],
+    },
+    () => CreateCustomPluginRequest,
+    () => CreateCustomPluginResponse,
+];
+var CreateWorkerConfiguration = [
+    9,
+    n0,
+    _CWC,
+    {
+        [_h]: ["POST", "/v1/worker-configurations", 200],
+    },
+    () => CreateWorkerConfigurationRequest,
+    () => CreateWorkerConfigurationResponse,
+];
+var DeleteConnector = [
+    9,
+    n0,
+    _DC,
+    {
+        [_h]: ["DELETE", "/v1/connectors/{connectorArn}", 200],
+    },
+    () => DeleteConnectorRequest,
+    () => DeleteConnectorResponse,
+];
+var DeleteCustomPlugin = [
+    9,
+    n0,
+    _DCP,
+    {
+        [_h]: ["DELETE", "/v1/custom-plugins/{customPluginArn}", 200],
+    },
+    () => DeleteCustomPluginRequest,
+    () => DeleteCustomPluginResponse,
+];
+var DeleteWorkerConfiguration = [
+    9,
+    n0,
+    _DWC,
+    {
+        [_h]: ["DELETE", "/v1/worker-configurations/{workerConfigurationArn}", 200],
+    },
+    () => DeleteWorkerConfigurationRequest,
+    () => DeleteWorkerConfigurationResponse,
+];
+var DescribeConnector = [
+    9,
+    n0,
+    _DCe,
+    {
+        [_h]: ["GET", "/v1/connectors/{connectorArn}", 200],
+    },
+    () => DescribeConnectorRequest,
+    () => DescribeConnectorResponse,
+];
+var DescribeConnectorOperation = [
+    9,
+    n0,
+    _DCO,
+    {
+        [_h]: ["GET", "/v1/connectorOperations/{connectorOperationArn}", 200],
+    },
+    () => DescribeConnectorOperationRequest,
+    () => DescribeConnectorOperationResponse,
+];
+var DescribeCustomPlugin = [
+    9,
+    n0,
+    _DCPe,
+    {
+        [_h]: ["GET", "/v1/custom-plugins/{customPluginArn}", 200],
+    },
+    () => DescribeCustomPluginRequest,
+    () => DescribeCustomPluginResponse,
+];
+var DescribeWorkerConfiguration = [
+    9,
+    n0,
+    _DWCe,
+    {
+        [_h]: ["GET", "/v1/worker-configurations/{workerConfigurationArn}", 200],
+    },
+    () => DescribeWorkerConfigurationRequest,
+    () => DescribeWorkerConfigurationResponse,
+];
+var ListConnectorOperations = [
+    9,
+    n0,
+    _LCO,
+    {
+        [_h]: ["GET", "/v1/connectors/{connectorArn}/operations", 200],
+    },
+    () => ListConnectorOperationsRequest,
+    () => ListConnectorOperationsResponse,
+];
+var ListConnectors = [
+    9,
+    n0,
+    _LC,
+    {
+        [_h]: ["GET", "/v1/connectors", 200],
+    },
+    () => ListConnectorsRequest,
+    () => ListConnectorsResponse,
+];
+var ListCustomPlugins = [
+    9,
+    n0,
+    _LCP,
+    {
+        [_h]: ["GET", "/v1/custom-plugins", 200],
+    },
+    () => ListCustomPluginsRequest,
+    () => ListCustomPluginsResponse,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    {
+        [_h]: ["GET", "/v1/tags/{resourceArn}", 200],
+    },
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var ListWorkerConfigurations = [
+    9,
+    n0,
+    _LWC,
+    {
+        [_h]: ["GET", "/v1/worker-configurations", 200],
+    },
+    () => ListWorkerConfigurationsRequest,
+    () => ListWorkerConfigurationsResponse,
+];
+var TagResource = [
+    9,
+    n0,
+    _TR,
+    {
+        [_h]: ["POST", "/v1/tags/{resourceArn}", 200],
+    },
+    () => TagResourceRequest,
+    () => TagResourceResponse,
+];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    {
+        [_h]: ["DELETE", "/v1/tags/{resourceArn}", 200],
+    },
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
+var UpdateConnector = [
+    9,
+    n0,
+    _UC,
+    {
+        [_h]: ["PUT", "/v1/connectors/{connectorArn}", 200],
+    },
+    () => UpdateConnectorRequest,
+    () => UpdateConnectorResponse,
+];
 
 class CreateConnectorCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KafkaConnect", "CreateConnector", {})
     .n("KafkaConnectClient", "CreateConnectorCommand")
-    .f(CreateConnectorRequestFilterSensitiveLog, void 0)
-    .ser(se_CreateConnectorCommand)
-    .de(de_CreateConnectorCommand)
+    .sc(CreateConnector)
     .build() {
 }
 
@@ -1118,16 +1303,11 @@ class CreateCustomPluginCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KafkaConnect", "CreateCustomPlugin", {})
     .n("KafkaConnectClient", "CreateCustomPluginCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateCustomPluginCommand)
-    .de(de_CreateCustomPluginCommand)
+    .sc(CreateCustomPlugin)
     .build() {
 }
 
@@ -1135,16 +1315,11 @@ class CreateWorkerConfigurationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KafkaConnect", "CreateWorkerConfiguration", {})
     .n("KafkaConnectClient", "CreateWorkerConfigurationCommand")
-    .f(CreateWorkerConfigurationRequestFilterSensitiveLog, void 0)
-    .ser(se_CreateWorkerConfigurationCommand)
-    .de(de_CreateWorkerConfigurationCommand)
+    .sc(CreateWorkerConfiguration)
     .build() {
 }
 
@@ -1152,16 +1327,11 @@ class DeleteConnectorCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KafkaConnect", "DeleteConnector", {})
     .n("KafkaConnectClient", "DeleteConnectorCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteConnectorCommand)
-    .de(de_DeleteConnectorCommand)
+    .sc(DeleteConnector)
     .build() {
 }
 
@@ -1169,16 +1339,11 @@ class DeleteCustomPluginCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KafkaConnect", "DeleteCustomPlugin", {})
     .n("KafkaConnectClient", "DeleteCustomPluginCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteCustomPluginCommand)
-    .de(de_DeleteCustomPluginCommand)
+    .sc(DeleteCustomPlugin)
     .build() {
 }
 
@@ -1186,16 +1351,11 @@ class DeleteWorkerConfigurationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KafkaConnect", "DeleteWorkerConfiguration", {})
     .n("KafkaConnectClient", "DeleteWorkerConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteWorkerConfigurationCommand)
-    .de(de_DeleteWorkerConfigurationCommand)
+    .sc(DeleteWorkerConfiguration)
     .build() {
 }
 
@@ -1203,16 +1363,11 @@ class DescribeConnectorCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KafkaConnect", "DescribeConnector", {})
     .n("KafkaConnectClient", "DescribeConnectorCommand")
-    .f(void 0, DescribeConnectorResponseFilterSensitiveLog)
-    .ser(se_DescribeConnectorCommand)
-    .de(de_DescribeConnectorCommand)
+    .sc(DescribeConnector)
     .build() {
 }
 
@@ -1220,16 +1375,11 @@ class DescribeConnectorOperationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KafkaConnect", "DescribeConnectorOperation", {})
     .n("KafkaConnectClient", "DescribeConnectorOperationCommand")
-    .f(void 0, DescribeConnectorOperationResponseFilterSensitiveLog)
-    .ser(se_DescribeConnectorOperationCommand)
-    .de(de_DescribeConnectorOperationCommand)
+    .sc(DescribeConnectorOperation)
     .build() {
 }
 
@@ -1237,16 +1387,11 @@ class DescribeCustomPluginCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KafkaConnect", "DescribeCustomPlugin", {})
     .n("KafkaConnectClient", "DescribeCustomPluginCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeCustomPluginCommand)
-    .de(de_DescribeCustomPluginCommand)
+    .sc(DescribeCustomPlugin)
     .build() {
 }
 
@@ -1254,16 +1399,11 @@ class DescribeWorkerConfigurationCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KafkaConnect", "DescribeWorkerConfiguration", {})
     .n("KafkaConnectClient", "DescribeWorkerConfigurationCommand")
-    .f(void 0, DescribeWorkerConfigurationResponseFilterSensitiveLog)
-    .ser(se_DescribeWorkerConfigurationCommand)
-    .de(de_DescribeWorkerConfigurationCommand)
+    .sc(DescribeWorkerConfiguration)
     .build() {
 }
 
@@ -1271,16 +1411,11 @@ class ListConnectorOperationsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KafkaConnect", "ListConnectorOperations", {})
     .n("KafkaConnectClient", "ListConnectorOperationsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListConnectorOperationsCommand)
-    .de(de_ListConnectorOperationsCommand)
+    .sc(ListConnectorOperations)
     .build() {
 }
 
@@ -1288,16 +1423,11 @@ class ListConnectorsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KafkaConnect", "ListConnectors", {})
     .n("KafkaConnectClient", "ListConnectorsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListConnectorsCommand)
-    .de(de_ListConnectorsCommand)
+    .sc(ListConnectors)
     .build() {
 }
 
@@ -1305,16 +1435,11 @@ class ListCustomPluginsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KafkaConnect", "ListCustomPlugins", {})
     .n("KafkaConnectClient", "ListCustomPluginsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListCustomPluginsCommand)
-    .de(de_ListCustomPluginsCommand)
+    .sc(ListCustomPlugins)
     .build() {
 }
 
@@ -1322,16 +1447,11 @@ class ListTagsForResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KafkaConnect", "ListTagsForResource", {})
     .n("KafkaConnectClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -1339,16 +1459,11 @@ class ListWorkerConfigurationsCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KafkaConnect", "ListWorkerConfigurations", {})
     .n("KafkaConnectClient", "ListWorkerConfigurationsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListWorkerConfigurationsCommand)
-    .de(de_ListWorkerConfigurationsCommand)
+    .sc(ListWorkerConfigurations)
     .build() {
 }
 
@@ -1356,16 +1471,11 @@ class TagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KafkaConnect", "TagResource", {})
     .n("KafkaConnectClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -1373,16 +1483,11 @@ class UntagResourceCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KafkaConnect", "UntagResource", {})
     .n("KafkaConnectClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -1390,16 +1495,11 @@ class UpdateConnectorCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("KafkaConnect", "UpdateConnector", {})
     .n("KafkaConnectClient", "UpdateConnectorCommand")
-    .f(UpdateConnectorRequestFilterSensitiveLog, void 0)
-    .ser(se_UpdateConnectorCommand)
-    .de(de_UpdateConnectorCommand)
+    .sc(UpdateConnector)
     .build() {
 }
 
@@ -1443,18 +1543,16 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.BadRequestException = BadRequestException;
-exports.ConflictException = ConflictException;
+exports.BadRequestException = BadRequestException$1;
+exports.ConflictException = ConflictException$1;
 exports.ConnectorOperationState = ConnectorOperationState;
 exports.ConnectorOperationStepState = ConnectorOperationStepState;
 exports.ConnectorOperationStepType = ConnectorOperationStepType;
 exports.ConnectorOperationType = ConnectorOperationType;
 exports.ConnectorState = ConnectorState;
 exports.CreateConnectorCommand = CreateConnectorCommand;
-exports.CreateConnectorRequestFilterSensitiveLog = CreateConnectorRequestFilterSensitiveLog;
 exports.CreateCustomPluginCommand = CreateCustomPluginCommand;
 exports.CreateWorkerConfigurationCommand = CreateWorkerConfigurationCommand;
-exports.CreateWorkerConfigurationRequestFilterSensitiveLog = CreateWorkerConfigurationRequestFilterSensitiveLog;
 exports.CustomPluginContentType = CustomPluginContentType;
 exports.CustomPluginState = CustomPluginState;
 exports.DeleteConnectorCommand = DeleteConnectorCommand;
@@ -1462,32 +1560,27 @@ exports.DeleteCustomPluginCommand = DeleteCustomPluginCommand;
 exports.DeleteWorkerConfigurationCommand = DeleteWorkerConfigurationCommand;
 exports.DescribeConnectorCommand = DescribeConnectorCommand;
 exports.DescribeConnectorOperationCommand = DescribeConnectorOperationCommand;
-exports.DescribeConnectorOperationResponseFilterSensitiveLog = DescribeConnectorOperationResponseFilterSensitiveLog;
-exports.DescribeConnectorResponseFilterSensitiveLog = DescribeConnectorResponseFilterSensitiveLog;
 exports.DescribeCustomPluginCommand = DescribeCustomPluginCommand;
 exports.DescribeWorkerConfigurationCommand = DescribeWorkerConfigurationCommand;
-exports.DescribeWorkerConfigurationResponseFilterSensitiveLog = DescribeWorkerConfigurationResponseFilterSensitiveLog;
-exports.ForbiddenException = ForbiddenException;
-exports.InternalServerErrorException = InternalServerErrorException;
+exports.ForbiddenException = ForbiddenException$1;
+exports.InternalServerErrorException = InternalServerErrorException$1;
 exports.KafkaClusterClientAuthenticationType = KafkaClusterClientAuthenticationType;
 exports.KafkaClusterEncryptionInTransitType = KafkaClusterEncryptionInTransitType;
 exports.KafkaConnect = KafkaConnect;
 exports.KafkaConnectClient = KafkaConnectClient;
-exports.KafkaConnectServiceException = KafkaConnectServiceException;
+exports.KafkaConnectServiceException = KafkaConnectServiceException$1;
 exports.ListConnectorOperationsCommand = ListConnectorOperationsCommand;
 exports.ListConnectorsCommand = ListConnectorsCommand;
 exports.ListCustomPluginsCommand = ListCustomPluginsCommand;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
 exports.ListWorkerConfigurationsCommand = ListWorkerConfigurationsCommand;
-exports.NotFoundException = NotFoundException;
-exports.ServiceUnavailableException = ServiceUnavailableException;
+exports.NotFoundException = NotFoundException$1;
+exports.ServiceUnavailableException = ServiceUnavailableException$1;
 exports.TagResourceCommand = TagResourceCommand;
-exports.TooManyRequestsException = TooManyRequestsException;
-exports.UnauthorizedException = UnauthorizedException;
+exports.TooManyRequestsException = TooManyRequestsException$1;
+exports.UnauthorizedException = UnauthorizedException$1;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateConnectorCommand = UpdateConnectorCommand;
-exports.UpdateConnectorRequestFilterSensitiveLog = UpdateConnectorRequestFilterSensitiveLog;
-exports.WorkerConfigurationRevisionDescriptionFilterSensitiveLog = WorkerConfigurationRevisionDescriptionFilterSensitiveLog;
 exports.WorkerConfigurationState = WorkerConfigurationState;
 exports.paginateListConnectorOperations = paginateListConnectorOperations;
 exports.paginateListConnectors = paginateListConnectors;