@aws-sdk/client-kafka 3.428.0 → 3.430.0

package/dist-es/protocols/Aws_restJson1.js

@@ -121,6 +121,31 @@ export const se_CreateConfigurationCommand = async (input, context) => {
         body,
     });
 };
+export const se_CreateReplicatorCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/replication/v1/replicators";
+    let body;
+    body = JSON.stringify(take(input, {
+        description: [, , `Description`],
+        kafkaClusters: [, (_) => se___listOfKafkaCluster(_, context), `KafkaClusters`],
+        replicationInfoList: [, (_) => se___listOfReplicationInfo(_, context), `ReplicationInfoList`],
+        replicatorName: [, , `ReplicatorName`],
+        serviceExecutionRoleArn: [, , `ServiceExecutionRoleArn`],
+        tags: [, (_) => _json(_), `Tags`],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_CreateVpcConnectionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -198,6 +223,27 @@ export const se_DeleteConfigurationCommand = async (input, context) => {
         body,
     });
 };
+export const se_DeleteReplicatorCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/replication/v1/replicators/{ReplicatorArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "ReplicatorArn", () => input.ReplicatorArn, "{ReplicatorArn}", false);
+    const query = map({
+        currentVersion: [, input.CurrentVersion],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const se_DeleteVpcConnectionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -312,6 +358,23 @@ export const se_DescribeConfigurationRevisionCommand = async (input, context) =>
         body,
     });
 };
+export const se_DescribeReplicatorCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/replication/v1/replicators/{ReplicatorArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "ReplicatorArn", () => input.ReplicatorArn, "{ReplicatorArn}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_DescribeVpcConnectionCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -569,6 +632,27 @@ export const se_ListNodesCommand = async (input, context) => {
         body,
     });
 };
+export const se_ListReplicatorsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/replication/v1/replicators";
+    const query = map({
+        maxResults: [() => input.MaxResults !== void 0, () => input.MaxResults.toString()],
+        nextToken: [, input.NextToken],
+        replicatorNameFilter: [, input.ReplicatorNameFilter],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
 export const se_ListScramSecretsCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -914,6 +998,32 @@ export const se_UpdateMonitoringCommand = async (input, context) => {
         body,
     });
 };
+export const se_UpdateReplicationInfoCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/replication/v1/replicators/{ReplicatorArn}/replication-info";
+    resolvedPath = __resolvedPath(resolvedPath, input, "ReplicatorArn", () => input.ReplicatorArn, "{ReplicatorArn}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        consumerGroupReplication: [, (_) => se_ConsumerGroupReplicationUpdate(_, context), `ConsumerGroupReplication`],
+        currentVersion: [, , `CurrentVersion`],
+        sourceKafkaClusterArn: [, , `SourceKafkaClusterArn`],
+        targetKafkaClusterArn: [, , `TargetKafkaClusterArn`],
+        topicReplication: [, (_) => se_TopicReplicationUpdate(_, context), `TopicReplication`],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_UpdateSecurityCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -1227,6 +1337,62 @@ const de_CreateConfigurationCommandError = async (output, context) => {
             });
     }
 };
+export const de_CreateReplicatorCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CreateReplicatorCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        ReplicatorArn: [, __expectString, `replicatorArn`],
+        ReplicatorName: [, __expectString, `replicatorName`],
+        ReplicatorState: [, __expectString, `replicatorState`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_CreateReplicatorCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.kafka#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.kafka#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.kafka#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.kafka#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.kafka#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.kafka#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.kafka#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnauthorizedException":
+        case "com.amazonaws.kafka#UnauthorizedException":
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_CreateVpcConnectionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CreateVpcConnectionCommandError(output, context);
@@ -1406,6 +1572,58 @@ const de_DeleteConfigurationCommandError = async (output, context) => {
             });
     }
 };
+export const de_DeleteReplicatorCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DeleteReplicatorCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        ReplicatorArn: [, __expectString, `replicatorArn`],
+        ReplicatorState: [, __expectString, `replicatorState`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_DeleteReplicatorCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.kafka#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.kafka#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.kafka#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.kafka#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.kafka#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.kafka#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnauthorizedException":
+        case "com.amazonaws.kafka#UnauthorizedException":
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_DeleteVpcConnectionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_DeleteVpcConnectionCommandError(output, context);
@@ -1741,6 +1959,69 @@ const de_DescribeConfigurationRevisionCommandError = async (output, context) =>
             });
     }
 };
+export const de_DescribeReplicatorCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_DescribeReplicatorCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        CreationTime: [, (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `creationTime`],
+        CurrentVersion: [, __expectString, `currentVersion`],
+        IsReplicatorReference: [, __expectBoolean, `isReplicatorReference`],
+        KafkaClusters: [, (_) => de___listOfKafkaClusterDescription(_, context), `kafkaClusters`],
+        ReplicationInfoList: [, (_) => de___listOfReplicationInfoDescription(_, context), `replicationInfoList`],
+        ReplicatorArn: [, __expectString, `replicatorArn`],
+        ReplicatorDescription: [, __expectString, `replicatorDescription`],
+        ReplicatorName: [, __expectString, `replicatorName`],
+        ReplicatorResourceArn: [, __expectString, `replicatorResourceArn`],
+        ReplicatorState: [, __expectString, `replicatorState`],
+        ServiceExecutionRoleArn: [, __expectString, `serviceExecutionRoleArn`],
+        StateInfo: [, (_) => de_ReplicationStateInfo(_, context), `stateInfo`],
+        Tags: [, _json, `tags`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_DescribeReplicatorCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.kafka#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.kafka#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.kafka#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.kafka#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.kafka#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.kafka#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnauthorizedException":
+        case "com.amazonaws.kafka#UnauthorizedException":
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_DescribeVpcConnectionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_DescribeVpcConnectionCommandError(output, context);
@@ -2353,6 +2634,58 @@ const de_ListNodesCommandError = async (output, context) => {
             });
     }
 };
+export const de_ListReplicatorsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListReplicatorsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        NextToken: [, __expectString, `nextToken`],
+        Replicators: [, (_) => de___listOfReplicatorSummary(_, context), `replicators`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListReplicatorsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.kafka#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.kafka#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.kafka#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.kafka#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.kafka#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.kafka#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnauthorizedException":
+        case "com.amazonaws.kafka#UnauthorizedException":
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_ListScramSecretsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_ListScramSecretsCommandError(output, context);
@@ -3081,6 +3414,58 @@ const de_UpdateMonitoringCommandError = async (output, context) => {
             });
     }
 };
+export const de_UpdateReplicationInfoCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_UpdateReplicationInfoCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        ReplicatorArn: [, __expectString, `replicatorArn`],
+        ReplicatorState: [, __expectString, `replicatorState`],
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_UpdateReplicationInfoCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "BadRequestException":
+        case "com.amazonaws.kafka#BadRequestException":
+            throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "ForbiddenException":
+        case "com.amazonaws.kafka#ForbiddenException":
+            throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.kafka#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "NotFoundException":
+        case "com.amazonaws.kafka#NotFoundException":
+            throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "ServiceUnavailableException":
+        case "com.amazonaws.kafka#ServiceUnavailableException":
+            throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+        case "TooManyRequestsException":
+        case "com.amazonaws.kafka#TooManyRequestsException":
+            throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+        case "UnauthorizedException":
+        case "com.amazonaws.kafka#UnauthorizedException":
+            throw await de_UnauthorizedExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_UpdateSecurityCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_UpdateSecurityCommandError(output, context);
@@ -3305,6 +3690,20 @@ const se___listOfBrokerEBSVolumeInfo = (input, context) => {
         return se_BrokerEBSVolumeInfo(entry, context);
     });
 };
+const se___listOfKafkaCluster = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_KafkaCluster(entry, context);
+    });
+};
+const se___listOfReplicationInfo = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_ReplicationInfo(entry, context);
+    });
+};
 const se___listOfVpcConfig = (input, context) => {
     return input
         .filter((e) => e != null)
@@ -3312,6 +3711,11 @@ const se___listOfVpcConfig = (input, context) => {
         return se_VpcConfig(entry, context);
     });
 };
+const se_AmazonMskCluster = (input, context) => {
+    return take(input, {
+        mskClusterArn: [, , `MskClusterArn`],
+    });
+};
 const se_BrokerEBSVolumeInfo = (input, context) => {
     return take(input, {
         kafkaBrokerNodeId: [, , `KafkaBrokerNodeId`],
@@ -3362,6 +3766,22 @@ const se_ConnectivityInfo = (input, context) => {
         vpcConnectivity: [, (_) => se_VpcConnectivity(_, context), `VpcConnectivity`],
     });
 };
+const se_ConsumerGroupReplication = (input, context) => {
+    return take(input, {
+        consumerGroupsToExclude: [, _json, `ConsumerGroupsToExclude`],
+        consumerGroupsToReplicate: [, _json, `ConsumerGroupsToReplicate`],
+        detectAndCopyNewConsumerGroups: [, , `DetectAndCopyNewConsumerGroups`],
+        synchroniseConsumerGroupOffsets: [, , `SynchroniseConsumerGroupOffsets`],
+    });
+};
+const se_ConsumerGroupReplicationUpdate = (input, context) => {
+    return take(input, {
+        consumerGroupsToExclude: [, _json, `ConsumerGroupsToExclude`],
+        consumerGroupsToReplicate: [, _json, `ConsumerGroupsToReplicate`],
+        detectAndCopyNewConsumerGroups: [, , `DetectAndCopyNewConsumerGroups`],
+        synchroniseConsumerGroupOffsets: [, , `SynchroniseConsumerGroupOffsets`],
+    });
+};
 const se_EBSStorageInfo = (input, context) => {
     return take(input, {
         provisionedThroughput: [, (_) => se_ProvisionedThroughput(_, context), `ProvisionedThroughput`],
@@ -3401,6 +3821,18 @@ const se_JmxExporterInfo = (input, context) => {
         enabledInBroker: [, , `EnabledInBroker`],
     });
 };
+const se_KafkaCluster = (input, context) => {
+    return take(input, {
+        amazonMskCluster: [, (_) => se_AmazonMskCluster(_, context), `AmazonMskCluster`],
+        vpcConfig: [, (_) => se_KafkaClusterClientVpcConfig(_, context), `VpcConfig`],
+    });
+};
+const se_KafkaClusterClientVpcConfig = (input, context) => {
+    return take(input, {
+        securityGroupIds: [, _json, `SecurityGroupIds`],
+        subnetIds: [, _json, `SubnetIds`],
+    });
+};
 const se_LoggingInfo = (input, context) => {
     return take(input, {
         brokerLogs: [, (_) => se_BrokerLogs(_, context), `BrokerLogs`],
@@ -3447,6 +3879,15 @@ const se_PublicAccess = (input, context) => {
         type: [, , `Type`],
     });
 };
+const se_ReplicationInfo = (input, context) => {
+    return take(input, {
+        consumerGroupReplication: [, (_) => se_ConsumerGroupReplication(_, context), `ConsumerGroupReplication`],
+        sourceKafkaClusterArn: [, , `SourceKafkaClusterArn`],
+        targetCompressionType: [, , `TargetCompressionType`],
+        targetKafkaClusterArn: [, , `TargetKafkaClusterArn`],
+        topicReplication: [, (_) => se_TopicReplication(_, context), `TopicReplication`],
+    });
+};
 const se_S3 = (input, context) => {
     return take(input, {
         bucket: [, , `Bucket`],
@@ -3492,6 +3933,24 @@ const se_Tls = (input, context) => {
         enabled: [, , `Enabled`],
     });
 };
+const se_TopicReplication = (input, context) => {
+    return take(input, {
+        copyAccessControlListsForTopics: [, , `CopyAccessControlListsForTopics`],
+        copyTopicConfigurations: [, , `CopyTopicConfigurations`],
+        detectAndCopyNewTopics: [, , `DetectAndCopyNewTopics`],
+        topicsToExclude: [, _json, `TopicsToExclude`],
+        topicsToReplicate: [, _json, `TopicsToReplicate`],
+    });
+};
+const se_TopicReplicationUpdate = (input, context) => {
+    return take(input, {
+        copyAccessControlListsForTopics: [, , `CopyAccessControlListsForTopics`],
+        copyTopicConfigurations: [, , `CopyTopicConfigurations`],
+        detectAndCopyNewTopics: [, , `DetectAndCopyNewTopics`],
+        topicsToExclude: [, _json, `TopicsToExclude`],
+        topicsToReplicate: [, _json, `TopicsToReplicate`],
+    });
+};
 const se_Unauthenticated = (input, context) => {
     return take(input, {
         enabled: [, , `Enabled`],
@@ -3615,6 +4074,22 @@ const de___listOfConfigurationRevision = (output, context) => {
     });
     return retVal;
 };
+const de___listOfKafkaClusterDescription = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_KafkaClusterDescription(entry, context);
+    });
+    return retVal;
+};
+const de___listOfKafkaClusterSummary = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_KafkaClusterSummary(entry, context);
+    });
+    return retVal;
+};
 const de___listOfKafkaVersion = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
@@ -3631,6 +4106,30 @@ const de___listOfNodeInfo = (output, context) => {
     });
     return retVal;
 };
+const de___listOfReplicationInfoDescription = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ReplicationInfoDescription(entry, context);
+    });
+    return retVal;
+};
+const de___listOfReplicationInfoSummary = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ReplicationInfoSummary(entry, context);
+    });
+    return retVal;
+};
+const de___listOfReplicatorSummary = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ReplicatorSummary(entry, context);
+    });
+    return retVal;
+};
 const de___listOfUnprocessedScramSecret = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
@@ -3655,6 +4154,11 @@ const de___listOfVpcConnection = (output, context) => {
     });
     return retVal;
 };
+const de_AmazonMskCluster = (output, context) => {
+    return take(output, {
+        MskClusterArn: [, __expectString, `mskClusterArn`],
+    });
+};
 const de_BrokerEBSVolumeInfo = (output, context) => {
     return take(output, {
         KafkaBrokerNodeId: [, __expectString, `kafkaBrokerNodeId`],
@@ -3858,6 +4362,14 @@ const de_ConnectivityInfo = (output, context) => {
         VpcConnectivity: [, (_) => de_VpcConnectivity(_, context), `vpcConnectivity`],
     });
 };
+const de_ConsumerGroupReplication = (output, context) => {
+    return take(output, {
+        ConsumerGroupsToExclude: [, _json, `consumerGroupsToExclude`],
+        ConsumerGroupsToReplicate: [, _json, `consumerGroupsToReplicate`],
+        DetectAndCopyNewConsumerGroups: [, __expectBoolean, `detectAndCopyNewConsumerGroups`],
+        SynchroniseConsumerGroupOffsets: [, __expectBoolean, `synchroniseConsumerGroupOffsets`],
+    });
+};
 const de_EBSStorageInfo = (output, context) => {
     return take(output, {
         ProvisionedThroughput: [, (_) => de_ProvisionedThroughput(_, context), `provisionedThroughput`],
@@ -3908,6 +4420,25 @@ const de_JmxExporterInfo = (output, context) => {
         EnabledInBroker: [, __expectBoolean, `enabledInBroker`],
     });
 };
+const de_KafkaClusterClientVpcConfig = (output, context) => {
+    return take(output, {
+        SecurityGroupIds: [, _json, `securityGroupIds`],
+        SubnetIds: [, _json, `subnetIds`],
+    });
+};
+const de_KafkaClusterDescription = (output, context) => {
+    return take(output, {
+        AmazonMskCluster: [, (_) => de_AmazonMskCluster(_, context), `amazonMskCluster`],
+        KafkaClusterAlias: [, __expectString, `kafkaClusterAlias`],
+        VpcConfig: [, (_) => de_KafkaClusterClientVpcConfig(_, context), `vpcConfig`],
+    });
+};
+const de_KafkaClusterSummary = (output, context) => {
+    return take(output, {
+        AmazonMskCluster: [, (_) => de_AmazonMskCluster(_, context), `amazonMskCluster`],
+        KafkaClusterAlias: [, __expectString, `kafkaClusterAlias`],
+    });
+};
 const de_KafkaVersion = (output, context) => {
     return take(output, {
         Status: [, __expectString, `status`],
@@ -4003,6 +4534,44 @@ const de_PublicAccess = (output, context) => {
         Type: [, __expectString, `type`],
     });
 };
+const de_ReplicationInfoDescription = (output, context) => {
+    return take(output, {
+        ConsumerGroupReplication: [, (_) => de_ConsumerGroupReplication(_, context), `consumerGroupReplication`],
+        SourceKafkaClusterAlias: [, __expectString, `sourceKafkaClusterAlias`],
+        TargetCompressionType: [, __expectString, `targetCompressionType`],
+        TargetKafkaClusterAlias: [, __expectString, `targetKafkaClusterAlias`],
+        TopicReplication: [, (_) => de_TopicReplication(_, context), `topicReplication`],
+    });
+};
+const de_ReplicationInfoSummary = (output, context) => {
+    return take(output, {
+        SourceKafkaClusterAlias: [, __expectString, `sourceKafkaClusterAlias`],
+        TargetKafkaClusterAlias: [, __expectString, `targetKafkaClusterAlias`],
+    });
+};
+const de_ReplicationStateInfo = (output, context) => {
+    return take(output, {
+        Code: [, __expectString, `code`],
+        Message: [, __expectString, `message`],
+    });
+};
+const de_ReplicatorSummary = (output, context) => {
+    return take(output, {
+        CreationTime: [, (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)), `creationTime`],
+        CurrentVersion: [, __expectString, `currentVersion`],
+        IsReplicatorReference: [, __expectBoolean, `isReplicatorReference`],
+        KafkaClustersSummary: [, (_) => de___listOfKafkaClusterSummary(_, context), `kafkaClustersSummary`],
+        ReplicationInfoSummaryList: [
+            ,
+            (_) => de___listOfReplicationInfoSummary(_, context),
+            `replicationInfoSummaryList`,
+        ],
+        ReplicatorArn: [, __expectString, `replicatorArn`],
+        ReplicatorName: [, __expectString, `replicatorName`],
+        ReplicatorResourceArn: [, __expectString, `replicatorResourceArn`],
+        ReplicatorState: [, __expectString, `replicatorState`],
+    });
+};
 const de_S3 = (output, context) => {
     return take(output, {
         Bucket: [, __expectString, `bucket`],
@@ -4054,6 +4623,15 @@ const de_Tls = (output, context) => {
         Enabled: [, __expectBoolean, `enabled`],
     });
 };
+const de_TopicReplication = (output, context) => {
+    return take(output, {
+        CopyAccessControlListsForTopics: [, __expectBoolean, `copyAccessControlListsForTopics`],
+        CopyTopicConfigurations: [, __expectBoolean, `copyTopicConfigurations`],
+        DetectAndCopyNewTopics: [, __expectBoolean, `detectAndCopyNewTopics`],
+        TopicsToExclude: [, _json, `topicsToExclude`],
+        TopicsToReplicate: [, _json, `topicsToReplicate`],
+    });
+};
 const de_Unauthenticated = (output, context) => {
     return take(output, {
         Enabled: [, __expectBoolean, `enabled`],