@aws-sdk/client-ivs-realtime 3.329.0 → 3.332.0

package/dist-es/commands/index.js

@@ -2,7 +2,12 @@ export * from "./CreateParticipantTokenCommand";
 export * from "./CreateStageCommand";
 export * from "./DeleteStageCommand";
 export * from "./DisconnectParticipantCommand";
+export * from "./GetParticipantCommand";
 export * from "./GetStageCommand";
+export * from "./GetStageSessionCommand";
+export * from "./ListParticipantEventsCommand";
+export * from "./ListParticipantsCommand";
+export * from "./ListStageSessionsCommand";
 export * from "./ListStagesCommand";
 export * from "./ListTagsForResourceCommand";
 export * from "./TagResourceCommand";

package/dist-es/models/models_0.js

@@ -82,6 +82,24 @@ export class ConflictException extends __BaseException {
         this.exceptionMessage = opts.exceptionMessage;
     }
 }
+export const ParticipantState = {
+    CONNECTED: "CONNECTED",
+    DISCONNECTED: "DISCONNECTED",
+};
+export const EventErrorCode = {
+    INSUFFICIENT_CAPABILITIES: "INSUFFICIENT_CAPABILITIES",
+};
+export const EventName = {
+    JOINED: "JOINED",
+    JOIN_ERROR: "JOIN_ERROR",
+    LEFT: "LEFT",
+    PUBLISH_ERROR: "PUBLISH_ERROR",
+    PUBLISH_STARTED: "PUBLISH_STARTED",
+    PUBLISH_STOPPED: "PUBLISH_STOPPED",
+    SUBSCRIBE_ERROR: "SUBSCRIBE_ERROR",
+    SUBSCRIBE_STARTED: "SUBSCRIBE_STARTED",
+    SUBSCRIBE_STOPPED: "SUBSCRIBE_STOPPED",
+};
 export class InternalServerException extends __BaseException {
     constructor(opts) {
         super({

package/dist-es/pagination/ListParticipantEventsPaginator.js

@@ -0,0 +1,25 @@
+import { ListParticipantEventsCommand, } from "../commands/ListParticipantEventsCommand";
+import { IVSRealTimeClient } from "../IVSRealTimeClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListParticipantEventsCommand(input), ...args);
+};
+export async function* paginateListParticipantEvents(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 IVSRealTimeClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected IVSRealTime | IVSRealTimeClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListParticipantsPaginator.js

@@ -0,0 +1,25 @@
+import { ListParticipantsCommand, } from "../commands/ListParticipantsCommand";
+import { IVSRealTimeClient } from "../IVSRealTimeClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListParticipantsCommand(input), ...args);
+};
+export async function* paginateListParticipants(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 IVSRealTimeClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected IVSRealTime | IVSRealTimeClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListStageSessionsPaginator.js

@@ -0,0 +1,25 @@
+import { ListStageSessionsCommand, } from "../commands/ListStageSessionsCommand";
+import { IVSRealTimeClient } from "../IVSRealTimeClient";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListStageSessionsCommand(input), ...args);
+};
+export async function* paginateListStageSessions(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 IVSRealTimeClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected IVSRealTime | IVSRealTimeClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/index.js

@@ -1,2 +1,5 @@
 export * from "./Interfaces";
+export * from "./ListParticipantEventsPaginator";
+export * from "./ListParticipantsPaginator";
+export * from "./ListStageSessionsPaginator";
 export * from "./ListStagesPaginator";

package/dist-es/protocols/Aws_restJson1.js

@@ -1,5 +1,5 @@
 import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
-import { _json, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, resolvedPath as __resolvedPath, take, withBaseException, } from "@aws-sdk/smithy-client";
+import { _json, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, resolvedPath as __resolvedPath, take, withBaseException, } from "@aws-sdk/smithy-client";
 import { IVSRealTimeServiceException as __BaseException } from "../models/IVSRealTimeServiceException";
 import { AccessDeniedException, ConflictException, InternalServerException, PendingVerification, ResourceNotFoundException, ServiceQuotaExceededException, ValidationException, } from "../models/models_0";
 export const se_CreateParticipantTokenCommand = async (input, context) => {
@@ -90,6 +90,28 @@ export const se_DisconnectParticipantCommand = async (input, context) => {
         body,
     });
 };
+export const se_GetParticipantCommand = 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 || ""}` + "/GetParticipant";
+    let body;
+    body = JSON.stringify(take(input, {
+        participantId: [],
+        sessionId: [],
+        stageArn: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_GetStageCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -110,6 +132,77 @@ export const se_GetStageCommand = async (input, context) => {
         body,
     });
 };
+export const se_GetStageSessionCommand = 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 || ""}` + "/GetStageSession";
+    let body;
+    body = JSON.stringify(take(input, {
+        sessionId: [],
+        stageArn: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_ListParticipantEventsCommand = 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 || ""}` + "/ListParticipantEvents";
+    let body;
+    body = JSON.stringify(take(input, {
+        maxResults: [],
+        nextToken: [],
+        participantId: [],
+        sessionId: [],
+        stageArn: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const se_ListParticipantsCommand = 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 || ""}` + "/ListParticipants";
+    let body;
+    body = JSON.stringify(take(input, {
+        filterByPublished: [],
+        filterByState: [],
+        filterByUserId: [],
+        maxResults: [],
+        nextToken: [],
+        sessionId: [],
+        stageArn: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_ListStagesCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -131,6 +224,28 @@ export const se_ListStagesCommand = async (input, context) => {
         body,
     });
 };
+export const se_ListStageSessionsCommand = 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 || ""}` + "/ListStageSessions";
+    let body;
+    body = JSON.stringify(take(input, {
+        maxResults: [],
+        nextToken: [],
+        stageArn: [],
+    }));
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const se_ListTagsForResourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
@@ -379,6 +494,45 @@ const de_DisconnectParticipantCommandError = async (output, context) => {
             });
     }
 };
+export const de_GetParticipantCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetParticipantCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        participant: (_) => de_Participant(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetParticipantCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.ivsrealtime#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.ivsrealtime#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_GetStageCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_GetStageCommandError(output, context);
@@ -418,6 +572,119 @@ const de_GetStageCommandError = async (output, context) => {
             });
     }
 };
+export const de_GetStageSessionCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_GetStageSessionCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        stageSession: (_) => de_StageSession(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_GetStageSessionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.ivsrealtime#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.ivsrealtime#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_ListParticipantEventsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListParticipantEventsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        events: (_) => de_EventList(_, context),
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListParticipantEventsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.ivsrealtime#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.ivsrealtime#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+export const de_ListParticipantsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListParticipantsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        nextToken: __expectString,
+        participants: (_) => de_ParticipantList(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListParticipantsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.ivsrealtime#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.ivsrealtime#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_ListStagesCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_ListStagesCommandError(output, context);
@@ -458,6 +725,43 @@ const de_ListStagesCommandError = async (output, context) => {
             });
     }
 };
+export const de_ListStageSessionsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_ListStageSessionsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        nextToken: __expectString,
+        stageSessions: (_) => de_StageSessionList(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_ListStageSessionsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.ivsrealtime#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.ivsrealtime#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
 export const de_ListTagsForResourceCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_ListTagsForResourceCommandError(output, context);
@@ -704,6 +1008,50 @@ const de_ValidationExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_Event = (output, context) => {
+    return take(output, {
+        errorCode: __expectString,
+        eventTime: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        name: __expectString,
+        participantId: __expectString,
+        remoteParticipantId: __expectString,
+    });
+};
+const de_EventList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_Event(entry, context);
+    });
+    return retVal;
+};
+const de_Participant = (output, context) => {
+    return take(output, {
+        attributes: _json,
+        firstJoinTime: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        participantId: __expectString,
+        published: __expectBoolean,
+        state: __expectString,
+        userId: __expectString,
+    });
+};
+const de_ParticipantList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ParticipantSummary(entry, context);
+    });
+    return retVal;
+};
+const de_ParticipantSummary = (output, context) => {
+    return take(output, {
+        firstJoinTime: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        participantId: __expectString,
+        published: __expectBoolean,
+        state: __expectString,
+        userId: __expectString,
+    });
+};
 const de_ParticipantToken = (output, context) => {
     return take(output, {
         attributes: _json,
@@ -723,6 +1071,28 @@ const de_ParticipantTokenList = (output, context) => {
     });
     return retVal;
 };
+const de_StageSession = (output, context) => {
+    return take(output, {
+        endTime: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        sessionId: __expectString,
+        startTime: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+    });
+};
+const de_StageSessionList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_StageSessionSummary(entry, context);
+    });
+    return retVal;
+};
+const de_StageSessionSummary = (output, context) => {
+    return take(output, {
+        endTime: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        sessionId: __expectString,
+        startTime: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+    });
+};
 const deserializeMetadata = (output) => ({
     httpStatusCode: output.statusCode,
     requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],

package/dist-types/IVSRealTime.d.ts

@@ -3,8 +3,13 @@ import { CreateParticipantTokenCommandInput, CreateParticipantTokenCommandOutput
 import { CreateStageCommandInput, CreateStageCommandOutput } from "./commands/CreateStageCommand";
 import { DeleteStageCommandInput, DeleteStageCommandOutput } from "./commands/DeleteStageCommand";
 import { DisconnectParticipantCommandInput, DisconnectParticipantCommandOutput } from "./commands/DisconnectParticipantCommand";
+import { GetParticipantCommandInput, GetParticipantCommandOutput } from "./commands/GetParticipantCommand";
 import { GetStageCommandInput, GetStageCommandOutput } from "./commands/GetStageCommand";
+import { GetStageSessionCommandInput, GetStageSessionCommandOutput } from "./commands/GetStageSessionCommand";
+import { ListParticipantEventsCommandInput, ListParticipantEventsCommandOutput } from "./commands/ListParticipantEventsCommand";
+import { ListParticipantsCommandInput, ListParticipantsCommandOutput } from "./commands/ListParticipantsCommand";
 import { ListStagesCommandInput, ListStagesCommandOutput } from "./commands/ListStagesCommand";
+import { ListStageSessionsCommandInput, ListStageSessionsCommandOutput } from "./commands/ListStageSessionsCommand";
 import { ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput } from "./commands/ListTagsForResourceCommand";
 import { TagResourceCommandInput, TagResourceCommandOutput } from "./commands/TagResourceCommand";
 import { UntagResourceCommandInput, UntagResourceCommandOutput } from "./commands/UntagResourceCommand";
@@ -35,18 +40,48 @@ export interface IVSRealTime {
     disconnectParticipant(args: DisconnectParticipantCommandInput, options?: __HttpHandlerOptions): Promise<DisconnectParticipantCommandOutput>;
     disconnectParticipant(args: DisconnectParticipantCommandInput, cb: (err: any, data?: DisconnectParticipantCommandOutput) => void): void;
     disconnectParticipant(args: DisconnectParticipantCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DisconnectParticipantCommandOutput) => void): void;
+    /**
+     * @see {@link GetParticipantCommand}
+     */
+    getParticipant(args: GetParticipantCommandInput, options?: __HttpHandlerOptions): Promise<GetParticipantCommandOutput>;
+    getParticipant(args: GetParticipantCommandInput, cb: (err: any, data?: GetParticipantCommandOutput) => void): void;
+    getParticipant(args: GetParticipantCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetParticipantCommandOutput) => void): void;
     /**
      * @see {@link GetStageCommand}
      */
     getStage(args: GetStageCommandInput, options?: __HttpHandlerOptions): Promise<GetStageCommandOutput>;
     getStage(args: GetStageCommandInput, cb: (err: any, data?: GetStageCommandOutput) => void): void;
     getStage(args: GetStageCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetStageCommandOutput) => void): void;
+    /**
+     * @see {@link GetStageSessionCommand}
+     */
+    getStageSession(args: GetStageSessionCommandInput, options?: __HttpHandlerOptions): Promise<GetStageSessionCommandOutput>;
+    getStageSession(args: GetStageSessionCommandInput, cb: (err: any, data?: GetStageSessionCommandOutput) => void): void;
+    getStageSession(args: GetStageSessionCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetStageSessionCommandOutput) => void): void;
+    /**
+     * @see {@link ListParticipantEventsCommand}
+     */
+    listParticipantEvents(args: ListParticipantEventsCommandInput, options?: __HttpHandlerOptions): Promise<ListParticipantEventsCommandOutput>;
+    listParticipantEvents(args: ListParticipantEventsCommandInput, cb: (err: any, data?: ListParticipantEventsCommandOutput) => void): void;
+    listParticipantEvents(args: ListParticipantEventsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListParticipantEventsCommandOutput) => void): void;
+    /**
+     * @see {@link ListParticipantsCommand}
+     */
+    listParticipants(args: ListParticipantsCommandInput, options?: __HttpHandlerOptions): Promise<ListParticipantsCommandOutput>;
+    listParticipants(args: ListParticipantsCommandInput, cb: (err: any, data?: ListParticipantsCommandOutput) => void): void;
+    listParticipants(args: ListParticipantsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListParticipantsCommandOutput) => void): void;
     /**
      * @see {@link ListStagesCommand}
      */
     listStages(args: ListStagesCommandInput, options?: __HttpHandlerOptions): Promise<ListStagesCommandOutput>;
     listStages(args: ListStagesCommandInput, cb: (err: any, data?: ListStagesCommandOutput) => void): void;
     listStages(args: ListStagesCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListStagesCommandOutput) => void): void;
+    /**
+     * @see {@link ListStageSessionsCommand}
+     */
+    listStageSessions(args: ListStageSessionsCommandInput, options?: __HttpHandlerOptions): Promise<ListStageSessionsCommandOutput>;
+    listStageSessions(args: ListStageSessionsCommandInput, cb: (err: any, data?: ListStageSessionsCommandOutput) => void): void;
+    listStageSessions(args: ListStageSessionsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListStageSessionsCommandOutput) => void): void;
     /**
      * @see {@link ListTagsForResourceCommand}
      */
@@ -81,7 +116,24 @@ export interface IVSRealTime {
  * 	  API and an AWS EventBridge event stream for responses. JSON is used for both requests and responses,
  * 	  including errors.
  *     </p>
- *          <p>Terminology: The IVS stage API sometimes is referred to as the IVS RealTime API.</p>
+ *          <p>Terminology:</p>
+ *          <ul>
+ *             <li>
+ *                <p>The IVS stage API sometimes is referred to as the IVS <i>RealTime</i>
+ *           API.</p>
+ *             </li>
+ *             <li>
+ *                <p>A <i>participant token</i> is an authorization token used to publish/subscribe
+ *           to a stage.</p>
+ *             </li>
+ *             <li>
+ *                <p>A <i>participant object</i> represents participants
+ *           (people) in the stage and contains information about them. When a token is created, it
+ *           includes a participant ID; when a participant uses that token to join a stage, the
+ *           participant is associated with that participant ID There is a 1:1 mapping between
+ *           participant tokens and participants.</p>
+ *             </li>
+ *          </ul>
  *          <p>
  *             <b>Resources</b>
  *          </p>
@@ -129,14 +181,38 @@ export interface IVSRealTime {
  *             </li>
  *             <li>
  *                <p>
+ *                   <a>GetParticipant</a> — Gets information about the specified
+ *           participant token.</p>
+ *             </li>
+ *             <li>
+ *                <p>
  *                   <a>GetStage</a> — Gets information for the specified stage.</p>
  *             </li>
  *             <li>
  *                <p>
+ *                   <a>GetStageSession</a> — Gets information for the specified stage
+ *           session.</p>
+ *             </li>
+ *             <li>
+ *                <p>
+ *                   <a>ListParticipantEvents</a> — Lists events for a specified
+ *           participant that occurred during a specified stage session.</p>
+ *             </li>
+ *             <li>
+ *                <p>
+ *                   <a>ListParticipants</a> — Lists all participants in a specified stage
+ *           session.</p>
+ *             </li>
+ *             <li>
+ *                <p>
  *                   <a>ListStages</a> — Gets summary information about all stages in your account, in the AWS region where the API request is processed.</p>
  *             </li>
  *             <li>
  *                <p>
+ *                   <a>ListStageSessions</a> — Gets all sessions for a specified stage.</p>
+ *             </li>
+ *             <li>
+ *                <p>
  *                   <a>UpdateStage</a> — Updates a stage’s configuration.</p>
  *             </li>
  *          </ul>