@aws-sdk/client-ivs 3.50.0 → 3.53.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,959 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { IvsServiceException as __BaseException } from "./IvsServiceException";
+
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    
+    exceptionMessage?: string;
+    
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+export interface BatchGetChannelRequest {
+    
+    arns: string[] | undefined;
+}
+export declare namespace BatchGetChannelRequest {
+    
+    const filterSensitiveLog: (obj: BatchGetChannelRequest) => any;
+}
+export declare enum ChannelLatencyMode {
+    LowLatency = "LOW",
+    NormalLatency = "NORMAL"
+}
+export declare enum ChannelType {
+    BasicChannelType = "BASIC",
+    StandardChannelType = "STANDARD"
+}
+
+export interface Channel {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    latencyMode?: ChannelLatencyMode | string;
+    
+    type?: ChannelType | string;
+    
+    recordingConfigurationArn?: string;
+    
+    ingestEndpoint?: string;
+    
+    playbackUrl?: string;
+    
+    authorized?: boolean;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace Channel {
+    
+    const filterSensitiveLog: (obj: Channel) => any;
+}
+
+export interface BatchError {
+    
+    arn?: string;
+    
+    code?: string;
+    
+    message?: string;
+}
+export declare namespace BatchError {
+    
+    const filterSensitiveLog: (obj: BatchError) => any;
+}
+export interface BatchGetChannelResponse {
+    
+    channels?: Channel[];
+    
+    errors?: BatchError[];
+}
+export declare namespace BatchGetChannelResponse {
+    
+    const filterSensitiveLog: (obj: BatchGetChannelResponse) => any;
+}
+export interface BatchGetStreamKeyRequest {
+    
+    arns: string[] | undefined;
+}
+export declare namespace BatchGetStreamKeyRequest {
+    
+    const filterSensitiveLog: (obj: BatchGetStreamKeyRequest) => any;
+}
+
+export interface StreamKey {
+    
+    arn?: string;
+    
+    value?: string;
+    
+    channelArn?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace StreamKey {
+    
+    const filterSensitiveLog: (obj: StreamKey) => any;
+}
+export interface BatchGetStreamKeyResponse {
+    
+    streamKeys?: StreamKey[];
+    
+    errors?: BatchError[];
+}
+export declare namespace BatchGetStreamKeyResponse {
+    
+    const filterSensitiveLog: (obj: BatchGetStreamKeyResponse) => any;
+}
+export interface CreateChannelRequest {
+    
+    name?: string;
+    
+    latencyMode?: ChannelLatencyMode | string;
+    
+    type?: ChannelType | string;
+    
+    authorized?: boolean;
+    
+    recordingConfigurationArn?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateChannelRequest {
+    
+    const filterSensitiveLog: (obj: CreateChannelRequest) => any;
+}
+export interface CreateChannelResponse {
+    
+    channel?: Channel;
+    
+    streamKey?: StreamKey;
+}
+export declare namespace CreateChannelResponse {
+    
+    const filterSensitiveLog: (obj: CreateChannelResponse) => any;
+}
+
+export declare class PendingVerification extends __BaseException {
+    readonly name: "PendingVerification";
+    readonly $fault: "client";
+    
+    exceptionMessage?: string;
+    
+    constructor(opts: __ExceptionOptionType<PendingVerification, __BaseException>);
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    
+    exceptionMessage?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+
+export declare class ServiceQuotaExceededException extends __BaseException {
+    readonly name: "ServiceQuotaExceededException";
+    readonly $fault: "client";
+    
+    exceptionMessage?: string;
+    
+    constructor(opts: __ExceptionOptionType<ServiceQuotaExceededException, __BaseException>);
+}
+
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    
+    exceptionMessage?: string;
+    
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    
+    exceptionMessage?: string;
+    
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+
+export interface S3DestinationConfiguration {
+    
+    bucketName: string | undefined;
+}
+export declare namespace S3DestinationConfiguration {
+    
+    const filterSensitiveLog: (obj: S3DestinationConfiguration) => any;
+}
+
+export interface DestinationConfiguration {
+    
+    s3?: S3DestinationConfiguration;
+}
+export declare namespace DestinationConfiguration {
+    
+    const filterSensitiveLog: (obj: DestinationConfiguration) => any;
+}
+export declare enum RecordingMode {
+    Disabled = "DISABLED",
+    Interval = "INTERVAL"
+}
+
+export interface ThumbnailConfiguration {
+    
+    recordingMode?: RecordingMode | string;
+    
+    targetIntervalSeconds?: number;
+}
+export declare namespace ThumbnailConfiguration {
+    
+    const filterSensitiveLog: (obj: ThumbnailConfiguration) => any;
+}
+export interface CreateRecordingConfigurationRequest {
+    
+    name?: string;
+    
+    destinationConfiguration: DestinationConfiguration | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    thumbnailConfiguration?: ThumbnailConfiguration;
+}
+export declare namespace CreateRecordingConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: CreateRecordingConfigurationRequest) => any;
+}
+export declare enum RecordingConfigurationState {
+    Active = "ACTIVE",
+    CreateFailed = "CREATE_FAILED",
+    Creating = "CREATING"
+}
+
+export interface RecordingConfiguration {
+    
+    arn: string | undefined;
+    
+    name?: string;
+    
+    destinationConfiguration: DestinationConfiguration | undefined;
+    
+    state: RecordingConfigurationState | string | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+    
+    thumbnailConfiguration?: ThumbnailConfiguration;
+}
+export declare namespace RecordingConfiguration {
+    
+    const filterSensitiveLog: (obj: RecordingConfiguration) => any;
+}
+export interface CreateRecordingConfigurationResponse {
+    
+    recordingConfiguration?: RecordingConfiguration;
+}
+export declare namespace CreateRecordingConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: CreateRecordingConfigurationResponse) => any;
+}
+
+export declare class InternalServerException extends __BaseException {
+    readonly name: "InternalServerException";
+    readonly $fault: "server";
+    
+    exceptionMessage?: string;
+    
+    constructor(opts: __ExceptionOptionType<InternalServerException, __BaseException>);
+}
+export interface CreateStreamKeyRequest {
+    
+    channelArn: string | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateStreamKeyRequest {
+    
+    const filterSensitiveLog: (obj: CreateStreamKeyRequest) => any;
+}
+export interface CreateStreamKeyResponse {
+    
+    streamKey?: StreamKey;
+}
+export declare namespace CreateStreamKeyResponse {
+    
+    const filterSensitiveLog: (obj: CreateStreamKeyResponse) => any;
+}
+export interface DeleteChannelRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace DeleteChannelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteChannelRequest) => any;
+}
+export interface DeletePlaybackKeyPairRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace DeletePlaybackKeyPairRequest {
+    
+    const filterSensitiveLog: (obj: DeletePlaybackKeyPairRequest) => any;
+}
+export interface DeletePlaybackKeyPairResponse {
+}
+export declare namespace DeletePlaybackKeyPairResponse {
+    
+    const filterSensitiveLog: (obj: DeletePlaybackKeyPairResponse) => any;
+}
+export interface DeleteRecordingConfigurationRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace DeleteRecordingConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteRecordingConfigurationRequest) => any;
+}
+export interface DeleteStreamKeyRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace DeleteStreamKeyRequest {
+    
+    const filterSensitiveLog: (obj: DeleteStreamKeyRequest) => any;
+}
+export interface GetChannelRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace GetChannelRequest {
+    
+    const filterSensitiveLog: (obj: GetChannelRequest) => any;
+}
+export interface GetChannelResponse {
+    
+    channel?: Channel;
+}
+export declare namespace GetChannelResponse {
+    
+    const filterSensitiveLog: (obj: GetChannelResponse) => any;
+}
+export interface GetPlaybackKeyPairRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace GetPlaybackKeyPairRequest {
+    
+    const filterSensitiveLog: (obj: GetPlaybackKeyPairRequest) => any;
+}
+
+export interface PlaybackKeyPair {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    fingerprint?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace PlaybackKeyPair {
+    
+    const filterSensitiveLog: (obj: PlaybackKeyPair) => any;
+}
+export interface GetPlaybackKeyPairResponse {
+    
+    keyPair?: PlaybackKeyPair;
+}
+export declare namespace GetPlaybackKeyPairResponse {
+    
+    const filterSensitiveLog: (obj: GetPlaybackKeyPairResponse) => any;
+}
+export interface GetRecordingConfigurationRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace GetRecordingConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: GetRecordingConfigurationRequest) => any;
+}
+export interface GetRecordingConfigurationResponse {
+    
+    recordingConfiguration?: RecordingConfiguration;
+}
+export declare namespace GetRecordingConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: GetRecordingConfigurationResponse) => any;
+}
+
+export declare class ChannelNotBroadcasting extends __BaseException {
+    readonly name: "ChannelNotBroadcasting";
+    readonly $fault: "client";
+    
+    exceptionMessage?: string;
+    
+    constructor(opts: __ExceptionOptionType<ChannelNotBroadcasting, __BaseException>);
+}
+export interface GetStreamRequest {
+    
+    channelArn: string | undefined;
+}
+export declare namespace GetStreamRequest {
+    
+    const filterSensitiveLog: (obj: GetStreamRequest) => any;
+}
+export declare enum StreamHealth {
+    Starving = "STARVING",
+    StreamHealthy = "HEALTHY",
+    Unknown = "UNKNOWN"
+}
+export declare enum StreamState {
+    StreamLive = "LIVE",
+    StreamOffline = "OFFLINE"
+}
+
+export interface _Stream {
+    
+    channelArn?: string;
+    
+    streamId?: string;
+    
+    playbackUrl?: string;
+    
+    startTime?: Date;
+    
+    state?: StreamState | string;
+    
+    health?: StreamHealth | string;
+    
+    viewerCount?: number;
+}
+export declare namespace _Stream {
+    
+    const filterSensitiveLog: (obj: _Stream) => any;
+}
+export interface GetStreamResponse {
+    
+    stream?: _Stream;
+}
+export declare namespace GetStreamResponse {
+    
+    const filterSensitiveLog: (obj: GetStreamResponse) => any;
+}
+export interface GetStreamKeyRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace GetStreamKeyRequest {
+    
+    const filterSensitiveLog: (obj: GetStreamKeyRequest) => any;
+}
+export interface GetStreamKeyResponse {
+    
+    streamKey?: StreamKey;
+}
+export declare namespace GetStreamKeyResponse {
+    
+    const filterSensitiveLog: (obj: GetStreamKeyResponse) => any;
+}
+export interface GetStreamSessionRequest {
+    
+    channelArn: string | undefined;
+    
+    streamId?: string;
+}
+export declare namespace GetStreamSessionRequest {
+    
+    const filterSensitiveLog: (obj: GetStreamSessionRequest) => any;
+}
+
+export interface AudioConfiguration {
+    
+    codec?: string;
+    
+    targetBitrate?: number;
+    
+    sampleRate?: number;
+    
+    channels?: number;
+}
+export declare namespace AudioConfiguration {
+    
+    const filterSensitiveLog: (obj: AudioConfiguration) => any;
+}
+
+export interface VideoConfiguration {
+    
+    avcProfile?: string;
+    
+    avcLevel?: string;
+    
+    codec?: string;
+    
+    encoder?: string;
+    
+    targetBitrate?: number;
+    
+    targetFramerate?: number;
+    
+    videoHeight?: number;
+    
+    videoWidth?: number;
+}
+export declare namespace VideoConfiguration {
+    
+    const filterSensitiveLog: (obj: VideoConfiguration) => any;
+}
+
+export interface IngestConfiguration {
+    
+    video?: VideoConfiguration;
+    
+    audio?: AudioConfiguration;
+}
+export declare namespace IngestConfiguration {
+    
+    const filterSensitiveLog: (obj: IngestConfiguration) => any;
+}
+
+export interface StreamEvent {
+    
+    name?: string;
+    
+    type?: string;
+    
+    eventTime?: Date;
+}
+export declare namespace StreamEvent {
+    
+    const filterSensitiveLog: (obj: StreamEvent) => any;
+}
+
+export interface StreamSession {
+    
+    streamId?: string;
+    
+    startTime?: Date;
+    
+    endTime?: Date;
+    
+    channel?: Channel;
+    
+    ingestConfiguration?: IngestConfiguration;
+    
+    recordingConfiguration?: RecordingConfiguration;
+    
+    truncatedEvents?: StreamEvent[];
+}
+export declare namespace StreamSession {
+    
+    const filterSensitiveLog: (obj: StreamSession) => any;
+}
+export interface GetStreamSessionResponse {
+    
+    streamSession?: StreamSession;
+}
+export declare namespace GetStreamSessionResponse {
+    
+    const filterSensitiveLog: (obj: GetStreamSessionResponse) => any;
+}
+export interface ImportPlaybackKeyPairRequest {
+    
+    publicKeyMaterial: string | undefined;
+    
+    name?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ImportPlaybackKeyPairRequest {
+    
+    const filterSensitiveLog: (obj: ImportPlaybackKeyPairRequest) => any;
+}
+export interface ImportPlaybackKeyPairResponse {
+    
+    keyPair?: PlaybackKeyPair;
+}
+export declare namespace ImportPlaybackKeyPairResponse {
+    
+    const filterSensitiveLog: (obj: ImportPlaybackKeyPairResponse) => any;
+}
+export interface ListChannelsRequest {
+    
+    filterByName?: string;
+    
+    filterByRecordingConfigurationArn?: string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListChannelsRequest {
+    
+    const filterSensitiveLog: (obj: ListChannelsRequest) => any;
+}
+
+export interface ChannelSummary {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    latencyMode?: ChannelLatencyMode | string;
+    
+    authorized?: boolean;
+    
+    recordingConfigurationArn?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ChannelSummary {
+    
+    const filterSensitiveLog: (obj: ChannelSummary) => any;
+}
+export interface ListChannelsResponse {
+    
+    channels: ChannelSummary[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListChannelsResponse {
+    
+    const filterSensitiveLog: (obj: ListChannelsResponse) => any;
+}
+export interface ListPlaybackKeyPairsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListPlaybackKeyPairsRequest {
+    
+    const filterSensitiveLog: (obj: ListPlaybackKeyPairsRequest) => any;
+}
+
+export interface PlaybackKeyPairSummary {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace PlaybackKeyPairSummary {
+    
+    const filterSensitiveLog: (obj: PlaybackKeyPairSummary) => any;
+}
+export interface ListPlaybackKeyPairsResponse {
+    
+    keyPairs: PlaybackKeyPairSummary[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListPlaybackKeyPairsResponse {
+    
+    const filterSensitiveLog: (obj: ListPlaybackKeyPairsResponse) => any;
+}
+export interface ListRecordingConfigurationsRequest {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListRecordingConfigurationsRequest {
+    
+    const filterSensitiveLog: (obj: ListRecordingConfigurationsRequest) => any;
+}
+
+export interface RecordingConfigurationSummary {
+    
+    arn: string | undefined;
+    
+    name?: string;
+    
+    destinationConfiguration: DestinationConfiguration | undefined;
+    
+    state: RecordingConfigurationState | string | undefined;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace RecordingConfigurationSummary {
+    
+    const filterSensitiveLog: (obj: RecordingConfigurationSummary) => any;
+}
+export interface ListRecordingConfigurationsResponse {
+    
+    recordingConfigurations: RecordingConfigurationSummary[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListRecordingConfigurationsResponse {
+    
+    const filterSensitiveLog: (obj: ListRecordingConfigurationsResponse) => any;
+}
+export interface ListStreamKeysRequest {
+    
+    channelArn: string | undefined;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListStreamKeysRequest {
+    
+    const filterSensitiveLog: (obj: ListStreamKeysRequest) => any;
+}
+
+export interface StreamKeySummary {
+    
+    arn?: string;
+    
+    channelArn?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace StreamKeySummary {
+    
+    const filterSensitiveLog: (obj: StreamKeySummary) => any;
+}
+export interface ListStreamKeysResponse {
+    
+    streamKeys: StreamKeySummary[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListStreamKeysResponse {
+    
+    const filterSensitiveLog: (obj: ListStreamKeysResponse) => any;
+}
+
+export interface StreamFilters {
+    
+    health?: StreamHealth | string;
+}
+export declare namespace StreamFilters {
+    
+    const filterSensitiveLog: (obj: StreamFilters) => any;
+}
+export interface ListStreamsRequest {
+    
+    filterBy?: StreamFilters;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListStreamsRequest {
+    
+    const filterSensitiveLog: (obj: ListStreamsRequest) => any;
+}
+
+export interface StreamSummary {
+    
+    channelArn?: string;
+    
+    streamId?: string;
+    
+    state?: StreamState | string;
+    
+    health?: StreamHealth | string;
+    
+    viewerCount?: number;
+    
+    startTime?: Date;
+}
+export declare namespace StreamSummary {
+    
+    const filterSensitiveLog: (obj: StreamSummary) => any;
+}
+export interface ListStreamsResponse {
+    
+    streams: StreamSummary[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListStreamsResponse {
+    
+    const filterSensitiveLog: (obj: ListStreamsResponse) => any;
+}
+export interface ListStreamSessionsRequest {
+    
+    channelArn: string | undefined;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListStreamSessionsRequest {
+    
+    const filterSensitiveLog: (obj: ListStreamSessionsRequest) => any;
+}
+
+export interface StreamSessionSummary {
+    
+    streamId?: string;
+    
+    startTime?: Date;
+    
+    endTime?: Date;
+    
+    hasErrorEvent?: boolean;
+}
+export declare namespace StreamSessionSummary {
+    
+    const filterSensitiveLog: (obj: StreamSessionSummary) => any;
+}
+export interface ListStreamSessionsResponse {
+    
+    streamSessions: StreamSessionSummary[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListStreamSessionsResponse {
+    
+    const filterSensitiveLog: (obj: ListStreamSessionsResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    resourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface PutMetadataRequest {
+    
+    channelArn: string | undefined;
+    
+    metadata: string | undefined;
+}
+export declare namespace PutMetadataRequest {
+    
+    const filterSensitiveLog: (obj: PutMetadataRequest) => any;
+}
+
+export declare class ThrottlingException extends __BaseException {
+    readonly name: "ThrottlingException";
+    readonly $fault: "client";
+    
+    exceptionMessage?: string;
+    
+    constructor(opts: __ExceptionOptionType<ThrottlingException, __BaseException>);
+}
+export interface StopStreamRequest {
+    
+    channelArn: string | undefined;
+}
+export declare namespace StopStreamRequest {
+    
+    const filterSensitiveLog: (obj: StopStreamRequest) => any;
+}
+export interface StopStreamResponse {
+}
+export declare namespace StopStreamResponse {
+    
+    const filterSensitiveLog: (obj: StopStreamResponse) => any;
+}
+
+export declare class StreamUnavailable extends __BaseException {
+    readonly name: "StreamUnavailable";
+    readonly $fault: "server";
+    
+    exceptionMessage?: string;
+    
+    constructor(opts: __ExceptionOptionType<StreamUnavailable, __BaseException>);
+}
+export interface TagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    resourceArn: string | undefined;
+    
+    tagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateChannelRequest {
+    
+    arn: string | undefined;
+    
+    name?: string;
+    
+    latencyMode?: ChannelLatencyMode | string;
+    
+    type?: ChannelType | string;
+    
+    authorized?: boolean;
+    
+    recordingConfigurationArn?: string;
+}
+export declare namespace UpdateChannelRequest {
+    
+    const filterSensitiveLog: (obj: UpdateChannelRequest) => any;
+}
+export interface UpdateChannelResponse {
+    
+    channel?: Channel;
+}
+export declare namespace UpdateChannelResponse {
+    
+    const filterSensitiveLog: (obj: UpdateChannelResponse) => any;
+}