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.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type ChannelName = string;
export type MessageTtlSeconds = number;
export type TagKey = string;
export type TagValue = string;
export type ResourceARN = string;
export type ErrorMessage = string;
export type DeviceName = string;
export type StreamName = string;
export type MediaType = string;
export type KmsKeyId = string;
export type DataRetentionInHours = number;
export type Version = string;
export type FailedStatusDetails = string;
export type HubDeviceArn = string;
export type MediaUriSecretArn = string | redacted.Redacted<string>;
export type ScheduleExpression = string;
export type DurationInSeconds = number;
export type EdgeRetentionInHours = number;
export type MaxLocalMediaSizeInMB = number;
export type DeleteAfterUpload = boolean;
export type JobStatusDetails = string;
export type DestinationUri = string;
export type DestinationRegion = string;
export type SamplingInterval = number;
export type FormatConfigValue = string;
export type WidthPixels = number;
export type HeightPixels = number;
export type MappedResourceConfigurationListLimit = number;
export type NextToken = string;
export type Type = string;
export type DataEndpoint = string;
export type ResourceEndpoint = string;
export type ListEdgeAgentConfigurationsInputLimit = number;
export type ListStreamsInputLimit = number;
export type DataRetentionChangeInHours = number;
export type ChannelType = "SINGLE_MASTER" | "FULL_MESH" | (string & {});
export declare const ChannelType: S.String;
export interface SingleMasterConfiguration {
    MessageTtlSeconds?: number;
}
export declare const SingleMasterConfiguration: S.Schema<SingleMasterConfiguration>;
export interface Tag {
    Key: string;
    Value: string;
}
export declare const Tag: S.Schema<Tag>;
export type TagOnCreateList = Tag[];
export declare const TagOnCreateList: S.$Array<S.Schema<Tag>>;
export interface CreateSignalingChannelInput {
    ChannelName: string;
    ChannelType?: ChannelType;
    SingleMasterConfiguration?: SingleMasterConfiguration;
    Tags?: Tag[];
}
export declare const CreateSignalingChannelInput: S.Schema<CreateSignalingChannelInput>;
export interface CreateSignalingChannelOutput {
    ChannelARN?: string;
}
export declare const CreateSignalingChannelOutput: S.Schema<CreateSignalingChannelOutput>;
export type ResourceTags = {
    [key: string]: string | undefined;
};
export declare const ResourceTags: S.$Record<S.String, S.optional<S.String>>;
export type DefaultStorageTier = "HOT" | "WARM" | (string & {});
export declare const DefaultStorageTier: S.String;
export interface StreamStorageConfiguration {
    DefaultStorageTier: DefaultStorageTier;
}
export declare const StreamStorageConfiguration: S.Schema<StreamStorageConfiguration>;
export interface CreateStreamInput {
    DeviceName?: string;
    StreamName: string;
    MediaType?: string;
    KmsKeyId?: string;
    DataRetentionInHours?: number;
    Tags?: {
        [key: string]: string | undefined;
    };
    StreamStorageConfiguration?: StreamStorageConfiguration;
}
export declare const CreateStreamInput: S.Schema<CreateStreamInput>;
export interface CreateStreamOutput {
    StreamARN?: string;
}
export declare const CreateStreamOutput: S.Schema<CreateStreamOutput>;
export interface DeleteEdgeConfigurationInput {
    StreamName?: string;
    StreamARN?: string;
}
export declare const DeleteEdgeConfigurationInput: S.Schema<DeleteEdgeConfigurationInput>;
export interface DeleteEdgeConfigurationOutput {
}
export declare const DeleteEdgeConfigurationOutput: S.Schema<DeleteEdgeConfigurationOutput>;
export interface DeleteSignalingChannelInput {
    ChannelARN: string;
    CurrentVersion?: string;
}
export declare const DeleteSignalingChannelInput: S.Schema<DeleteSignalingChannelInput>;
export interface DeleteSignalingChannelOutput {
}
export declare const DeleteSignalingChannelOutput: S.Schema<DeleteSignalingChannelOutput>;
export interface DeleteStreamInput {
    StreamARN: string;
    CurrentVersion?: string;
}
export declare const DeleteStreamInput: S.Schema<DeleteStreamInput>;
export interface DeleteStreamOutput {
}
export declare const DeleteStreamOutput: S.Schema<DeleteStreamOutput>;
export interface DescribeEdgeConfigurationInput {
    StreamName?: string;
    StreamARN?: string;
}
export declare const DescribeEdgeConfigurationInput: S.Schema<DescribeEdgeConfigurationInput>;
export type SyncStatus = "SYNCING" | "ACKNOWLEDGED" | "IN_SYNC" | "SYNC_FAILED" | "DELETING" | "DELETE_FAILED" | "DELETING_ACKNOWLEDGED" | (string & {});
export declare const SyncStatus: S.String;
export type MediaUriType = "RTSP_URI" | "FILE_URI" | (string & {});
export declare const MediaUriType: S.String;
export interface MediaSourceConfig {
    MediaUriSecretArn: string | redacted.Redacted<string>;
    MediaUriType: MediaUriType;
}
export declare const MediaSourceConfig: S.Schema<MediaSourceConfig>;
export interface ScheduleConfig {
    ScheduleExpression: string;
    DurationInSeconds: number;
}
export declare const ScheduleConfig: S.Schema<ScheduleConfig>;
export interface RecorderConfig {
    MediaSourceConfig: MediaSourceConfig;
    ScheduleConfig?: ScheduleConfig;
}
export declare const RecorderConfig: S.Schema<RecorderConfig>;
export interface UploaderConfig {
    ScheduleConfig: ScheduleConfig;
}
export declare const UploaderConfig: S.Schema<UploaderConfig>;
export type StrategyOnFullSize = "DELETE_OLDEST_MEDIA" | "DENY_NEW_MEDIA" | (string & {});
export declare const StrategyOnFullSize: S.String;
export interface LocalSizeConfig {
    MaxLocalMediaSizeInMB?: number;
    StrategyOnFullSize?: StrategyOnFullSize;
}
export declare const LocalSizeConfig: S.Schema<LocalSizeConfig>;
export interface DeletionConfig {
    EdgeRetentionInHours?: number;
    LocalSizeConfig?: LocalSizeConfig;
    DeleteAfterUpload?: boolean;
}
export declare const DeletionConfig: S.Schema<DeletionConfig>;
export interface EdgeConfig {
    HubDeviceArn: string;
    RecorderConfig: RecorderConfig;
    UploaderConfig?: UploaderConfig;
    DeletionConfig?: DeletionConfig;
}
export declare const EdgeConfig: S.Schema<EdgeConfig>;
export type RecorderStatus = "SUCCESS" | "USER_ERROR" | "SYSTEM_ERROR" | (string & {});
export declare const RecorderStatus: S.String;
export interface LastRecorderStatus {
    JobStatusDetails?: string;
    LastCollectedTime?: Date;
    LastUpdatedTime?: Date;
    RecorderStatus?: RecorderStatus;
}
export declare const LastRecorderStatus: S.Schema<LastRecorderStatus>;
export type UploaderStatus = "SUCCESS" | "USER_ERROR" | "SYSTEM_ERROR" | (string & {});
export declare const UploaderStatus: S.String;
export interface LastUploaderStatus {
    JobStatusDetails?: string;
    LastCollectedTime?: Date;
    LastUpdatedTime?: Date;
    UploaderStatus?: UploaderStatus;
}
export declare const LastUploaderStatus: S.Schema<LastUploaderStatus>;
export interface EdgeAgentStatus {
    LastRecorderStatus?: LastRecorderStatus;
    LastUploaderStatus?: LastUploaderStatus;
}
export declare const EdgeAgentStatus: S.Schema<EdgeAgentStatus>;
export interface DescribeEdgeConfigurationOutput {
    StreamName?: string;
    StreamARN?: string;
    CreationTime?: Date;
    LastUpdatedTime?: Date;
    SyncStatus?: SyncStatus;
    FailedStatusDetails?: string;
    EdgeConfig?: EdgeConfig;
    EdgeAgentStatus?: EdgeAgentStatus;
}
export declare const DescribeEdgeConfigurationOutput: S.Schema<DescribeEdgeConfigurationOutput>;
export interface DescribeImageGenerationConfigurationInput {
    StreamName?: string;
    StreamARN?: string;
}
export declare const DescribeImageGenerationConfigurationInput: S.Schema<DescribeImageGenerationConfigurationInput>;
export type ConfigurationStatus = "ENABLED" | "DISABLED" | (string & {});
export declare const ConfigurationStatus: S.String;
export type ImageSelectorType = "SERVER_TIMESTAMP" | "PRODUCER_TIMESTAMP" | (string & {});
export declare const ImageSelectorType: S.String;
export interface ImageGenerationDestinationConfig {
    Uri: string;
    DestinationRegion: string;
}
export declare const ImageGenerationDestinationConfig: S.Schema<ImageGenerationDestinationConfig>;
export type Format = "JPEG" | "PNG" | (string & {});
export declare const Format: S.String;
export type FormatConfigKey = "JPEGQuality" | (string & {});
export declare const FormatConfigKey: S.String;
export type FormatConfig = {
    [key in FormatConfigKey]?: string;
};
export declare const FormatConfig: S.$Record<S.String, S.optional<S.String>>;
export interface ImageGenerationConfiguration {
    Status: ConfigurationStatus;
    ImageSelectorType: ImageSelectorType;
    DestinationConfig: ImageGenerationDestinationConfig;
    SamplingInterval: number;
    Format: Format;
    FormatConfig?: {
        [key: string]: string | undefined;
    };
    WidthPixels?: number;
    HeightPixels?: number;
}
export declare const ImageGenerationConfiguration: S.Schema<ImageGenerationConfiguration>;
export interface DescribeImageGenerationConfigurationOutput {
    ImageGenerationConfiguration?: ImageGenerationConfiguration;
}
export declare const DescribeImageGenerationConfigurationOutput: S.Schema<DescribeImageGenerationConfigurationOutput>;
export interface DescribeMappedResourceConfigurationInput {
    StreamName?: string;
    StreamARN?: string;
    MaxResults?: number;
    NextToken?: string;
}
export declare const DescribeMappedResourceConfigurationInput: S.Schema<DescribeMappedResourceConfigurationInput>;
export interface MappedResourceConfigurationListItem {
    Type?: string;
    ARN?: string;
}
export declare const MappedResourceConfigurationListItem: S.Schema<MappedResourceConfigurationListItem>;
export type MappedResourceConfigurationList = MappedResourceConfigurationListItem[];
export declare const MappedResourceConfigurationList: S.$Array<S.Schema<MappedResourceConfigurationListItem>>;
export interface DescribeMappedResourceConfigurationOutput {
    MappedResourceConfigurationList?: MappedResourceConfigurationListItem[];
    NextToken?: string;
}
export declare const DescribeMappedResourceConfigurationOutput: S.Schema<DescribeMappedResourceConfigurationOutput>;
export interface DescribeMediaStorageConfigurationInput {
    ChannelName?: string;
    ChannelARN?: string;
}
export declare const DescribeMediaStorageConfigurationInput: S.Schema<DescribeMediaStorageConfigurationInput>;
export type MediaStorageConfigurationStatus = "ENABLED" | "DISABLED" | (string & {});
export declare const MediaStorageConfigurationStatus: S.String;
export interface MediaStorageConfiguration {
    StreamARN?: string;
    Status: MediaStorageConfigurationStatus;
}
export declare const MediaStorageConfiguration: S.Schema<MediaStorageConfiguration>;
export interface DescribeMediaStorageConfigurationOutput {
    MediaStorageConfiguration?: MediaStorageConfiguration;
}
export declare const DescribeMediaStorageConfigurationOutput: S.Schema<DescribeMediaStorageConfigurationOutput>;
export interface DescribeNotificationConfigurationInput {
    StreamName?: string;
    StreamARN?: string;
}
export declare const DescribeNotificationConfigurationInput: S.Schema<DescribeNotificationConfigurationInput>;
export interface NotificationDestinationConfig {
    Uri: string;
}
export declare const NotificationDestinationConfig: S.Schema<NotificationDestinationConfig>;
export interface NotificationConfiguration {
    Status: ConfigurationStatus;
    DestinationConfig: NotificationDestinationConfig;
}
export declare const NotificationConfiguration: S.Schema<NotificationConfiguration>;
export interface DescribeNotificationConfigurationOutput {
    NotificationConfiguration?: NotificationConfiguration;
}
export declare const DescribeNotificationConfigurationOutput: S.Schema<DescribeNotificationConfigurationOutput>;
export interface DescribeSignalingChannelInput {
    ChannelName?: string;
    ChannelARN?: string;
}
export declare const DescribeSignalingChannelInput: S.Schema<DescribeSignalingChannelInput>;
export type Status = "CREATING" | "ACTIVE" | "UPDATING" | "DELETING" | (string & {});
export declare const Status: S.String;
export interface ChannelInfo {
    ChannelName?: string;
    ChannelARN?: string;
    ChannelType?: ChannelType;
    ChannelStatus?: Status;
    CreationTime?: Date;
    SingleMasterConfiguration?: SingleMasterConfiguration;
    Version?: string;
}
export declare const ChannelInfo: S.Schema<ChannelInfo>;
export interface DescribeSignalingChannelOutput {
    ChannelInfo?: ChannelInfo;
}
export declare const DescribeSignalingChannelOutput: S.Schema<DescribeSignalingChannelOutput>;
export interface DescribeStreamInput {
    StreamName?: string;
    StreamARN?: string;
}
export declare const DescribeStreamInput: S.Schema<DescribeStreamInput>;
export interface StreamInfo {
    DeviceName?: string;
    StreamName?: string;
    StreamARN?: string;
    MediaType?: string;
    KmsKeyId?: string;
    Version?: string;
    Status?: Status;
    CreationTime?: Date;
    DataRetentionInHours?: number;
}
export declare const StreamInfo: S.Schema<StreamInfo>;
export interface DescribeStreamOutput {
    StreamInfo?: StreamInfo;
}
export declare const DescribeStreamOutput: S.Schema<DescribeStreamOutput>;
export interface DescribeStreamStorageConfigurationInput {
    StreamName?: string;
    StreamARN?: string;
}
export declare const DescribeStreamStorageConfigurationInput: S.Schema<DescribeStreamStorageConfigurationInput>;
export interface DescribeStreamStorageConfigurationOutput {
    StreamName?: string;
    StreamARN?: string;
    StreamStorageConfiguration?: StreamStorageConfiguration;
}
export declare const DescribeStreamStorageConfigurationOutput: S.Schema<DescribeStreamStorageConfigurationOutput>;
export type APIName = "PUT_MEDIA" | "GET_MEDIA" | "LIST_FRAGMENTS" | "GET_MEDIA_FOR_FRAGMENT_LIST" | "GET_HLS_STREAMING_SESSION_URL" | "GET_DASH_STREAMING_SESSION_URL" | "GET_CLIP" | "GET_IMAGES" | (string & {});
export declare const APIName: S.String;
export interface GetDataEndpointInput {
    StreamName?: string;
    StreamARN?: string;
    APIName: APIName;
}
export declare const GetDataEndpointInput: S.Schema<GetDataEndpointInput>;
export interface GetDataEndpointOutput {
    DataEndpoint?: string;
}
export declare const GetDataEndpointOutput: S.Schema<GetDataEndpointOutput>;
export type ChannelProtocol = "WSS" | "HTTPS" | "WEBRTC" | (string & {});
export declare const ChannelProtocol: S.String;
export type ListOfProtocols = ChannelProtocol[];
export declare const ListOfProtocols: S.$Array<S.String>;
export type ChannelRole = "MASTER" | "VIEWER" | (string & {});
export declare const ChannelRole: S.String;
export interface SingleMasterChannelEndpointConfiguration {
    Protocols?: ChannelProtocol[];
    Role?: ChannelRole;
}
export declare const SingleMasterChannelEndpointConfiguration: S.Schema<SingleMasterChannelEndpointConfiguration>;
export interface GetSignalingChannelEndpointInput {
    ChannelARN: string;
    SingleMasterChannelEndpointConfiguration?: SingleMasterChannelEndpointConfiguration;
}
export declare const GetSignalingChannelEndpointInput: S.Schema<GetSignalingChannelEndpointInput>;
export interface ResourceEndpointListItem {
    Protocol?: ChannelProtocol;
    ResourceEndpoint?: string;
}
export declare const ResourceEndpointListItem: S.Schema<ResourceEndpointListItem>;
export type ResourceEndpointList = ResourceEndpointListItem[];
export declare const ResourceEndpointList: S.$Array<S.Schema<ResourceEndpointListItem>>;
export interface GetSignalingChannelEndpointOutput {
    ResourceEndpointList?: ResourceEndpointListItem[];
}
export declare const GetSignalingChannelEndpointOutput: S.Schema<GetSignalingChannelEndpointOutput>;
export interface ListEdgeAgentConfigurationsInput {
    HubDeviceArn: string;
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListEdgeAgentConfigurationsInput: S.Schema<ListEdgeAgentConfigurationsInput>;
export interface ListEdgeAgentConfigurationsEdgeConfig {
    StreamName?: string;
    StreamARN?: string;
    CreationTime?: Date;
    LastUpdatedTime?: Date;
    SyncStatus?: SyncStatus;
    FailedStatusDetails?: string;
    EdgeConfig?: EdgeConfig;
}
export declare const ListEdgeAgentConfigurationsEdgeConfig: S.Schema<ListEdgeAgentConfigurationsEdgeConfig>;
export type ListEdgeAgentConfigurationsEdgeConfigList = ListEdgeAgentConfigurationsEdgeConfig[];
export declare const ListEdgeAgentConfigurationsEdgeConfigList: S.$Array<S.Schema<ListEdgeAgentConfigurationsEdgeConfig>>;
export interface ListEdgeAgentConfigurationsOutput {
    EdgeConfigs?: ListEdgeAgentConfigurationsEdgeConfig[];
    NextToken?: string;
}
export declare const ListEdgeAgentConfigurationsOutput: S.Schema<ListEdgeAgentConfigurationsOutput>;
export type ComparisonOperator = "BEGINS_WITH" | (string & {});
export declare const ComparisonOperator: S.String;
export interface ChannelNameCondition {
    ComparisonOperator?: ComparisonOperator;
    ComparisonValue?: string;
}
export declare const ChannelNameCondition: S.Schema<ChannelNameCondition>;
export interface ListSignalingChannelsInput {
    MaxResults?: number;
    NextToken?: string;
    ChannelNameCondition?: ChannelNameCondition;
}
export declare const ListSignalingChannelsInput: S.Schema<ListSignalingChannelsInput>;
export type ChannelInfoList = ChannelInfo[];
export declare const ChannelInfoList: S.$Array<S.Schema<ChannelInfo>>;
export interface ListSignalingChannelsOutput {
    ChannelInfoList?: ChannelInfo[];
    NextToken?: string;
}
export declare const ListSignalingChannelsOutput: S.Schema<ListSignalingChannelsOutput>;
export interface StreamNameCondition {
    ComparisonOperator?: ComparisonOperator;
    ComparisonValue?: string;
}
export declare const StreamNameCondition: S.Schema<StreamNameCondition>;
export interface ListStreamsInput {
    MaxResults?: number;
    NextToken?: string;
    StreamNameCondition?: StreamNameCondition;
}
export declare const ListStreamsInput: S.Schema<ListStreamsInput>;
export type StreamInfoList = StreamInfo[];
export declare const StreamInfoList: S.$Array<S.Schema<StreamInfo>>;
export interface ListStreamsOutput {
    StreamInfoList?: StreamInfo[];
    NextToken?: string;
}
export declare const ListStreamsOutput: S.Schema<ListStreamsOutput>;
export interface ListTagsForResourceInput {
    NextToken?: string;
    ResourceARN: string;
}
export declare const ListTagsForResourceInput: S.Schema<ListTagsForResourceInput>;
export interface ListTagsForResourceOutput {
    NextToken?: string;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const ListTagsForResourceOutput: S.Schema<ListTagsForResourceOutput>;
export interface ListTagsForStreamInput {
    NextToken?: string;
    StreamARN?: string;
    StreamName?: string;
}
export declare const ListTagsForStreamInput: S.Schema<ListTagsForStreamInput>;
export interface ListTagsForStreamOutput {
    NextToken?: string;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const ListTagsForStreamOutput: S.Schema<ListTagsForStreamOutput>;
export interface StartEdgeConfigurationUpdateInput {
    StreamName?: string;
    StreamARN?: string;
    EdgeConfig: EdgeConfig;
}
export declare const StartEdgeConfigurationUpdateInput: S.Schema<StartEdgeConfigurationUpdateInput>;
export interface StartEdgeConfigurationUpdateOutput {
    StreamName?: string;
    StreamARN?: string;
    CreationTime?: Date;
    LastUpdatedTime?: Date;
    SyncStatus?: SyncStatus;
    FailedStatusDetails?: string;
    EdgeConfig?: EdgeConfig;
}
export declare const StartEdgeConfigurationUpdateOutput: S.Schema<StartEdgeConfigurationUpdateOutput>;
export type TagList = Tag[];
export declare const TagList: S.$Array<S.Schema<Tag>>;
export interface TagResourceInput {
    ResourceARN: string;
    Tags: Tag[];
}
export declare const TagResourceInput: S.Schema<TagResourceInput>;
export interface TagResourceOutput {
}
export declare const TagResourceOutput: S.Schema<TagResourceOutput>;
export interface TagStreamInput {
    StreamARN?: string;
    StreamName?: string;
    Tags: {
        [key: string]: string | undefined;
    };
}
export declare const TagStreamInput: S.Schema<TagStreamInput>;
export interface TagStreamOutput {
}
export declare const TagStreamOutput: S.Schema<TagStreamOutput>;
export type TagKeyList = string[];
export declare const TagKeyList: S.$Array<S.String>;
export interface UntagResourceInput {
    ResourceARN: string;
    TagKeyList: string[];
}
export declare const UntagResourceInput: S.Schema<UntagResourceInput>;
export interface UntagResourceOutput {
}
export declare const UntagResourceOutput: S.Schema<UntagResourceOutput>;
export interface UntagStreamInput {
    StreamARN?: string;
    StreamName?: string;
    TagKeyList: string[];
}
export declare const UntagStreamInput: S.Schema<UntagStreamInput>;
export interface UntagStreamOutput {
}
export declare const UntagStreamOutput: S.Schema<UntagStreamOutput>;
export type UpdateDataRetentionOperation = "INCREASE_DATA_RETENTION" | "DECREASE_DATA_RETENTION" | (string & {});
export declare const UpdateDataRetentionOperation: S.String;
export interface UpdateDataRetentionInput {
    StreamName?: string;
    StreamARN?: string;
    CurrentVersion: string;
    Operation: UpdateDataRetentionOperation;
    DataRetentionChangeInHours: number;
}
export declare const UpdateDataRetentionInput: S.Schema<UpdateDataRetentionInput>;
export interface UpdateDataRetentionOutput {
}
export declare const UpdateDataRetentionOutput: S.Schema<UpdateDataRetentionOutput>;
export interface UpdateImageGenerationConfigurationInput {
    StreamName?: string;
    StreamARN?: string;
    ImageGenerationConfiguration?: ImageGenerationConfiguration;
}
export declare const UpdateImageGenerationConfigurationInput: S.Schema<UpdateImageGenerationConfigurationInput>;
export interface UpdateImageGenerationConfigurationOutput {
}
export declare const UpdateImageGenerationConfigurationOutput: S.Schema<UpdateImageGenerationConfigurationOutput>;
export interface UpdateMediaStorageConfigurationInput {
    ChannelARN: string;
    MediaStorageConfiguration: MediaStorageConfiguration;
}
export declare const UpdateMediaStorageConfigurationInput: S.Schema<UpdateMediaStorageConfigurationInput>;
export interface UpdateMediaStorageConfigurationOutput {
}
export declare const UpdateMediaStorageConfigurationOutput: S.Schema<UpdateMediaStorageConfigurationOutput>;
export interface UpdateNotificationConfigurationInput {
    StreamName?: string;
    StreamARN?: string;
    NotificationConfiguration?: NotificationConfiguration;
}
export declare const UpdateNotificationConfigurationInput: S.Schema<UpdateNotificationConfigurationInput>;
export interface UpdateNotificationConfigurationOutput {
}
export declare const UpdateNotificationConfigurationOutput: S.Schema<UpdateNotificationConfigurationOutput>;
export interface UpdateSignalingChannelInput {
    ChannelARN: string;
    CurrentVersion: string;
    SingleMasterConfiguration?: SingleMasterConfiguration;
}
export declare const UpdateSignalingChannelInput: S.Schema<UpdateSignalingChannelInput>;
export interface UpdateSignalingChannelOutput {
}
export declare const UpdateSignalingChannelOutput: S.Schema<UpdateSignalingChannelOutput>;
export interface UpdateStreamInput {
    StreamName?: string;
    StreamARN?: string;
    CurrentVersion: string;
    DeviceName?: string;
    MediaType?: string;
}
export declare const UpdateStreamInput: S.Schema<UpdateStreamInput>;
export interface UpdateStreamOutput {
}
export declare const UpdateStreamOutput: S.Schema<UpdateStreamOutput>;
export interface UpdateStreamStorageConfigurationInput {
    StreamName?: string;
    StreamARN?: string;
    CurrentVersion: string;
    StreamStorageConfiguration: StreamStorageConfiguration;
}
export declare const UpdateStreamStorageConfigurationInput: S.Schema<UpdateStreamStorageConfigurationInput>;
export interface UpdateStreamStorageConfigurationOutput {
}
export declare const UpdateStreamStorageConfigurationOutput: S.Schema<UpdateStreamStorageConfigurationOutput>;
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class AccessDeniedException extends AccessDeniedException_base {
}
declare const AccountChannelLimitExceededException_base: S.Class<AccountChannelLimitExceededException, S.TaggedStruct<"AccountChannelLimitExceededException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class AccountChannelLimitExceededException extends AccountChannelLimitExceededException_base {
}
declare const ClientLimitExceededException_base: S.Class<ClientLimitExceededException, S.TaggedStruct<"ClientLimitExceededException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ClientLimitExceededException extends ClientLimitExceededException_base {
}
declare const InvalidArgumentException_base: S.Class<InvalidArgumentException, S.TaggedStruct<"InvalidArgumentException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidArgumentException extends InvalidArgumentException_base {
}
declare const ResourceInUseException_base: S.Class<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceInUseException extends ResourceInUseException_base {
}
declare const TagsPerResourceExceededLimitException_base: S.Class<TagsPerResourceExceededLimitException, S.TaggedStruct<"TagsPerResourceExceededLimitException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class TagsPerResourceExceededLimitException extends TagsPerResourceExceededLimitException_base {
}
declare const AccountStreamLimitExceededException_base: S.Class<AccountStreamLimitExceededException, S.TaggedStruct<"AccountStreamLimitExceededException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class AccountStreamLimitExceededException extends AccountStreamLimitExceededException_base {
}
declare const DeviceStreamLimitExceededException_base: S.Class<DeviceStreamLimitExceededException, S.TaggedStruct<"DeviceStreamLimitExceededException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class DeviceStreamLimitExceededException extends DeviceStreamLimitExceededException_base {
}
declare const InvalidDeviceException_base: S.Class<InvalidDeviceException, S.TaggedStruct<"InvalidDeviceException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidDeviceException extends InvalidDeviceException_base {
}
declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
}
declare const StreamEdgeConfigurationNotFoundException_base: S.Class<StreamEdgeConfigurationNotFoundException, S.TaggedStruct<"StreamEdgeConfigurationNotFoundException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class StreamEdgeConfigurationNotFoundException extends StreamEdgeConfigurationNotFoundException_base {
}
declare const VersionMismatchException_base: S.Class<VersionMismatchException, S.TaggedStruct<"VersionMismatchException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class VersionMismatchException extends VersionMismatchException_base {
}
declare const NotAuthorizedException_base: S.Class<NotAuthorizedException, S.TaggedStruct<"NotAuthorizedException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class NotAuthorizedException extends NotAuthorizedException_base {
}
declare const InvalidResourceFormatException_base: S.Class<InvalidResourceFormatException, S.TaggedStruct<"InvalidResourceFormatException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidResourceFormatException extends InvalidResourceFormatException_base {
}
declare const NoDataRetentionException_base: S.Class<NoDataRetentionException, S.TaggedStruct<"NoDataRetentionException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class NoDataRetentionException extends NoDataRetentionException_base {
}
export type CreateSignalingChannelError = AccessDeniedException | AccountChannelLimitExceededException | ClientLimitExceededException | InvalidArgumentException | ResourceInUseException | TagsPerResourceExceededLimitException | CommonErrors;
/**
 * Creates a signaling channel.
 *
 * `CreateSignalingChannel` is an asynchronous operation.
 */
export declare const createSignalingChannel: API.OperationMethod<CreateSignalingChannelInput, CreateSignalingChannelOutput, CreateSignalingChannelError, Credentials | Region | HttpClient.HttpClient>;
export type CreateStreamError = AccountStreamLimitExceededException | ClientLimitExceededException | DeviceStreamLimitExceededException | InvalidArgumentException | InvalidDeviceException | ResourceInUseException | TagsPerResourceExceededLimitException | CommonErrors;
/**
 * Creates a new Kinesis video stream.
 *
 * When you create a new stream, Kinesis Video Streams assigns it a version number.
 * When you change the stream's metadata, Kinesis Video Streams updates the version.
 *
 * `CreateStream` is an asynchronous operation.
 *
 * For information about how the service works, see How it Works.
 *
 * You must have permissions for the `KinesisVideo:CreateStream`
 * action.
 */
export declare const createStream: API.OperationMethod<CreateStreamInput, CreateStreamOutput, CreateStreamError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteEdgeConfigurationError = AccessDeniedException | ClientLimitExceededException | InvalidArgumentException | ResourceNotFoundException | StreamEdgeConfigurationNotFoundException | CommonErrors;
/**
 * An asynchronous API that deletes a stream’s existing edge configuration, as well as the corresponding media from the Edge Agent.
 *
 * When you invoke this API, the sync status is set to `DELETING`. A deletion process starts, in which active edge jobs are stopped and all media is deleted from the edge device. The time to delete varies, depending on the total amount of stored media. If the deletion process fails, the sync status changes to `DELETE_FAILED`. You will need to re-try the deletion.
 *
 * When the deletion process has completed successfully, the edge configuration is no longer accessible.
 */
export declare const deleteEdgeConfiguration: API.OperationMethod<DeleteEdgeConfigurationInput, DeleteEdgeConfigurationOutput, DeleteEdgeConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteSignalingChannelError = AccessDeniedException | ClientLimitExceededException | InvalidArgumentException | ResourceInUseException | ResourceNotFoundException | VersionMismatchException | CommonErrors;
/**
 * Deletes a specified signaling channel. `DeleteSignalingChannel` is an
 * asynchronous operation. If you don't specify the channel's current version, the most
 * recent version is deleted.
 */
export declare const deleteSignalingChannel: API.OperationMethod<DeleteSignalingChannelInput, DeleteSignalingChannelOutput, DeleteSignalingChannelError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteStreamError = ClientLimitExceededException | InvalidArgumentException | NotAuthorizedException | ResourceInUseException | ResourceNotFoundException | VersionMismatchException | CommonErrors;
/**
 * Deletes a Kinesis video stream and the data contained in the stream.
 *
 * This method marks the stream for deletion, and makes the data in the stream
 * inaccessible immediately.
 *
 * To ensure that you have the latest version of the stream before deleting it, you
 * can specify the stream version. Kinesis Video Streams assigns a version to each stream.
 * When you update a stream, Kinesis Video Streams assigns a new version number. To get the
 * latest stream version, use the `DescribeStream` API.
 *
 * This operation requires permission for the `KinesisVideo:DeleteStream`
 * action.
 */
export declare const deleteStream: API.OperationMethod<DeleteStreamInput, DeleteStreamOutput, DeleteStreamError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeEdgeConfigurationError = AccessDeniedException | ClientLimitExceededException | InvalidArgumentException | ResourceNotFoundException | StreamEdgeConfigurationNotFoundException | CommonErrors;
/**
 * Describes a stream’s edge configuration that was set using the
 * `StartEdgeConfigurationUpdate` API and the latest status of the edge
 * agent's recorder and uploader jobs. Use this API to get the status of the configuration
 * to determine if the configuration is in sync with the Edge Agent. Use this API to
 * evaluate the health of the Edge Agent.
 */
export declare const describeEdgeConfiguration: API.OperationMethod<DescribeEdgeConfigurationInput, DescribeEdgeConfigurationOutput, DescribeEdgeConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeImageGenerationConfigurationError = AccessDeniedException | ClientLimitExceededException | InvalidArgumentException | ResourceNotFoundException | CommonErrors;
/**
 * Gets the `ImageGenerationConfiguration` for a given Kinesis video stream.
 */
export declare const describeImageGenerationConfiguration: API.OperationMethod<DescribeImageGenerationConfigurationInput, DescribeImageGenerationConfigurationOutput, DescribeImageGenerationConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeMappedResourceConfigurationError = AccessDeniedException | ClientLimitExceededException | InvalidArgumentException | ResourceNotFoundException | CommonErrors;
/**
 * Returns the most current information about the stream. The `streamName`
 * or `streamARN` should be provided in the input.
 */
export declare const describeMappedResourceConfiguration: API.OperationMethod<DescribeMappedResourceConfigurationInput, DescribeMappedResourceConfigurationOutput, DescribeMappedResourceConfigurationError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: DescribeMappedResourceConfigurationInput) => stream.Stream<DescribeMappedResourceConfigurationOutput, DescribeMappedResourceConfigurationError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: DescribeMappedResourceConfigurationInput) => stream.Stream<MappedResourceConfigurationListItem, DescribeMappedResourceConfigurationError, Credentials | Region | HttpClient.HttpClient>;
};
export type DescribeMediaStorageConfigurationError = AccessDeniedException | ClientLimitExceededException | InvalidArgumentException | ResourceNotFoundException | CommonErrors;
/**
 * Returns the most current information about the channel. Specify the `ChannelName`
 * or `ChannelARN` in the input.
 */
export declare const describeMediaStorageConfiguration: API.OperationMethod<DescribeMediaStorageConfigurationInput, DescribeMediaStorageConfigurationOutput, DescribeMediaStorageConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeNotificationConfigurationError = AccessDeniedException | ClientLimitExceededException | InvalidArgumentException | ResourceNotFoundException | CommonErrors;
/**
 * Gets the `NotificationConfiguration` for a given Kinesis video stream.
 */
export declare const describeNotificationConfiguration: API.OperationMethod<DescribeNotificationConfigurationInput, DescribeNotificationConfigurationOutput, DescribeNotificationConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeSignalingChannelError = AccessDeniedException | ClientLimitExceededException | InvalidArgumentException | ResourceNotFoundException | CommonErrors;
/**
 * Returns the most current information about the signaling channel. You must specify
 * either the name or the Amazon Resource Name (ARN) of the channel that you want to
 * describe.
 */
export declare const describeSignalingChannel: API.OperationMethod<DescribeSignalingChannelInput, DescribeSignalingChannelOutput, DescribeSignalingChannelError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeStreamError = ClientLimitExceededException | InvalidArgumentException | NotAuthorizedException | ResourceNotFoundException | CommonErrors;
/**
 * Returns the most current information about the specified stream. You must specify
 * either the `StreamName` or the `StreamARN`.
 */
export declare const describeStream: API.OperationMethod<DescribeStreamInput, DescribeStreamOutput, DescribeStreamError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeStreamStorageConfigurationError = AccessDeniedException | ClientLimitExceededException | InvalidArgumentException | ResourceNotFoundException | CommonErrors;
/**
 * Retrieves the current storage configuration for the specified Kinesis video stream.
 *
 * In the request, you must specify either the `StreamName` or the `StreamARN`.
 *
 * You must have permissions for the `KinesisVideo:DescribeStreamStorageConfiguration` action.
 */
export declare const describeStreamStorageConfiguration: API.OperationMethod<DescribeStreamStorageConfigurationInput, DescribeStreamStorageConfigurationOutput, DescribeStreamStorageConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type GetDataEndpointError = ClientLimitExceededException | InvalidArgumentException | NotAuthorizedException | ResourceNotFoundException | CommonErrors;
/**
 * Gets an endpoint for a specified stream for either reading or writing. Use this
 * endpoint in your application to read from the specified stream (using the
 * `GetMedia` or `GetMediaForFragmentList` operations) or write
 * to it (using the `PutMedia` operation).
 *
 * The returned endpoint does not have the API name appended. The client needs to
 * add the API name to the returned endpoint.
 *
 * In the request, specify the stream either by `StreamName` or
 * `StreamARN`.
 */
export declare const getDataEndpoint: API.OperationMethod<GetDataEndpointInput, GetDataEndpointOutput, GetDataEndpointError, Credentials | Region | HttpClient.HttpClient>;
export type GetSignalingChannelEndpointError = AccessDeniedException | ClientLimitExceededException | InvalidArgumentException | ResourceInUseException | ResourceNotFoundException | CommonErrors;
/**
 * Provides an endpoint for the specified signaling channel to send and receive messages.
 * This API uses the `SingleMasterChannelEndpointConfiguration` input parameter,
 * which consists of the `Protocols` and `Role` properties.
 *
 * `Protocols` is used to determine the communication mechanism. For example,
 * if you specify `WSS` as the protocol, this API produces a secure websocket
 * endpoint. If you specify `HTTPS` as the protocol, this API generates an HTTPS
 * endpoint. If you specify `WEBRTC` as the protocol, but the signaling channel isn't
 * configured for ingestion, you will receive the error
 * `InvalidArgumentException`.
 *
 * `Role` determines the messaging permissions. A `MASTER` role
 * results in this API generating an endpoint that a client can use to communicate with any
 * of the viewers on the channel. A `VIEWER` role results in this API generating
 * an endpoint that a client can use to communicate only with a `MASTER`.
 */
export declare const getSignalingChannelEndpoint: API.OperationMethod<GetSignalingChannelEndpointInput, GetSignalingChannelEndpointOutput, GetSignalingChannelEndpointError, Credentials | Region | HttpClient.HttpClient>;
export type ListEdgeAgentConfigurationsError = ClientLimitExceededException | InvalidArgumentException | NotAuthorizedException | CommonErrors;
/**
 * Returns an array of edge configurations associated with the specified Edge Agent.
 *
 * In the request, you must specify the Edge Agent `HubDeviceArn`.
 */
export declare const listEdgeAgentConfigurations: API.OperationMethod<ListEdgeAgentConfigurationsInput, ListEdgeAgentConfigurationsOutput, ListEdgeAgentConfigurationsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListEdgeAgentConfigurationsInput) => stream.Stream<ListEdgeAgentConfigurationsOutput, ListEdgeAgentConfigurationsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListEdgeAgentConfigurationsInput) => stream.Stream<ListEdgeAgentConfigurationsEdgeConfig, ListEdgeAgentConfigurationsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListSignalingChannelsError = AccessDeniedException | ClientLimitExceededException | InvalidArgumentException | CommonErrors;
/**
 * Returns an array of `ChannelInfo` objects. Each object describes a
 * signaling channel. To retrieve only those channels that satisfy a specific condition,
 * you can specify a `ChannelNameCondition`.
 */
export declare const listSignalingChannels: API.OperationMethod<ListSignalingChannelsInput, ListSignalingChannelsOutput, ListSignalingChannelsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListSignalingChannelsInput) => stream.Stream<ListSignalingChannelsOutput, ListSignalingChannelsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListSignalingChannelsInput) => stream.Stream<ChannelInfo, ListSignalingChannelsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListStreamsError = ClientLimitExceededException | InvalidArgumentException | CommonErrors;
/**
 * Returns an array of `StreamInfo` objects. Each object describes a
 * stream. To retrieve only streams that satisfy a specific condition, you can specify a
 * `StreamNameCondition`.
 */
export declare const listStreams: API.OperationMethod<ListStreamsInput, ListStreamsOutput, ListStreamsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListStreamsInput) => stream.Stream<ListStreamsOutput, ListStreamsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListStreamsInput) => stream.Stream<StreamInfo, ListStreamsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListTagsForResourceError = AccessDeniedException | ClientLimitExceededException | InvalidArgumentException | ResourceNotFoundException | CommonErrors;
/**
 * Returns a list of tags associated with the specified signaling channel.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceInput, ListTagsForResourceOutput, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type ListTagsForStreamError = ClientLimitExceededException | InvalidArgumentException | InvalidResourceFormatException | NotAuthorizedException | ResourceNotFoundException | CommonErrors;
/**
 * Returns a list of tags associated with the specified stream.
 *
 * In the request, you must specify either the `StreamName` or the
 * `StreamARN`.
 */
export declare const listTagsForStream: API.OperationMethod<ListTagsForStreamInput, ListTagsForStreamOutput, ListTagsForStreamError, Credentials | Region | HttpClient.HttpClient>;
export type StartEdgeConfigurationUpdateError = AccessDeniedException | ClientLimitExceededException | InvalidArgumentException | NoDataRetentionException | ResourceInUseException | ResourceNotFoundException | CommonErrors;
/**
 * An asynchronous API that updates a stream’s existing edge configuration.
 * The Kinesis Video Stream will sync the stream’s edge configuration with the Edge Agent IoT Greengrass
 * component that runs on an IoT Hub Device, setup at your premise. The time to sync can vary
 * and depends on the connectivity of the Hub Device.
 * The `SyncStatus` will be updated as the edge configuration is acknowledged,
 * and synced with the Edge Agent.
 *
 * If this API is invoked for the first time, a new edge configuration will be created for the stream,
 * and the sync status will be set to `SYNCING`. You will have to wait for the sync status
 * to reach a terminal state such as: `IN_SYNC`, or `SYNC_FAILED`, before using this API again.
 * If you invoke this API during the syncing process, a `ResourceInUseException` will be thrown.
 * The connectivity of the stream’s edge configuration and the Edge Agent will be retried for 15 minutes. After 15 minutes,
 * the status will transition into the `SYNC_FAILED` state.
 *
 * To move an edge configuration from one device to another, use DeleteEdgeConfiguration to delete
 * the current edge configuration. You can then invoke StartEdgeConfigurationUpdate with an updated Hub Device ARN.
 */
export declare const startEdgeConfigurationUpdate: API.OperationMethod<StartEdgeConfigurationUpdateInput, StartEdgeConfigurationUpdateOutput, StartEdgeConfigurationUpdateError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = AccessDeniedException | ClientLimitExceededException | InvalidArgumentException | ResourceNotFoundException | TagsPerResourceExceededLimitException | CommonErrors;
/**
 * Adds one or more tags to a signaling channel. A *tag* is a
 * key-value pair (the value is optional) that you can define and assign to Amazon Web Services resources.
 * If you specify a tag that already exists, the tag value is replaced with the value that
 * you specify in the request. For more information, see Using Cost Allocation
 * Tags in the Billing and Cost Management and Cost Management User
 * Guide.
 */
export declare const tagResource: API.OperationMethod<TagResourceInput, TagResourceOutput, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type TagStreamError = ClientLimitExceededException | InvalidArgumentException | InvalidResourceFormatException | NotAuthorizedException | ResourceNotFoundException | TagsPerResourceExceededLimitException | CommonErrors;
/**
 * Adds one or more tags to a stream. A *tag* is a key-value pair
 * (the value is optional) that you can define and assign to Amazon Web Services resources. If you specify
 * a tag that already exists, the tag value is replaced with the value that you specify in
 * the request. For more information, see Using Cost Allocation
 * Tags in the *Billing and Cost Management and Cost Management User Guide*.
 *
 * You must provide either the `StreamName` or the
 * `StreamARN`.
 *
 * This operation requires permission for the `KinesisVideo:TagStream`
 * action.
 *
 * A Kinesis video stream can support up to 50 tags.
 */
export declare const tagStream: API.OperationMethod<TagStreamInput, TagStreamOutput, TagStreamError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = AccessDeniedException | ClientLimitExceededException | InvalidArgumentException | ResourceNotFoundException | CommonErrors;
/**
 * Removes one or more tags from a signaling channel. In the request, specify only a tag
 * key or keys; don't specify the value. If you specify a tag key that does not exist, it's
 * ignored.
 */
export declare const untagResource: API.OperationMethod<UntagResourceInput, UntagResourceOutput, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagStreamError = ClientLimitExceededException | InvalidArgumentException | InvalidResourceFormatException | NotAuthorizedException | ResourceNotFoundException | CommonErrors;
/**
 * Removes one or more tags from a stream. In the request, specify only a tag key or
 * keys; don't specify the value. If you specify a tag key that does not exist, it's
 * ignored.
 *
 * In the request, you must provide the `StreamName` or
 * `StreamARN`.
 */
export declare const untagStream: API.OperationMethod<UntagStreamInput, UntagStreamOutput, UntagStreamError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateDataRetentionError = ClientLimitExceededException | InvalidArgumentException | NotAuthorizedException | ResourceInUseException | ResourceNotFoundException | VersionMismatchException | CommonErrors;
/**
 * Increases or decreases the stream's data retention period by the value that you
 * specify. To indicate whether you want to increase or decrease the data retention period,
 * specify the `Operation` parameter in the request body. In the request, you
 * must specify either the `StreamName` or the `StreamARN`.
 *
 * This operation requires permission for the
 * `KinesisVideo:UpdateDataRetention` action.
 *
 * Changing the data retention period affects the data in the stream as
 * follows:
 *
 * - If the data retention period is increased, existing data is retained for
 * the new retention period. For example, if the data retention period is increased
 * from one hour to seven hours, all existing data is retained for seven
 * hours.
 *
 * - If the data retention period is decreased, existing data is retained for
 * the new retention period. For example, if the data retention period is decreased
 * from seven hours to one hour, all existing data is retained for one hour, and
 * any data older than one hour is deleted immediately.
 */
export declare const updateDataRetention: API.OperationMethod<UpdateDataRetentionInput, UpdateDataRetentionOutput, UpdateDataRetentionError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateImageGenerationConfigurationError = AccessDeniedException | ClientLimitExceededException | InvalidArgumentException | NoDataRetentionException | ResourceInUseException | ResourceNotFoundException | CommonErrors;
/**
 * Updates the `StreamInfo` and `ImageProcessingConfiguration` fields.
 */
export declare const updateImageGenerationConfiguration: API.OperationMethod<UpdateImageGenerationConfigurationInput, UpdateImageGenerationConfigurationOutput, UpdateImageGenerationConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateMediaStorageConfigurationError = AccessDeniedException | ClientLimitExceededException | InvalidArgumentException | NoDataRetentionException | ResourceInUseException | ResourceNotFoundException | CommonErrors;
/**
 * Associates a `SignalingChannel` to a stream to store the media. There are
 * two signaling modes that you can specify :
 *
 * - If `StorageStatus` is enabled, the data will be stored in the
 * `StreamARN` provided. In order for WebRTC Ingestion to work, the stream must have data retention
 * enabled.
 *
 * - If `StorageStatus` is disabled, no data will be stored, and the
 * `StreamARN` parameter will not be needed.
 *
 * If `StorageStatus` is enabled, direct peer-to-peer (master-viewer) connections no
 * longer occur. Peers connect directly to the storage session. You must call the
 * `JoinStorageSession` API to trigger an SDP offer send and establish a
 * connection between a peer and the storage session.
 */
export declare const updateMediaStorageConfiguration: API.OperationMethod<UpdateMediaStorageConfigurationInput, UpdateMediaStorageConfigurationOutput, UpdateMediaStorageConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateNotificationConfigurationError = AccessDeniedException | ClientLimitExceededException | InvalidArgumentException | NoDataRetentionException | ResourceInUseException | ResourceNotFoundException | CommonErrors;
/**
 * Updates the notification information for a stream.
 */
export declare const updateNotificationConfiguration: API.OperationMethod<UpdateNotificationConfigurationInput, UpdateNotificationConfigurationOutput, UpdateNotificationConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateSignalingChannelError = AccessDeniedException | ClientLimitExceededException | InvalidArgumentException | ResourceInUseException | ResourceNotFoundException | VersionMismatchException | CommonErrors;
/**
 * Updates the existing signaling channel. This is an asynchronous operation and takes
 * time to complete.
 *
 * If the `MessageTtlSeconds` value is updated (either increased or reduced),
 * it only applies to new messages sent via this channel after it's been updated. Existing
 * messages are still expired as per the previous `MessageTtlSeconds`
 * value.
 */
export declare const updateSignalingChannel: API.OperationMethod<UpdateSignalingChannelInput, UpdateSignalingChannelOutput, UpdateSignalingChannelError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateStreamError = ClientLimitExceededException | InvalidArgumentException | NotAuthorizedException | ResourceInUseException | ResourceNotFoundException | VersionMismatchException | CommonErrors;
/**
 * Updates stream metadata, such as the device name and media type.
 *
 * You must provide the stream name or the Amazon Resource Name (ARN) of the
 * stream.
 *
 * To make sure that you have the latest version of the stream before updating it, you
 * can specify the stream version. Kinesis Video Streams assigns a version to each stream.
 * When you update a stream, Kinesis Video Streams assigns a new version number. To get the
 * latest stream version, use the `DescribeStream` API.
 *
 * `UpdateStream` is an asynchronous operation, and takes time to
 * complete.
 */
export declare const updateStream: API.OperationMethod<UpdateStreamInput, UpdateStreamOutput, UpdateStreamError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateStreamStorageConfigurationError = AccessDeniedException | ClientLimitExceededException | InvalidArgumentException | ResourceInUseException | ResourceNotFoundException | VersionMismatchException | CommonErrors;
/**
 * Updates the storage configuration for an existing Kinesis video stream.
 *
 * This operation allows you to modify the storage tier settings for a stream, enabling you to optimize storage costs and performance based on your access patterns.
 *
 * `UpdateStreamStorageConfiguration` is an asynchronous operation.
 *
 * You must have permissions for the `KinesisVideo:UpdateStreamStorageConfiguration` action.
 */
export declare const updateStreamStorageConfiguration: API.OperationMethod<UpdateStreamStorageConfigurationInput, UpdateStreamStorageConfigurationOutput, UpdateStreamStorageConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=kinesis-video.d.ts.map