@aws-sdk/client-chime-sdk-media-pipelines 3.145.0 → 3.154.0

package/dist-es/ChimeSDKMediaPipelines.js

@@ -1,9 +1,14 @@
 import { __extends } from "tslib";
 import { ChimeSDKMediaPipelinesClient } from "./ChimeSDKMediaPipelinesClient";
 import { CreateMediaCapturePipelineCommand, } from "./commands/CreateMediaCapturePipelineCommand";
+import { CreateMediaConcatenationPipelineCommand, } from "./commands/CreateMediaConcatenationPipelineCommand";
+import { CreateMediaLiveConnectorPipelineCommand, } from "./commands/CreateMediaLiveConnectorPipelineCommand";
 import { DeleteMediaCapturePipelineCommand, } from "./commands/DeleteMediaCapturePipelineCommand";
+import { DeleteMediaPipelineCommand, } from "./commands/DeleteMediaPipelineCommand";
 import { GetMediaCapturePipelineCommand, } from "./commands/GetMediaCapturePipelineCommand";
+import { GetMediaPipelineCommand, } from "./commands/GetMediaPipelineCommand";
 import { ListMediaCapturePipelinesCommand, } from "./commands/ListMediaCapturePipelinesCommand";
+import { ListMediaPipelinesCommand, } from "./commands/ListMediaPipelinesCommand";
 import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceCommand";
 import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
@@ -26,6 +31,34 @@ var ChimeSDKMediaPipelines = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    ChimeSDKMediaPipelines.prototype.createMediaConcatenationPipeline = function (args, optionsOrCb, cb) {
+        var command = new CreateMediaConcatenationPipelineCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    ChimeSDKMediaPipelines.prototype.createMediaLiveConnectorPipeline = function (args, optionsOrCb, cb) {
+        var command = new CreateMediaLiveConnectorPipelineCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     ChimeSDKMediaPipelines.prototype.deleteMediaCapturePipeline = function (args, optionsOrCb, cb) {
         var command = new DeleteMediaCapturePipelineCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -40,6 +73,20 @@ var ChimeSDKMediaPipelines = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    ChimeSDKMediaPipelines.prototype.deleteMediaPipeline = function (args, optionsOrCb, cb) {
+        var command = new DeleteMediaPipelineCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     ChimeSDKMediaPipelines.prototype.getMediaCapturePipeline = function (args, optionsOrCb, cb) {
         var command = new GetMediaCapturePipelineCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -54,6 +101,20 @@ var ChimeSDKMediaPipelines = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    ChimeSDKMediaPipelines.prototype.getMediaPipeline = function (args, optionsOrCb, cb) {
+        var command = new GetMediaPipelineCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     ChimeSDKMediaPipelines.prototype.listMediaCapturePipelines = function (args, optionsOrCb, cb) {
         var command = new ListMediaCapturePipelinesCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -68,6 +129,20 @@ var ChimeSDKMediaPipelines = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    ChimeSDKMediaPipelines.prototype.listMediaPipelines = function (args, optionsOrCb, cb) {
+        var command = new ListMediaPipelinesCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     ChimeSDKMediaPipelines.prototype.listTagsForResource = function (args, optionsOrCb, cb) {
         var command = new ListTagsForResourceCommand(args);
         if (typeof optionsOrCb === "function") {

package/dist-es/commands/CreateMediaConcatenationPipelineCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateMediaConcatenationPipelineRequestFilterSensitiveLog, CreateMediaConcatenationPipelineResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1CreateMediaConcatenationPipelineCommand, serializeAws_restJson1CreateMediaConcatenationPipelineCommand, } from "../protocols/Aws_restJson1";
+var CreateMediaConcatenationPipelineCommand = (function (_super) {
+    __extends(CreateMediaConcatenationPipelineCommand, _super);
+    function CreateMediaConcatenationPipelineCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateMediaConcatenationPipelineCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeSDKMediaPipelinesClient";
+        var commandName = "CreateMediaConcatenationPipelineCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateMediaConcatenationPipelineRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateMediaConcatenationPipelineResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateMediaConcatenationPipelineCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateMediaConcatenationPipelineCommand(input, context);
+    };
+    CreateMediaConcatenationPipelineCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateMediaConcatenationPipelineCommand(output, context);
+    };
+    return CreateMediaConcatenationPipelineCommand;
+}($Command));
+export { CreateMediaConcatenationPipelineCommand };

package/dist-es/commands/CreateMediaLiveConnectorPipelineCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateMediaLiveConnectorPipelineRequestFilterSensitiveLog, CreateMediaLiveConnectorPipelineResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1CreateMediaLiveConnectorPipelineCommand, serializeAws_restJson1CreateMediaLiveConnectorPipelineCommand, } from "../protocols/Aws_restJson1";
+var CreateMediaLiveConnectorPipelineCommand = (function (_super) {
+    __extends(CreateMediaLiveConnectorPipelineCommand, _super);
+    function CreateMediaLiveConnectorPipelineCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateMediaLiveConnectorPipelineCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeSDKMediaPipelinesClient";
+        var commandName = "CreateMediaLiveConnectorPipelineCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateMediaLiveConnectorPipelineRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateMediaLiveConnectorPipelineResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateMediaLiveConnectorPipelineCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1CreateMediaLiveConnectorPipelineCommand(input, context);
+    };
+    CreateMediaLiveConnectorPipelineCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1CreateMediaLiveConnectorPipelineCommand(output, context);
+    };
+    return CreateMediaLiveConnectorPipelineCommand;
+}($Command));
+export { CreateMediaLiveConnectorPipelineCommand };

package/dist-es/commands/DeleteMediaPipelineCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteMediaPipelineRequestFilterSensitiveLog } from "../models/models_0";
+import { deserializeAws_restJson1DeleteMediaPipelineCommand, serializeAws_restJson1DeleteMediaPipelineCommand, } from "../protocols/Aws_restJson1";
+var DeleteMediaPipelineCommand = (function (_super) {
+    __extends(DeleteMediaPipelineCommand, _super);
+    function DeleteMediaPipelineCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteMediaPipelineCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeSDKMediaPipelinesClient";
+        var commandName = "DeleteMediaPipelineCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteMediaPipelineRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: function (output) { return output; },
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteMediaPipelineCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1DeleteMediaPipelineCommand(input, context);
+    };
+    DeleteMediaPipelineCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1DeleteMediaPipelineCommand(output, context);
+    };
+    return DeleteMediaPipelineCommand;
+}($Command));
+export { DeleteMediaPipelineCommand };

package/dist-es/commands/GetMediaPipelineCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetMediaPipelineRequestFilterSensitiveLog, GetMediaPipelineResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1GetMediaPipelineCommand, serializeAws_restJson1GetMediaPipelineCommand, } from "../protocols/Aws_restJson1";
+var GetMediaPipelineCommand = (function (_super) {
+    __extends(GetMediaPipelineCommand, _super);
+    function GetMediaPipelineCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetMediaPipelineCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeSDKMediaPipelinesClient";
+        var commandName = "GetMediaPipelineCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetMediaPipelineRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetMediaPipelineResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetMediaPipelineCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1GetMediaPipelineCommand(input, context);
+    };
+    GetMediaPipelineCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1GetMediaPipelineCommand(output, context);
+    };
+    return GetMediaPipelineCommand;
+}($Command));
+export { GetMediaPipelineCommand };

package/dist-es/commands/ListMediaPipelinesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListMediaPipelinesRequestFilterSensitiveLog, ListMediaPipelinesResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListMediaPipelinesCommand, serializeAws_restJson1ListMediaPipelinesCommand, } from "../protocols/Aws_restJson1";
+var ListMediaPipelinesCommand = (function (_super) {
+    __extends(ListMediaPipelinesCommand, _super);
+    function ListMediaPipelinesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListMediaPipelinesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ChimeSDKMediaPipelinesClient";
+        var commandName = "ListMediaPipelinesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListMediaPipelinesRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListMediaPipelinesResponseFilterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListMediaPipelinesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_restJson1ListMediaPipelinesCommand(input, context);
+    };
+    ListMediaPipelinesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_restJson1ListMediaPipelinesCommand(output, context);
+    };
+    return ListMediaPipelinesCommand;
+}($Command));
+export { ListMediaPipelinesCommand };

package/dist-es/commands/index.js

@@ -1,7 +1,12 @@
 export * from "./CreateMediaCapturePipelineCommand";
+export * from "./CreateMediaConcatenationPipelineCommand";
+export * from "./CreateMediaLiveConnectorPipelineCommand";
 export * from "./DeleteMediaCapturePipelineCommand";
+export * from "./DeleteMediaPipelineCommand";
 export * from "./GetMediaCapturePipelineCommand";
+export * from "./GetMediaPipelineCommand";
 export * from "./ListMediaCapturePipelinesCommand";
+export * from "./ListMediaPipelinesCommand";
 export * from "./ListTagsForResourceCommand";
 export * from "./TagResourceCommand";
 export * from "./UntagResourceCommand";

package/dist-es/models/models_0.js

@@ -1,11 +1,43 @@
 import { __assign, __extends } from "tslib";
 import { SENSITIVE_STRING } from "@aws-sdk/smithy-client";
 import { ChimeSDKMediaPipelinesServiceException as __BaseException } from "./ChimeSDKMediaPipelinesServiceException";
+export var AudioArtifactsConcatenationState;
+(function (AudioArtifactsConcatenationState) {
+    AudioArtifactsConcatenationState["Enabled"] = "Enabled";
+})(AudioArtifactsConcatenationState || (AudioArtifactsConcatenationState = {}));
+export var ArtifactsConcatenationState;
+(function (ArtifactsConcatenationState) {
+    ArtifactsConcatenationState["Disabled"] = "Disabled";
+    ArtifactsConcatenationState["Enabled"] = "Enabled";
+})(ArtifactsConcatenationState || (ArtifactsConcatenationState = {}));
 export var AudioMuxType;
 (function (AudioMuxType) {
     AudioMuxType["AudioOnly"] = "AudioOnly";
     AudioMuxType["AudioWithActiveSpeakerVideo"] = "AudioWithActiveSpeakerVideo";
+    AudioMuxType["AudioWithCompositedVideo"] = "AudioWithCompositedVideo";
 })(AudioMuxType || (AudioMuxType = {}));
+export var ContentShareLayoutOption;
+(function (ContentShareLayoutOption) {
+    ContentShareLayoutOption["Horizontal"] = "Horizontal";
+    ContentShareLayoutOption["PresenterOnly"] = "PresenterOnly";
+    ContentShareLayoutOption["Vertical"] = "Vertical";
+})(ContentShareLayoutOption || (ContentShareLayoutOption = {}));
+export var PresenterPosition;
+(function (PresenterPosition) {
+    PresenterPosition["BottomLeft"] = "BottomLeft";
+    PresenterPosition["BottomRight"] = "BottomRight";
+    PresenterPosition["TopLeft"] = "TopLeft";
+    PresenterPosition["TopRight"] = "TopRight";
+})(PresenterPosition || (PresenterPosition = {}));
+export var LayoutOption;
+(function (LayoutOption) {
+    LayoutOption["GridView"] = "GridView";
+})(LayoutOption || (LayoutOption = {}));
+export var ResolutionOption;
+(function (ResolutionOption) {
+    ResolutionOption["FHD"] = "FHD";
+    ResolutionOption["HD"] = "HD";
+})(ResolutionOption || (ResolutionOption = {}));
 export var ContentMuxType;
 (function (ContentMuxType) {
     ContentMuxType["ContentOnly"] = "ContentOnly";
@@ -19,6 +51,11 @@ export var VideoMuxType;
 (function (VideoMuxType) {
     VideoMuxType["VideoOnly"] = "VideoOnly";
 })(VideoMuxType || (VideoMuxType = {}));
+export var AudioChannelsOption;
+(function (AudioChannelsOption) {
+    AudioChannelsOption["Mono"] = "Mono";
+    AudioChannelsOption["Stereo"] = "Stereo";
+})(AudioChannelsOption || (AudioChannelsOption = {}));
 export var ErrorCode;
 (function (ErrorCode) {
     ErrorCode["BadRequest"] = "BadRequest";
@@ -150,6 +187,27 @@ var UnauthorizedClientException = (function (_super) {
     return UnauthorizedClientException;
 }(__BaseException));
 export { UnauthorizedClientException };
+export var ConcatenationSinkType;
+(function (ConcatenationSinkType) {
+    ConcatenationSinkType["S3Bucket"] = "S3Bucket";
+})(ConcatenationSinkType || (ConcatenationSinkType = {}));
+export var ConcatenationSourceType;
+(function (ConcatenationSourceType) {
+    ConcatenationSourceType["MediaCapturePipeline"] = "MediaCapturePipeline";
+})(ConcatenationSourceType || (ConcatenationSourceType = {}));
+export var LiveConnectorSinkType;
+(function (LiveConnectorSinkType) {
+    LiveConnectorSinkType["RTMP"] = "RTMP";
+})(LiveConnectorSinkType || (LiveConnectorSinkType = {}));
+export var LiveConnectorMuxType;
+(function (LiveConnectorMuxType) {
+    LiveConnectorMuxType["AudioWithActiveSpeakerVideo"] = "AudioWithActiveSpeakerVideo";
+    LiveConnectorMuxType["AudioWithCompositedVideo"] = "AudioWithCompositedVideo";
+})(LiveConnectorMuxType || (LiveConnectorMuxType = {}));
+export var LiveConnectorSourceType;
+(function (LiveConnectorSourceType) {
+    LiveConnectorSourceType["ChimeSdkMeeting"] = "ChimeSdkMeeting";
+})(LiveConnectorSourceType || (LiveConnectorSourceType = {}));
 var NotFoundException = (function (_super) {
     __extends(NotFoundException, _super);
     function NotFoundException(opts) {
@@ -165,7 +223,18 @@ var NotFoundException = (function (_super) {
     return NotFoundException;
 }(__BaseException));
 export { NotFoundException };
+export var AudioConcatenationConfigurationFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var CompositedVideoConcatenationConfigurationFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var ContentConcatenationConfigurationFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var DataChannelConcatenationConfigurationFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var MeetingEventsConcatenationConfigurationFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var TranscriptionMessagesConcatenationConfigurationFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var VideoConcatenationConfigurationFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var ArtifactsConcatenationConfigurationFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 export var AudioArtifactsConfigurationFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var PresenterOnlyConfigurationFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var GridViewConfigurationFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var CompositedVideoArtifactsConfigurationFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 export var ContentArtifactsConfigurationFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 export var VideoArtifactsConfigurationFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 export var ArtifactsConfigurationFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -186,14 +255,56 @@ export var MediaCapturePipelineFilterSensitiveLog = function (obj) { return (__a
 export var CreateMediaCapturePipelineResponseFilterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.MediaCapturePipeline && {
     MediaCapturePipeline: MediaCapturePipelineFilterSensitiveLog(obj.MediaCapturePipeline),
 }))); };
+export var S3BucketSinkConfigurationFilterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.Destination && { Destination: SENSITIVE_STRING }))); };
+export var ConcatenationSinkFilterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.S3BucketSinkConfiguration && {
+    S3BucketSinkConfiguration: S3BucketSinkConfigurationFilterSensitiveLog(obj.S3BucketSinkConfiguration),
+}))); };
+export var ChimeSdkMeetingConcatenationConfigurationFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var MediaCapturePipelineSourceConfigurationFilterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.MediaPipelineArn && { MediaPipelineArn: SENSITIVE_STRING }))); };
+export var ConcatenationSourceFilterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.MediaCapturePipelineSourceConfiguration && {
+    MediaCapturePipelineSourceConfiguration: MediaCapturePipelineSourceConfigurationFilterSensitiveLog(obj.MediaCapturePipelineSourceConfiguration),
+}))); };
+export var CreateMediaConcatenationPipelineRequestFilterSensitiveLog = function (obj) { return (__assign(__assign(__assign(__assign({}, obj), (obj.Sources && { Sources: obj.Sources.map(function (item) { return ConcatenationSourceFilterSensitiveLog(item); }) })), (obj.Sinks && { Sinks: obj.Sinks.map(function (item) { return ConcatenationSinkFilterSensitiveLog(item); }) })), (obj.ClientRequestToken && { ClientRequestToken: SENSITIVE_STRING }))); };
+export var MediaConcatenationPipelineFilterSensitiveLog = function (obj) { return (__assign(__assign(__assign({}, obj), (obj.Sources && { Sources: obj.Sources.map(function (item) { return ConcatenationSourceFilterSensitiveLog(item); }) })), (obj.Sinks && { Sinks: obj.Sinks.map(function (item) { return ConcatenationSinkFilterSensitiveLog(item); }) }))); };
+export var CreateMediaConcatenationPipelineResponseFilterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.MediaConcatenationPipeline && {
+    MediaConcatenationPipeline: MediaConcatenationPipelineFilterSensitiveLog(obj.MediaConcatenationPipeline),
+}))); };
+export var LiveConnectorRTMPConfigurationFilterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.Url && { Url: SENSITIVE_STRING }))); };
+export var LiveConnectorSinkConfigurationFilterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.RTMPConfiguration && {
+    RTMPConfiguration: LiveConnectorRTMPConfigurationFilterSensitiveLog(obj.RTMPConfiguration),
+}))); };
+export var ChimeSdkMeetingLiveConnectorConfigurationFilterSensitiveLog = function (obj) { return (__assign(__assign(__assign({}, obj), (obj.Arn && { Arn: SENSITIVE_STRING })), (obj.SourceConfiguration && {
+    SourceConfiguration: SourceConfigurationFilterSensitiveLog(obj.SourceConfiguration),
+}))); };
+export var LiveConnectorSourceConfigurationFilterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.ChimeSdkMeetingLiveConnectorConfiguration && {
+    ChimeSdkMeetingLiveConnectorConfiguration: ChimeSdkMeetingLiveConnectorConfigurationFilterSensitiveLog(obj.ChimeSdkMeetingLiveConnectorConfiguration),
+}))); };
+export var CreateMediaLiveConnectorPipelineRequestFilterSensitiveLog = function (obj) { return (__assign(__assign(__assign(__assign({}, obj), (obj.Sources && { Sources: obj.Sources.map(function (item) { return LiveConnectorSourceConfigurationFilterSensitiveLog(item); }) })), (obj.Sinks && { Sinks: obj.Sinks.map(function (item) { return LiveConnectorSinkConfigurationFilterSensitiveLog(item); }) })), (obj.ClientRequestToken && { ClientRequestToken: SENSITIVE_STRING }))); };
+export var MediaLiveConnectorPipelineFilterSensitiveLog = function (obj) { return (__assign(__assign(__assign({}, obj), (obj.Sources && { Sources: obj.Sources.map(function (item) { return LiveConnectorSourceConfigurationFilterSensitiveLog(item); }) })), (obj.Sinks && { Sinks: obj.Sinks.map(function (item) { return LiveConnectorSinkConfigurationFilterSensitiveLog(item); }) }))); };
+export var CreateMediaLiveConnectorPipelineResponseFilterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.MediaLiveConnectorPipeline && {
+    MediaLiveConnectorPipeline: MediaLiveConnectorPipelineFilterSensitiveLog(obj.MediaLiveConnectorPipeline),
+}))); };
 export var DeleteMediaCapturePipelineRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var DeleteMediaPipelineRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 export var GetMediaCapturePipelineRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 export var GetMediaCapturePipelineResponseFilterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.MediaCapturePipeline && {
     MediaCapturePipeline: MediaCapturePipelineFilterSensitiveLog(obj.MediaCapturePipeline),
 }))); };
+export var GetMediaPipelineRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var MediaPipelineFilterSensitiveLog = function (obj) { return (__assign(__assign(__assign(__assign({}, obj), (obj.MediaCapturePipeline && {
+    MediaCapturePipeline: MediaCapturePipelineFilterSensitiveLog(obj.MediaCapturePipeline),
+})), (obj.MediaLiveConnectorPipeline && {
+    MediaLiveConnectorPipeline: MediaLiveConnectorPipelineFilterSensitiveLog(obj.MediaLiveConnectorPipeline),
+})), (obj.MediaConcatenationPipeline && {
+    MediaConcatenationPipeline: MediaConcatenationPipelineFilterSensitiveLog(obj.MediaConcatenationPipeline),
+}))); };
+export var GetMediaPipelineResponseFilterSensitiveLog = function (obj) { return (__assign(__assign({}, obj), (obj.MediaPipeline && { MediaPipeline: MediaPipelineFilterSensitiveLog(obj.MediaPipeline) }))); };
 export var ListMediaCapturePipelinesRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 export var MediaCapturePipelineSummaryFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 export var ListMediaCapturePipelinesResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var ListMediaPipelinesRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var MediaPipelineSummaryFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+export var ListMediaPipelinesResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 export var ListTagsForResourceRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 export var ListTagsForResourceResponseFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 export var TagResourceRequestFilterSensitiveLog = function (obj) { return (__assign({}, obj)); };

package/dist-es/pagination/ListMediaPipelinesPaginator.js

@@ -0,0 +1,75 @@
+import { __asyncGenerator, __await, __awaiter, __generator, __read, __spreadArray } from "tslib";
+import { ChimeSDKMediaPipelines } from "../ChimeSDKMediaPipelines";
+import { ChimeSDKMediaPipelinesClient } from "../ChimeSDKMediaPipelinesClient";
+import { ListMediaPipelinesCommand, } from "../commands/ListMediaPipelinesCommand";
+var makePagedClientRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.send.apply(client, __spreadArray([new ListMediaPipelinesCommand(input)], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+var makePagedRequest = function (client, input) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4, client.listMediaPipelines.apply(client, __spreadArray([input], __read(args), false))];
+                case 1: return [2, _a.sent()];
+            }
+        });
+    });
+};
+export function paginateListMediaPipelines(config, input) {
+    var additionalArguments = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        additionalArguments[_i - 2] = arguments[_i];
+    }
+    return __asyncGenerator(this, arguments, function paginateListMediaPipelines_1() {
+        var token, hasNext, page, prevToken;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    token = config.startingToken || undefined;
+                    hasNext = true;
+                    _a.label = 1;
+                case 1:
+                    if (!hasNext) return [3, 9];
+                    input.NextToken = token;
+                    input["MaxResults"] = config.pageSize;
+                    if (!(config.client instanceof ChimeSDKMediaPipelines)) return [3, 3];
+                    return [4, __await(makePagedRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 2:
+                    page = _a.sent();
+                    return [3, 6];
+                case 3:
+                    if (!(config.client instanceof ChimeSDKMediaPipelinesClient)) return [3, 5];
+                    return [4, __await(makePagedClientRequest.apply(void 0, __spreadArray([config.client, input], __read(additionalArguments), false)))];
+                case 4:
+                    page = _a.sent();
+                    return [3, 6];
+                case 5: throw new Error("Invalid client, expected ChimeSDKMediaPipelines | ChimeSDKMediaPipelinesClient");
+                case 6: return [4, __await(page)];
+                case 7: return [4, _a.sent()];
+                case 8:
+                    _a.sent();
+                    prevToken = token;
+                    token = page.NextToken;
+                    hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+                    return [3, 1];
+                case 9: return [4, __await(undefined)];
+                case 10: return [2, _a.sent()];
+            }
+        });
+    });
+}

package/dist-es/pagination/index.js

@@ -1,2 +1,3 @@
 export * from "./Interfaces";
 export * from "./ListMediaCapturePipelinesPaginator";
+export * from "./ListMediaPipelinesPaginator";