import * as HttpClient from "effect/unstable/http/HttpClient";
import * as redacted from "effect/Redacted";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.js";
import * as T from "../traits.js";
import * as C from "../category.js";
import { SensitiveString } from "../sensitive.js";
const svc = T.AwsApiService({
    sdkId: "IVS RealTime",
    serviceShapeName: "AmazonInteractiveVideoServiceRealTime",
});
const auth = T.AwsAuthSigv4({ name: "ivs" });
const ver = T.ServiceVersion("2020-07-14");
const proto = T.AwsProtocolsRestJson1();
const rules = T.EndpointResolver((p, _) => {
    const { Region, UseDualStack = false, UseFIPS = false, Endpoint } = p;
    const e = (u, p = {}, h = {}) => ({
        type: "endpoint",
        endpoint: { url: u, properties: p, headers: h },
    });
    const err = (m) => ({
        type: "error",
        message: m,
    });
    if (Endpoint != null) {
        if (UseFIPS === true) {
            return err("Invalid Configuration: FIPS and custom endpoint are not supported");
        }
        if (UseDualStack === true) {
            return err("Invalid Configuration: Dualstack and custom endpoint are not supported");
        }
        return e(Endpoint);
    }
    if (Region != null) {
        {
            const PartitionResult = _.partition(Region);
            if (PartitionResult != null && PartitionResult !== false) {
                if (UseFIPS === true && UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsFIPS") &&
                        true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://ivsrealtime-fips.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("FIPS and DualStack are enabled, but this partition does not support one or both");
                }
                if (UseFIPS === true) {
                    if (_.getAttr(PartitionResult, "supportsFIPS") === true) {
                        return e(`https://ivsrealtime-fips.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
                    }
                    return err("FIPS is enabled but this partition does not support FIPS");
                }
                if (UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://ivsrealtime.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("DualStack is enabled but this partition does not support DualStack");
                }
                return e(`https://ivsrealtime.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
            }
        }
    }
    return err("Invalid Configuration: Missing Region");
});
export const Video = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    width: S.optional(S.Number),
    height: S.optional(S.Number),
    framerate: S.optional(S.Number),
    bitrate: S.optional(S.Number),
})).annotate({ identifier: "Video" });
export const Tags = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, S.String.pipe(S.optional));
export const CreateEncoderConfigurationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    name: S.optional(S.String),
    video: S.optional(Video),
    tags: S.optional(Tags),
}).pipe(T.all(T.Http({ method: "POST", uri: "/CreateEncoderConfiguration" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateEncoderConfigurationRequest",
});
export const EncoderConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.String,
    name: S.optional(S.String),
    video: S.optional(Video),
    tags: S.optional(Tags),
})).annotate({
    identifier: "EncoderConfiguration",
});
export const CreateEncoderConfigurationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ encoderConfiguration: S.optional(EncoderConfiguration) })).annotate({
    identifier: "CreateEncoderConfigurationResponse",
});
export const ParticipantAttributes = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, S.String.pipe(S.optional));
export const IngestProtocol = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const CreateIngestConfigurationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    name: S.optional(S.String),
    stageArn: S.optional(S.String),
    userId: S.optional(S.String),
    attributes: S.optional(ParticipantAttributes),
    ingestProtocol: IngestProtocol,
    insecureIngest: S.optional(S.Boolean),
    redundantIngest: S.optional(S.Boolean),
    tags: S.optional(Tags),
}).pipe(T.all(T.Http({ method: "POST", uri: "/CreateIngestConfiguration" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateIngestConfigurationRequest",
});
export const RedundantIngestCredential = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    participantId: S.optional(S.String),
    streamKey: S.optional(SensitiveString),
})).annotate({
    identifier: "RedundantIngestCredential",
});
export const RedundantIngestCredentials = /*@__PURE__*/ /*#__PURE__*/ S.Array(RedundantIngestCredential);
export const IngestConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    name: S.optional(S.String),
    arn: S.String,
    ingestProtocol: IngestProtocol,
    streamKey: SensitiveString,
    stageArn: S.String,
    participantId: S.String,
    state: S.String,
    userId: S.optional(S.String),
    redundantIngest: S.optional(S.Boolean),
    redundantIngestCredentials: S.optional(RedundantIngestCredentials),
    attributes: S.optional(ParticipantAttributes),
    tags: S.optional(Tags),
})).annotate({
    identifier: "IngestConfiguration",
});
export const CreateIngestConfigurationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ingestConfiguration: S.optional(IngestConfiguration) })).annotate({
    identifier: "CreateIngestConfigurationResponse",
});
export const ParticipantTokenAttributes = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, S.String.pipe(S.optional));
export const ParticipantTokenCapabilities = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const CreateParticipantTokenRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    stageArn: S.String,
    duration: S.optional(S.Number),
    userId: S.optional(S.String),
    attributes: S.optional(ParticipantTokenAttributes),
    capabilities: S.optional(ParticipantTokenCapabilities),
}).pipe(T.all(T.Http({ method: "POST", uri: "/CreateParticipantToken" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateParticipantTokenRequest",
});
export const ParticipantToken = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    participantId: S.optional(S.String),
    token: S.optional(SensitiveString),
    userId: S.optional(S.String),
    attributes: S.optional(ParticipantTokenAttributes),
    duration: S.optional(S.Number),
    capabilities: S.optional(ParticipantTokenCapabilities),
    expirationTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
})).annotate({
    identifier: "ParticipantToken",
});
export const CreateParticipantTokenResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ participantToken: S.optional(ParticipantToken) })).annotate({
    identifier: "CreateParticipantTokenResponse",
});
export const ParticipantTokenConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    duration: S.optional(S.Number),
    userId: S.optional(S.String),
    attributes: S.optional(ParticipantTokenAttributes),
    capabilities: S.optional(ParticipantTokenCapabilities),
})).annotate({
    identifier: "ParticipantTokenConfiguration",
});
export const ParticipantTokenConfigurations = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(ParticipantTokenConfiguration);
export const ParticipantRecordingMediaType = 
/*@__PURE__*/ /*#__PURE__*/ S.String;
export const ParticipantRecordingMediaTypeList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(ParticipantRecordingMediaType);
export const ThumbnailStorageType = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ThumbnailStorageTypeList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(ThumbnailStorageType);
export const ThumbnailRecordingMode = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ParticipantThumbnailConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    targetIntervalSeconds: S.optional(S.Number),
    storage: S.optional(ThumbnailStorageTypeList),
    recordingMode: S.optional(ThumbnailRecordingMode),
})).annotate({
    identifier: "ParticipantThumbnailConfiguration",
});
export const ParticipantRecordingHlsConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ targetSegmentDurationSeconds: S.optional(S.Number) })).annotate({
    identifier: "ParticipantRecordingHlsConfiguration",
});
export const AutoParticipantRecordingConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    storageConfigurationArn: S.String,
    mediaTypes: S.optional(ParticipantRecordingMediaTypeList),
    thumbnailConfiguration: S.optional(ParticipantThumbnailConfiguration),
    recordingReconnectWindowSeconds: S.optional(S.Number),
    hlsConfiguration: S.optional(ParticipantRecordingHlsConfiguration),
    recordParticipantReplicas: S.optional(S.Boolean),
})).annotate({
    identifier: "AutoParticipantRecordingConfiguration",
});
export const CreateStageRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    name: S.optional(S.String),
    participantTokenConfigurations: S.optional(ParticipantTokenConfigurations),
    tags: S.optional(Tags),
    autoParticipantRecordingConfiguration: S.optional(AutoParticipantRecordingConfiguration),
}).pipe(T.all(T.Http({ method: "POST", uri: "/CreateStage" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateStageRequest",
});
export const StageEndpoints = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    events: S.optional(S.String),
    whip: S.optional(S.String),
    rtmp: S.optional(S.String),
    rtmps: S.optional(S.String),
})).annotate({ identifier: "StageEndpoints" });
export const Stage = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.String,
    name: S.optional(S.String),
    activeSessionId: S.optional(S.String),
    tags: S.optional(Tags),
    autoParticipantRecordingConfiguration: S.optional(AutoParticipantRecordingConfiguration),
    endpoints: S.optional(StageEndpoints),
})).annotate({ identifier: "Stage" });
export const ParticipantTokenList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(ParticipantToken);
export const CreateStageResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    stage: S.optional(Stage),
    participantTokens: S.optional(ParticipantTokenList),
})).annotate({
    identifier: "CreateStageResponse",
});
export const S3StorageConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ bucketName: S.String })).annotate({
    identifier: "S3StorageConfiguration",
});
export const CreateStorageConfigurationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    name: S.optional(S.String),
    s3: S3StorageConfiguration,
    tags: S.optional(Tags),
}).pipe(T.all(T.Http({ method: "POST", uri: "/CreateStorageConfiguration" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreateStorageConfigurationRequest",
});
export const StorageConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.String,
    name: S.optional(S.String),
    s3: S.optional(S3StorageConfiguration),
    tags: S.optional(Tags),
})).annotate({
    identifier: "StorageConfiguration",
});
export const CreateStorageConfigurationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ storageConfiguration: S.optional(StorageConfiguration) })).annotate({
    identifier: "CreateStorageConfigurationResponse",
});
export const DeleteEncoderConfigurationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ arn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/DeleteEncoderConfiguration" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteEncoderConfigurationRequest",
});
export const DeleteEncoderConfigurationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DeleteEncoderConfigurationResponse",
});
export const DeleteIngestConfigurationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ arn: S.String, force: S.optional(S.Boolean) }).pipe(T.all(T.Http({ method: "POST", uri: "/DeleteIngestConfiguration" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteIngestConfigurationRequest",
});
export const DeleteIngestConfigurationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DeleteIngestConfigurationResponse",
});
export const DeletePublicKeyRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ arn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/DeletePublicKey" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeletePublicKeyRequest",
});
export const DeletePublicKeyResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DeletePublicKeyResponse",
});
export const DeleteStageRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ arn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/DeleteStage" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteStageRequest",
});
export const DeleteStageResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DeleteStageResponse",
});
export const DeleteStorageConfigurationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ arn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/DeleteStorageConfiguration" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeleteStorageConfigurationRequest",
});
export const DeleteStorageConfigurationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DeleteStorageConfigurationResponse",
});
export const DisconnectParticipantRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    stageArn: S.String,
    participantId: S.String,
    reason: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/DisconnectParticipant" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DisconnectParticipantRequest",
});
export const DisconnectParticipantResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "DisconnectParticipantResponse",
});
export const GetCompositionRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ arn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/GetComposition" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetCompositionRequest",
});
export const VideoAspectRatio = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const VideoFillMode = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const GridConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    featuredParticipantAttribute: S.optional(S.String),
    omitStoppedVideo: S.optional(S.Boolean),
    videoAspectRatio: S.optional(VideoAspectRatio),
    videoFillMode: S.optional(VideoFillMode),
    gridGap: S.optional(S.Number),
    participantOrderAttribute: S.optional(S.String),
})).annotate({
    identifier: "GridConfiguration",
});
export const PipBehavior = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const PipPosition = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const PipConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    featuredParticipantAttribute: S.optional(S.String),
    omitStoppedVideo: S.optional(S.Boolean),
    videoFillMode: S.optional(VideoFillMode),
    gridGap: S.optional(S.Number),
    pipParticipantAttribute: S.optional(S.String),
    pipBehavior: S.optional(PipBehavior),
    pipOffset: S.optional(S.Number),
    pipPosition: S.optional(PipPosition),
    pipWidth: S.optional(S.Number),
    pipHeight: S.optional(S.Number),
    participantOrderAttribute: S.optional(S.String),
})).annotate({
    identifier: "PipConfiguration",
});
export const LayoutConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    grid: S.optional(GridConfiguration),
    pip: S.optional(PipConfiguration),
})).annotate({
    identifier: "LayoutConfiguration",
});
export const ChannelDestinationConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    channelArn: S.String,
    encoderConfigurationArn: S.optional(S.String),
})).annotate({
    identifier: "ChannelDestinationConfiguration",
});
export const EncoderConfigurationArnList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const CompositionRecordingHlsConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ targetSegmentDurationSeconds: S.optional(S.Number) })).annotate({
    identifier: "CompositionRecordingHlsConfiguration",
});
export const RecordingConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    hlsConfiguration: S.optional(CompositionRecordingHlsConfiguration),
    format: S.optional(S.String),
})).annotate({
    identifier: "RecordingConfiguration",
});
export const CompositionThumbnailConfiguration = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    targetIntervalSeconds: S.optional(S.Number),
    storage: S.optional(ThumbnailStorageTypeList),
})).annotate({
    identifier: "CompositionThumbnailConfiguration",
});
export const CompositionThumbnailConfigurationList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(CompositionThumbnailConfiguration);
export const S3DestinationConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    storageConfigurationArn: S.String,
    encoderConfigurationArns: EncoderConfigurationArnList,
    recordingConfiguration: S.optional(RecordingConfiguration),
    thumbnailConfigurations: S.optional(CompositionThumbnailConfigurationList),
})).annotate({
    identifier: "S3DestinationConfiguration",
});
export const DestinationConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    name: S.optional(S.String),
    channel: S.optional(ChannelDestinationConfiguration),
    s3: S.optional(S3DestinationConfiguration),
})).annotate({
    identifier: "DestinationConfiguration",
});
export const S3Detail = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ recordingPrefix: S.String })).annotate({ identifier: "S3Detail" });
export const DestinationDetail = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ s3: S.optional(S3Detail) })).annotate({
    identifier: "DestinationDetail",
});
export const Destination = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    id: S.String,
    state: S.String,
    startTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    endTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    configuration: DestinationConfiguration,
    detail: S.optional(DestinationDetail),
})).annotate({ identifier: "Destination" });
export const DestinationList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Destination);
export const Composition = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.String,
    stageArn: S.String,
    state: S.String,
    layout: LayoutConfiguration,
    destinations: DestinationList,
    tags: S.optional(Tags),
    startTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    endTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
})).annotate({ identifier: "Composition" });
export const GetCompositionResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ composition: S.optional(Composition) })).annotate({
    identifier: "GetCompositionResponse",
});
export const GetEncoderConfigurationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ arn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/GetEncoderConfiguration" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetEncoderConfigurationRequest",
});
export const GetEncoderConfigurationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ encoderConfiguration: S.optional(EncoderConfiguration) })).annotate({
    identifier: "GetEncoderConfigurationResponse",
});
export const GetIngestConfigurationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ arn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/GetIngestConfiguration" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetIngestConfigurationRequest",
});
export const GetIngestConfigurationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ingestConfiguration: S.optional(IngestConfiguration) })).annotate({
    identifier: "GetIngestConfigurationResponse",
});
export const GetParticipantRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    stageArn: S.String,
    sessionId: S.String,
    participantId: S.String,
}).pipe(T.all(T.Http({ method: "POST", uri: "/GetParticipant" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetParticipantRequest",
});
export const ParticipantProtocol = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const Participant = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    participantId: S.optional(S.String),
    userId: S.optional(S.String),
    state: S.optional(S.String),
    firstJoinTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    attributes: S.optional(ParticipantAttributes),
    published: S.optional(S.Boolean),
    ispName: S.optional(S.String),
    osName: S.optional(S.String),
    osVersion: S.optional(S.String),
    browserName: S.optional(S.String),
    browserVersion: S.optional(S.String),
    sdkVersion: S.optional(S.String),
    recordingS3BucketName: S.optional(S.String),
    recordingS3Prefix: S.optional(S.String),
    recordingState: S.optional(S.String),
    protocol: S.optional(ParticipantProtocol),
    replicationType: S.optional(S.String),
    replicationState: S.optional(S.String),
    sourceStageArn: S.optional(S.String),
    sourceSessionId: S.optional(S.String),
    redundantIngest: S.optional(S.Boolean),
    ingestConfigurationArn: S.optional(S.String),
})).annotate({ identifier: "Participant" });
export const GetParticipantResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ participant: S.optional(Participant) })).annotate({
    identifier: "GetParticipantResponse",
});
export const GetPublicKeyRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ arn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/GetPublicKey" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetPublicKeyRequest",
});
export const PublicKey = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.optional(S.String),
    name: S.optional(S.String),
    publicKeyMaterial: S.optional(S.String),
    fingerprint: S.optional(S.String),
    tags: S.optional(Tags),
})).annotate({ identifier: "PublicKey" });
export const GetPublicKeyResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ publicKey: S.optional(PublicKey) })).annotate({
    identifier: "GetPublicKeyResponse",
});
export const GetStageRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ arn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/GetStage" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetStageRequest",
});
export const GetStageResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ stage: S.optional(Stage) })).annotate({
    identifier: "GetStageResponse",
});
export const GetStageSessionRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ stageArn: S.String, sessionId: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/GetStageSession" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetStageSessionRequest",
});
export const StageSession = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    sessionId: S.optional(S.String),
    startTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    endTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
})).annotate({ identifier: "StageSession" });
export const GetStageSessionResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ stageSession: S.optional(StageSession) })).annotate({
    identifier: "GetStageSessionResponse",
});
export const GetStorageConfigurationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ arn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/GetStorageConfiguration" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "GetStorageConfigurationRequest",
});
export const GetStorageConfigurationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ storageConfiguration: S.optional(StorageConfiguration) })).annotate({
    identifier: "GetStorageConfigurationResponse",
});
export const ImportPublicKeyRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    publicKeyMaterial: S.String,
    name: S.optional(S.String),
    tags: S.optional(Tags),
}).pipe(T.all(T.Http({ method: "POST", uri: "/ImportPublicKey" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ImportPublicKeyRequest",
});
export const ImportPublicKeyResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ publicKey: S.optional(PublicKey) })).annotate({
    identifier: "ImportPublicKeyResponse",
});
export const ListCompositionsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    filterByStageArn: S.optional(S.String),
    filterByEncoderConfigurationArn: S.optional(S.String),
    nextToken: S.optional(S.String),
    maxResults: S.optional(S.Number),
}).pipe(T.all(T.Http({ method: "POST", uri: "/ListCompositions" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListCompositionsRequest",
});
export const DestinationSummary = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    id: S.String,
    state: S.String,
    startTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    endTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
})).annotate({
    identifier: "DestinationSummary",
});
export const DestinationSummaryList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(DestinationSummary);
export const CompositionSummary = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.String,
    stageArn: S.String,
    destinations: DestinationSummaryList,
    state: S.String,
    tags: S.optional(Tags),
    startTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    endTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
})).annotate({
    identifier: "CompositionSummary",
});
export const CompositionSummaryList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(CompositionSummary);
export const ListCompositionsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    compositions: CompositionSummaryList,
    nextToken: S.optional(S.String),
})).annotate({
    identifier: "ListCompositionsResponse",
});
export const ListEncoderConfigurationsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    nextToken: S.optional(S.String),
    maxResults: S.optional(S.Number),
}).pipe(T.all(T.Http({ method: "POST", uri: "/ListEncoderConfigurations" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListEncoderConfigurationsRequest",
});
export const EncoderConfigurationSummary = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.String,
    name: S.optional(S.String),
    tags: S.optional(Tags),
})).annotate({
    identifier: "EncoderConfigurationSummary",
});
export const EncoderConfigurationSummaryList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(EncoderConfigurationSummary);
export const ListEncoderConfigurationsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    encoderConfigurations: EncoderConfigurationSummaryList,
    nextToken: S.optional(S.String),
})).annotate({
    identifier: "ListEncoderConfigurationsResponse",
});
export const ListIngestConfigurationsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    filterByStageArn: S.optional(S.String),
    filterByState: S.optional(S.String),
    nextToken: S.optional(S.String),
    maxResults: S.optional(S.Number),
}).pipe(T.all(T.Http({ method: "POST", uri: "/ListIngestConfigurations" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListIngestConfigurationsRequest",
});
export const IngestConfigurationSummary = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    name: S.optional(S.String),
    arn: S.String,
    ingestProtocol: IngestProtocol,
    stageArn: S.String,
    participantId: S.String,
    state: S.String,
    userId: S.optional(S.String),
    redundantIngest: S.optional(S.Boolean),
})).annotate({
    identifier: "IngestConfigurationSummary",
});
export const IngestConfigurationList = /*@__PURE__*/ /*#__PURE__*/ S.Array(IngestConfigurationSummary);
export const ListIngestConfigurationsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ingestConfigurations: IngestConfigurationList,
    nextToken: S.optional(S.String),
})).annotate({
    identifier: "ListIngestConfigurationsResponse",
});
export const ListParticipantEventsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    stageArn: S.String,
    sessionId: S.String,
    participantId: S.String,
    nextToken: S.optional(S.String),
    maxResults: S.optional(S.Number),
}).pipe(T.all(T.Http({ method: "POST", uri: "/ListParticipantEvents" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListParticipantEventsRequest",
});
export const EventErrorCode = /*@__PURE__*/ /*#__PURE__*/ S.String;
export const ExchangedParticipantToken = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    capabilities: S.optional(ParticipantTokenCapabilities),
    attributes: S.optional(ParticipantTokenAttributes),
    userId: S.optional(S.String),
    expirationTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
})).annotate({
    identifier: "ExchangedParticipantToken",
});
export const Event = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    name: S.optional(S.String),
    participantId: S.optional(S.String),
    eventTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    remoteParticipantId: S.optional(S.String),
    errorCode: S.optional(EventErrorCode),
    destinationStageArn: S.optional(S.String),
    destinationSessionId: S.optional(S.String),
    replica: S.optional(S.Boolean),
    previousToken: S.optional(ExchangedParticipantToken),
    newToken: S.optional(ExchangedParticipantToken),
})).annotate({ identifier: "Event" });
export const EventList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Event);
export const ListParticipantEventsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ events: EventList, nextToken: S.optional(S.String) })).annotate({
    identifier: "ListParticipantEventsResponse",
});
export const ListParticipantReplicasRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    sourceStageArn: S.String,
    participantId: S.String,
    nextToken: S.optional(S.String),
    maxResults: S.optional(S.Number),
}).pipe(T.all(T.Http({ method: "POST", uri: "/ListParticipantReplicas" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListParticipantReplicasRequest",
});
export const ParticipantReplica = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    sourceStageArn: S.String,
    participantId: S.String,
    sourceSessionId: S.String,
    destinationStageArn: S.String,
    destinationSessionId: S.String,
    replicationState: S.String,
})).annotate({
    identifier: "ParticipantReplica",
});
export const ParticipantReplicaList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(ParticipantReplica);
export const ListParticipantReplicasResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    replicas: ParticipantReplicaList,
    nextToken: S.optional(S.String),
})).annotate({
    identifier: "ListParticipantReplicasResponse",
});
export const ListParticipantsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    stageArn: S.String,
    sessionId: S.String,
    filterByUserId: S.optional(S.String),
    filterByPublished: S.optional(S.Boolean),
    filterByState: S.optional(S.String),
    nextToken: S.optional(S.String),
    maxResults: S.optional(S.Number),
    filterByRecordingState: S.optional(S.String),
}).pipe(T.all(T.Http({ method: "POST", uri: "/ListParticipants" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListParticipantsRequest",
});
export const ParticipantSummary = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    participantId: S.optional(S.String),
    userId: S.optional(S.String),
    state: S.optional(S.String),
    firstJoinTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    published: S.optional(S.Boolean),
    recordingState: S.optional(S.String),
    replicationType: S.optional(S.String),
    replicationState: S.optional(S.String),
    sourceStageArn: S.optional(S.String),
    sourceSessionId: S.optional(S.String),
    redundantIngest: S.optional(S.Boolean),
    ingestConfigurationArn: S.optional(S.String),
})).annotate({
    identifier: "ParticipantSummary",
});
export const ParticipantList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(ParticipantSummary);
export const ListParticipantsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    participants: ParticipantList,
    nextToken: S.optional(S.String),
})).annotate({
    identifier: "ListParticipantsResponse",
});
export const ListPublicKeysRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    nextToken: S.optional(S.String),
    maxResults: S.optional(S.Number),
}).pipe(T.all(T.Http({ method: "POST", uri: "/ListPublicKeys" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListPublicKeysRequest",
});
export const PublicKeySummary = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.optional(S.String),
    name: S.optional(S.String),
    tags: S.optional(Tags),
})).annotate({
    identifier: "PublicKeySummary",
});
export const PublicKeyList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(PublicKeySummary);
export const ListPublicKeysResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ publicKeys: PublicKeyList, nextToken: S.optional(S.String) })).annotate({
    identifier: "ListPublicKeysResponse",
});
export const ListStagesRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    nextToken: S.optional(S.String),
    maxResults: S.optional(S.Number),
}).pipe(T.all(T.Http({ method: "POST", uri: "/ListStages" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListStagesRequest",
});
export const StageSummary = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.String,
    name: S.optional(S.String),
    activeSessionId: S.optional(S.String),
    tags: S.optional(Tags),
})).annotate({ identifier: "StageSummary" });
export const StageSummaryList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(StageSummary);
export const ListStagesResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ stages: StageSummaryList, nextToken: S.optional(S.String) })).annotate({
    identifier: "ListStagesResponse",
});
export const ListStageSessionsRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    stageArn: S.String,
    nextToken: S.optional(S.String),
    maxResults: S.optional(S.Number),
}).pipe(T.all(T.Http({ method: "POST", uri: "/ListStageSessions" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListStageSessionsRequest",
});
export const StageSessionSummary = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    sessionId: S.optional(S.String),
    startTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
    endTime: S.optional(T.DateFromString.pipe(T.TimestampFormat("date-time"))),
})).annotate({
    identifier: "StageSessionSummary",
});
export const StageSessionList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(StageSessionSummary);
export const ListStageSessionsResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    stageSessions: StageSessionList,
    nextToken: S.optional(S.String),
})).annotate({
    identifier: "ListStageSessionsResponse",
});
export const ListStorageConfigurationsRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    nextToken: S.optional(S.String),
    maxResults: S.optional(S.Number),
}).pipe(T.all(T.Http({ method: "POST", uri: "/ListStorageConfigurations" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListStorageConfigurationsRequest",
});
export const StorageConfigurationSummary = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.String,
    name: S.optional(S.String),
    s3: S.optional(S3StorageConfiguration),
    tags: S.optional(Tags),
})).annotate({
    identifier: "StorageConfigurationSummary",
});
export const StorageConfigurationSummaryList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(StorageConfigurationSummary);
export const ListStorageConfigurationsResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    storageConfigurations: StorageConfigurationSummaryList,
    nextToken: S.optional(S.String),
})).annotate({
    identifier: "ListStorageConfigurationsResponse",
});
export const ListTagsForResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ resourceArn: S.String.pipe(T.HttpLabel("resourceArn")) }).pipe(T.all(T.Http({ method: "GET", uri: "/tags/{resourceArn}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListTagsForResourceRequest",
});
export const ListTagsForResourceResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ tags: Tags })).annotate({
    identifier: "ListTagsForResourceResponse",
});
export const DestinationConfigurationList = /*@__PURE__*/ /*#__PURE__*/ S.Array(DestinationConfiguration);
export const StartCompositionRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    stageArn: S.String,
    idempotencyToken: S.optional(S.String).pipe(T.IdempotencyToken()),
    layout: S.optional(LayoutConfiguration),
    destinations: DestinationConfigurationList,
    tags: S.optional(Tags),
}).pipe(T.all(T.Http({ method: "POST", uri: "/StartComposition" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "StartCompositionRequest",
});
export const StartCompositionResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ composition: S.optional(Composition) })).annotate({
    identifier: "StartCompositionResponse",
});
export const StartParticipantReplicationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    sourceStageArn: S.String,
    destinationStageArn: S.String,
    participantId: S.String,
    reconnectWindowSeconds: S.optional(S.Number),
    attributes: S.optional(ParticipantAttributes),
}).pipe(T.all(T.Http({ method: "POST", uri: "/StartParticipantReplication" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "StartParticipantReplicationRequest",
});
export const StartParticipantReplicationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    accessControlAllowOrigin: S.optional(S.String).pipe(T.HttpHeader("Access-Control-Allow-Origin")),
    accessControlExposeHeaders: S.optional(S.String).pipe(T.HttpHeader("Access-Control-Expose-Headers")),
    cacheControl: S.optional(S.String).pipe(T.HttpHeader("Cache-Control")),
    contentSecurityPolicy: S.optional(S.String).pipe(T.HttpHeader("Content-Security-Policy")),
    strictTransportSecurity: S.optional(S.String).pipe(T.HttpHeader("Strict-Transport-Security")),
    xContentTypeOptions: S.optional(S.String).pipe(T.HttpHeader("X-Content-Type-Options")),
    xFrameOptions: S.optional(S.String).pipe(T.HttpHeader("X-Frame-Options")),
})).annotate({
    identifier: "StartParticipantReplicationResponse",
});
export const StopCompositionRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ arn: S.String }).pipe(T.all(T.Http({ method: "POST", uri: "/StopComposition" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "StopCompositionRequest",
});
export const StopCompositionResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "StopCompositionResponse",
});
export const StopParticipantReplicationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    sourceStageArn: S.String,
    destinationStageArn: S.String,
    participantId: S.String,
}).pipe(T.all(T.Http({ method: "POST", uri: "/StopParticipantReplication" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "StopParticipantReplicationRequest",
});
export const StopParticipantReplicationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    accessControlAllowOrigin: S.optional(S.String).pipe(T.HttpHeader("Access-Control-Allow-Origin")),
    accessControlExposeHeaders: S.optional(S.String).pipe(T.HttpHeader("Access-Control-Expose-Headers")),
    cacheControl: S.optional(S.String).pipe(T.HttpHeader("Cache-Control")),
    contentSecurityPolicy: S.optional(S.String).pipe(T.HttpHeader("Content-Security-Policy")),
    strictTransportSecurity: S.optional(S.String).pipe(T.HttpHeader("Strict-Transport-Security")),
    xContentTypeOptions: S.optional(S.String).pipe(T.HttpHeader("X-Content-Type-Options")),
    xFrameOptions: S.optional(S.String).pipe(T.HttpHeader("X-Frame-Options")),
})).annotate({
    identifier: "StopParticipantReplicationResponse",
});
export const TagResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    resourceArn: S.String.pipe(T.HttpLabel("resourceArn")),
    tags: Tags,
}).pipe(T.all(T.Http({ method: "POST", uri: "/tags/{resourceArn}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "TagResourceRequest",
});
export const TagResourceResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "TagResourceResponse",
});
export const TagKeyList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const UntagResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    resourceArn: S.String.pipe(T.HttpLabel("resourceArn")),
    tagKeys: TagKeyList.pipe(T.HttpQuery("tagKeys")),
}).pipe(T.all(T.Http({ method: "DELETE", uri: "/tags/{resourceArn}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UntagResourceRequest",
});
export const UntagResourceResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({})).annotate({
    identifier: "UntagResourceResponse",
});
export const UpdateIngestConfigurationRequest = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.String,
    stageArn: S.optional(S.String),
    redundantIngest: S.optional(S.Boolean),
}).pipe(T.all(T.Http({ method: "POST", uri: "/UpdateIngestConfiguration" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateIngestConfigurationRequest",
});
export const UpdateIngestConfigurationResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ ingestConfiguration: S.optional(IngestConfiguration) })).annotate({
    identifier: "UpdateIngestConfigurationResponse",
});
export const UpdateStageRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    arn: S.String,
    name: S.optional(S.String),
    autoParticipantRecordingConfiguration: S.optional(AutoParticipantRecordingConfiguration),
}).pipe(T.all(T.Http({ method: "POST", uri: "/UpdateStage" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdateStageRequest",
});
export const UpdateStageResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ stage: S.optional(Stage) })).annotate({
    identifier: "UpdateStageResponse",
});
//# Errors
export class AccessDeniedException extends S.TaggedErrorClass()("AccessDeniedException", {
    accessControlAllowOrigin: S.optional(S.String).pipe(T.HttpHeader("Access-Control-Allow-Origin")),
    accessControlExposeHeaders: S.optional(S.String).pipe(T.HttpHeader("Access-Control-Expose-Headers")),
    cacheControl: S.optional(S.String).pipe(T.HttpHeader("Cache-Control")),
    contentSecurityPolicy: S.optional(S.String).pipe(T.HttpHeader("Content-Security-Policy")),
    strictTransportSecurity: S.optional(S.String).pipe(T.HttpHeader("Strict-Transport-Security")),
    xContentTypeOptions: S.optional(S.String).pipe(T.HttpHeader("X-Content-Type-Options")),
    xFrameOptions: S.optional(S.String).pipe(T.HttpHeader("X-Frame-Options")),
    xAmznErrorType: S.optional(S.String).pipe(T.HttpHeader("x-amzn-ErrorType")),
    exceptionMessage: S.optional(S.String),
}).pipe(C.withAuthError) {
}
export class ConflictException extends S.TaggedErrorClass()("ConflictException", {
    accessControlAllowOrigin: S.optional(S.String).pipe(T.HttpHeader("Access-Control-Allow-Origin")),
    accessControlExposeHeaders: S.optional(S.String).pipe(T.HttpHeader("Access-Control-Expose-Headers")),
    cacheControl: S.optional(S.String).pipe(T.HttpHeader("Cache-Control")),
    contentSecurityPolicy: S.optional(S.String).pipe(T.HttpHeader("Content-Security-Policy")),
    strictTransportSecurity: S.optional(S.String).pipe(T.HttpHeader("Strict-Transport-Security")),
    xContentTypeOptions: S.optional(S.String).pipe(T.HttpHeader("X-Content-Type-Options")),
    xFrameOptions: S.optional(S.String).pipe(T.HttpHeader("X-Frame-Options")),
    xAmznErrorType: S.optional(S.String).pipe(T.HttpHeader("x-amzn-ErrorType")),
    exceptionMessage: S.optional(S.String),
}).pipe(C.withConflictError) {
}
export class InternalServerException extends S.TaggedErrorClass()("InternalServerException", {
    accessControlAllowOrigin: S.optional(S.String).pipe(T.HttpHeader("Access-Control-Allow-Origin")),
    accessControlExposeHeaders: S.optional(S.String).pipe(T.HttpHeader("Access-Control-Expose-Headers")),
    cacheControl: S.optional(S.String).pipe(T.HttpHeader("Cache-Control")),
    contentSecurityPolicy: S.optional(S.String).pipe(T.HttpHeader("Content-Security-Policy")),
    strictTransportSecurity: S.optional(S.String).pipe(T.HttpHeader("Strict-Transport-Security")),
    xContentTypeOptions: S.optional(S.String).pipe(T.HttpHeader("X-Content-Type-Options")),
    xFrameOptions: S.optional(S.String).pipe(T.HttpHeader("X-Frame-Options")),
    xAmznErrorType: S.optional(S.String).pipe(T.HttpHeader("x-amzn-ErrorType")),
    exceptionMessage: S.optional(S.String),
}).pipe(C.withServerError) {
}
export class PendingVerification extends S.TaggedErrorClass()("PendingVerification", {
    accessControlAllowOrigin: S.optional(S.String).pipe(T.HttpHeader("Access-Control-Allow-Origin")),
    accessControlExposeHeaders: S.optional(S.String).pipe(T.HttpHeader("Access-Control-Expose-Headers")),
    cacheControl: S.optional(S.String).pipe(T.HttpHeader("Cache-Control")),
    contentSecurityPolicy: S.optional(S.String).pipe(T.HttpHeader("Content-Security-Policy")),
    strictTransportSecurity: S.optional(S.String).pipe(T.HttpHeader("Strict-Transport-Security")),
    xContentTypeOptions: S.optional(S.String).pipe(T.HttpHeader("X-Content-Type-Options")),
    xFrameOptions: S.optional(S.String).pipe(T.HttpHeader("X-Frame-Options")),
    xAmznErrorType: S.optional(S.String).pipe(T.HttpHeader("x-amzn-ErrorType")),
    exceptionMessage: S.optional(S.String),
}).pipe(C.withAuthError) {
}
export class ResourceNotFoundException extends S.TaggedErrorClass()("ResourceNotFoundException", {
    accessControlAllowOrigin: S.optional(S.String).pipe(T.HttpHeader("Access-Control-Allow-Origin")),
    accessControlExposeHeaders: S.optional(S.String).pipe(T.HttpHeader("Access-Control-Expose-Headers")),
    cacheControl: S.optional(S.String).pipe(T.HttpHeader("Cache-Control")),
    contentSecurityPolicy: S.optional(S.String).pipe(T.HttpHeader("Content-Security-Policy")),
    strictTransportSecurity: S.optional(S.String).pipe(T.HttpHeader("Strict-Transport-Security")),
    xContentTypeOptions: S.optional(S.String).pipe(T.HttpHeader("X-Content-Type-Options")),
    xFrameOptions: S.optional(S.String).pipe(T.HttpHeader("X-Frame-Options")),
    xAmznErrorType: S.optional(S.String).pipe(T.HttpHeader("x-amzn-ErrorType")),
    exceptionMessage: S.optional(S.String),
}).pipe(C.withBadRequestError) {
}
export class ServiceQuotaExceededException extends S.TaggedErrorClass()("ServiceQuotaExceededException", {
    accessControlAllowOrigin: S.optional(S.String).pipe(T.HttpHeader("Access-Control-Allow-Origin")),
    accessControlExposeHeaders: S.optional(S.String).pipe(T.HttpHeader("Access-Control-Expose-Headers")),
    cacheControl: S.optional(S.String).pipe(T.HttpHeader("Cache-Control")),
    contentSecurityPolicy: S.optional(S.String).pipe(T.HttpHeader("Content-Security-Policy")),
    strictTransportSecurity: S.optional(S.String).pipe(T.HttpHeader("Strict-Transport-Security")),
    xContentTypeOptions: S.optional(S.String).pipe(T.HttpHeader("X-Content-Type-Options")),
    xFrameOptions: S.optional(S.String).pipe(T.HttpHeader("X-Frame-Options")),
    xAmznErrorType: S.optional(S.String).pipe(T.HttpHeader("x-amzn-ErrorType")),
    exceptionMessage: S.optional(S.String),
}).pipe(C.withQuotaError) {
}
export class ValidationException extends S.TaggedErrorClass()("ValidationException", {
    accessControlAllowOrigin: S.optional(S.String).pipe(T.HttpHeader("Access-Control-Allow-Origin")),
    accessControlExposeHeaders: S.optional(S.String).pipe(T.HttpHeader("Access-Control-Expose-Headers")),
    cacheControl: S.optional(S.String).pipe(T.HttpHeader("Cache-Control")),
    contentSecurityPolicy: S.optional(S.String).pipe(T.HttpHeader("Content-Security-Policy")),
    strictTransportSecurity: S.optional(S.String).pipe(T.HttpHeader("Strict-Transport-Security")),
    xContentTypeOptions: S.optional(S.String).pipe(T.HttpHeader("X-Content-Type-Options")),
    xFrameOptions: S.optional(S.String).pipe(T.HttpHeader("X-Frame-Options")),
    xAmznErrorType: S.optional(S.String).pipe(T.HttpHeader("x-amzn-ErrorType")),
    exceptionMessage: S.optional(S.String),
}).pipe(C.withBadRequestError) {
}
/**
 * Creates an EncoderConfiguration object.
 */
export const createEncoderConfiguration = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateEncoderConfigurationRequest,
    output: CreateEncoderConfigurationResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        InternalServerException,
        PendingVerification,
        ResourceNotFoundException,
        ServiceQuotaExceededException,
        ValidationException,
    ],
}));
/**
 * Creates a new IngestConfiguration resource, used to specify the ingest protocol for a stage.
 */
export const createIngestConfiguration = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateIngestConfigurationRequest,
    output: CreateIngestConfigurationResponse,
    errors: [
        AccessDeniedException,
        PendingVerification,
        ServiceQuotaExceededException,
        ValidationException,
    ],
}));
/**
 * Creates an additional token for a specified stage. This can be done after stage creation
 * or when tokens expire. Tokens always are scoped to the stage for which they are
 * created.
 *
 * Encryption keys are owned by Amazon IVS and never used directly by your
 * application.
 */
export const createParticipantToken = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateParticipantTokenRequest,
    output: CreateParticipantTokenResponse,
    errors: [
        AccessDeniedException,
        PendingVerification,
        ResourceNotFoundException,
        ServiceQuotaExceededException,
        ValidationException,
    ],
}));
/**
 * Creates a new stage (and optionally participant tokens).
 */
export const createStage = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateStageRequest,
    output: CreateStageResponse,
    errors: [
        AccessDeniedException,
        PendingVerification,
        ServiceQuotaExceededException,
        ValidationException,
    ],
}));
/**
 * Creates a new storage configuration, used to enable recording to Amazon S3.
 * When a StorageConfiguration is created, IVS will modify the S3 bucketPolicy of the provided bucket.
 * This will ensure that IVS has sufficient permissions to write content to the provided bucket.
 */
export const createStorageConfiguration = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreateStorageConfigurationRequest,
    output: CreateStorageConfigurationResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        InternalServerException,
        PendingVerification,
        ResourceNotFoundException,
        ServiceQuotaExceededException,
        ValidationException,
    ],
}));
/**
 * Deletes an EncoderConfiguration resource. Ensures that no Compositions are using this
 * template; otherwise, returns an error.
 */
export const deleteEncoderConfiguration = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteEncoderConfigurationRequest,
    output: DeleteEncoderConfigurationResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        InternalServerException,
        ResourceNotFoundException,
        ServiceQuotaExceededException,
        ValidationException,
    ],
}));
/**
 * Deletes a specified IngestConfiguration, so it can no longer be used to broadcast. An IngestConfiguration cannot be deleted if the publisher is actively streaming to a stage, unless `force` is set to `true`.
 */
export const deleteIngestConfiguration = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteIngestConfigurationRequest,
    output: DeleteIngestConfigurationResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        PendingVerification,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Deletes the specified public key used to sign stage participant tokens.
 * This invalidates future participant tokens generated using the key pair’s private key.
 */
export const deletePublicKey = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeletePublicKeyRequest,
    output: DeletePublicKeyResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        PendingVerification,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Shuts down and deletes the specified stage (disconnecting all participants). This operation also
 * removes the `stageArn` from the associated IngestConfiguration, if there are participants
 * using the IngestConfiguration to publish to the stage.
 */
export const deleteStage = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteStageRequest,
    output: DeleteStageResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        PendingVerification,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Deletes the storage configuration for the specified ARN.
 *
 * If you try to delete a storage configuration that is used by a Composition, you will get an error (409 ConflictException).
 * To avoid this, for all Compositions that reference the storage configuration, first use StopComposition and wait for it to complete,
 * then use DeleteStorageConfiguration.
 */
export const deleteStorageConfiguration = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeleteStorageConfigurationRequest,
    output: DeleteStorageConfigurationResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        InternalServerException,
        ResourceNotFoundException,
        ServiceQuotaExceededException,
        ValidationException,
    ],
}));
/**
 * Disconnects a specified participant from a specified stage. If the participant is publishing using
 * an IngestConfiguration, DisconnectParticipant also updates the `stageArn`
 * in the IngestConfiguration to be an empty string.
 */
export const disconnectParticipant = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DisconnectParticipantRequest,
    output: DisconnectParticipantResponse,
    errors: [
        AccessDeniedException,
        PendingVerification,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Get information about the specified Composition resource.
 */
export const getComposition = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetCompositionRequest,
    output: GetCompositionResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        InternalServerException,
        ResourceNotFoundException,
        ServiceQuotaExceededException,
        ValidationException,
    ],
}));
/**
 * Gets information about the specified EncoderConfiguration resource.
 */
export const getEncoderConfiguration = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetEncoderConfigurationRequest,
    output: GetEncoderConfigurationResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        InternalServerException,
        ResourceNotFoundException,
        ServiceQuotaExceededException,
        ValidationException,
    ],
}));
/**
 * Gets information about the specified IngestConfiguration.
 */
export const getIngestConfiguration = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetIngestConfigurationRequest,
    output: GetIngestConfigurationResponse,
    errors: [
        AccessDeniedException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Gets information about the specified participant token.
 */
export const getParticipant = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetParticipantRequest,
    output: GetParticipantResponse,
    errors: [
        AccessDeniedException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Gets information for the specified public key.
 */
export const getPublicKey = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetPublicKeyRequest,
    output: GetPublicKeyResponse,
    errors: [
        AccessDeniedException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Gets information for the specified stage.
 */
export const getStage = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetStageRequest,
    output: GetStageResponse,
    errors: [
        AccessDeniedException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Gets information for the specified stage session.
 */
export const getStageSession = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetStageSessionRequest,
    output: GetStageSessionResponse,
    errors: [
        AccessDeniedException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Gets the storage configuration for the specified ARN.
 */
export const getStorageConfiguration = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: GetStorageConfigurationRequest,
    output: GetStorageConfigurationResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        InternalServerException,
        ResourceNotFoundException,
        ServiceQuotaExceededException,
        ValidationException,
    ],
}));
/**
 * Import a public key to be used for signing stage participant tokens.
 */
export const importPublicKey = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ImportPublicKeyRequest,
    output: ImportPublicKeyResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        PendingVerification,
        ServiceQuotaExceededException,
        ValidationException,
    ],
}));
/**
 * Gets summary information about all Compositions in your account, in the AWS region
 * where the API request is processed.
 */
export const listCompositions = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListCompositionsRequest,
    output: ListCompositionsResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        InternalServerException,
        ServiceQuotaExceededException,
        ValidationException,
    ],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        pageSize: "maxResults",
    },
}));
/**
 * Gets summary information about all EncoderConfigurations in your account, in the AWS
 * region where the API request is processed.
 */
export const listEncoderConfigurations = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListEncoderConfigurationsRequest,
    output: ListEncoderConfigurationsResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        InternalServerException,
        ServiceQuotaExceededException,
        ValidationException,
    ],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        pageSize: "maxResults",
    },
}));
/**
 * Lists all IngestConfigurations in your account, in the AWS region where the API request is processed.
 */
export const listIngestConfigurations = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListIngestConfigurationsRequest,
    output: ListIngestConfigurationsResponse,
    errors: [AccessDeniedException, ValidationException],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        items: "ingestConfigurations",
        pageSize: "maxResults",
    },
}));
/**
 * Lists events for a specified participant that occurred during a specified stage
 * session.
 */
export const listParticipantEvents = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListParticipantEventsRequest,
    output: ListParticipantEventsResponse,
    errors: [AccessDeniedException, ValidationException],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        pageSize: "maxResults",
    },
}));
/**
 * Lists all the replicas for a participant from a source stage.
 */
export const listParticipantReplicas = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListParticipantReplicasRequest,
    output: ListParticipantReplicasResponse,
    errors: [AccessDeniedException, ValidationException],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        items: "replicas",
        pageSize: "maxResults",
    },
}));
/**
 * Lists all participants in a specified stage session.
 */
export const listParticipants = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListParticipantsRequest,
    output: ListParticipantsResponse,
    errors: [AccessDeniedException, ValidationException],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        pageSize: "maxResults",
    },
}));
/**
 * Gets summary information about all public keys in your account, in the AWS region where the API request is processed.
 */
export const listPublicKeys = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListPublicKeysRequest,
    output: ListPublicKeysResponse,
    errors: [AccessDeniedException, ValidationException],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        items: "publicKeys",
        pageSize: "maxResults",
    },
}));
/**
 * Gets summary information about all stages in your account, in the AWS region where the
 * API request is processed.
 */
export const listStages = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListStagesRequest,
    output: ListStagesResponse,
    errors: [AccessDeniedException, ConflictException, ValidationException],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        pageSize: "maxResults",
    },
}));
/**
 * Gets all sessions for a specified stage.
 */
export const listStageSessions = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListStageSessionsRequest,
    output: ListStageSessionsResponse,
    errors: [AccessDeniedException, ValidationException],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        pageSize: "maxResults",
    },
}));
/**
 * Gets summary information about all storage configurations in your account,
 * in the AWS region where the API request is processed.
 */
export const listStorageConfigurations = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListStorageConfigurationsRequest,
    output: ListStorageConfigurationsResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        InternalServerException,
        ServiceQuotaExceededException,
        ValidationException,
    ],
    pagination: {
        inputToken: "nextToken",
        outputToken: "nextToken",
        pageSize: "maxResults",
    },
}));
/**
 * Gets information about AWS tags for the specified ARN.
 */
export const listTagsForResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListTagsForResourceRequest,
    output: ListTagsForResourceResponse,
    errors: [
        InternalServerException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Starts a Composition from a stage based on the configuration provided in the
 * request.
 *
 * A Composition is an ephemeral resource that exists after this operation returns
 * successfully. Composition stops and the resource is deleted:
 *
 * - When StopComposition is called.
 *
 * - After a 1-minute timeout, when all participants are disconnected from the
 * stage.
 *
 * - After a 1-minute timeout, if there are no participants in the stage when
 * StartComposition is called.
 *
 * - When broadcasting to the IVS channel fails and all retries are exhausted.
 *
 * - When broadcasting is disconnected and all attempts to reconnect are
 * exhausted.
 */
export const startComposition = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: StartCompositionRequest,
    output: StartCompositionResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        InternalServerException,
        PendingVerification,
        ResourceNotFoundException,
        ServiceQuotaExceededException,
        ValidationException,
    ],
}));
/**
 * Starts replicating a publishing participant from a source stage to a destination stage.
 */
export const startParticipantReplication = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: StartParticipantReplicationRequest,
    output: StartParticipantReplicationResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        InternalServerException,
        PendingVerification,
        ResourceNotFoundException,
        ServiceQuotaExceededException,
        ValidationException,
    ],
}));
/**
 * Stops and deletes a Composition resource. Any broadcast from the Composition resource
 * is stopped.
 */
export const stopComposition = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: StopCompositionRequest,
    output: StopCompositionResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        InternalServerException,
        ResourceNotFoundException,
        ServiceQuotaExceededException,
        ValidationException,
    ],
}));
/**
 * Stops a replicated participant session.
 */
export const stopParticipantReplication = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: StopParticipantReplicationRequest,
    output: StopParticipantReplicationResponse,
    errors: [
        AccessDeniedException,
        InternalServerException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Adds or updates tags for the AWS resource with the specified ARN.
 */
export const tagResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: TagResourceRequest,
    output: TagResourceResponse,
    errors: [
        InternalServerException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Removes tags from the resource with the specified ARN.
 */
export const untagResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UntagResourceRequest,
    output: UntagResourceResponse,
    errors: [
        InternalServerException,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Updates a specified IngestConfiguration. Only the stage ARN attached to the IngestConfiguration can be updated. An IngestConfiguration that is active cannot be updated.
 */
export const updateIngestConfiguration = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateIngestConfigurationRequest,
    output: UpdateIngestConfigurationResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        PendingVerification,
        ResourceNotFoundException,
        ValidationException,
    ],
}));
/**
 * Updates a stage’s configuration.
 */
export const updateStage = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdateStageRequest,
    output: UpdateStageResponse,
    errors: [
        AccessDeniedException,
        ConflictException,
        PendingVerification,
        ResourceNotFoundException,
        ServiceQuotaExceededException,
        ValidationException,
    ],
}));
//# sourceMappingURL=ivs-realtime.js.map