@aws-sdk/client-chime-sdk-media-pipelines 3.418.0 → 3.419.0

package/dist-es/commands/CreateMediaPipelineKinesisVideoStreamPoolCommand.js

@@ -0,0 +1,48 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { CreateMediaPipelineKinesisVideoStreamPoolRequestFilterSensitiveLog, CreateMediaPipelineKinesisVideoStreamPoolResponseFilterSensitiveLog, } from "../models/models_0";
+import { de_CreateMediaPipelineKinesisVideoStreamPoolCommand, se_CreateMediaPipelineKinesisVideoStreamPoolCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateMediaPipelineKinesisVideoStreamPoolCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateMediaPipelineKinesisVideoStreamPoolCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ChimeSDKMediaPipelinesClient";
+        const commandName = "CreateMediaPipelineKinesisVideoStreamPoolCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateMediaPipelineKinesisVideoStreamPoolRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateMediaPipelineKinesisVideoStreamPoolResponseFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "ChimeSDKMediaPipelinesService",
+                operation: "CreateMediaPipelineKinesisVideoStreamPool",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateMediaPipelineKinesisVideoStreamPoolCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateMediaPipelineKinesisVideoStreamPoolCommand(output, context);
+    }
+}

package/dist-es/commands/CreateMediaStreamPipelineCommand.js

@@ -0,0 +1,48 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { CreateMediaStreamPipelineRequestFilterSensitiveLog, CreateMediaStreamPipelineResponseFilterSensitiveLog, } from "../models/models_0";
+import { de_CreateMediaStreamPipelineCommand, se_CreateMediaStreamPipelineCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateMediaStreamPipelineCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateMediaStreamPipelineCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ChimeSDKMediaPipelinesClient";
+        const commandName = "CreateMediaStreamPipelineCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateMediaStreamPipelineRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateMediaStreamPipelineResponseFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "ChimeSDKMediaPipelinesService",
+                operation: "CreateMediaStreamPipeline",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateMediaStreamPipelineCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateMediaStreamPipelineCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteMediaPipelineKinesisVideoStreamPoolCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_DeleteMediaPipelineKinesisVideoStreamPoolCommand, se_DeleteMediaPipelineKinesisVideoStreamPoolCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class DeleteMediaPipelineKinesisVideoStreamPoolCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteMediaPipelineKinesisVideoStreamPoolCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ChimeSDKMediaPipelinesClient";
+        const commandName = "DeleteMediaPipelineKinesisVideoStreamPoolCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "ChimeSDKMediaPipelinesService",
+                operation: "DeleteMediaPipelineKinesisVideoStreamPool",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_DeleteMediaPipelineKinesisVideoStreamPoolCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_DeleteMediaPipelineKinesisVideoStreamPoolCommand(output, context);
+    }
+}

package/dist-es/commands/GetMediaPipelineKinesisVideoStreamPoolCommand.js

@@ -0,0 +1,48 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { GetMediaPipelineKinesisVideoStreamPoolResponseFilterSensitiveLog, } from "../models/models_0";
+import { de_GetMediaPipelineKinesisVideoStreamPoolCommand, se_GetMediaPipelineKinesisVideoStreamPoolCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class GetMediaPipelineKinesisVideoStreamPoolCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetMediaPipelineKinesisVideoStreamPoolCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ChimeSDKMediaPipelinesClient";
+        const commandName = "GetMediaPipelineKinesisVideoStreamPoolCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: GetMediaPipelineKinesisVideoStreamPoolResponseFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "ChimeSDKMediaPipelinesService",
+                operation: "GetMediaPipelineKinesisVideoStreamPool",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_GetMediaPipelineKinesisVideoStreamPoolCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_GetMediaPipelineKinesisVideoStreamPoolCommand(output, context);
+    }
+}

package/dist-es/commands/ListMediaPipelineKinesisVideoStreamPoolsCommand.js

@@ -0,0 +1,48 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { ListMediaPipelineKinesisVideoStreamPoolsResponseFilterSensitiveLog, } from "../models/models_0";
+import { de_ListMediaPipelineKinesisVideoStreamPoolsCommand, se_ListMediaPipelineKinesisVideoStreamPoolsCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class ListMediaPipelineKinesisVideoStreamPoolsCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListMediaPipelineKinesisVideoStreamPoolsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ChimeSDKMediaPipelinesClient";
+        const commandName = "ListMediaPipelineKinesisVideoStreamPoolsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: ListMediaPipelineKinesisVideoStreamPoolsResponseFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "ChimeSDKMediaPipelinesService",
+                operation: "ListMediaPipelineKinesisVideoStreamPools",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_ListMediaPipelineKinesisVideoStreamPoolsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_ListMediaPipelineKinesisVideoStreamPoolsCommand(output, context);
+    }
+}

package/dist-es/commands/UpdateMediaPipelineKinesisVideoStreamPoolCommand.js

@@ -0,0 +1,48 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { UpdateMediaPipelineKinesisVideoStreamPoolResponseFilterSensitiveLog, } from "../models/models_0";
+import { de_UpdateMediaPipelineKinesisVideoStreamPoolCommand, se_UpdateMediaPipelineKinesisVideoStreamPoolCommand, } from "../protocols/Aws_restJson1";
+export { $Command };
+export class UpdateMediaPipelineKinesisVideoStreamPoolCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateMediaPipelineKinesisVideoStreamPoolCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "ChimeSDKMediaPipelinesClient";
+        const commandName = "UpdateMediaPipelineKinesisVideoStreamPoolCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: UpdateMediaPipelineKinesisVideoStreamPoolResponseFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "ChimeSDKMediaPipelinesService",
+                operation: "UpdateMediaPipelineKinesisVideoStreamPool",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_UpdateMediaPipelineKinesisVideoStreamPoolCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_UpdateMediaPipelineKinesisVideoStreamPoolCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -3,16 +3,21 @@ export * from "./CreateMediaConcatenationPipelineCommand";
 export * from "./CreateMediaInsightsPipelineCommand";
 export * from "./CreateMediaInsightsPipelineConfigurationCommand";
 export * from "./CreateMediaLiveConnectorPipelineCommand";
+export * from "./CreateMediaPipelineKinesisVideoStreamPoolCommand";
+export * from "./CreateMediaStreamPipelineCommand";
 export * from "./DeleteMediaCapturePipelineCommand";
 export * from "./DeleteMediaInsightsPipelineConfigurationCommand";
 export * from "./DeleteMediaPipelineCommand";
+export * from "./DeleteMediaPipelineKinesisVideoStreamPoolCommand";
 export * from "./GetMediaCapturePipelineCommand";
 export * from "./GetMediaInsightsPipelineConfigurationCommand";
 export * from "./GetMediaPipelineCommand";
+export * from "./GetMediaPipelineKinesisVideoStreamPoolCommand";
 export * from "./GetSpeakerSearchTaskCommand";
 export * from "./GetVoiceToneAnalysisTaskCommand";
 export * from "./ListMediaCapturePipelinesCommand";
 export * from "./ListMediaInsightsPipelineConfigurationsCommand";
+export * from "./ListMediaPipelineKinesisVideoStreamPoolsCommand";
 export * from "./ListMediaPipelinesCommand";
 export * from "./ListTagsForResourceCommand";
 export * from "./StartSpeakerSearchTaskCommand";
@@ -23,3 +28,4 @@ export * from "./TagResourceCommand";
 export * from "./UntagResourceCommand";
 export * from "./UpdateMediaInsightsPipelineConfigurationCommand";
 export * from "./UpdateMediaInsightsPipelineStatusCommand";
+export * from "./UpdateMediaPipelineKinesisVideoStreamPoolCommand";

package/dist-es/models/models_0.js

@@ -334,6 +334,20 @@ export class ConflictException extends __BaseException {
         this.RequestId = opts.RequestId;
     }
 }
+export const KinesisVideoStreamPoolStatus = {
+    ACTIVE: "ACTIVE",
+    CREATING: "CREATING",
+    DELETING: "DELETING",
+    FAILED: "FAILED",
+    UPDATING: "UPDATING",
+};
+export const MediaStreamType = {
+    IndividualAudio: "IndividualAudio",
+    MixedAudio: "MixedAudio",
+};
+export const MediaStreamPipelineSinkType = {
+    KinesisVideoStreamPool: "KinesisVideoStreamPool",
+};
 export const MediaPipelineTaskStatus = {
     Failed: "Failed",
     InProgress: "InProgress",
@@ -553,6 +567,45 @@ export const CreateMediaLiveConnectorPipelineResponseFilterSensitiveLog = (obj)
         MediaLiveConnectorPipeline: MediaLiveConnectorPipelineFilterSensitiveLog(obj.MediaLiveConnectorPipeline),
     }),
 });
+export const CreateMediaPipelineKinesisVideoStreamPoolRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ClientRequestToken && { ClientRequestToken: SENSITIVE_STRING }),
+});
+export const KinesisVideoStreamPoolConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.PoolArn && { PoolArn: SENSITIVE_STRING }),
+});
+export const CreateMediaPipelineKinesisVideoStreamPoolResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.KinesisVideoStreamPoolConfiguration && {
+        KinesisVideoStreamPoolConfiguration: KinesisVideoStreamPoolConfigurationFilterSensitiveLog(obj.KinesisVideoStreamPoolConfiguration),
+    }),
+});
+export const MediaStreamSinkFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.SinkArn && { SinkArn: SENSITIVE_STRING }),
+});
+export const MediaStreamSourceFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.SourceArn && { SourceArn: SENSITIVE_STRING }),
+});
+export const CreateMediaStreamPipelineRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Sources && { Sources: obj.Sources.map((item) => MediaStreamSourceFilterSensitiveLog(item)) }),
+    ...(obj.Sinks && { Sinks: obj.Sinks.map((item) => MediaStreamSinkFilterSensitiveLog(item)) }),
+    ...(obj.ClientRequestToken && { ClientRequestToken: SENSITIVE_STRING }),
+});
+export const MediaStreamPipelineFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Sources && { Sources: obj.Sources.map((item) => MediaStreamSourceFilterSensitiveLog(item)) }),
+    ...(obj.Sinks && { Sinks: obj.Sinks.map((item) => MediaStreamSinkFilterSensitiveLog(item)) }),
+});
+export const CreateMediaStreamPipelineResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.MediaStreamPipeline && {
+        MediaStreamPipeline: MediaStreamPipelineFilterSensitiveLog(obj.MediaStreamPipeline),
+    }),
+});
 export const GetMediaCapturePipelineResponseFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.MediaCapturePipeline && {
@@ -579,11 +632,20 @@ export const MediaPipelineFilterSensitiveLog = (obj) => ({
     ...(obj.MediaInsightsPipeline && {
         MediaInsightsPipeline: MediaInsightsPipelineFilterSensitiveLog(obj.MediaInsightsPipeline),
     }),
+    ...(obj.MediaStreamPipeline && {
+        MediaStreamPipeline: MediaStreamPipelineFilterSensitiveLog(obj.MediaStreamPipeline),
+    }),
 });
 export const GetMediaPipelineResponseFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.MediaPipeline && { MediaPipeline: MediaPipelineFilterSensitiveLog(obj.MediaPipeline) }),
 });
+export const GetMediaPipelineKinesisVideoStreamPoolResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.KinesisVideoStreamPoolConfiguration && {
+        KinesisVideoStreamPoolConfiguration: KinesisVideoStreamPoolConfigurationFilterSensitiveLog(obj.KinesisVideoStreamPoolConfiguration),
+    }),
+});
 export const MediaInsightsPipelineConfigurationSummaryFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.MediaInsightsPipelineConfigurationArn && { MediaInsightsPipelineConfigurationArn: SENSITIVE_STRING }),
@@ -594,6 +656,16 @@ export const ListMediaInsightsPipelineConfigurationsResponseFilterSensitiveLog =
         MediaInsightsPipelineConfigurations: obj.MediaInsightsPipelineConfigurations.map((item) => MediaInsightsPipelineConfigurationSummaryFilterSensitiveLog(item)),
     }),
 });
+export const KinesisVideoStreamPoolSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.PoolArn && { PoolArn: SENSITIVE_STRING }),
+});
+export const ListMediaPipelineKinesisVideoStreamPoolsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.KinesisVideoStreamPools && {
+        KinesisVideoStreamPools: obj.KinesisVideoStreamPools.map((item) => KinesisVideoStreamPoolSummaryFilterSensitiveLog(item)),
+    }),
+});
 export const StartSpeakerSearchTaskRequestFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.VoiceProfileDomainArn && { VoiceProfileDomainArn: SENSITIVE_STRING }),
@@ -616,3 +688,9 @@ export const UpdateMediaInsightsPipelineConfigurationResponseFilterSensitiveLog
         MediaInsightsPipelineConfiguration: MediaInsightsPipelineConfigurationFilterSensitiveLog(obj.MediaInsightsPipelineConfiguration),
     }),
 });
+export const UpdateMediaPipelineKinesisVideoStreamPoolResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.KinesisVideoStreamPoolConfiguration && {
+        KinesisVideoStreamPoolConfiguration: KinesisVideoStreamPoolConfigurationFilterSensitiveLog(obj.KinesisVideoStreamPoolConfiguration),
+    }),
+});

package/dist-es/pagination/ListMediaPipelineKinesisVideoStreamPoolsPaginator.js

@@ -0,0 +1,25 @@
+import { ChimeSDKMediaPipelinesClient } from "../ChimeSDKMediaPipelinesClient";
+import { ListMediaPipelineKinesisVideoStreamPoolsCommand, } from "../commands/ListMediaPipelineKinesisVideoStreamPoolsCommand";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListMediaPipelineKinesisVideoStreamPoolsCommand(input), ...args);
+};
+export async function* paginateListMediaPipelineKinesisVideoStreamPools(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.NextToken = token;
+        input["MaxResults"] = config.pageSize;
+        if (config.client instanceof ChimeSDKMediaPipelinesClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected ChimeSDKMediaPipelines | ChimeSDKMediaPipelinesClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.NextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/index.js

@@ -1,4 +1,5 @@
 export * from "./Interfaces";
 export * from "./ListMediaCapturePipelinesPaginator";
 export * from "./ListMediaInsightsPipelineConfigurationsPaginator";
+export * from "./ListMediaPipelineKinesisVideoStreamPoolsPaginator";
 export * from "./ListMediaPipelinesPaginator";