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 * as T from "../traits.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type Name = string;
export type Description = string;
export type TagKey = string;
export type TagValue = string;
export type Id = string;
export type LongName = string;
export type Uri = string;
export type RoleArn = string;
export type StringWithLengthBetween0And32768 = string | redacted.Redacted<string>;
export type ConfigurationProfileType = string;
export type KmsKeyIdentifier = string;
export type Arn = string;
export type MinutesBetween0And24Hours = number;
export type GrowthFactor = number;
export type Percentage = number;
export type StringWithLengthBetween1And2048 = string;
export type ExtensionOrParameterName = string;
export type Identifier = string;
export type StringWithLengthBetween1And255 = string;
export type VersionLabel = string;
export type DeploymentStrategyId = string;
export type DeletionProtectionDuration = number;
export type StringWithLengthBetween1And64 = string;
export type Version = string;
export type Iso8601DateTime = Date;
export type MaxResults = number;
export type NextToken = string;
export type QueryName = string;
export type DynamicParameterKey = string;
export type KmsKeyIdentifierOrEmpty = string;
export type TagMap = {
    [key: string]: string | undefined;
};
export declare const TagMap: S.$Record<S.String, S.optional<S.String>>;
export interface CreateApplicationRequest {
    Name: string;
    Description?: string;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateApplicationRequest: S.Schema<CreateApplicationRequest>;
export interface Application {
    Id?: string;
    Name?: string;
    Description?: string;
}
export declare const Application: S.Schema<Application>;
export type BadRequestReason = "InvalidConfiguration" | (string & {});
export declare const BadRequestReason: S.String;
export interface InvalidConfigurationDetail {
    Constraint?: string;
    Location?: string;
    Reason?: string;
    Type?: string;
    Value?: string;
}
export declare const InvalidConfigurationDetail: S.Schema<InvalidConfigurationDetail>;
export type InvalidConfigurationDetailList = InvalidConfigurationDetail[];
export declare const InvalidConfigurationDetailList: S.$Array<S.Schema<InvalidConfigurationDetail>>;
export type BadRequestDetails = {
    InvalidConfiguration: InvalidConfigurationDetail[];
};
export declare const BadRequestDetails: S.Union<readonly [S.Struct<{
    readonly InvalidConfiguration: S.$Array<S.Schema<InvalidConfigurationDetail>>;
}>]>;
export type ValidatorType = "JSON_SCHEMA" | "LAMBDA" | (string & {});
export declare const ValidatorType: S.String;
export interface Validator {
    Type: ValidatorType;
    Content: string | redacted.Redacted<string>;
}
export declare const Validator: S.Schema<Validator>;
export type ValidatorList = Validator[];
export declare const ValidatorList: S.$Array<S.Schema<Validator>>;
export interface CreateConfigurationProfileRequest {
    ApplicationId: string;
    Name: string;
    Description?: string;
    LocationUri: string;
    RetrievalRoleArn?: string;
    Validators?: Validator[];
    Tags?: {
        [key: string]: string | undefined;
    };
    Type?: string;
    KmsKeyIdentifier?: string;
}
export declare const CreateConfigurationProfileRequest: S.Schema<CreateConfigurationProfileRequest>;
export interface ConfigurationProfile {
    ApplicationId?: string;
    Id?: string;
    Name?: string;
    Description?: string;
    LocationUri?: string;
    RetrievalRoleArn?: string;
    Validators?: Validator[];
    Type?: string;
    KmsKeyArn?: string;
    KmsKeyIdentifier?: string;
}
export declare const ConfigurationProfile: S.Schema<ConfigurationProfile>;
export type GrowthType = "LINEAR" | "EXPONENTIAL" | (string & {});
export declare const GrowthType: S.String;
export type ReplicateTo = "NONE" | "SSM_DOCUMENT" | (string & {});
export declare const ReplicateTo: S.String;
export interface CreateDeploymentStrategyRequest {
    Name: string;
    Description?: string;
    DeploymentDurationInMinutes: number;
    FinalBakeTimeInMinutes?: number;
    GrowthFactor: number;
    GrowthType?: GrowthType;
    ReplicateTo?: ReplicateTo;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateDeploymentStrategyRequest: S.Schema<CreateDeploymentStrategyRequest>;
export interface DeploymentStrategy {
    Id?: string;
    Name?: string;
    Description?: string;
    DeploymentDurationInMinutes?: number;
    GrowthType?: GrowthType;
    GrowthFactor?: number;
    FinalBakeTimeInMinutes?: number;
    ReplicateTo?: ReplicateTo;
}
export declare const DeploymentStrategy: S.Schema<DeploymentStrategy>;
export interface Monitor {
    AlarmArn: string;
    AlarmRoleArn?: string;
}
export declare const Monitor: S.Schema<Monitor>;
export type MonitorList = Monitor[];
export declare const MonitorList: S.$Array<S.Schema<Monitor>>;
export interface CreateEnvironmentRequest {
    ApplicationId: string;
    Name: string;
    Description?: string;
    Monitors?: Monitor[];
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateEnvironmentRequest: S.Schema<CreateEnvironmentRequest>;
export type EnvironmentState = "READY_FOR_DEPLOYMENT" | "DEPLOYING" | "ROLLING_BACK" | "ROLLED_BACK" | "REVERTED" | (string & {});
export declare const EnvironmentState: S.String;
export interface Environment {
    ApplicationId?: string;
    Id?: string;
    Name?: string;
    Description?: string;
    State?: EnvironmentState;
    Monitors?: Monitor[];
}
export declare const Environment: S.Schema<Environment>;
export type ActionPoint = "PRE_CREATE_HOSTED_CONFIGURATION_VERSION" | "PRE_START_DEPLOYMENT" | "AT_DEPLOYMENT_TICK" | "ON_DEPLOYMENT_START" | "ON_DEPLOYMENT_STEP" | "ON_DEPLOYMENT_BAKING" | "ON_DEPLOYMENT_COMPLETE" | "ON_DEPLOYMENT_ROLLED_BACK" | (string & {});
export declare const ActionPoint: S.String;
export interface Action {
    Name?: string;
    Description?: string;
    Uri?: string;
    RoleArn?: string;
}
export declare const Action: S.Schema<Action>;
export type ActionList = Action[];
export declare const ActionList: S.$Array<S.Schema<Action>>;
export type ActionsMap = {
    [key in ActionPoint]?: Action[];
};
export declare const ActionsMap: S.$Record<S.String, S.optional<S.$Array<S.Schema<Action>>>>;
export interface Parameter {
    Description?: string;
    Required?: boolean;
    Dynamic?: boolean;
}
export declare const Parameter: S.Schema<Parameter>;
export type ParameterMap = {
    [key: string]: Parameter | undefined;
};
export declare const ParameterMap: S.$Record<S.String, S.optional<S.Schema<Parameter>>>;
export interface CreateExtensionRequest {
    Name: string;
    Description?: string;
    Actions: {
        [key: string]: Action[] | undefined;
    };
    Parameters?: {
        [key: string]: Parameter | undefined;
    };
    Tags?: {
        [key: string]: string | undefined;
    };
    LatestVersionNumber?: number;
}
export declare const CreateExtensionRequest: S.Schema<CreateExtensionRequest>;
export interface Extension {
    Id?: string;
    Name?: string;
    VersionNumber?: number;
    Arn?: string;
    Description?: string;
    Actions?: {
        [key: string]: Action[] | undefined;
    };
    Parameters?: {
        [key: string]: Parameter | undefined;
    };
}
export declare const Extension: S.Schema<Extension>;
export type ParameterValueMap = {
    [key: string]: string | undefined;
};
export declare const ParameterValueMap: S.$Record<S.String, S.optional<S.String>>;
export interface CreateExtensionAssociationRequest {
    ExtensionIdentifier: string;
    ExtensionVersionNumber?: number;
    ResourceIdentifier: string;
    Parameters?: {
        [key: string]: string | undefined;
    };
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateExtensionAssociationRequest: S.Schema<CreateExtensionAssociationRequest>;
export interface ExtensionAssociation {
    Id?: string;
    ExtensionArn?: string;
    ResourceArn?: string;
    Arn?: string;
    Parameters?: {
        [key: string]: string | undefined;
    };
    ExtensionVersionNumber?: number;
}
export declare const ExtensionAssociation: S.Schema<ExtensionAssociation>;
export interface CreateHostedConfigurationVersionRequest {
    ApplicationId: string;
    ConfigurationProfileId: string;
    Description?: string;
    Content: T.StreamingInputBody;
    ContentType: string;
    LatestVersionNumber?: number;
    VersionLabel?: string;
}
export declare const CreateHostedConfigurationVersionRequest: S.Schema<CreateHostedConfigurationVersionRequest>;
export interface HostedConfigurationVersion {
    ApplicationId?: string;
    ConfigurationProfileId?: string;
    VersionNumber?: number;
    Description?: string;
    Content?: T.StreamingOutputBody;
    ContentType?: string;
    VersionLabel?: string;
    KmsKeyArn?: string;
}
export declare const HostedConfigurationVersion: S.Schema<HostedConfigurationVersion>;
export type BytesMeasure = "KILOBYTES" | (string & {});
export declare const BytesMeasure: S.String;
export interface DeleteApplicationRequest {
    ApplicationId: string;
}
export declare const DeleteApplicationRequest: S.Schema<DeleteApplicationRequest>;
export interface DeleteApplicationResponse {
}
export declare const DeleteApplicationResponse: S.Schema<DeleteApplicationResponse>;
export type DeletionProtectionCheck = "ACCOUNT_DEFAULT" | "APPLY" | "BYPASS" | (string & {});
export declare const DeletionProtectionCheck: S.String;
export interface DeleteConfigurationProfileRequest {
    ApplicationId: string;
    ConfigurationProfileId: string;
    DeletionProtectionCheck?: DeletionProtectionCheck;
}
export declare const DeleteConfigurationProfileRequest: S.Schema<DeleteConfigurationProfileRequest>;
export interface DeleteConfigurationProfileResponse {
}
export declare const DeleteConfigurationProfileResponse: S.Schema<DeleteConfigurationProfileResponse>;
export interface DeleteDeploymentStrategyRequest {
    DeploymentStrategyId: string;
}
export declare const DeleteDeploymentStrategyRequest: S.Schema<DeleteDeploymentStrategyRequest>;
export interface DeleteDeploymentStrategyResponse {
}
export declare const DeleteDeploymentStrategyResponse: S.Schema<DeleteDeploymentStrategyResponse>;
export interface DeleteEnvironmentRequest {
    EnvironmentId: string;
    ApplicationId: string;
    DeletionProtectionCheck?: DeletionProtectionCheck;
}
export declare const DeleteEnvironmentRequest: S.Schema<DeleteEnvironmentRequest>;
export interface DeleteEnvironmentResponse {
}
export declare const DeleteEnvironmentResponse: S.Schema<DeleteEnvironmentResponse>;
export interface DeleteExtensionRequest {
    ExtensionIdentifier: string;
    VersionNumber?: number;
}
export declare const DeleteExtensionRequest: S.Schema<DeleteExtensionRequest>;
export interface DeleteExtensionResponse {
}
export declare const DeleteExtensionResponse: S.Schema<DeleteExtensionResponse>;
export interface DeleteExtensionAssociationRequest {
    ExtensionAssociationId: string;
}
export declare const DeleteExtensionAssociationRequest: S.Schema<DeleteExtensionAssociationRequest>;
export interface DeleteExtensionAssociationResponse {
}
export declare const DeleteExtensionAssociationResponse: S.Schema<DeleteExtensionAssociationResponse>;
export interface DeleteHostedConfigurationVersionRequest {
    ApplicationId: string;
    ConfigurationProfileId: string;
    VersionNumber: number;
}
export declare const DeleteHostedConfigurationVersionRequest: S.Schema<DeleteHostedConfigurationVersionRequest>;
export interface DeleteHostedConfigurationVersionResponse {
}
export declare const DeleteHostedConfigurationVersionResponse: S.Schema<DeleteHostedConfigurationVersionResponse>;
export interface GetAccountSettingsRequest {
}
export declare const GetAccountSettingsRequest: S.Schema<GetAccountSettingsRequest>;
export interface DeletionProtectionSettings {
    Enabled?: boolean;
    ProtectionPeriodInMinutes?: number;
}
export declare const DeletionProtectionSettings: S.Schema<DeletionProtectionSettings>;
export interface AccountSettings {
    DeletionProtection?: DeletionProtectionSettings;
}
export declare const AccountSettings: S.Schema<AccountSettings>;
export interface GetApplicationRequest {
    ApplicationId: string;
}
export declare const GetApplicationRequest: S.Schema<GetApplicationRequest>;
export interface GetConfigurationRequest {
    Application: string;
    Environment: string;
    Configuration: string;
    ClientId: string;
    ClientConfigurationVersion?: string;
}
export declare const GetConfigurationRequest: S.Schema<GetConfigurationRequest>;
export interface Configuration {
    Content?: T.StreamingOutputBody;
    ConfigurationVersion?: string;
    ContentType?: string;
}
export declare const Configuration: S.Schema<Configuration>;
export interface GetConfigurationProfileRequest {
    ApplicationId: string;
    ConfigurationProfileId: string;
}
export declare const GetConfigurationProfileRequest: S.Schema<GetConfigurationProfileRequest>;
export interface GetDeploymentRequest {
    ApplicationId: string;
    EnvironmentId: string;
    DeploymentNumber: number;
}
export declare const GetDeploymentRequest: S.Schema<GetDeploymentRequest>;
export type DeploymentState = "BAKING" | "VALIDATING" | "DEPLOYING" | "COMPLETE" | "ROLLING_BACK" | "ROLLED_BACK" | "REVERTED" | (string & {});
export declare const DeploymentState: S.String;
export type DeploymentEventType = "PERCENTAGE_UPDATED" | "ROLLBACK_STARTED" | "ROLLBACK_COMPLETED" | "BAKE_TIME_STARTED" | "DEPLOYMENT_STARTED" | "DEPLOYMENT_COMPLETED" | "REVERT_COMPLETED" | (string & {});
export declare const DeploymentEventType: S.String;
export type TriggeredBy = "USER" | "APPCONFIG" | "CLOUDWATCH_ALARM" | "INTERNAL_ERROR" | (string & {});
export declare const TriggeredBy: S.String;
export interface ActionInvocation {
    ExtensionIdentifier?: string;
    ActionName?: string;
    Uri?: string;
    RoleArn?: string;
    ErrorMessage?: string;
    ErrorCode?: string;
    InvocationId?: string;
}
export declare const ActionInvocation: S.Schema<ActionInvocation>;
export type ActionInvocations = ActionInvocation[];
export declare const ActionInvocations: S.$Array<S.Schema<ActionInvocation>>;
export interface DeploymentEvent {
    EventType?: DeploymentEventType;
    TriggeredBy?: TriggeredBy;
    Description?: string;
    ActionInvocations?: ActionInvocation[];
    OccurredAt?: Date;
}
export declare const DeploymentEvent: S.Schema<DeploymentEvent>;
export type DeploymentEvents = DeploymentEvent[];
export declare const DeploymentEvents: S.$Array<S.Schema<DeploymentEvent>>;
export interface AppliedExtension {
    ExtensionId?: string;
    ExtensionAssociationId?: string;
    VersionNumber?: number;
    Parameters?: {
        [key: string]: string | undefined;
    };
}
export declare const AppliedExtension: S.Schema<AppliedExtension>;
export type AppliedExtensions = AppliedExtension[];
export declare const AppliedExtensions: S.$Array<S.Schema<AppliedExtension>>;
export interface Deployment {
    ApplicationId?: string;
    EnvironmentId?: string;
    DeploymentStrategyId?: string;
    ConfigurationProfileId?: string;
    DeploymentNumber?: number;
    ConfigurationName?: string;
    ConfigurationLocationUri?: string;
    ConfigurationVersion?: string;
    Description?: string;
    DeploymentDurationInMinutes?: number;
    GrowthType?: GrowthType;
    GrowthFactor?: number;
    FinalBakeTimeInMinutes?: number;
    State?: DeploymentState;
    EventLog?: DeploymentEvent[];
    PercentageComplete?: number;
    StartedAt?: Date;
    CompletedAt?: Date;
    AppliedExtensions?: AppliedExtension[];
    KmsKeyArn?: string;
    KmsKeyIdentifier?: string;
    VersionLabel?: string;
}
export declare const Deployment: S.Schema<Deployment>;
export interface GetDeploymentStrategyRequest {
    DeploymentStrategyId: string;
}
export declare const GetDeploymentStrategyRequest: S.Schema<GetDeploymentStrategyRequest>;
export interface GetEnvironmentRequest {
    ApplicationId: string;
    EnvironmentId: string;
}
export declare const GetEnvironmentRequest: S.Schema<GetEnvironmentRequest>;
export interface GetExtensionRequest {
    ExtensionIdentifier: string;
    VersionNumber?: number;
}
export declare const GetExtensionRequest: S.Schema<GetExtensionRequest>;
export interface GetExtensionAssociationRequest {
    ExtensionAssociationId: string;
}
export declare const GetExtensionAssociationRequest: S.Schema<GetExtensionAssociationRequest>;
export interface GetHostedConfigurationVersionRequest {
    ApplicationId: string;
    ConfigurationProfileId: string;
    VersionNumber: number;
}
export declare const GetHostedConfigurationVersionRequest: S.Schema<GetHostedConfigurationVersionRequest>;
export interface ListApplicationsRequest {
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListApplicationsRequest: S.Schema<ListApplicationsRequest>;
export type ApplicationList = Application[];
export declare const ApplicationList: S.$Array<S.Schema<Application>>;
export interface Applications {
    Items?: Application[];
    NextToken?: string;
}
export declare const Applications: S.Schema<Applications>;
export interface ListConfigurationProfilesRequest {
    ApplicationId: string;
    MaxResults?: number;
    NextToken?: string;
    Type?: string;
}
export declare const ListConfigurationProfilesRequest: S.Schema<ListConfigurationProfilesRequest>;
export type ValidatorTypeList = ValidatorType[];
export declare const ValidatorTypeList: S.$Array<S.String>;
export interface ConfigurationProfileSummary {
    ApplicationId?: string;
    Id?: string;
    Name?: string;
    LocationUri?: string;
    ValidatorTypes?: ValidatorType[];
    Type?: string;
}
export declare const ConfigurationProfileSummary: S.Schema<ConfigurationProfileSummary>;
export type ConfigurationProfileSummaryList = ConfigurationProfileSummary[];
export declare const ConfigurationProfileSummaryList: S.$Array<S.Schema<ConfigurationProfileSummary>>;
export interface ConfigurationProfiles {
    Items?: ConfigurationProfileSummary[];
    NextToken?: string;
}
export declare const ConfigurationProfiles: S.Schema<ConfigurationProfiles>;
export interface ListDeploymentsRequest {
    ApplicationId: string;
    EnvironmentId: string;
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListDeploymentsRequest: S.Schema<ListDeploymentsRequest>;
export interface DeploymentSummary {
    DeploymentNumber?: number;
    ConfigurationName?: string;
    ConfigurationVersion?: string;
    DeploymentDurationInMinutes?: number;
    GrowthType?: GrowthType;
    GrowthFactor?: number;
    FinalBakeTimeInMinutes?: number;
    State?: DeploymentState;
    PercentageComplete?: number;
    StartedAt?: Date;
    CompletedAt?: Date;
    VersionLabel?: string;
}
export declare const DeploymentSummary: S.Schema<DeploymentSummary>;
export type DeploymentList = DeploymentSummary[];
export declare const DeploymentList: S.$Array<S.Schema<DeploymentSummary>>;
export interface Deployments {
    Items?: DeploymentSummary[];
    NextToken?: string;
}
export declare const Deployments: S.Schema<Deployments>;
export interface ListDeploymentStrategiesRequest {
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListDeploymentStrategiesRequest: S.Schema<ListDeploymentStrategiesRequest>;
export type DeploymentStrategyList = DeploymentStrategy[];
export declare const DeploymentStrategyList: S.$Array<S.Schema<DeploymentStrategy>>;
export interface DeploymentStrategies {
    Items?: DeploymentStrategy[];
    NextToken?: string;
}
export declare const DeploymentStrategies: S.Schema<DeploymentStrategies>;
export interface ListEnvironmentsRequest {
    ApplicationId: string;
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListEnvironmentsRequest: S.Schema<ListEnvironmentsRequest>;
export type EnvironmentList = Environment[];
export declare const EnvironmentList: S.$Array<S.Schema<Environment>>;
export interface Environments {
    Items?: Environment[];
    NextToken?: string;
}
export declare const Environments: S.Schema<Environments>;
export interface ListExtensionAssociationsRequest {
    ResourceIdentifier?: string;
    ExtensionIdentifier?: string;
    ExtensionVersionNumber?: number;
    MaxResults?: number;
    NextToken?: string;
}
export declare const ListExtensionAssociationsRequest: S.Schema<ListExtensionAssociationsRequest>;
export interface ExtensionAssociationSummary {
    Id?: string;
    ExtensionArn?: string;
    ResourceArn?: string;
}
export declare const ExtensionAssociationSummary: S.Schema<ExtensionAssociationSummary>;
export type ExtensionAssociationSummaries = ExtensionAssociationSummary[];
export declare const ExtensionAssociationSummaries: S.$Array<S.Schema<ExtensionAssociationSummary>>;
export interface ExtensionAssociations {
    Items?: ExtensionAssociationSummary[];
    NextToken?: string;
}
export declare const ExtensionAssociations: S.Schema<ExtensionAssociations>;
export interface ListExtensionsRequest {
    MaxResults?: number;
    NextToken?: string;
    Name?: string;
}
export declare const ListExtensionsRequest: S.Schema<ListExtensionsRequest>;
export interface ExtensionSummary {
    Id?: string;
    Name?: string;
    VersionNumber?: number;
    Arn?: string;
    Description?: string;
}
export declare const ExtensionSummary: S.Schema<ExtensionSummary>;
export type ExtensionSummaries = ExtensionSummary[];
export declare const ExtensionSummaries: S.$Array<S.Schema<ExtensionSummary>>;
export interface Extensions {
    Items?: ExtensionSummary[];
    NextToken?: string;
}
export declare const Extensions: S.Schema<Extensions>;
export interface ListHostedConfigurationVersionsRequest {
    ApplicationId: string;
    ConfigurationProfileId: string;
    MaxResults?: number;
    NextToken?: string;
    VersionLabel?: string;
}
export declare const ListHostedConfigurationVersionsRequest: S.Schema<ListHostedConfigurationVersionsRequest>;
export interface HostedConfigurationVersionSummary {
    ApplicationId?: string;
    ConfigurationProfileId?: string;
    VersionNumber?: number;
    Description?: string;
    ContentType?: string;
    VersionLabel?: string;
    KmsKeyArn?: string;
}
export declare const HostedConfigurationVersionSummary: S.Schema<HostedConfigurationVersionSummary>;
export type HostedConfigurationVersionSummaryList = HostedConfigurationVersionSummary[];
export declare const HostedConfigurationVersionSummaryList: S.$Array<S.Schema<HostedConfigurationVersionSummary>>;
export interface HostedConfigurationVersions {
    Items?: HostedConfigurationVersionSummary[];
    NextToken?: string;
}
export declare const HostedConfigurationVersions: S.Schema<HostedConfigurationVersions>;
export interface ListTagsForResourceRequest {
    ResourceArn: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export interface ResourceTags {
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const ResourceTags: S.Schema<ResourceTags>;
export type DynamicParameterMap = {
    [key: string]: string | undefined;
};
export declare const DynamicParameterMap: S.$Record<S.String, S.optional<S.String>>;
export interface StartDeploymentRequest {
    ApplicationId: string;
    EnvironmentId: string;
    DeploymentStrategyId: string;
    ConfigurationProfileId: string;
    ConfigurationVersion: string;
    Description?: string;
    Tags?: {
        [key: string]: string | undefined;
    };
    KmsKeyIdentifier?: string;
    DynamicExtensionParameters?: {
        [key: string]: string | undefined;
    };
}
export declare const StartDeploymentRequest: S.Schema<StartDeploymentRequest>;
export interface StopDeploymentRequest {
    ApplicationId: string;
    EnvironmentId: string;
    DeploymentNumber: number;
    AllowRevert?: boolean;
}
export declare const StopDeploymentRequest: S.Schema<StopDeploymentRequest>;
export interface TagResourceRequest {
    ResourceArn: string;
    Tags: {
        [key: string]: string | undefined;
    };
}
export declare const TagResourceRequest: S.Schema<TagResourceRequest>;
export interface TagResourceResponse {
}
export declare const TagResourceResponse: S.Schema<TagResourceResponse>;
export type TagKeyList = string[];
export declare const TagKeyList: S.$Array<S.String>;
export interface UntagResourceRequest {
    ResourceArn: string;
    TagKeys: string[];
}
export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
export interface UntagResourceResponse {
}
export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
export interface UpdateAccountSettingsRequest {
    DeletionProtection?: DeletionProtectionSettings;
}
export declare const UpdateAccountSettingsRequest: S.Schema<UpdateAccountSettingsRequest>;
export interface UpdateApplicationRequest {
    ApplicationId: string;
    Name?: string;
    Description?: string;
}
export declare const UpdateApplicationRequest: S.Schema<UpdateApplicationRequest>;
export interface UpdateConfigurationProfileRequest {
    ApplicationId: string;
    ConfigurationProfileId: string;
    Name?: string;
    Description?: string;
    RetrievalRoleArn?: string;
    Validators?: Validator[];
    KmsKeyIdentifier?: string;
}
export declare const UpdateConfigurationProfileRequest: S.Schema<UpdateConfigurationProfileRequest>;
export interface UpdateDeploymentStrategyRequest {
    DeploymentStrategyId: string;
    Description?: string;
    DeploymentDurationInMinutes?: number;
    FinalBakeTimeInMinutes?: number;
    GrowthFactor?: number;
    GrowthType?: GrowthType;
}
export declare const UpdateDeploymentStrategyRequest: S.Schema<UpdateDeploymentStrategyRequest>;
export interface UpdateEnvironmentRequest {
    ApplicationId: string;
    EnvironmentId: string;
    Name?: string;
    Description?: string;
    Monitors?: Monitor[];
}
export declare const UpdateEnvironmentRequest: S.Schema<UpdateEnvironmentRequest>;
export interface UpdateExtensionRequest {
    ExtensionIdentifier: string;
    Description?: string;
    Actions?: {
        [key: string]: Action[] | undefined;
    };
    Parameters?: {
        [key: string]: Parameter | undefined;
    };
    VersionNumber?: number;
}
export declare const UpdateExtensionRequest: S.Schema<UpdateExtensionRequest>;
export interface UpdateExtensionAssociationRequest {
    ExtensionAssociationId: string;
    Parameters?: {
        [key: string]: string | undefined;
    };
}
export declare const UpdateExtensionAssociationRequest: S.Schema<UpdateExtensionAssociationRequest>;
export interface ValidateConfigurationRequest {
    ApplicationId: string;
    ConfigurationProfileId: string;
    ConfigurationVersion: string;
}
export declare const ValidateConfigurationRequest: S.Schema<ValidateConfigurationRequest>;
export interface ValidateConfigurationResponse {
}
export declare const ValidateConfigurationResponse: S.Schema<ValidateConfigurationResponse>;
declare const BadRequestException_base: S.Class<BadRequestException, S.TaggedStruct<"BadRequestException", {
    readonly Message: S.optional<S.String>;
    readonly Reason: S.optional<S.String>;
    readonly Details: S.optional<S.Union<readonly [S.Struct<{
        readonly InvalidConfiguration: S.$Array<S.Schema<InvalidConfigurationDetail>>;
    }>]>>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class BadRequestException extends BadRequestException_base {
}
declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
});
export declare class InternalServerException extends InternalServerException_base {
}
declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        QuotaError: true;
    };
});
export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
}
declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly Message: S.optional<S.String>;
    readonly ResourceName: 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 ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class ConflictException extends ConflictException_base {
}
declare const PayloadTooLargeException_base: S.Class<PayloadTooLargeException, S.TaggedStruct<"PayloadTooLargeException", {
    readonly Message: S.optional<S.String>;
    readonly Measure: S.optional<S.String>;
    readonly Limit: S.optional<S.Number>;
    readonly Size: S.optional<S.Number>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class PayloadTooLargeException extends PayloadTooLargeException_base {
}
export type CreateApplicationError = BadRequestException | InternalServerException | ServiceQuotaExceededException | CommonErrors;
/**
 * Creates an application. In AppConfig, an application is simply an
 * organizational construct like a folder. This organizational construct has a relationship
 * with some unit of executable code. For example, you could create an application called
 * MyMobileApp to organize and manage configuration data for a mobile application installed by
 * your users.
 */
export declare const createApplication: API.OperationMethod<CreateApplicationRequest, Application, CreateApplicationError, Credentials | Region | HttpClient.HttpClient>;
export type CreateConfigurationProfileError = BadRequestException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | CommonErrors;
/**
 * Creates a configuration profile, which is information that enables AppConfig
 * to access the configuration source. Valid configuration sources include the
 * following:
 *
 * - Configuration data in YAML, JSON, and other formats stored in the AppConfig hosted configuration store
 *
 * - Configuration data stored as objects in an Amazon Simple Storage Service (Amazon S3)
 * bucket
 *
 * - Pipelines stored in CodePipeline
 *
 * - Secrets stored in Secrets Manager
 *
 * - Standard and secure string parameters stored in Amazon Web Services Systems Manager Parameter Store
 *
 * - Configuration data in SSM documents stored in the Systems Manager document store
 *
 * A configuration profile includes the following information:
 *
 * - The URI location of the configuration data.
 *
 * - The Identity and Access Management (IAM) role that provides access to the configuration data.
 *
 * - A validator for the configuration data. Available validators include either a JSON
 * Schema or an Amazon Web Services Lambda function.
 *
 * For more information, see Create a
 * Configuration and a Configuration Profile in the AppConfig
 * User Guide.
 */
export declare const createConfigurationProfile: API.OperationMethod<CreateConfigurationProfileRequest, ConfigurationProfile, CreateConfigurationProfileError, Credentials | Region | HttpClient.HttpClient>;
export type CreateDeploymentStrategyError = BadRequestException | InternalServerException | ServiceQuotaExceededException | CommonErrors;
/**
 * Creates a deployment strategy that defines important criteria for rolling out your
 * configuration to the designated targets. A deployment strategy includes the overall
 * duration required, a percentage of targets to receive the deployment during each interval,
 * an algorithm that defines how percentage grows, and bake time.
 */
export declare const createDeploymentStrategy: API.OperationMethod<CreateDeploymentStrategyRequest, DeploymentStrategy, CreateDeploymentStrategyError, Credentials | Region | HttpClient.HttpClient>;
export type CreateEnvironmentError = BadRequestException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | CommonErrors;
/**
 * Creates an environment. For each application, you define one or more environments. An
 * environment is a deployment group of AppConfig targets, such as applications in a
 * `Beta` or `Production` environment. You can also define
 * environments for application subcomponents such as the `Web`,
 * `Mobile` and `Back-end` components for your application. You can
 * configure Amazon CloudWatch alarms for each environment. The system monitors alarms during a
 * configuration deployment. If an alarm is triggered, the system rolls back the
 * configuration.
 */
export declare const createEnvironment: API.OperationMethod<CreateEnvironmentRequest, Environment, CreateEnvironmentError, Credentials | Region | HttpClient.HttpClient>;
export type CreateExtensionError = BadRequestException | ConflictException | InternalServerException | ServiceQuotaExceededException | CommonErrors;
/**
 * Creates an AppConfig extension. An extension augments your ability to inject
 * logic or behavior at different points during the AppConfig workflow of creating
 * or deploying a configuration.
 *
 * You can create your own extensions or use the Amazon Web Services authored extensions provided by
 * AppConfig. For an AppConfig extension that uses Lambda, you must create a Lambda function to perform any computation and processing
 * defined in the extension. If you plan to create custom versions of the Amazon Web Services
 * authored notification extensions, you only need to specify an Amazon Resource Name (ARN) in
 * the `Uri` field for the new extension version.
 *
 * - For a custom EventBridge notification extension, enter the ARN of the EventBridge
 * default events in the `Uri` field.
 *
 * - For a custom Amazon SNS notification extension, enter the ARN of an Amazon SNS
 * topic in the `Uri` field.
 *
 * - For a custom Amazon SQS notification extension, enter the ARN of an Amazon SQS
 * message queue in the `Uri` field.
 *
 * For more information about extensions, see Extending
 * workflows in the *AppConfig User Guide*.
 */
export declare const createExtension: API.OperationMethod<CreateExtensionRequest, Extension, CreateExtensionError, Credentials | Region | HttpClient.HttpClient>;
export type CreateExtensionAssociationError = BadRequestException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | CommonErrors;
/**
 * When you create an extension or configure an Amazon Web Services authored extension, you
 * associate the extension with an AppConfig application, environment, or
 * configuration profile. For example, you can choose to run the AppConfig
 * deployment events to Amazon SNS
 * Amazon Web Services authored extension and receive notifications on an Amazon SNS
 * topic anytime a configuration deployment is started for a specific application. Defining
 * which extension to associate with an AppConfig resource is called an
 * *extension association*. An extension association is a specified
 * relationship between an extension and an AppConfig resource, such as an
 * application or a configuration profile. For more information about extensions and
 * associations, see Extending
 * workflows in the *AppConfig User Guide*.
 */
export declare const createExtensionAssociation: API.OperationMethod<CreateExtensionAssociationRequest, ExtensionAssociation, CreateExtensionAssociationError, Credentials | Region | HttpClient.HttpClient>;
export type CreateHostedConfigurationVersionError = BadRequestException | ConflictException | InternalServerException | PayloadTooLargeException | ResourceNotFoundException | ServiceQuotaExceededException | CommonErrors;
/**
 * Creates a new configuration in the AppConfig hosted configuration store. If
 * you're creating a feature flag, we recommend you familiarize yourself with the JSON schema
 * for feature flag data. For more information, see Type reference for AWS.AppConfig.FeatureFlags in the
 * *AppConfig User Guide*.
 */
export declare const createHostedConfigurationVersion: API.OperationMethod<CreateHostedConfigurationVersionRequest, HostedConfigurationVersion, CreateHostedConfigurationVersionError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteApplicationError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Deletes an application.
 */
export declare const deleteApplication: API.OperationMethod<DeleteApplicationRequest, DeleteApplicationResponse, DeleteApplicationError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteConfigurationProfileError = BadRequestException | ConflictException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Deletes a configuration profile.
 *
 * To prevent users from unintentionally deleting actively-used configuration profiles,
 * enable deletion
 * protection.
 */
export declare const deleteConfigurationProfile: API.OperationMethod<DeleteConfigurationProfileRequest, DeleteConfigurationProfileResponse, DeleteConfigurationProfileError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteDeploymentStrategyError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Deletes a deployment strategy.
 */
export declare const deleteDeploymentStrategy: API.OperationMethod<DeleteDeploymentStrategyRequest, DeleteDeploymentStrategyResponse, DeleteDeploymentStrategyError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteEnvironmentError = BadRequestException | ConflictException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Deletes an environment.
 *
 * To prevent users from unintentionally deleting actively-used environments, enable deletion
 * protection.
 */
export declare const deleteEnvironment: API.OperationMethod<DeleteEnvironmentRequest, DeleteEnvironmentResponse, DeleteEnvironmentError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteExtensionError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Deletes an AppConfig extension. You must delete all associations to an
 * extension before you delete the extension.
 */
export declare const deleteExtension: API.OperationMethod<DeleteExtensionRequest, DeleteExtensionResponse, DeleteExtensionError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteExtensionAssociationError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Deletes an extension association. This action doesn't delete extensions defined in the
 * association.
 */
export declare const deleteExtensionAssociation: API.OperationMethod<DeleteExtensionAssociationRequest, DeleteExtensionAssociationResponse, DeleteExtensionAssociationError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteHostedConfigurationVersionError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Deletes a version of a configuration from the AppConfig hosted configuration
 * store.
 */
export declare const deleteHostedConfigurationVersion: API.OperationMethod<DeleteHostedConfigurationVersionRequest, DeleteHostedConfigurationVersionResponse, DeleteHostedConfigurationVersionError, Credentials | Region | HttpClient.HttpClient>;
export type GetAccountSettingsError = BadRequestException | InternalServerException | CommonErrors;
/**
 * Returns information about the status of the `DeletionProtection`
 * parameter.
 */
export declare const getAccountSettings: API.OperationMethod<GetAccountSettingsRequest, AccountSettings, GetAccountSettingsError, Credentials | Region | HttpClient.HttpClient>;
export type GetApplicationError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Retrieves information about an application.
 */
export declare const getApplication: API.OperationMethod<GetApplicationRequest, Application, GetApplicationError, Credentials | Region | HttpClient.HttpClient>;
export type GetConfigurationError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * (Deprecated) Retrieves the latest deployed configuration.
 *
 * Note the following important information.
 *
 * - This API action is deprecated. Calls to receive configuration data should use
 * the StartConfigurationSession and GetLatestConfiguration APIs instead.
 *
 * - GetConfiguration is a priced call. For more information, see
 * Pricing.
 */
export declare const getConfiguration: API.OperationMethod<GetConfigurationRequest, Configuration, GetConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export type GetConfigurationProfileError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Retrieves information about a configuration profile.
 */
export declare const getConfigurationProfile: API.OperationMethod<GetConfigurationProfileRequest, ConfigurationProfile, GetConfigurationProfileError, Credentials | Region | HttpClient.HttpClient>;
export type GetDeploymentError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Retrieves information about a configuration deployment.
 */
export declare const getDeployment: API.OperationMethod<GetDeploymentRequest, Deployment, GetDeploymentError, Credentials | Region | HttpClient.HttpClient>;
export type GetDeploymentStrategyError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Retrieves information about a deployment strategy. A deployment strategy defines
 * important criteria for rolling out your configuration to the designated targets. A
 * deployment strategy includes the overall duration required, a percentage of targets to
 * receive the deployment during each interval, an algorithm that defines how percentage
 * grows, and bake time.
 */
export declare const getDeploymentStrategy: API.OperationMethod<GetDeploymentStrategyRequest, DeploymentStrategy, GetDeploymentStrategyError, Credentials | Region | HttpClient.HttpClient>;
export type GetEnvironmentError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Retrieves information about an environment. An environment is a deployment group of
 * AppConfig applications, such as applications in a `Production`
 * environment or in an `EU_Region` environment. Each configuration deployment
 * targets an environment. You can enable one or more Amazon CloudWatch alarms for an environment. If
 * an alarm is triggered during a deployment, AppConfig roles back the
 * configuration.
 */
export declare const getEnvironment: API.OperationMethod<GetEnvironmentRequest, Environment, GetEnvironmentError, Credentials | Region | HttpClient.HttpClient>;
export type GetExtensionError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Returns information about an AppConfig extension.
 */
export declare const getExtension: API.OperationMethod<GetExtensionRequest, Extension, GetExtensionError, Credentials | Region | HttpClient.HttpClient>;
export type GetExtensionAssociationError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Returns information about an AppConfig extension association. For more
 * information about extensions and associations, see Extending
 * workflows in the *AppConfig User Guide*.
 */
export declare const getExtensionAssociation: API.OperationMethod<GetExtensionAssociationRequest, ExtensionAssociation, GetExtensionAssociationError, Credentials | Region | HttpClient.HttpClient>;
export type GetHostedConfigurationVersionError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Retrieves information about a specific configuration version.
 */
export declare const getHostedConfigurationVersion: API.OperationMethod<GetHostedConfigurationVersionRequest, HostedConfigurationVersion, GetHostedConfigurationVersionError, Credentials | Region | HttpClient.HttpClient>;
export type ListApplicationsError = BadRequestException | InternalServerException | CommonErrors;
/**
 * Lists all applications in your Amazon Web Services account.
 */
export declare const listApplications: API.OperationMethod<ListApplicationsRequest, Applications, ListApplicationsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListApplicationsRequest) => stream.Stream<Applications, ListApplicationsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListApplicationsRequest) => stream.Stream<Application, ListApplicationsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListConfigurationProfilesError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Lists the configuration profiles for an application.
 */
export declare const listConfigurationProfiles: API.OperationMethod<ListConfigurationProfilesRequest, ConfigurationProfiles, ListConfigurationProfilesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListConfigurationProfilesRequest) => stream.Stream<ConfigurationProfiles, ListConfigurationProfilesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListConfigurationProfilesRequest) => stream.Stream<ConfigurationProfileSummary, ListConfigurationProfilesError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListDeploymentsError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Lists the deployments for an environment in descending deployment number order.
 */
export declare const listDeployments: API.OperationMethod<ListDeploymentsRequest, Deployments, ListDeploymentsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListDeploymentsRequest) => stream.Stream<Deployments, ListDeploymentsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListDeploymentsRequest) => stream.Stream<DeploymentSummary, ListDeploymentsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListDeploymentStrategiesError = BadRequestException | InternalServerException | CommonErrors;
/**
 * Lists deployment strategies.
 */
export declare const listDeploymentStrategies: API.OperationMethod<ListDeploymentStrategiesRequest, DeploymentStrategies, ListDeploymentStrategiesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListDeploymentStrategiesRequest) => stream.Stream<DeploymentStrategies, ListDeploymentStrategiesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListDeploymentStrategiesRequest) => stream.Stream<DeploymentStrategy, ListDeploymentStrategiesError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListEnvironmentsError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Lists the environments for an application.
 */
export declare const listEnvironments: API.OperationMethod<ListEnvironmentsRequest, Environments, ListEnvironmentsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListEnvironmentsRequest) => stream.Stream<Environments, ListEnvironmentsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListEnvironmentsRequest) => stream.Stream<Environment, ListEnvironmentsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListExtensionAssociationsError = BadRequestException | InternalServerException | CommonErrors;
/**
 * Lists all AppConfig extension associations in the account. For more
 * information about extensions and associations, see Extending
 * workflows in the *AppConfig User Guide*.
 */
export declare const listExtensionAssociations: API.OperationMethod<ListExtensionAssociationsRequest, ExtensionAssociations, ListExtensionAssociationsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListExtensionAssociationsRequest) => stream.Stream<ExtensionAssociations, ListExtensionAssociationsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListExtensionAssociationsRequest) => stream.Stream<ExtensionAssociationSummary, ListExtensionAssociationsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListExtensionsError = BadRequestException | InternalServerException | CommonErrors;
/**
 * Lists all custom and Amazon Web Services authored AppConfig extensions in the
 * account. For more information about extensions, see Extending
 * workflows in the *AppConfig User Guide*.
 */
export declare const listExtensions: API.OperationMethod<ListExtensionsRequest, Extensions, ListExtensionsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListExtensionsRequest) => stream.Stream<Extensions, ListExtensionsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListExtensionsRequest) => stream.Stream<ExtensionSummary, ListExtensionsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListHostedConfigurationVersionsError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Lists configurations stored in the AppConfig hosted configuration store by
 * version.
 */
export declare const listHostedConfigurationVersions: API.OperationMethod<ListHostedConfigurationVersionsRequest, HostedConfigurationVersions, ListHostedConfigurationVersionsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListHostedConfigurationVersionsRequest) => stream.Stream<HostedConfigurationVersions, ListHostedConfigurationVersionsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListHostedConfigurationVersionsRequest) => stream.Stream<HostedConfigurationVersionSummary, ListHostedConfigurationVersionsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListTagsForResourceError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Retrieves the list of key-value tags assigned to the resource.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ResourceTags, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type StartDeploymentError = BadRequestException | ConflictException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Starts a deployment.
 */
export declare const startDeployment: API.OperationMethod<StartDeploymentRequest, Deployment, StartDeploymentError, Credentials | Region | HttpClient.HttpClient>;
export type StopDeploymentError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Stops a deployment. This API action works only on deployments that have a status of
 * `DEPLOYING`, unless an `AllowRevert` parameter is supplied. If the
 * `AllowRevert` parameter is supplied, the status of an in-progress deployment
 * will be `ROLLED_BACK`. The status of a completed deployment will be
 * `REVERTED`. AppConfig only allows a revert within 72 hours of
 * deployment completion.
 */
export declare const stopDeployment: API.OperationMethod<StopDeploymentRequest, Deployment, StopDeploymentError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Assigns metadata to an AppConfig resource. Tags help organize and categorize
 * your AppConfig resources. Each tag consists of a key and an optional value, both
 * of which you define. You can specify a maximum of 50 tags for a resource.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResponse, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Deletes a tag key and value from an AppConfig resource.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResponse, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateAccountSettingsError = BadRequestException | InternalServerException | CommonErrors;
/**
 * Updates the value of the `DeletionProtection` parameter.
 */
export declare const updateAccountSettings: API.OperationMethod<UpdateAccountSettingsRequest, AccountSettings, UpdateAccountSettingsError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateApplicationError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Updates an application.
 */
export declare const updateApplication: API.OperationMethod<UpdateApplicationRequest, Application, UpdateApplicationError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateConfigurationProfileError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Updates a configuration profile.
 */
export declare const updateConfigurationProfile: API.OperationMethod<UpdateConfigurationProfileRequest, ConfigurationProfile, UpdateConfigurationProfileError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateDeploymentStrategyError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Updates a deployment strategy.
 */
export declare const updateDeploymentStrategy: API.OperationMethod<UpdateDeploymentStrategyRequest, DeploymentStrategy, UpdateDeploymentStrategyError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateEnvironmentError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Updates an environment.
 */
export declare const updateEnvironment: API.OperationMethod<UpdateEnvironmentRequest, Environment, UpdateEnvironmentError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateExtensionError = BadRequestException | ConflictException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Updates an AppConfig extension. For more information about extensions, see
 * Extending
 * workflows in the *AppConfig User Guide*.
 */
export declare const updateExtension: API.OperationMethod<UpdateExtensionRequest, Extension, UpdateExtensionError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateExtensionAssociationError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Updates an association. For more information about extensions and associations, see
 * Extending
 * workflows in the *AppConfig User Guide*.
 */
export declare const updateExtensionAssociation: API.OperationMethod<UpdateExtensionAssociationRequest, ExtensionAssociation, UpdateExtensionAssociationError, Credentials | Region | HttpClient.HttpClient>;
export type ValidateConfigurationError = BadRequestException | InternalServerException | ResourceNotFoundException | CommonErrors;
/**
 * Uses the validators in a configuration profile to validate a configuration.
 */
export declare const validateConfiguration: API.OperationMethod<ValidateConfigurationRequest, ValidateConfigurationResponse, ValidateConfigurationError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=appconfig.d.ts.map