@aws-sdk/client-sagemaker 3.50.0 → 3.53.0

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

@@ -0,0 +1,3935 @@
+import { ActionSource, ActionStatus, AdditionalInferenceSpecificationDefinition, AlgorithmSpecification, AlgorithmStatus, AlgorithmStatusDetails, AlgorithmValidationSpecification, AnnotationConsolidationConfig, AppNetworkAccessType, AppSecurityGroupManagement, AppSpecification, AppStatus, AppType, ArtifactSource, AsyncInferenceConfig, AthenaDatasetDefinition, AuthMode, AutoMLCandidate, AutoMLChannel, AutoMLJobArtifacts, AutoMLJobCompletionCriteria, AutoMLJobConfig, AutoMLJobObjective, AutoMLJobSecondaryStatus, AutoMLJobStatus, AutoMLOutputDataConfig, AutoMLPartialFailureReason, BatchStrategy, Bias, CaptureStatus, Channel, CheckpointConfig, CognitoConfig, CognitoMemberDefinition, CollectionConfiguration, CompilationJobStatus, ContainerDefinition, ContentClassifier, ContextSource, DataCaptureConfig, DataQualityAppSpecification, DataQualityBaselineConfig, DataQualityJobInput, DeploymentConfig, DomainSettings, EdgeOutputConfig, EdgePresetDeploymentType, EndpointInput, EnvironmentParameterRanges, FeatureDefinition, FlowDefinitionOutputConfig, GitConfig, HumanLoopActivationConfig, HumanLoopConfig, HumanLoopRequestSource, HyperParameterTrainingJobDefinition, HyperParameterTuningJobConfig, HyperParameterTuningJobObjectiveType, HyperParameterTuningJobWarmStartConfig, InferenceSpecification, InputConfig, KernelGatewayImageConfig, MetadataProperties, MetricsSource, ModelApprovalStatus, ModelDeployConfig, MonitoringConstraintsResource, MonitoringNetworkConfig, MonitoringOutputConfig, MonitoringResources, MonitoringStatisticsResource, MonitoringStoppingCondition, NeoVpcConfig, ObjectiveStatus, OfflineStoreConfig, OnlineStoreConfig, OutputConfig, OutputDataConfig, ProblemType, ProcessingInstanceType, ProcessingS3DataDistributionType, ProcessingS3InputMode, ProcessingS3UploadMode, ProductionVariant, ProductionVariantAcceleratorType, ProductionVariantInstanceType, ProductionVariantServerlessConfig, PublicWorkforceTaskPrice, ResourceConfig, ResourceSpec, RetryStrategy, StoppingCondition, Tag, TrainingSpecification, TransformInput, TransformJobDefinition, TransformOutput, TransformResources, UserContext, UserSettings, VpcConfig } from "./models_0";
+
+export interface EndpointInputConfiguration {
+    
+    InstanceType: ProductionVariantInstanceType | string | undefined;
+    
+    InferenceSpecificationName?: string;
+    
+    EnvironmentParameterRanges?: EnvironmentParameterRanges;
+}
+export declare namespace EndpointInputConfiguration {
+    
+    const filterSensitiveLog: (obj: EndpointInputConfiguration) => any;
+}
+
+export interface RecommendationJobResourceLimit {
+    
+    MaxNumberOfTests?: number;
+    
+    MaxParallelOfTests?: number;
+}
+export declare namespace RecommendationJobResourceLimit {
+    
+    const filterSensitiveLog: (obj: RecommendationJobResourceLimit) => any;
+}
+
+export interface Phase {
+    
+    InitialNumberOfUsers?: number;
+    
+    SpawnRate?: number;
+    
+    DurationInSeconds?: number;
+}
+export declare namespace Phase {
+    
+    const filterSensitiveLog: (obj: Phase) => any;
+}
+export declare enum TrafficType {
+    PHASES = "PHASES"
+}
+
+export interface TrafficPattern {
+    
+    TrafficType?: TrafficType | string;
+    
+    Phases?: Phase[];
+}
+export declare namespace TrafficPattern {
+    
+    const filterSensitiveLog: (obj: TrafficPattern) => any;
+}
+
+export interface RecommendationJobInputConfig {
+    
+    ModelPackageVersionArn: string | undefined;
+    
+    JobDurationInSeconds?: number;
+    
+    TrafficPattern?: TrafficPattern;
+    
+    ResourceLimit?: RecommendationJobResourceLimit;
+    
+    EndpointConfigurations?: EndpointInputConfiguration[];
+}
+export declare namespace RecommendationJobInputConfig {
+    
+    const filterSensitiveLog: (obj: RecommendationJobInputConfig) => any;
+}
+export declare enum RecommendationJobType {
+    ADVANCED = "Advanced",
+    DEFAULT = "Default"
+}
+
+export interface ModelLatencyThreshold {
+    
+    Percentile?: string;
+    
+    ValueInMilliseconds?: number;
+}
+export declare namespace ModelLatencyThreshold {
+    
+    const filterSensitiveLog: (obj: ModelLatencyThreshold) => any;
+}
+
+export interface RecommendationJobStoppingConditions {
+    
+    MaxInvocations?: number;
+    
+    ModelLatencyThresholds?: ModelLatencyThreshold[];
+}
+export declare namespace RecommendationJobStoppingConditions {
+    
+    const filterSensitiveLog: (obj: RecommendationJobStoppingConditions) => any;
+}
+export interface CreateInferenceRecommendationsJobRequest {
+    
+    JobName: string | undefined;
+    
+    JobType: RecommendationJobType | string | undefined;
+    
+    RoleArn: string | undefined;
+    
+    InputConfig: RecommendationJobInputConfig | undefined;
+    
+    JobDescription?: string;
+    
+    StoppingConditions?: RecommendationJobStoppingConditions;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateInferenceRecommendationsJobRequest {
+    
+    const filterSensitiveLog: (obj: CreateInferenceRecommendationsJobRequest) => any;
+}
+export interface CreateInferenceRecommendationsJobResponse {
+    
+    JobArn: string | undefined;
+}
+export declare namespace CreateInferenceRecommendationsJobResponse {
+    
+    const filterSensitiveLog: (obj: CreateInferenceRecommendationsJobResponse) => any;
+}
+
+export interface UiConfig {
+    
+    UiTemplateS3Uri?: string;
+    
+    HumanTaskUiArn?: string;
+}
+export declare namespace UiConfig {
+    
+    const filterSensitiveLog: (obj: UiConfig) => any;
+}
+
+export interface HumanTaskConfig {
+    
+    WorkteamArn: string | undefined;
+    
+    UiConfig: UiConfig | undefined;
+    
+    PreHumanTaskLambdaArn: string | undefined;
+    
+    TaskKeywords?: string[];
+    
+    TaskTitle: string | undefined;
+    
+    TaskDescription: string | undefined;
+    
+    NumberOfHumanWorkersPerDataObject: number | undefined;
+    
+    TaskTimeLimitInSeconds: number | undefined;
+    
+    TaskAvailabilityLifetimeInSeconds?: number;
+    
+    MaxConcurrentTaskCount?: number;
+    
+    AnnotationConsolidationConfig: AnnotationConsolidationConfig | undefined;
+    
+    PublicWorkforceTaskPrice?: PublicWorkforceTaskPrice;
+}
+export declare namespace HumanTaskConfig {
+    
+    const filterSensitiveLog: (obj: HumanTaskConfig) => any;
+}
+
+export interface LabelingJobDataAttributes {
+    
+    ContentClassifiers?: (ContentClassifier | string)[];
+}
+export declare namespace LabelingJobDataAttributes {
+    
+    const filterSensitiveLog: (obj: LabelingJobDataAttributes) => any;
+}
+
+export interface LabelingJobS3DataSource {
+    
+    ManifestS3Uri: string | undefined;
+}
+export declare namespace LabelingJobS3DataSource {
+    
+    const filterSensitiveLog: (obj: LabelingJobS3DataSource) => any;
+}
+
+export interface LabelingJobSnsDataSource {
+    
+    SnsTopicArn: string | undefined;
+}
+export declare namespace LabelingJobSnsDataSource {
+    
+    const filterSensitiveLog: (obj: LabelingJobSnsDataSource) => any;
+}
+
+export interface LabelingJobDataSource {
+    
+    S3DataSource?: LabelingJobS3DataSource;
+    
+    SnsDataSource?: LabelingJobSnsDataSource;
+}
+export declare namespace LabelingJobDataSource {
+    
+    const filterSensitiveLog: (obj: LabelingJobDataSource) => any;
+}
+
+export interface LabelingJobInputConfig {
+    
+    DataSource: LabelingJobDataSource | undefined;
+    
+    DataAttributes?: LabelingJobDataAttributes;
+}
+export declare namespace LabelingJobInputConfig {
+    
+    const filterSensitiveLog: (obj: LabelingJobInputConfig) => any;
+}
+
+export interface LabelingJobResourceConfig {
+    
+    VolumeKmsKeyId?: string;
+}
+export declare namespace LabelingJobResourceConfig {
+    
+    const filterSensitiveLog: (obj: LabelingJobResourceConfig) => any;
+}
+
+export interface LabelingJobAlgorithmsConfig {
+    
+    LabelingJobAlgorithmSpecificationArn: string | undefined;
+    
+    InitialActiveLearningModelArn?: string;
+    
+    LabelingJobResourceConfig?: LabelingJobResourceConfig;
+}
+export declare namespace LabelingJobAlgorithmsConfig {
+    
+    const filterSensitiveLog: (obj: LabelingJobAlgorithmsConfig) => any;
+}
+
+export interface LabelingJobOutputConfig {
+    
+    S3OutputPath: string | undefined;
+    
+    KmsKeyId?: string;
+    
+    SnsTopicArn?: string;
+}
+export declare namespace LabelingJobOutputConfig {
+    
+    const filterSensitiveLog: (obj: LabelingJobOutputConfig) => any;
+}
+
+export interface LabelingJobStoppingConditions {
+    
+    MaxHumanLabeledObjectCount?: number;
+    
+    MaxPercentageOfInputDatasetLabeled?: number;
+}
+export declare namespace LabelingJobStoppingConditions {
+    
+    const filterSensitiveLog: (obj: LabelingJobStoppingConditions) => any;
+}
+export interface CreateLabelingJobRequest {
+    
+    LabelingJobName: string | undefined;
+    
+    LabelAttributeName: string | undefined;
+    
+    InputConfig: LabelingJobInputConfig | undefined;
+    
+    OutputConfig: LabelingJobOutputConfig | undefined;
+    
+    RoleArn: string | undefined;
+    
+    LabelCategoryConfigS3Uri?: string;
+    
+    StoppingConditions?: LabelingJobStoppingConditions;
+    
+    LabelingJobAlgorithmsConfig?: LabelingJobAlgorithmsConfig;
+    
+    HumanTaskConfig: HumanTaskConfig | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateLabelingJobRequest {
+    
+    const filterSensitiveLog: (obj: CreateLabelingJobRequest) => any;
+}
+export interface CreateLabelingJobResponse {
+    
+    LabelingJobArn: string | undefined;
+}
+export declare namespace CreateLabelingJobResponse {
+    
+    const filterSensitiveLog: (obj: CreateLabelingJobResponse) => any;
+}
+export declare enum InferenceExecutionMode {
+    DIRECT = "Direct",
+    SERIAL = "Serial"
+}
+
+export interface InferenceExecutionConfig {
+    
+    Mode: InferenceExecutionMode | string | undefined;
+}
+export declare namespace InferenceExecutionConfig {
+    
+    const filterSensitiveLog: (obj: InferenceExecutionConfig) => any;
+}
+export interface CreateModelInput {
+    
+    ModelName: string | undefined;
+    
+    PrimaryContainer?: ContainerDefinition;
+    
+    Containers?: ContainerDefinition[];
+    
+    InferenceExecutionConfig?: InferenceExecutionConfig;
+    
+    ExecutionRoleArn: string | undefined;
+    
+    Tags?: Tag[];
+    
+    VpcConfig?: VpcConfig;
+    
+    EnableNetworkIsolation?: boolean;
+}
+export declare namespace CreateModelInput {
+    
+    const filterSensitiveLog: (obj: CreateModelInput) => any;
+}
+export interface CreateModelOutput {
+    
+    ModelArn: string | undefined;
+}
+export declare namespace CreateModelOutput {
+    
+    const filterSensitiveLog: (obj: CreateModelOutput) => any;
+}
+
+export interface ModelBiasAppSpecification {
+    
+    ImageUri: string | undefined;
+    
+    ConfigUri: string | undefined;
+    
+    Environment?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ModelBiasAppSpecification {
+    
+    const filterSensitiveLog: (obj: ModelBiasAppSpecification) => any;
+}
+
+export interface ModelBiasBaselineConfig {
+    
+    BaseliningJobName?: string;
+    
+    ConstraintsResource?: MonitoringConstraintsResource;
+}
+export declare namespace ModelBiasBaselineConfig {
+    
+    const filterSensitiveLog: (obj: ModelBiasBaselineConfig) => any;
+}
+
+export interface MonitoringGroundTruthS3Input {
+    
+    S3Uri?: string;
+}
+export declare namespace MonitoringGroundTruthS3Input {
+    
+    const filterSensitiveLog: (obj: MonitoringGroundTruthS3Input) => any;
+}
+
+export interface ModelBiasJobInput {
+    
+    EndpointInput: EndpointInput | undefined;
+    
+    GroundTruthS3Input: MonitoringGroundTruthS3Input | undefined;
+}
+export declare namespace ModelBiasJobInput {
+    
+    const filterSensitiveLog: (obj: ModelBiasJobInput) => any;
+}
+export interface CreateModelBiasJobDefinitionRequest {
+    
+    JobDefinitionName: string | undefined;
+    
+    ModelBiasBaselineConfig?: ModelBiasBaselineConfig;
+    
+    ModelBiasAppSpecification: ModelBiasAppSpecification | undefined;
+    
+    ModelBiasJobInput: ModelBiasJobInput | undefined;
+    
+    ModelBiasJobOutputConfig: MonitoringOutputConfig | undefined;
+    
+    JobResources: MonitoringResources | undefined;
+    
+    NetworkConfig?: MonitoringNetworkConfig;
+    
+    RoleArn: string | undefined;
+    
+    StoppingCondition?: MonitoringStoppingCondition;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateModelBiasJobDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: CreateModelBiasJobDefinitionRequest) => any;
+}
+export interface CreateModelBiasJobDefinitionResponse {
+    
+    JobDefinitionArn: string | undefined;
+}
+export declare namespace CreateModelBiasJobDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: CreateModelBiasJobDefinitionResponse) => any;
+}
+
+export interface ModelExplainabilityAppSpecification {
+    
+    ImageUri: string | undefined;
+    
+    ConfigUri: string | undefined;
+    
+    Environment?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ModelExplainabilityAppSpecification {
+    
+    const filterSensitiveLog: (obj: ModelExplainabilityAppSpecification) => any;
+}
+
+export interface ModelExplainabilityBaselineConfig {
+    
+    BaseliningJobName?: string;
+    
+    ConstraintsResource?: MonitoringConstraintsResource;
+}
+export declare namespace ModelExplainabilityBaselineConfig {
+    
+    const filterSensitiveLog: (obj: ModelExplainabilityBaselineConfig) => any;
+}
+
+export interface ModelExplainabilityJobInput {
+    
+    EndpointInput: EndpointInput | undefined;
+}
+export declare namespace ModelExplainabilityJobInput {
+    
+    const filterSensitiveLog: (obj: ModelExplainabilityJobInput) => any;
+}
+export interface CreateModelExplainabilityJobDefinitionRequest {
+    
+    JobDefinitionName: string | undefined;
+    
+    ModelExplainabilityBaselineConfig?: ModelExplainabilityBaselineConfig;
+    
+    ModelExplainabilityAppSpecification: ModelExplainabilityAppSpecification | undefined;
+    
+    ModelExplainabilityJobInput: ModelExplainabilityJobInput | undefined;
+    
+    ModelExplainabilityJobOutputConfig: MonitoringOutputConfig | undefined;
+    
+    JobResources: MonitoringResources | undefined;
+    
+    NetworkConfig?: MonitoringNetworkConfig;
+    
+    RoleArn: string | undefined;
+    
+    StoppingCondition?: MonitoringStoppingCondition;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateModelExplainabilityJobDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: CreateModelExplainabilityJobDefinitionRequest) => any;
+}
+export interface CreateModelExplainabilityJobDefinitionResponse {
+    
+    JobDefinitionArn: string | undefined;
+}
+export declare namespace CreateModelExplainabilityJobDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: CreateModelExplainabilityJobDefinitionResponse) => any;
+}
+
+export interface FileSource {
+    
+    ContentType?: string;
+    
+    ContentDigest?: string;
+    
+    S3Uri: string | undefined;
+}
+export declare namespace FileSource {
+    
+    const filterSensitiveLog: (obj: FileSource) => any;
+}
+
+export interface DriftCheckBias {
+    
+    ConfigFile?: FileSource;
+    
+    PreTrainingConstraints?: MetricsSource;
+    
+    PostTrainingConstraints?: MetricsSource;
+}
+export declare namespace DriftCheckBias {
+    
+    const filterSensitiveLog: (obj: DriftCheckBias) => any;
+}
+
+export interface DriftCheckExplainability {
+    
+    Constraints?: MetricsSource;
+    
+    ConfigFile?: FileSource;
+}
+export declare namespace DriftCheckExplainability {
+    
+    const filterSensitiveLog: (obj: DriftCheckExplainability) => any;
+}
+
+export interface DriftCheckModelDataQuality {
+    
+    Statistics?: MetricsSource;
+    
+    Constraints?: MetricsSource;
+}
+export declare namespace DriftCheckModelDataQuality {
+    
+    const filterSensitiveLog: (obj: DriftCheckModelDataQuality) => any;
+}
+
+export interface DriftCheckModelQuality {
+    
+    Statistics?: MetricsSource;
+    
+    Constraints?: MetricsSource;
+}
+export declare namespace DriftCheckModelQuality {
+    
+    const filterSensitiveLog: (obj: DriftCheckModelQuality) => any;
+}
+
+export interface DriftCheckBaselines {
+    
+    Bias?: DriftCheckBias;
+    
+    Explainability?: DriftCheckExplainability;
+    
+    ModelQuality?: DriftCheckModelQuality;
+    
+    ModelDataQuality?: DriftCheckModelDataQuality;
+}
+export declare namespace DriftCheckBaselines {
+    
+    const filterSensitiveLog: (obj: DriftCheckBaselines) => any;
+}
+
+export interface Explainability {
+    
+    Report?: MetricsSource;
+}
+export declare namespace Explainability {
+    
+    const filterSensitiveLog: (obj: Explainability) => any;
+}
+
+export interface ModelDataQuality {
+    
+    Statistics?: MetricsSource;
+    
+    Constraints?: MetricsSource;
+}
+export declare namespace ModelDataQuality {
+    
+    const filterSensitiveLog: (obj: ModelDataQuality) => any;
+}
+
+export interface ModelQuality {
+    
+    Statistics?: MetricsSource;
+    
+    Constraints?: MetricsSource;
+}
+export declare namespace ModelQuality {
+    
+    const filterSensitiveLog: (obj: ModelQuality) => any;
+}
+
+export interface ModelMetrics {
+    
+    ModelQuality?: ModelQuality;
+    
+    ModelDataQuality?: ModelDataQuality;
+    
+    Bias?: Bias;
+    
+    Explainability?: Explainability;
+}
+export declare namespace ModelMetrics {
+    
+    const filterSensitiveLog: (obj: ModelMetrics) => any;
+}
+
+export interface SourceAlgorithm {
+    
+    ModelDataUrl?: string;
+    
+    AlgorithmName: string | undefined;
+}
+export declare namespace SourceAlgorithm {
+    
+    const filterSensitiveLog: (obj: SourceAlgorithm) => any;
+}
+
+export interface SourceAlgorithmSpecification {
+    
+    SourceAlgorithms: SourceAlgorithm[] | undefined;
+}
+export declare namespace SourceAlgorithmSpecification {
+    
+    const filterSensitiveLog: (obj: SourceAlgorithmSpecification) => any;
+}
+
+export interface ModelPackageValidationProfile {
+    
+    ProfileName: string | undefined;
+    
+    TransformJobDefinition: TransformJobDefinition | undefined;
+}
+export declare namespace ModelPackageValidationProfile {
+    
+    const filterSensitiveLog: (obj: ModelPackageValidationProfile) => any;
+}
+
+export interface ModelPackageValidationSpecification {
+    
+    ValidationRole: string | undefined;
+    
+    ValidationProfiles: ModelPackageValidationProfile[] | undefined;
+}
+export declare namespace ModelPackageValidationSpecification {
+    
+    const filterSensitiveLog: (obj: ModelPackageValidationSpecification) => any;
+}
+export interface CreateModelPackageInput {
+    
+    ModelPackageName?: string;
+    
+    ModelPackageGroupName?: string;
+    
+    ModelPackageDescription?: string;
+    
+    InferenceSpecification?: InferenceSpecification;
+    
+    ValidationSpecification?: ModelPackageValidationSpecification;
+    
+    SourceAlgorithmSpecification?: SourceAlgorithmSpecification;
+    
+    CertifyForMarketplace?: boolean;
+    
+    Tags?: Tag[];
+    
+    ModelApprovalStatus?: ModelApprovalStatus | string;
+    
+    MetadataProperties?: MetadataProperties;
+    
+    ModelMetrics?: ModelMetrics;
+    
+    ClientToken?: string;
+    
+    CustomerMetadataProperties?: {
+        [key: string]: string;
+    };
+    
+    DriftCheckBaselines?: DriftCheckBaselines;
+    
+    Domain?: string;
+    
+    Task?: string;
+    
+    SamplePayloadUrl?: string;
+    
+    AdditionalInferenceSpecifications?: AdditionalInferenceSpecificationDefinition[];
+}
+export declare namespace CreateModelPackageInput {
+    
+    const filterSensitiveLog: (obj: CreateModelPackageInput) => any;
+}
+export interface CreateModelPackageOutput {
+    
+    ModelPackageArn: string | undefined;
+}
+export declare namespace CreateModelPackageOutput {
+    
+    const filterSensitiveLog: (obj: CreateModelPackageOutput) => any;
+}
+export interface CreateModelPackageGroupInput {
+    
+    ModelPackageGroupName: string | undefined;
+    
+    ModelPackageGroupDescription?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateModelPackageGroupInput {
+    
+    const filterSensitiveLog: (obj: CreateModelPackageGroupInput) => any;
+}
+export interface CreateModelPackageGroupOutput {
+    
+    ModelPackageGroupArn: string | undefined;
+}
+export declare namespace CreateModelPackageGroupOutput {
+    
+    const filterSensitiveLog: (obj: CreateModelPackageGroupOutput) => any;
+}
+export declare enum MonitoringProblemType {
+    BINARY_CLASSIFICATION = "BinaryClassification",
+    MULTICLASS_CLASSIFICATION = "MulticlassClassification",
+    REGRESSION = "Regression"
+}
+
+export interface ModelQualityAppSpecification {
+    
+    ImageUri: string | undefined;
+    
+    ContainerEntrypoint?: string[];
+    
+    ContainerArguments?: string[];
+    
+    RecordPreprocessorSourceUri?: string;
+    
+    PostAnalyticsProcessorSourceUri?: string;
+    
+    ProblemType?: MonitoringProblemType | string;
+    
+    Environment?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ModelQualityAppSpecification {
+    
+    const filterSensitiveLog: (obj: ModelQualityAppSpecification) => any;
+}
+
+export interface ModelQualityBaselineConfig {
+    
+    BaseliningJobName?: string;
+    
+    ConstraintsResource?: MonitoringConstraintsResource;
+}
+export declare namespace ModelQualityBaselineConfig {
+    
+    const filterSensitiveLog: (obj: ModelQualityBaselineConfig) => any;
+}
+
+export interface ModelQualityJobInput {
+    
+    EndpointInput: EndpointInput | undefined;
+    
+    GroundTruthS3Input: MonitoringGroundTruthS3Input | undefined;
+}
+export declare namespace ModelQualityJobInput {
+    
+    const filterSensitiveLog: (obj: ModelQualityJobInput) => any;
+}
+export interface CreateModelQualityJobDefinitionRequest {
+    
+    JobDefinitionName: string | undefined;
+    
+    ModelQualityBaselineConfig?: ModelQualityBaselineConfig;
+    
+    ModelQualityAppSpecification: ModelQualityAppSpecification | undefined;
+    
+    ModelQualityJobInput: ModelQualityJobInput | undefined;
+    
+    ModelQualityJobOutputConfig: MonitoringOutputConfig | undefined;
+    
+    JobResources: MonitoringResources | undefined;
+    
+    NetworkConfig?: MonitoringNetworkConfig;
+    
+    RoleArn: string | undefined;
+    
+    StoppingCondition?: MonitoringStoppingCondition;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateModelQualityJobDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: CreateModelQualityJobDefinitionRequest) => any;
+}
+export interface CreateModelQualityJobDefinitionResponse {
+    
+    JobDefinitionArn: string | undefined;
+}
+export declare namespace CreateModelQualityJobDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: CreateModelQualityJobDefinitionResponse) => any;
+}
+
+export interface MonitoringBaselineConfig {
+    
+    BaseliningJobName?: string;
+    
+    ConstraintsResource?: MonitoringConstraintsResource;
+    
+    StatisticsResource?: MonitoringStatisticsResource;
+}
+export declare namespace MonitoringBaselineConfig {
+    
+    const filterSensitiveLog: (obj: MonitoringBaselineConfig) => any;
+}
+
+export interface MonitoringAppSpecification {
+    
+    ImageUri: string | undefined;
+    
+    ContainerEntrypoint?: string[];
+    
+    ContainerArguments?: string[];
+    
+    RecordPreprocessorSourceUri?: string;
+    
+    PostAnalyticsProcessorSourceUri?: string;
+}
+export declare namespace MonitoringAppSpecification {
+    
+    const filterSensitiveLog: (obj: MonitoringAppSpecification) => any;
+}
+
+export interface MonitoringInput {
+    
+    EndpointInput: EndpointInput | undefined;
+}
+export declare namespace MonitoringInput {
+    
+    const filterSensitiveLog: (obj: MonitoringInput) => any;
+}
+
+export interface NetworkConfig {
+    
+    EnableInterContainerTrafficEncryption?: boolean;
+    
+    EnableNetworkIsolation?: boolean;
+    
+    VpcConfig?: VpcConfig;
+}
+export declare namespace NetworkConfig {
+    
+    const filterSensitiveLog: (obj: NetworkConfig) => any;
+}
+
+export interface MonitoringJobDefinition {
+    
+    BaselineConfig?: MonitoringBaselineConfig;
+    
+    MonitoringInputs: MonitoringInput[] | undefined;
+    
+    MonitoringOutputConfig: MonitoringOutputConfig | undefined;
+    
+    MonitoringResources: MonitoringResources | undefined;
+    
+    MonitoringAppSpecification: MonitoringAppSpecification | undefined;
+    
+    StoppingCondition?: MonitoringStoppingCondition;
+    
+    Environment?: {
+        [key: string]: string;
+    };
+    
+    NetworkConfig?: NetworkConfig;
+    
+    RoleArn: string | undefined;
+}
+export declare namespace MonitoringJobDefinition {
+    
+    const filterSensitiveLog: (obj: MonitoringJobDefinition) => any;
+}
+export declare enum MonitoringType {
+    DATA_QUALITY = "DataQuality",
+    MODEL_BIAS = "ModelBias",
+    MODEL_EXPLAINABILITY = "ModelExplainability",
+    MODEL_QUALITY = "ModelQuality"
+}
+
+export interface ScheduleConfig {
+    
+    ScheduleExpression: string | undefined;
+}
+export declare namespace ScheduleConfig {
+    
+    const filterSensitiveLog: (obj: ScheduleConfig) => any;
+}
+
+export interface MonitoringScheduleConfig {
+    
+    ScheduleConfig?: ScheduleConfig;
+    
+    MonitoringJobDefinition?: MonitoringJobDefinition;
+    
+    MonitoringJobDefinitionName?: string;
+    
+    MonitoringType?: MonitoringType | string;
+}
+export declare namespace MonitoringScheduleConfig {
+    
+    const filterSensitiveLog: (obj: MonitoringScheduleConfig) => any;
+}
+export interface CreateMonitoringScheduleRequest {
+    
+    MonitoringScheduleName: string | undefined;
+    
+    MonitoringScheduleConfig: MonitoringScheduleConfig | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateMonitoringScheduleRequest {
+    
+    const filterSensitiveLog: (obj: CreateMonitoringScheduleRequest) => any;
+}
+export interface CreateMonitoringScheduleResponse {
+    
+    MonitoringScheduleArn: string | undefined;
+}
+export declare namespace CreateMonitoringScheduleResponse {
+    
+    const filterSensitiveLog: (obj: CreateMonitoringScheduleResponse) => any;
+}
+export declare enum NotebookInstanceAcceleratorType {
+    ML_EIA1_LARGE = "ml.eia1.large",
+    ML_EIA1_MEDIUM = "ml.eia1.medium",
+    ML_EIA1_XLARGE = "ml.eia1.xlarge",
+    ML_EIA2_LARGE = "ml.eia2.large",
+    ML_EIA2_MEDIUM = "ml.eia2.medium",
+    ML_EIA2_XLARGE = "ml.eia2.xlarge"
+}
+export declare enum DirectInternetAccess {
+    DISABLED = "Disabled",
+    ENABLED = "Enabled"
+}
+export declare enum _InstanceType {
+    ML_C4_2XLARGE = "ml.c4.2xlarge",
+    ML_C4_4XLARGE = "ml.c4.4xlarge",
+    ML_C4_8XLARGE = "ml.c4.8xlarge",
+    ML_C4_XLARGE = "ml.c4.xlarge",
+    ML_C5D_18XLARGE = "ml.c5d.18xlarge",
+    ML_C5D_2XLARGE = "ml.c5d.2xlarge",
+    ML_C5D_4XLARGE = "ml.c5d.4xlarge",
+    ML_C5D_9XLARGE = "ml.c5d.9xlarge",
+    ML_C5D_XLARGE = "ml.c5d.xlarge",
+    ML_C5_18XLARGE = "ml.c5.18xlarge",
+    ML_C5_2XLARGE = "ml.c5.2xlarge",
+    ML_C5_4XLARGE = "ml.c5.4xlarge",
+    ML_C5_9XLARGE = "ml.c5.9xlarge",
+    ML_C5_XLARGE = "ml.c5.xlarge",
+    ML_G4DN_12XLARGE = "ml.g4dn.12xlarge",
+    ML_G4DN_16XLARGE = "ml.g4dn.16xlarge",
+    ML_G4DN_2XLARGE = "ml.g4dn.2xlarge",
+    ML_G4DN_4XLARGE = "ml.g4dn.4xlarge",
+    ML_G4DN_8XLARGE = "ml.g4dn.8xlarge",
+    ML_G4DN_XLARGE = "ml.g4dn.xlarge",
+    ML_M4_10XLARGE = "ml.m4.10xlarge",
+    ML_M4_16XLARGE = "ml.m4.16xlarge",
+    ML_M4_2XLARGE = "ml.m4.2xlarge",
+    ML_M4_4XLARGE = "ml.m4.4xlarge",
+    ML_M4_XLARGE = "ml.m4.xlarge",
+    ML_M5D_12XLARGE = "ml.m5d.12xlarge",
+    ML_M5D_16XLARGE = "ml.m5d.16xlarge",
+    ML_M5D_24XLARGE = "ml.m5d.24xlarge",
+    ML_M5D_2XLARGE = "ml.m5d.2xlarge",
+    ML_M5D_4XLARGE = "ml.m5d.4xlarge",
+    ML_M5D_8XLARGE = "ml.m5d.8xlarge",
+    ML_M5D_LARGE = "ml.m5d.large",
+    ML_M5D_XLARGE = "ml.m5d.xlarge",
+    ML_M5_12XLARGE = "ml.m5.12xlarge",
+    ML_M5_24XLARGE = "ml.m5.24xlarge",
+    ML_M5_2XLARGE = "ml.m5.2xlarge",
+    ML_M5_4XLARGE = "ml.m5.4xlarge",
+    ML_M5_XLARGE = "ml.m5.xlarge",
+    ML_P2_16XLARGE = "ml.p2.16xlarge",
+    ML_P2_8XLARGE = "ml.p2.8xlarge",
+    ML_P2_XLARGE = "ml.p2.xlarge",
+    ML_P3DN_24XLARGE = "ml.p3dn.24xlarge",
+    ML_P3_16XLARGE = "ml.p3.16xlarge",
+    ML_P3_2XLARGE = "ml.p3.2xlarge",
+    ML_P3_8XLARGE = "ml.p3.8xlarge",
+    ML_R5_12XLARGE = "ml.r5.12xlarge",
+    ML_R5_16XLARGE = "ml.r5.16xlarge",
+    ML_R5_24XLARGE = "ml.r5.24xlarge",
+    ML_R5_2XLARGE = "ml.r5.2xlarge",
+    ML_R5_4XLARGE = "ml.r5.4xlarge",
+    ML_R5_8XLARGE = "ml.r5.8xlarge",
+    ML_R5_LARGE = "ml.r5.large",
+    ML_R5_XLARGE = "ml.r5.xlarge",
+    ML_T2_2XLARGE = "ml.t2.2xlarge",
+    ML_T2_LARGE = "ml.t2.large",
+    ML_T2_MEDIUM = "ml.t2.medium",
+    ML_T2_XLARGE = "ml.t2.xlarge",
+    ML_T3_2XLARGE = "ml.t3.2xlarge",
+    ML_T3_LARGE = "ml.t3.large",
+    ML_T3_MEDIUM = "ml.t3.medium",
+    ML_T3_XLARGE = "ml.t3.xlarge"
+}
+export declare enum RootAccess {
+    DISABLED = "Disabled",
+    ENABLED = "Enabled"
+}
+export interface CreateNotebookInstanceInput {
+    
+    NotebookInstanceName: string | undefined;
+    
+    InstanceType: _InstanceType | string | undefined;
+    
+    SubnetId?: string;
+    
+    SecurityGroupIds?: string[];
+    
+    RoleArn: string | undefined;
+    
+    KmsKeyId?: string;
+    
+    Tags?: Tag[];
+    
+    LifecycleConfigName?: string;
+    
+    DirectInternetAccess?: DirectInternetAccess | string;
+    
+    VolumeSizeInGB?: number;
+    
+    AcceleratorTypes?: (NotebookInstanceAcceleratorType | string)[];
+    
+    DefaultCodeRepository?: string;
+    
+    AdditionalCodeRepositories?: string[];
+    
+    RootAccess?: RootAccess | string;
+    
+    PlatformIdentifier?: string;
+}
+export declare namespace CreateNotebookInstanceInput {
+    
+    const filterSensitiveLog: (obj: CreateNotebookInstanceInput) => any;
+}
+export interface CreateNotebookInstanceOutput {
+    
+    NotebookInstanceArn?: string;
+}
+export declare namespace CreateNotebookInstanceOutput {
+    
+    const filterSensitiveLog: (obj: CreateNotebookInstanceOutput) => any;
+}
+
+export interface NotebookInstanceLifecycleHook {
+    
+    Content?: string;
+}
+export declare namespace NotebookInstanceLifecycleHook {
+    
+    const filterSensitiveLog: (obj: NotebookInstanceLifecycleHook) => any;
+}
+export interface CreateNotebookInstanceLifecycleConfigInput {
+    
+    NotebookInstanceLifecycleConfigName: string | undefined;
+    
+    OnCreate?: NotebookInstanceLifecycleHook[];
+    
+    OnStart?: NotebookInstanceLifecycleHook[];
+}
+export declare namespace CreateNotebookInstanceLifecycleConfigInput {
+    
+    const filterSensitiveLog: (obj: CreateNotebookInstanceLifecycleConfigInput) => any;
+}
+export interface CreateNotebookInstanceLifecycleConfigOutput {
+    
+    NotebookInstanceLifecycleConfigArn?: string;
+}
+export declare namespace CreateNotebookInstanceLifecycleConfigOutput {
+    
+    const filterSensitiveLog: (obj: CreateNotebookInstanceLifecycleConfigOutput) => any;
+}
+
+export interface ParallelismConfiguration {
+    
+    MaxParallelExecutionSteps: number | undefined;
+}
+export declare namespace ParallelismConfiguration {
+    
+    const filterSensitiveLog: (obj: ParallelismConfiguration) => any;
+}
+
+export interface PipelineDefinitionS3Location {
+    
+    Bucket: string | undefined;
+    
+    ObjectKey: string | undefined;
+    
+    VersionId?: string;
+}
+export declare namespace PipelineDefinitionS3Location {
+    
+    const filterSensitiveLog: (obj: PipelineDefinitionS3Location) => any;
+}
+export interface CreatePipelineRequest {
+    
+    PipelineName: string | undefined;
+    
+    PipelineDisplayName?: string;
+    
+    PipelineDefinition?: string;
+    
+    PipelineDefinitionS3Location?: PipelineDefinitionS3Location;
+    
+    PipelineDescription?: string;
+    
+    ClientRequestToken?: string;
+    
+    RoleArn: string | undefined;
+    
+    Tags?: Tag[];
+    
+    ParallelismConfiguration?: ParallelismConfiguration;
+}
+export declare namespace CreatePipelineRequest {
+    
+    const filterSensitiveLog: (obj: CreatePipelineRequest) => any;
+}
+export interface CreatePipelineResponse {
+    
+    PipelineArn?: string;
+}
+export declare namespace CreatePipelineResponse {
+    
+    const filterSensitiveLog: (obj: CreatePipelineResponse) => any;
+}
+export interface CreatePresignedDomainUrlRequest {
+    
+    DomainId: string | undefined;
+    
+    UserProfileName: string | undefined;
+    
+    SessionExpirationDurationInSeconds?: number;
+    
+    ExpiresInSeconds?: number;
+}
+export declare namespace CreatePresignedDomainUrlRequest {
+    
+    const filterSensitiveLog: (obj: CreatePresignedDomainUrlRequest) => any;
+}
+export interface CreatePresignedDomainUrlResponse {
+    
+    AuthorizedUrl?: string;
+}
+export declare namespace CreatePresignedDomainUrlResponse {
+    
+    const filterSensitiveLog: (obj: CreatePresignedDomainUrlResponse) => any;
+}
+export interface CreatePresignedNotebookInstanceUrlInput {
+    
+    NotebookInstanceName: string | undefined;
+    
+    SessionExpirationDurationInSeconds?: number;
+}
+export declare namespace CreatePresignedNotebookInstanceUrlInput {
+    
+    const filterSensitiveLog: (obj: CreatePresignedNotebookInstanceUrlInput) => any;
+}
+export interface CreatePresignedNotebookInstanceUrlOutput {
+    
+    AuthorizedUrl?: string;
+}
+export declare namespace CreatePresignedNotebookInstanceUrlOutput {
+    
+    const filterSensitiveLog: (obj: CreatePresignedNotebookInstanceUrlOutput) => any;
+}
+
+export interface ExperimentConfig {
+    
+    ExperimentName?: string;
+    
+    TrialName?: string;
+    
+    TrialComponentDisplayName?: string;
+}
+export declare namespace ExperimentConfig {
+    
+    const filterSensitiveLog: (obj: ExperimentConfig) => any;
+}
+export declare enum DataDistributionType {
+    FULLYREPLICATED = "FullyReplicated",
+    SHARDEDBYS3KEY = "ShardedByS3Key"
+}
+export declare enum InputMode {
+    FILE = "File",
+    PIPE = "Pipe"
+}
+export declare enum RedshiftResultCompressionType {
+    BZIP2 = "BZIP2",
+    GZIP = "GZIP",
+    NONE = "None",
+    SNAPPY = "SNAPPY",
+    ZSTD = "ZSTD"
+}
+export declare enum RedshiftResultFormat {
+    CSV = "CSV",
+    PARQUET = "PARQUET"
+}
+
+export interface RedshiftDatasetDefinition {
+    
+    ClusterId: string | undefined;
+    
+    Database: string | undefined;
+    
+    DbUser: string | undefined;
+    
+    QueryString: string | undefined;
+    
+    ClusterRoleArn: string | undefined;
+    
+    OutputS3Uri: string | undefined;
+    
+    KmsKeyId?: string;
+    
+    OutputFormat: RedshiftResultFormat | string | undefined;
+    
+    OutputCompression?: RedshiftResultCompressionType | string;
+}
+export declare namespace RedshiftDatasetDefinition {
+    
+    const filterSensitiveLog: (obj: RedshiftDatasetDefinition) => any;
+}
+
+export interface DatasetDefinition {
+    
+    AthenaDatasetDefinition?: AthenaDatasetDefinition;
+    
+    RedshiftDatasetDefinition?: RedshiftDatasetDefinition;
+    
+    LocalPath?: string;
+    
+    DataDistributionType?: DataDistributionType | string;
+    
+    InputMode?: InputMode | string;
+}
+export declare namespace DatasetDefinition {
+    
+    const filterSensitiveLog: (obj: DatasetDefinition) => any;
+}
+export declare enum ProcessingS3CompressionType {
+    GZIP = "Gzip",
+    NONE = "None"
+}
+export declare enum ProcessingS3DataType {
+    MANIFEST_FILE = "ManifestFile",
+    S3_PREFIX = "S3Prefix"
+}
+
+export interface ProcessingS3Input {
+    
+    S3Uri: string | undefined;
+    
+    LocalPath?: string;
+    
+    S3DataType: ProcessingS3DataType | string | undefined;
+    
+    S3InputMode?: ProcessingS3InputMode | string;
+    
+    S3DataDistributionType?: ProcessingS3DataDistributionType | string;
+    
+    S3CompressionType?: ProcessingS3CompressionType | string;
+}
+export declare namespace ProcessingS3Input {
+    
+    const filterSensitiveLog: (obj: ProcessingS3Input) => any;
+}
+
+export interface ProcessingInput {
+    
+    InputName: string | undefined;
+    
+    AppManaged?: boolean;
+    
+    S3Input?: ProcessingS3Input;
+    
+    DatasetDefinition?: DatasetDefinition;
+}
+export declare namespace ProcessingInput {
+    
+    const filterSensitiveLog: (obj: ProcessingInput) => any;
+}
+
+export interface ProcessingFeatureStoreOutput {
+    
+    FeatureGroupName: string | undefined;
+}
+export declare namespace ProcessingFeatureStoreOutput {
+    
+    const filterSensitiveLog: (obj: ProcessingFeatureStoreOutput) => any;
+}
+
+export interface ProcessingS3Output {
+    
+    S3Uri: string | undefined;
+    
+    LocalPath: string | undefined;
+    
+    S3UploadMode: ProcessingS3UploadMode | string | undefined;
+}
+export declare namespace ProcessingS3Output {
+    
+    const filterSensitiveLog: (obj: ProcessingS3Output) => any;
+}
+
+export interface ProcessingOutput {
+    
+    OutputName: string | undefined;
+    
+    S3Output?: ProcessingS3Output;
+    
+    FeatureStoreOutput?: ProcessingFeatureStoreOutput;
+    
+    AppManaged?: boolean;
+}
+export declare namespace ProcessingOutput {
+    
+    const filterSensitiveLog: (obj: ProcessingOutput) => any;
+}
+
+export interface ProcessingOutputConfig {
+    
+    Outputs: ProcessingOutput[] | undefined;
+    
+    KmsKeyId?: string;
+}
+export declare namespace ProcessingOutputConfig {
+    
+    const filterSensitiveLog: (obj: ProcessingOutputConfig) => any;
+}
+
+export interface ProcessingClusterConfig {
+    
+    InstanceCount: number | undefined;
+    
+    InstanceType: ProcessingInstanceType | string | undefined;
+    
+    VolumeSizeInGB: number | undefined;
+    
+    VolumeKmsKeyId?: string;
+}
+export declare namespace ProcessingClusterConfig {
+    
+    const filterSensitiveLog: (obj: ProcessingClusterConfig) => any;
+}
+
+export interface ProcessingResources {
+    
+    ClusterConfig: ProcessingClusterConfig | undefined;
+}
+export declare namespace ProcessingResources {
+    
+    const filterSensitiveLog: (obj: ProcessingResources) => any;
+}
+
+export interface ProcessingStoppingCondition {
+    
+    MaxRuntimeInSeconds: number | undefined;
+}
+export declare namespace ProcessingStoppingCondition {
+    
+    const filterSensitiveLog: (obj: ProcessingStoppingCondition) => any;
+}
+export interface CreateProcessingJobRequest {
+    
+    ProcessingInputs?: ProcessingInput[];
+    
+    ProcessingOutputConfig?: ProcessingOutputConfig;
+    
+    ProcessingJobName: string | undefined;
+    
+    ProcessingResources: ProcessingResources | undefined;
+    
+    StoppingCondition?: ProcessingStoppingCondition;
+    
+    AppSpecification: AppSpecification | undefined;
+    
+    Environment?: {
+        [key: string]: string;
+    };
+    
+    NetworkConfig?: NetworkConfig;
+    
+    RoleArn: string | undefined;
+    
+    Tags?: Tag[];
+    
+    ExperimentConfig?: ExperimentConfig;
+}
+export declare namespace CreateProcessingJobRequest {
+    
+    const filterSensitiveLog: (obj: CreateProcessingJobRequest) => any;
+}
+export interface CreateProcessingJobResponse {
+    
+    ProcessingJobArn: string | undefined;
+}
+export declare namespace CreateProcessingJobResponse {
+    
+    const filterSensitiveLog: (obj: CreateProcessingJobResponse) => any;
+}
+
+export interface ProvisioningParameter {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace ProvisioningParameter {
+    
+    const filterSensitiveLog: (obj: ProvisioningParameter) => any;
+}
+
+export interface ServiceCatalogProvisioningDetails {
+    
+    ProductId: string | undefined;
+    
+    ProvisioningArtifactId?: string;
+    
+    PathId?: string;
+    
+    ProvisioningParameters?: ProvisioningParameter[];
+}
+export declare namespace ServiceCatalogProvisioningDetails {
+    
+    const filterSensitiveLog: (obj: ServiceCatalogProvisioningDetails) => any;
+}
+export interface CreateProjectInput {
+    
+    ProjectName: string | undefined;
+    
+    ProjectDescription?: string;
+    
+    ServiceCatalogProvisioningDetails: ServiceCatalogProvisioningDetails | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateProjectInput {
+    
+    const filterSensitiveLog: (obj: CreateProjectInput) => any;
+}
+export interface CreateProjectOutput {
+    
+    ProjectArn: string | undefined;
+    
+    ProjectId: string | undefined;
+}
+export declare namespace CreateProjectOutput {
+    
+    const filterSensitiveLog: (obj: CreateProjectOutput) => any;
+}
+export declare enum StudioLifecycleConfigAppType {
+    JupyterServer = "JupyterServer",
+    KernelGateway = "KernelGateway"
+}
+export interface CreateStudioLifecycleConfigRequest {
+    
+    StudioLifecycleConfigName: string | undefined;
+    
+    StudioLifecycleConfigContent: string | undefined;
+    
+    StudioLifecycleConfigAppType: StudioLifecycleConfigAppType | string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateStudioLifecycleConfigRequest {
+    
+    const filterSensitiveLog: (obj: CreateStudioLifecycleConfigRequest) => any;
+}
+export interface CreateStudioLifecycleConfigResponse {
+    
+    StudioLifecycleConfigArn?: string;
+}
+export declare namespace CreateStudioLifecycleConfigResponse {
+    
+    const filterSensitiveLog: (obj: CreateStudioLifecycleConfigResponse) => any;
+}
+
+export interface DebugHookConfig {
+    
+    LocalPath?: string;
+    
+    S3OutputPath: string | undefined;
+    
+    HookParameters?: {
+        [key: string]: string;
+    };
+    
+    CollectionConfigurations?: CollectionConfiguration[];
+}
+export declare namespace DebugHookConfig {
+    
+    const filterSensitiveLog: (obj: DebugHookConfig) => any;
+}
+
+export interface DebugRuleConfiguration {
+    
+    RuleConfigurationName: string | undefined;
+    
+    LocalPath?: string;
+    
+    S3OutputPath?: string;
+    
+    RuleEvaluatorImage: string | undefined;
+    
+    InstanceType?: ProcessingInstanceType | string;
+    
+    VolumeSizeInGB?: number;
+    
+    RuleParameters?: {
+        [key: string]: string;
+    };
+}
+export declare namespace DebugRuleConfiguration {
+    
+    const filterSensitiveLog: (obj: DebugRuleConfiguration) => any;
+}
+
+export interface ProfilerConfig {
+    
+    S3OutputPath: string | undefined;
+    
+    ProfilingIntervalInMilliseconds?: number;
+    
+    ProfilingParameters?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ProfilerConfig {
+    
+    const filterSensitiveLog: (obj: ProfilerConfig) => any;
+}
+
+export interface ProfilerRuleConfiguration {
+    
+    RuleConfigurationName: string | undefined;
+    
+    LocalPath?: string;
+    
+    S3OutputPath?: string;
+    
+    RuleEvaluatorImage: string | undefined;
+    
+    InstanceType?: ProcessingInstanceType | string;
+    
+    VolumeSizeInGB?: number;
+    
+    RuleParameters?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ProfilerRuleConfiguration {
+    
+    const filterSensitiveLog: (obj: ProfilerRuleConfiguration) => any;
+}
+
+export interface TensorBoardOutputConfig {
+    
+    LocalPath?: string;
+    
+    S3OutputPath: string | undefined;
+}
+export declare namespace TensorBoardOutputConfig {
+    
+    const filterSensitiveLog: (obj: TensorBoardOutputConfig) => any;
+}
+export interface CreateTrainingJobRequest {
+    
+    TrainingJobName: string | undefined;
+    
+    HyperParameters?: {
+        [key: string]: string;
+    };
+    
+    AlgorithmSpecification: AlgorithmSpecification | undefined;
+    
+    RoleArn: string | undefined;
+    
+    InputDataConfig?: Channel[];
+    
+    OutputDataConfig: OutputDataConfig | undefined;
+    
+    ResourceConfig: ResourceConfig | undefined;
+    
+    VpcConfig?: VpcConfig;
+    
+    StoppingCondition: StoppingCondition | undefined;
+    
+    Tags?: Tag[];
+    
+    EnableNetworkIsolation?: boolean;
+    
+    EnableInterContainerTrafficEncryption?: boolean;
+    
+    EnableManagedSpotTraining?: boolean;
+    
+    CheckpointConfig?: CheckpointConfig;
+    
+    DebugHookConfig?: DebugHookConfig;
+    
+    DebugRuleConfigurations?: DebugRuleConfiguration[];
+    
+    TensorBoardOutputConfig?: TensorBoardOutputConfig;
+    
+    ExperimentConfig?: ExperimentConfig;
+    
+    ProfilerConfig?: ProfilerConfig;
+    
+    ProfilerRuleConfigurations?: ProfilerRuleConfiguration[];
+    
+    Environment?: {
+        [key: string]: string;
+    };
+    
+    RetryStrategy?: RetryStrategy;
+}
+export declare namespace CreateTrainingJobRequest {
+    
+    const filterSensitiveLog: (obj: CreateTrainingJobRequest) => any;
+}
+export interface CreateTrainingJobResponse {
+    
+    TrainingJobArn: string | undefined;
+}
+export declare namespace CreateTrainingJobResponse {
+    
+    const filterSensitiveLog: (obj: CreateTrainingJobResponse) => any;
+}
+export declare enum JoinSource {
+    INPUT = "Input",
+    NONE = "None"
+}
+
+export interface DataProcessing {
+    
+    InputFilter?: string;
+    
+    OutputFilter?: string;
+    
+    JoinSource?: JoinSource | string;
+}
+export declare namespace DataProcessing {
+    
+    const filterSensitiveLog: (obj: DataProcessing) => any;
+}
+
+export interface ModelClientConfig {
+    
+    InvocationsTimeoutInSeconds?: number;
+    
+    InvocationsMaxRetries?: number;
+}
+export declare namespace ModelClientConfig {
+    
+    const filterSensitiveLog: (obj: ModelClientConfig) => any;
+}
+export interface CreateTransformJobRequest {
+    
+    TransformJobName: string | undefined;
+    
+    ModelName: string | undefined;
+    
+    MaxConcurrentTransforms?: number;
+    
+    ModelClientConfig?: ModelClientConfig;
+    
+    MaxPayloadInMB?: number;
+    
+    BatchStrategy?: BatchStrategy | string;
+    
+    Environment?: {
+        [key: string]: string;
+    };
+    
+    TransformInput: TransformInput | undefined;
+    
+    TransformOutput: TransformOutput | undefined;
+    
+    TransformResources: TransformResources | undefined;
+    
+    DataProcessing?: DataProcessing;
+    
+    Tags?: Tag[];
+    
+    ExperimentConfig?: ExperimentConfig;
+}
+export declare namespace CreateTransformJobRequest {
+    
+    const filterSensitiveLog: (obj: CreateTransformJobRequest) => any;
+}
+export interface CreateTransformJobResponse {
+    
+    TransformJobArn: string | undefined;
+}
+export declare namespace CreateTransformJobResponse {
+    
+    const filterSensitiveLog: (obj: CreateTransformJobResponse) => any;
+}
+export interface CreateTrialRequest {
+    
+    TrialName: string | undefined;
+    
+    DisplayName?: string;
+    
+    ExperimentName: string | undefined;
+    
+    MetadataProperties?: MetadataProperties;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateTrialRequest {
+    
+    const filterSensitiveLog: (obj: CreateTrialRequest) => any;
+}
+export interface CreateTrialResponse {
+    
+    TrialArn?: string;
+}
+export declare namespace CreateTrialResponse {
+    
+    const filterSensitiveLog: (obj: CreateTrialResponse) => any;
+}
+
+export interface TrialComponentArtifact {
+    
+    MediaType?: string;
+    
+    Value: string | undefined;
+}
+export declare namespace TrialComponentArtifact {
+    
+    const filterSensitiveLog: (obj: TrialComponentArtifact) => any;
+}
+
+export declare type TrialComponentParameterValue = TrialComponentParameterValue.NumberValueMember | TrialComponentParameterValue.StringValueMember | TrialComponentParameterValue.$UnknownMember;
+export declare namespace TrialComponentParameterValue {
+    
+    interface StringValueMember {
+        StringValue: string;
+        NumberValue?: never;
+        $unknown?: never;
+    }
+    
+    interface NumberValueMember {
+        StringValue?: never;
+        NumberValue: number;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        StringValue?: never;
+        NumberValue?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        StringValue: (value: string) => T;
+        NumberValue: (value: number) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: TrialComponentParameterValue, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: TrialComponentParameterValue) => any;
+}
+export declare enum TrialComponentPrimaryStatus {
+    COMPLETED = "Completed",
+    FAILED = "Failed",
+    IN_PROGRESS = "InProgress",
+    STOPPED = "Stopped",
+    STOPPING = "Stopping"
+}
+
+export interface TrialComponentStatus {
+    
+    PrimaryStatus?: TrialComponentPrimaryStatus | string;
+    
+    Message?: string;
+}
+export declare namespace TrialComponentStatus {
+    
+    const filterSensitiveLog: (obj: TrialComponentStatus) => any;
+}
+export interface CreateTrialComponentRequest {
+    
+    TrialComponentName: string | undefined;
+    
+    DisplayName?: string;
+    
+    Status?: TrialComponentStatus;
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    Parameters?: {
+        [key: string]: TrialComponentParameterValue;
+    };
+    
+    InputArtifacts?: {
+        [key: string]: TrialComponentArtifact;
+    };
+    
+    OutputArtifacts?: {
+        [key: string]: TrialComponentArtifact;
+    };
+    
+    MetadataProperties?: MetadataProperties;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateTrialComponentRequest {
+    
+    const filterSensitiveLog: (obj: CreateTrialComponentRequest) => any;
+}
+export interface CreateTrialComponentResponse {
+    
+    TrialComponentArn?: string;
+}
+export declare namespace CreateTrialComponentResponse {
+    
+    const filterSensitiveLog: (obj: CreateTrialComponentResponse) => any;
+}
+export interface CreateUserProfileRequest {
+    
+    DomainId: string | undefined;
+    
+    UserProfileName: string | undefined;
+    
+    SingleSignOnUserIdentifier?: string;
+    
+    SingleSignOnUserValue?: string;
+    
+    Tags?: Tag[];
+    
+    UserSettings?: UserSettings;
+}
+export declare namespace CreateUserProfileRequest {
+    
+    const filterSensitiveLog: (obj: CreateUserProfileRequest) => any;
+}
+export interface CreateUserProfileResponse {
+    
+    UserProfileArn?: string;
+}
+export declare namespace CreateUserProfileResponse {
+    
+    const filterSensitiveLog: (obj: CreateUserProfileResponse) => any;
+}
+
+export interface OidcConfig {
+    
+    ClientId: string | undefined;
+    
+    ClientSecret: string | undefined;
+    
+    Issuer: string | undefined;
+    
+    AuthorizationEndpoint: string | undefined;
+    
+    TokenEndpoint: string | undefined;
+    
+    UserInfoEndpoint: string | undefined;
+    
+    LogoutEndpoint: string | undefined;
+    
+    JwksUri: string | undefined;
+}
+export declare namespace OidcConfig {
+    
+    const filterSensitiveLog: (obj: OidcConfig) => any;
+}
+
+export interface SourceIpConfig {
+    
+    Cidrs: string[] | undefined;
+}
+export declare namespace SourceIpConfig {
+    
+    const filterSensitiveLog: (obj: SourceIpConfig) => any;
+}
+export interface CreateWorkforceRequest {
+    
+    CognitoConfig?: CognitoConfig;
+    
+    OidcConfig?: OidcConfig;
+    
+    SourceIpConfig?: SourceIpConfig;
+    
+    WorkforceName: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateWorkforceRequest {
+    
+    const filterSensitiveLog: (obj: CreateWorkforceRequest) => any;
+}
+export interface CreateWorkforceResponse {
+    
+    WorkforceArn: string | undefined;
+}
+export declare namespace CreateWorkforceResponse {
+    
+    const filterSensitiveLog: (obj: CreateWorkforceResponse) => any;
+}
+
+export interface OidcMemberDefinition {
+    
+    Groups: string[] | undefined;
+}
+export declare namespace OidcMemberDefinition {
+    
+    const filterSensitiveLog: (obj: OidcMemberDefinition) => any;
+}
+
+export interface MemberDefinition {
+    
+    CognitoMemberDefinition?: CognitoMemberDefinition;
+    
+    OidcMemberDefinition?: OidcMemberDefinition;
+}
+export declare namespace MemberDefinition {
+    
+    const filterSensitiveLog: (obj: MemberDefinition) => any;
+}
+
+export interface NotificationConfiguration {
+    
+    NotificationTopicArn?: string;
+}
+export declare namespace NotificationConfiguration {
+    
+    const filterSensitiveLog: (obj: NotificationConfiguration) => any;
+}
+export interface CreateWorkteamRequest {
+    
+    WorkteamName: string | undefined;
+    
+    WorkforceName?: string;
+    
+    MemberDefinitions: MemberDefinition[] | undefined;
+    
+    Description: string | undefined;
+    
+    NotificationConfiguration?: NotificationConfiguration;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateWorkteamRequest {
+    
+    const filterSensitiveLog: (obj: CreateWorkteamRequest) => any;
+}
+export interface CreateWorkteamResponse {
+    
+    WorkteamArn?: string;
+}
+export declare namespace CreateWorkteamResponse {
+    
+    const filterSensitiveLog: (obj: CreateWorkteamResponse) => any;
+}
+
+export interface DataCaptureConfigSummary {
+    
+    EnableCapture: boolean | undefined;
+    
+    CaptureStatus: CaptureStatus | string | undefined;
+    
+    CurrentSamplingPercentage: number | undefined;
+    
+    DestinationS3Uri: string | undefined;
+    
+    KmsKeyId: string | undefined;
+}
+export declare namespace DataCaptureConfigSummary {
+    
+    const filterSensitiveLog: (obj: DataCaptureConfigSummary) => any;
+}
+export declare enum RuleEvaluationStatus {
+    ERROR = "Error",
+    IN_PROGRESS = "InProgress",
+    ISSUES_FOUND = "IssuesFound",
+    NO_ISSUES_FOUND = "NoIssuesFound",
+    STOPPED = "Stopped",
+    STOPPING = "Stopping"
+}
+
+export interface DebugRuleEvaluationStatus {
+    
+    RuleConfigurationName?: string;
+    
+    RuleEvaluationJobArn?: string;
+    
+    RuleEvaluationStatus?: RuleEvaluationStatus | string;
+    
+    StatusDetails?: string;
+    
+    LastModifiedTime?: Date;
+}
+export declare namespace DebugRuleEvaluationStatus {
+    
+    const filterSensitiveLog: (obj: DebugRuleEvaluationStatus) => any;
+}
+export interface DeleteActionRequest {
+    
+    ActionName: string | undefined;
+}
+export declare namespace DeleteActionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteActionRequest) => any;
+}
+export interface DeleteActionResponse {
+    
+    ActionArn?: string;
+}
+export declare namespace DeleteActionResponse {
+    
+    const filterSensitiveLog: (obj: DeleteActionResponse) => any;
+}
+export interface DeleteAlgorithmInput {
+    
+    AlgorithmName: string | undefined;
+}
+export declare namespace DeleteAlgorithmInput {
+    
+    const filterSensitiveLog: (obj: DeleteAlgorithmInput) => any;
+}
+export interface DeleteAppRequest {
+    
+    DomainId: string | undefined;
+    
+    UserProfileName: string | undefined;
+    
+    AppType: AppType | string | undefined;
+    
+    AppName: string | undefined;
+}
+export declare namespace DeleteAppRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAppRequest) => any;
+}
+export interface DeleteAppImageConfigRequest {
+    
+    AppImageConfigName: string | undefined;
+}
+export declare namespace DeleteAppImageConfigRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAppImageConfigRequest) => any;
+}
+export interface DeleteArtifactRequest {
+    
+    ArtifactArn?: string;
+    
+    Source?: ArtifactSource;
+}
+export declare namespace DeleteArtifactRequest {
+    
+    const filterSensitiveLog: (obj: DeleteArtifactRequest) => any;
+}
+export interface DeleteArtifactResponse {
+    
+    ArtifactArn?: string;
+}
+export declare namespace DeleteArtifactResponse {
+    
+    const filterSensitiveLog: (obj: DeleteArtifactResponse) => any;
+}
+export interface DeleteAssociationRequest {
+    
+    SourceArn: string | undefined;
+    
+    DestinationArn: string | undefined;
+}
+export declare namespace DeleteAssociationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAssociationRequest) => any;
+}
+export interface DeleteAssociationResponse {
+    
+    SourceArn?: string;
+    
+    DestinationArn?: string;
+}
+export declare namespace DeleteAssociationResponse {
+    
+    const filterSensitiveLog: (obj: DeleteAssociationResponse) => any;
+}
+export interface DeleteCodeRepositoryInput {
+    
+    CodeRepositoryName: string | undefined;
+}
+export declare namespace DeleteCodeRepositoryInput {
+    
+    const filterSensitiveLog: (obj: DeleteCodeRepositoryInput) => any;
+}
+export interface DeleteContextRequest {
+    
+    ContextName: string | undefined;
+}
+export declare namespace DeleteContextRequest {
+    
+    const filterSensitiveLog: (obj: DeleteContextRequest) => any;
+}
+export interface DeleteContextResponse {
+    
+    ContextArn?: string;
+}
+export declare namespace DeleteContextResponse {
+    
+    const filterSensitiveLog: (obj: DeleteContextResponse) => any;
+}
+export interface DeleteDataQualityJobDefinitionRequest {
+    
+    JobDefinitionName: string | undefined;
+}
+export declare namespace DeleteDataQualityJobDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDataQualityJobDefinitionRequest) => any;
+}
+export interface DeleteDeviceFleetRequest {
+    
+    DeviceFleetName: string | undefined;
+}
+export declare namespace DeleteDeviceFleetRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDeviceFleetRequest) => any;
+}
+export declare enum RetentionType {
+    Delete = "Delete",
+    Retain = "Retain"
+}
+
+export interface RetentionPolicy {
+    
+    HomeEfsFileSystem?: RetentionType | string;
+}
+export declare namespace RetentionPolicy {
+    
+    const filterSensitiveLog: (obj: RetentionPolicy) => any;
+}
+export interface DeleteDomainRequest {
+    
+    DomainId: string | undefined;
+    
+    RetentionPolicy?: RetentionPolicy;
+}
+export declare namespace DeleteDomainRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDomainRequest) => any;
+}
+export interface DeleteEndpointInput {
+    
+    EndpointName: string | undefined;
+}
+export declare namespace DeleteEndpointInput {
+    
+    const filterSensitiveLog: (obj: DeleteEndpointInput) => any;
+}
+export interface DeleteEndpointConfigInput {
+    
+    EndpointConfigName: string | undefined;
+}
+export declare namespace DeleteEndpointConfigInput {
+    
+    const filterSensitiveLog: (obj: DeleteEndpointConfigInput) => any;
+}
+export interface DeleteExperimentRequest {
+    
+    ExperimentName: string | undefined;
+}
+export declare namespace DeleteExperimentRequest {
+    
+    const filterSensitiveLog: (obj: DeleteExperimentRequest) => any;
+}
+export interface DeleteExperimentResponse {
+    
+    ExperimentArn?: string;
+}
+export declare namespace DeleteExperimentResponse {
+    
+    const filterSensitiveLog: (obj: DeleteExperimentResponse) => any;
+}
+export interface DeleteFeatureGroupRequest {
+    
+    FeatureGroupName: string | undefined;
+}
+export declare namespace DeleteFeatureGroupRequest {
+    
+    const filterSensitiveLog: (obj: DeleteFeatureGroupRequest) => any;
+}
+export interface DeleteFlowDefinitionRequest {
+    
+    FlowDefinitionName: string | undefined;
+}
+export declare namespace DeleteFlowDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteFlowDefinitionRequest) => any;
+}
+export interface DeleteFlowDefinitionResponse {
+}
+export declare namespace DeleteFlowDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: DeleteFlowDefinitionResponse) => any;
+}
+export interface DeleteHumanTaskUiRequest {
+    
+    HumanTaskUiName: string | undefined;
+}
+export declare namespace DeleteHumanTaskUiRequest {
+    
+    const filterSensitiveLog: (obj: DeleteHumanTaskUiRequest) => any;
+}
+export interface DeleteHumanTaskUiResponse {
+}
+export declare namespace DeleteHumanTaskUiResponse {
+    
+    const filterSensitiveLog: (obj: DeleteHumanTaskUiResponse) => any;
+}
+export interface DeleteImageRequest {
+    
+    ImageName: string | undefined;
+}
+export declare namespace DeleteImageRequest {
+    
+    const filterSensitiveLog: (obj: DeleteImageRequest) => any;
+}
+export interface DeleteImageResponse {
+}
+export declare namespace DeleteImageResponse {
+    
+    const filterSensitiveLog: (obj: DeleteImageResponse) => any;
+}
+export interface DeleteImageVersionRequest {
+    
+    ImageName: string | undefined;
+    
+    Version: number | undefined;
+}
+export declare namespace DeleteImageVersionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteImageVersionRequest) => any;
+}
+export interface DeleteImageVersionResponse {
+}
+export declare namespace DeleteImageVersionResponse {
+    
+    const filterSensitiveLog: (obj: DeleteImageVersionResponse) => any;
+}
+export interface DeleteModelInput {
+    
+    ModelName: string | undefined;
+}
+export declare namespace DeleteModelInput {
+    
+    const filterSensitiveLog: (obj: DeleteModelInput) => any;
+}
+export interface DeleteModelBiasJobDefinitionRequest {
+    
+    JobDefinitionName: string | undefined;
+}
+export declare namespace DeleteModelBiasJobDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteModelBiasJobDefinitionRequest) => any;
+}
+export interface DeleteModelExplainabilityJobDefinitionRequest {
+    
+    JobDefinitionName: string | undefined;
+}
+export declare namespace DeleteModelExplainabilityJobDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteModelExplainabilityJobDefinitionRequest) => any;
+}
+export interface DeleteModelPackageInput {
+    
+    ModelPackageName: string | undefined;
+}
+export declare namespace DeleteModelPackageInput {
+    
+    const filterSensitiveLog: (obj: DeleteModelPackageInput) => any;
+}
+export interface DeleteModelPackageGroupInput {
+    
+    ModelPackageGroupName: string | undefined;
+}
+export declare namespace DeleteModelPackageGroupInput {
+    
+    const filterSensitiveLog: (obj: DeleteModelPackageGroupInput) => any;
+}
+export interface DeleteModelPackageGroupPolicyInput {
+    
+    ModelPackageGroupName: string | undefined;
+}
+export declare namespace DeleteModelPackageGroupPolicyInput {
+    
+    const filterSensitiveLog: (obj: DeleteModelPackageGroupPolicyInput) => any;
+}
+export interface DeleteModelQualityJobDefinitionRequest {
+    
+    JobDefinitionName: string | undefined;
+}
+export declare namespace DeleteModelQualityJobDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteModelQualityJobDefinitionRequest) => any;
+}
+export interface DeleteMonitoringScheduleRequest {
+    
+    MonitoringScheduleName: string | undefined;
+}
+export declare namespace DeleteMonitoringScheduleRequest {
+    
+    const filterSensitiveLog: (obj: DeleteMonitoringScheduleRequest) => any;
+}
+export interface DeleteNotebookInstanceInput {
+    
+    NotebookInstanceName: string | undefined;
+}
+export declare namespace DeleteNotebookInstanceInput {
+    
+    const filterSensitiveLog: (obj: DeleteNotebookInstanceInput) => any;
+}
+export interface DeleteNotebookInstanceLifecycleConfigInput {
+    
+    NotebookInstanceLifecycleConfigName: string | undefined;
+}
+export declare namespace DeleteNotebookInstanceLifecycleConfigInput {
+    
+    const filterSensitiveLog: (obj: DeleteNotebookInstanceLifecycleConfigInput) => any;
+}
+export interface DeletePipelineRequest {
+    
+    PipelineName: string | undefined;
+    
+    ClientRequestToken?: string;
+}
+export declare namespace DeletePipelineRequest {
+    
+    const filterSensitiveLog: (obj: DeletePipelineRequest) => any;
+}
+export interface DeletePipelineResponse {
+    
+    PipelineArn?: string;
+}
+export declare namespace DeletePipelineResponse {
+    
+    const filterSensitiveLog: (obj: DeletePipelineResponse) => any;
+}
+export interface DeleteProjectInput {
+    
+    ProjectName: string | undefined;
+}
+export declare namespace DeleteProjectInput {
+    
+    const filterSensitiveLog: (obj: DeleteProjectInput) => any;
+}
+export interface DeleteStudioLifecycleConfigRequest {
+    
+    StudioLifecycleConfigName: string | undefined;
+}
+export declare namespace DeleteStudioLifecycleConfigRequest {
+    
+    const filterSensitiveLog: (obj: DeleteStudioLifecycleConfigRequest) => any;
+}
+export interface DeleteTagsInput {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace DeleteTagsInput {
+    
+    const filterSensitiveLog: (obj: DeleteTagsInput) => any;
+}
+export interface DeleteTagsOutput {
+}
+export declare namespace DeleteTagsOutput {
+    
+    const filterSensitiveLog: (obj: DeleteTagsOutput) => any;
+}
+export interface DeleteTrialRequest {
+    
+    TrialName: string | undefined;
+}
+export declare namespace DeleteTrialRequest {
+    
+    const filterSensitiveLog: (obj: DeleteTrialRequest) => any;
+}
+export interface DeleteTrialResponse {
+    
+    TrialArn?: string;
+}
+export declare namespace DeleteTrialResponse {
+    
+    const filterSensitiveLog: (obj: DeleteTrialResponse) => any;
+}
+export interface DeleteTrialComponentRequest {
+    
+    TrialComponentName: string | undefined;
+}
+export declare namespace DeleteTrialComponentRequest {
+    
+    const filterSensitiveLog: (obj: DeleteTrialComponentRequest) => any;
+}
+export interface DeleteTrialComponentResponse {
+    
+    TrialComponentArn?: string;
+}
+export declare namespace DeleteTrialComponentResponse {
+    
+    const filterSensitiveLog: (obj: DeleteTrialComponentResponse) => any;
+}
+export interface DeleteUserProfileRequest {
+    
+    DomainId: string | undefined;
+    
+    UserProfileName: string | undefined;
+}
+export declare namespace DeleteUserProfileRequest {
+    
+    const filterSensitiveLog: (obj: DeleteUserProfileRequest) => any;
+}
+export interface DeleteWorkforceRequest {
+    
+    WorkforceName: string | undefined;
+}
+export declare namespace DeleteWorkforceRequest {
+    
+    const filterSensitiveLog: (obj: DeleteWorkforceRequest) => any;
+}
+export interface DeleteWorkforceResponse {
+}
+export declare namespace DeleteWorkforceResponse {
+    
+    const filterSensitiveLog: (obj: DeleteWorkforceResponse) => any;
+}
+export interface DeleteWorkteamRequest {
+    
+    WorkteamName: string | undefined;
+}
+export declare namespace DeleteWorkteamRequest {
+    
+    const filterSensitiveLog: (obj: DeleteWorkteamRequest) => any;
+}
+export interface DeleteWorkteamResponse {
+    
+    Success: boolean | undefined;
+}
+export declare namespace DeleteWorkteamResponse {
+    
+    const filterSensitiveLog: (obj: DeleteWorkteamResponse) => any;
+}
+
+export interface DeployedImage {
+    
+    SpecifiedImage?: string;
+    
+    ResolvedImage?: string;
+    
+    ResolutionTime?: Date;
+}
+export declare namespace DeployedImage {
+    
+    const filterSensitiveLog: (obj: DeployedImage) => any;
+}
+export interface DeregisterDevicesRequest {
+    
+    DeviceFleetName: string | undefined;
+    
+    DeviceNames: string[] | undefined;
+}
+export declare namespace DeregisterDevicesRequest {
+    
+    const filterSensitiveLog: (obj: DeregisterDevicesRequest) => any;
+}
+export interface DescribeActionRequest {
+    
+    ActionName: string | undefined;
+}
+export declare namespace DescribeActionRequest {
+    
+    const filterSensitiveLog: (obj: DescribeActionRequest) => any;
+}
+export interface DescribeActionResponse {
+    
+    ActionName?: string;
+    
+    ActionArn?: string;
+    
+    Source?: ActionSource;
+    
+    ActionType?: string;
+    
+    Description?: string;
+    
+    Status?: ActionStatus | string;
+    
+    Properties?: {
+        [key: string]: string;
+    };
+    
+    CreationTime?: Date;
+    
+    CreatedBy?: UserContext;
+    
+    LastModifiedTime?: Date;
+    
+    LastModifiedBy?: UserContext;
+    
+    MetadataProperties?: MetadataProperties;
+    
+    LineageGroupArn?: string;
+}
+export declare namespace DescribeActionResponse {
+    
+    const filterSensitiveLog: (obj: DescribeActionResponse) => any;
+}
+export interface DescribeAlgorithmInput {
+    
+    AlgorithmName: string | undefined;
+}
+export declare namespace DescribeAlgorithmInput {
+    
+    const filterSensitiveLog: (obj: DescribeAlgorithmInput) => any;
+}
+export interface DescribeAlgorithmOutput {
+    
+    AlgorithmName: string | undefined;
+    
+    AlgorithmArn: string | undefined;
+    
+    AlgorithmDescription?: string;
+    
+    CreationTime: Date | undefined;
+    
+    TrainingSpecification: TrainingSpecification | undefined;
+    
+    InferenceSpecification?: InferenceSpecification;
+    
+    ValidationSpecification?: AlgorithmValidationSpecification;
+    
+    AlgorithmStatus: AlgorithmStatus | string | undefined;
+    
+    AlgorithmStatusDetails: AlgorithmStatusDetails | undefined;
+    
+    ProductId?: string;
+    
+    CertifyForMarketplace?: boolean;
+}
+export declare namespace DescribeAlgorithmOutput {
+    
+    const filterSensitiveLog: (obj: DescribeAlgorithmOutput) => any;
+}
+export interface DescribeAppRequest {
+    
+    DomainId: string | undefined;
+    
+    UserProfileName: string | undefined;
+    
+    AppType: AppType | string | undefined;
+    
+    AppName: string | undefined;
+}
+export declare namespace DescribeAppRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAppRequest) => any;
+}
+export interface DescribeAppResponse {
+    
+    AppArn?: string;
+    
+    AppType?: AppType | string;
+    
+    AppName?: string;
+    
+    DomainId?: string;
+    
+    UserProfileName?: string;
+    
+    Status?: AppStatus | string;
+    
+    LastHealthCheckTimestamp?: Date;
+    
+    LastUserActivityTimestamp?: Date;
+    
+    CreationTime?: Date;
+    
+    FailureReason?: string;
+    
+    ResourceSpec?: ResourceSpec;
+}
+export declare namespace DescribeAppResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAppResponse) => any;
+}
+export interface DescribeAppImageConfigRequest {
+    
+    AppImageConfigName: string | undefined;
+}
+export declare namespace DescribeAppImageConfigRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAppImageConfigRequest) => any;
+}
+export interface DescribeAppImageConfigResponse {
+    
+    AppImageConfigArn?: string;
+    
+    AppImageConfigName?: string;
+    
+    CreationTime?: Date;
+    
+    LastModifiedTime?: Date;
+    
+    KernelGatewayImageConfig?: KernelGatewayImageConfig;
+}
+export declare namespace DescribeAppImageConfigResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAppImageConfigResponse) => any;
+}
+export interface DescribeArtifactRequest {
+    
+    ArtifactArn: string | undefined;
+}
+export declare namespace DescribeArtifactRequest {
+    
+    const filterSensitiveLog: (obj: DescribeArtifactRequest) => any;
+}
+export interface DescribeArtifactResponse {
+    
+    ArtifactName?: string;
+    
+    ArtifactArn?: string;
+    
+    Source?: ArtifactSource;
+    
+    ArtifactType?: string;
+    
+    Properties?: {
+        [key: string]: string;
+    };
+    
+    CreationTime?: Date;
+    
+    CreatedBy?: UserContext;
+    
+    LastModifiedTime?: Date;
+    
+    LastModifiedBy?: UserContext;
+    
+    MetadataProperties?: MetadataProperties;
+    
+    LineageGroupArn?: string;
+}
+export declare namespace DescribeArtifactResponse {
+    
+    const filterSensitiveLog: (obj: DescribeArtifactResponse) => any;
+}
+export interface DescribeAutoMLJobRequest {
+    
+    AutoMLJobName: string | undefined;
+}
+export declare namespace DescribeAutoMLJobRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAutoMLJobRequest) => any;
+}
+
+export interface ModelDeployResult {
+    
+    EndpointName?: string;
+}
+export declare namespace ModelDeployResult {
+    
+    const filterSensitiveLog: (obj: ModelDeployResult) => any;
+}
+
+export interface ResolvedAttributes {
+    
+    AutoMLJobObjective?: AutoMLJobObjective;
+    
+    ProblemType?: ProblemType | string;
+    
+    CompletionCriteria?: AutoMLJobCompletionCriteria;
+}
+export declare namespace ResolvedAttributes {
+    
+    const filterSensitiveLog: (obj: ResolvedAttributes) => any;
+}
+export interface DescribeAutoMLJobResponse {
+    
+    AutoMLJobName: string | undefined;
+    
+    AutoMLJobArn: string | undefined;
+    
+    InputDataConfig: AutoMLChannel[] | undefined;
+    
+    OutputDataConfig: AutoMLOutputDataConfig | undefined;
+    
+    RoleArn: string | undefined;
+    
+    AutoMLJobObjective?: AutoMLJobObjective;
+    
+    ProblemType?: ProblemType | string;
+    
+    AutoMLJobConfig?: AutoMLJobConfig;
+    
+    CreationTime: Date | undefined;
+    
+    EndTime?: Date;
+    
+    LastModifiedTime: Date | undefined;
+    
+    FailureReason?: string;
+    
+    PartialFailureReasons?: AutoMLPartialFailureReason[];
+    
+    BestCandidate?: AutoMLCandidate;
+    
+    AutoMLJobStatus: AutoMLJobStatus | string | undefined;
+    
+    AutoMLJobSecondaryStatus: AutoMLJobSecondaryStatus | string | undefined;
+    
+    GenerateCandidateDefinitionsOnly?: boolean;
+    
+    AutoMLJobArtifacts?: AutoMLJobArtifacts;
+    
+    ResolvedAttributes?: ResolvedAttributes;
+    
+    ModelDeployConfig?: ModelDeployConfig;
+    
+    ModelDeployResult?: ModelDeployResult;
+}
+export declare namespace DescribeAutoMLJobResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAutoMLJobResponse) => any;
+}
+export interface DescribeCodeRepositoryInput {
+    
+    CodeRepositoryName: string | undefined;
+}
+export declare namespace DescribeCodeRepositoryInput {
+    
+    const filterSensitiveLog: (obj: DescribeCodeRepositoryInput) => any;
+}
+export interface DescribeCodeRepositoryOutput {
+    
+    CodeRepositoryName: string | undefined;
+    
+    CodeRepositoryArn: string | undefined;
+    
+    CreationTime: Date | undefined;
+    
+    LastModifiedTime: Date | undefined;
+    
+    GitConfig?: GitConfig;
+}
+export declare namespace DescribeCodeRepositoryOutput {
+    
+    const filterSensitiveLog: (obj: DescribeCodeRepositoryOutput) => any;
+}
+export interface DescribeCompilationJobRequest {
+    
+    CompilationJobName: string | undefined;
+}
+export declare namespace DescribeCompilationJobRequest {
+    
+    const filterSensitiveLog: (obj: DescribeCompilationJobRequest) => any;
+}
+
+export interface ModelArtifacts {
+    
+    S3ModelArtifacts: string | undefined;
+}
+export declare namespace ModelArtifacts {
+    
+    const filterSensitiveLog: (obj: ModelArtifacts) => any;
+}
+
+export interface ModelDigests {
+    
+    ArtifactDigest?: string;
+}
+export declare namespace ModelDigests {
+    
+    const filterSensitiveLog: (obj: ModelDigests) => any;
+}
+export interface DescribeCompilationJobResponse {
+    
+    CompilationJobName: string | undefined;
+    
+    CompilationJobArn: string | undefined;
+    
+    CompilationJobStatus: CompilationJobStatus | string | undefined;
+    
+    CompilationStartTime?: Date;
+    
+    CompilationEndTime?: Date;
+    
+    StoppingCondition: StoppingCondition | undefined;
+    
+    InferenceImage?: string;
+    
+    ModelPackageVersionArn?: string;
+    
+    CreationTime: Date | undefined;
+    
+    LastModifiedTime: Date | undefined;
+    
+    FailureReason: string | undefined;
+    
+    ModelArtifacts: ModelArtifacts | undefined;
+    
+    ModelDigests?: ModelDigests;
+    
+    RoleArn: string | undefined;
+    
+    InputConfig: InputConfig | undefined;
+    
+    OutputConfig: OutputConfig | undefined;
+    
+    VpcConfig?: NeoVpcConfig;
+}
+export declare namespace DescribeCompilationJobResponse {
+    
+    const filterSensitiveLog: (obj: DescribeCompilationJobResponse) => any;
+}
+export interface DescribeContextRequest {
+    
+    ContextName: string | undefined;
+}
+export declare namespace DescribeContextRequest {
+    
+    const filterSensitiveLog: (obj: DescribeContextRequest) => any;
+}
+export interface DescribeContextResponse {
+    
+    ContextName?: string;
+    
+    ContextArn?: string;
+    
+    Source?: ContextSource;
+    
+    ContextType?: string;
+    
+    Description?: string;
+    
+    Properties?: {
+        [key: string]: string;
+    };
+    
+    CreationTime?: Date;
+    
+    CreatedBy?: UserContext;
+    
+    LastModifiedTime?: Date;
+    
+    LastModifiedBy?: UserContext;
+    
+    LineageGroupArn?: string;
+}
+export declare namespace DescribeContextResponse {
+    
+    const filterSensitiveLog: (obj: DescribeContextResponse) => any;
+}
+export interface DescribeDataQualityJobDefinitionRequest {
+    
+    JobDefinitionName: string | undefined;
+}
+export declare namespace DescribeDataQualityJobDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDataQualityJobDefinitionRequest) => any;
+}
+export interface DescribeDataQualityJobDefinitionResponse {
+    
+    JobDefinitionArn: string | undefined;
+    
+    JobDefinitionName: string | undefined;
+    
+    CreationTime: Date | undefined;
+    
+    DataQualityBaselineConfig?: DataQualityBaselineConfig;
+    
+    DataQualityAppSpecification: DataQualityAppSpecification | undefined;
+    
+    DataQualityJobInput: DataQualityJobInput | undefined;
+    
+    DataQualityJobOutputConfig: MonitoringOutputConfig | undefined;
+    
+    JobResources: MonitoringResources | undefined;
+    
+    NetworkConfig?: MonitoringNetworkConfig;
+    
+    RoleArn: string | undefined;
+    
+    StoppingCondition?: MonitoringStoppingCondition;
+}
+export declare namespace DescribeDataQualityJobDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDataQualityJobDefinitionResponse) => any;
+}
+export interface DescribeDeviceRequest {
+    
+    NextToken?: string;
+    
+    DeviceName: string | undefined;
+    
+    DeviceFleetName: string | undefined;
+}
+export declare namespace DescribeDeviceRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDeviceRequest) => any;
+}
+
+export interface EdgeModel {
+    
+    ModelName: string | undefined;
+    
+    ModelVersion: string | undefined;
+    
+    LatestSampleTime?: Date;
+    
+    LatestInference?: Date;
+}
+export declare namespace EdgeModel {
+    
+    const filterSensitiveLog: (obj: EdgeModel) => any;
+}
+export interface DescribeDeviceResponse {
+    
+    DeviceArn?: string;
+    
+    DeviceName: string | undefined;
+    
+    Description?: string;
+    
+    DeviceFleetName: string | undefined;
+    
+    IotThingName?: string;
+    
+    RegistrationTime: Date | undefined;
+    
+    LatestHeartbeat?: Date;
+    
+    Models?: EdgeModel[];
+    
+    MaxModels?: number;
+    
+    NextToken?: string;
+    
+    AgentVersion?: string;
+}
+export declare namespace DescribeDeviceResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDeviceResponse) => any;
+}
+export interface DescribeDeviceFleetRequest {
+    
+    DeviceFleetName: string | undefined;
+}
+export declare namespace DescribeDeviceFleetRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDeviceFleetRequest) => any;
+}
+export interface DescribeDeviceFleetResponse {
+    
+    DeviceFleetName: string | undefined;
+    
+    DeviceFleetArn: string | undefined;
+    
+    OutputConfig: EdgeOutputConfig | undefined;
+    
+    Description?: string;
+    
+    CreationTime: Date | undefined;
+    
+    LastModifiedTime: Date | undefined;
+    
+    RoleArn?: string;
+    
+    IotRoleAlias?: string;
+}
+export declare namespace DescribeDeviceFleetResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDeviceFleetResponse) => any;
+}
+export interface DescribeDomainRequest {
+    
+    DomainId: string | undefined;
+}
+export declare namespace DescribeDomainRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDomainRequest) => any;
+}
+export declare enum DomainStatus {
+    Delete_Failed = "Delete_Failed",
+    Deleting = "Deleting",
+    Failed = "Failed",
+    InService = "InService",
+    Pending = "Pending",
+    Update_Failed = "Update_Failed",
+    Updating = "Updating"
+}
+export interface DescribeDomainResponse {
+    
+    DomainArn?: string;
+    
+    DomainId?: string;
+    
+    DomainName?: string;
+    
+    HomeEfsFileSystemId?: string;
+    
+    SingleSignOnManagedApplicationInstanceId?: string;
+    
+    Status?: DomainStatus | string;
+    
+    CreationTime?: Date;
+    
+    LastModifiedTime?: Date;
+    
+    FailureReason?: string;
+    
+    AuthMode?: AuthMode | string;
+    
+    DefaultUserSettings?: UserSettings;
+    
+    AppNetworkAccessType?: AppNetworkAccessType | string;
+    
+    HomeEfsFileSystemKmsKeyId?: string;
+    
+    SubnetIds?: string[];
+    
+    Url?: string;
+    
+    VpcId?: string;
+    
+    KmsKeyId?: string;
+    
+    DomainSettings?: DomainSettings;
+    
+    AppSecurityGroupManagement?: AppSecurityGroupManagement | string;
+    
+    SecurityGroupIdForDomainBoundary?: string;
+}
+export declare namespace DescribeDomainResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDomainResponse) => any;
+}
+export interface DescribeEdgePackagingJobRequest {
+    
+    EdgePackagingJobName: string | undefined;
+}
+export declare namespace DescribeEdgePackagingJobRequest {
+    
+    const filterSensitiveLog: (obj: DescribeEdgePackagingJobRequest) => any;
+}
+export declare enum EdgePackagingJobStatus {
+    Completed = "COMPLETED",
+    Failed = "FAILED",
+    InProgress = "INPROGRESS",
+    Starting = "STARTING",
+    Stopped = "STOPPED",
+    Stopping = "STOPPING"
+}
+export declare enum EdgePresetDeploymentStatus {
+    Completed = "COMPLETED",
+    Failed = "FAILED"
+}
+
+export interface EdgePresetDeploymentOutput {
+    
+    Type: EdgePresetDeploymentType | string | undefined;
+    
+    Artifact?: string;
+    
+    Status?: EdgePresetDeploymentStatus | string;
+    
+    StatusMessage?: string;
+}
+export declare namespace EdgePresetDeploymentOutput {
+    
+    const filterSensitiveLog: (obj: EdgePresetDeploymentOutput) => any;
+}
+export interface DescribeEdgePackagingJobResponse {
+    
+    EdgePackagingJobArn: string | undefined;
+    
+    EdgePackagingJobName: string | undefined;
+    
+    CompilationJobName?: string;
+    
+    ModelName?: string;
+    
+    ModelVersion?: string;
+    
+    RoleArn?: string;
+    
+    OutputConfig?: EdgeOutputConfig;
+    
+    ResourceKey?: string;
+    
+    EdgePackagingJobStatus: EdgePackagingJobStatus | string | undefined;
+    
+    EdgePackagingJobStatusMessage?: string;
+    
+    CreationTime?: Date;
+    
+    LastModifiedTime?: Date;
+    
+    ModelArtifact?: string;
+    
+    ModelSignature?: string;
+    
+    PresetDeploymentOutput?: EdgePresetDeploymentOutput;
+}
+export declare namespace DescribeEdgePackagingJobResponse {
+    
+    const filterSensitiveLog: (obj: DescribeEdgePackagingJobResponse) => any;
+}
+export interface DescribeEndpointInput {
+    
+    EndpointName: string | undefined;
+}
+export declare namespace DescribeEndpointInput {
+    
+    const filterSensitiveLog: (obj: DescribeEndpointInput) => any;
+}
+export declare enum EndpointStatus {
+    CREATING = "Creating",
+    DELETING = "Deleting",
+    FAILED = "Failed",
+    IN_SERVICE = "InService",
+    OUT_OF_SERVICE = "OutOfService",
+    ROLLING_BACK = "RollingBack",
+    SYSTEM_UPDATING = "SystemUpdating",
+    UPDATING = "Updating"
+}
+export declare enum VariantStatus {
+    ACTIVATING_TRAFFIC = "ActivatingTraffic",
+    BAKING = "Baking",
+    CREATING = "Creating",
+    DELETING = "Deleting",
+    UPDATING = "Updating"
+}
+
+export interface ProductionVariantStatus {
+    
+    Status: VariantStatus | string | undefined;
+    
+    StatusMessage?: string;
+    
+    StartTime?: Date;
+}
+export declare namespace ProductionVariantStatus {
+    
+    const filterSensitiveLog: (obj: ProductionVariantStatus) => any;
+}
+
+export interface PendingProductionVariantSummary {
+    
+    VariantName: string | undefined;
+    
+    DeployedImages?: DeployedImage[];
+    
+    CurrentWeight?: number;
+    
+    DesiredWeight?: number;
+    
+    CurrentInstanceCount?: number;
+    
+    DesiredInstanceCount?: number;
+    
+    InstanceType?: ProductionVariantInstanceType | string;
+    
+    AcceleratorType?: ProductionVariantAcceleratorType | string;
+    
+    VariantStatus?: ProductionVariantStatus[];
+    
+    CurrentServerlessConfig?: ProductionVariantServerlessConfig;
+    
+    DesiredServerlessConfig?: ProductionVariantServerlessConfig;
+}
+export declare namespace PendingProductionVariantSummary {
+    
+    const filterSensitiveLog: (obj: PendingProductionVariantSummary) => any;
+}
+
+export interface PendingDeploymentSummary {
+    
+    EndpointConfigName: string | undefined;
+    
+    ProductionVariants?: PendingProductionVariantSummary[];
+    
+    StartTime?: Date;
+}
+export declare namespace PendingDeploymentSummary {
+    
+    const filterSensitiveLog: (obj: PendingDeploymentSummary) => any;
+}
+
+export interface ProductionVariantSummary {
+    
+    VariantName: string | undefined;
+    
+    DeployedImages?: DeployedImage[];
+    
+    CurrentWeight?: number;
+    
+    DesiredWeight?: number;
+    
+    CurrentInstanceCount?: number;
+    
+    DesiredInstanceCount?: number;
+    
+    VariantStatus?: ProductionVariantStatus[];
+    
+    CurrentServerlessConfig?: ProductionVariantServerlessConfig;
+    
+    DesiredServerlessConfig?: ProductionVariantServerlessConfig;
+}
+export declare namespace ProductionVariantSummary {
+    
+    const filterSensitiveLog: (obj: ProductionVariantSummary) => any;
+}
+export interface DescribeEndpointOutput {
+    
+    EndpointName: string | undefined;
+    
+    EndpointArn: string | undefined;
+    
+    EndpointConfigName: string | undefined;
+    
+    ProductionVariants?: ProductionVariantSummary[];
+    
+    DataCaptureConfig?: DataCaptureConfigSummary;
+    
+    EndpointStatus: EndpointStatus | string | undefined;
+    
+    FailureReason?: string;
+    
+    CreationTime: Date | undefined;
+    
+    LastModifiedTime: Date | undefined;
+    
+    LastDeploymentConfig?: DeploymentConfig;
+    
+    AsyncInferenceConfig?: AsyncInferenceConfig;
+    
+    PendingDeploymentSummary?: PendingDeploymentSummary;
+}
+export declare namespace DescribeEndpointOutput {
+    
+    const filterSensitiveLog: (obj: DescribeEndpointOutput) => any;
+}
+export interface DescribeEndpointConfigInput {
+    
+    EndpointConfigName: string | undefined;
+}
+export declare namespace DescribeEndpointConfigInput {
+    
+    const filterSensitiveLog: (obj: DescribeEndpointConfigInput) => any;
+}
+export interface DescribeEndpointConfigOutput {
+    
+    EndpointConfigName: string | undefined;
+    
+    EndpointConfigArn: string | undefined;
+    
+    ProductionVariants: ProductionVariant[] | undefined;
+    
+    DataCaptureConfig?: DataCaptureConfig;
+    
+    KmsKeyId?: string;
+    
+    CreationTime: Date | undefined;
+    
+    AsyncInferenceConfig?: AsyncInferenceConfig;
+}
+export declare namespace DescribeEndpointConfigOutput {
+    
+    const filterSensitiveLog: (obj: DescribeEndpointConfigOutput) => any;
+}
+export interface DescribeExperimentRequest {
+    
+    ExperimentName: string | undefined;
+}
+export declare namespace DescribeExperimentRequest {
+    
+    const filterSensitiveLog: (obj: DescribeExperimentRequest) => any;
+}
+
+export interface ExperimentSource {
+    
+    SourceArn: string | undefined;
+    
+    SourceType?: string;
+}
+export declare namespace ExperimentSource {
+    
+    const filterSensitiveLog: (obj: ExperimentSource) => any;
+}
+export interface DescribeExperimentResponse {
+    
+    ExperimentName?: string;
+    
+    ExperimentArn?: string;
+    
+    DisplayName?: string;
+    
+    Source?: ExperimentSource;
+    
+    Description?: string;
+    
+    CreationTime?: Date;
+    
+    CreatedBy?: UserContext;
+    
+    LastModifiedTime?: Date;
+    
+    LastModifiedBy?: UserContext;
+}
+export declare namespace DescribeExperimentResponse {
+    
+    const filterSensitiveLog: (obj: DescribeExperimentResponse) => any;
+}
+export interface DescribeFeatureGroupRequest {
+    
+    FeatureGroupName: string | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeFeatureGroupRequest {
+    
+    const filterSensitiveLog: (obj: DescribeFeatureGroupRequest) => any;
+}
+export declare enum FeatureGroupStatus {
+    CREATED = "Created",
+    CREATE_FAILED = "CreateFailed",
+    CREATING = "Creating",
+    DELETE_FAILED = "DeleteFailed",
+    DELETING = "Deleting"
+}
+export declare enum OfflineStoreStatusValue {
+    ACTIVE = "Active",
+    BLOCKED = "Blocked",
+    DISABLED = "Disabled"
+}
+
+export interface OfflineStoreStatus {
+    
+    Status: OfflineStoreStatusValue | string | undefined;
+    
+    BlockedReason?: string;
+}
+export declare namespace OfflineStoreStatus {
+    
+    const filterSensitiveLog: (obj: OfflineStoreStatus) => any;
+}
+export interface DescribeFeatureGroupResponse {
+    
+    FeatureGroupArn: string | undefined;
+    
+    FeatureGroupName: string | undefined;
+    
+    RecordIdentifierFeatureName: string | undefined;
+    
+    EventTimeFeatureName: string | undefined;
+    
+    FeatureDefinitions: FeatureDefinition[] | undefined;
+    
+    CreationTime: Date | undefined;
+    
+    OnlineStoreConfig?: OnlineStoreConfig;
+    
+    OfflineStoreConfig?: OfflineStoreConfig;
+    
+    RoleArn?: string;
+    
+    FeatureGroupStatus?: FeatureGroupStatus | string;
+    
+    OfflineStoreStatus?: OfflineStoreStatus;
+    
+    FailureReason?: string;
+    
+    Description?: string;
+    
+    NextToken: string | undefined;
+}
+export declare namespace DescribeFeatureGroupResponse {
+    
+    const filterSensitiveLog: (obj: DescribeFeatureGroupResponse) => any;
+}
+export interface DescribeFlowDefinitionRequest {
+    
+    FlowDefinitionName: string | undefined;
+}
+export declare namespace DescribeFlowDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: DescribeFlowDefinitionRequest) => any;
+}
+export declare enum FlowDefinitionStatus {
+    ACTIVE = "Active",
+    DELETING = "Deleting",
+    FAILED = "Failed",
+    INITIALIZING = "Initializing"
+}
+export interface DescribeFlowDefinitionResponse {
+    
+    FlowDefinitionArn: string | undefined;
+    
+    FlowDefinitionName: string | undefined;
+    
+    FlowDefinitionStatus: FlowDefinitionStatus | string | undefined;
+    
+    CreationTime: Date | undefined;
+    
+    HumanLoopRequestSource?: HumanLoopRequestSource;
+    
+    HumanLoopActivationConfig?: HumanLoopActivationConfig;
+    
+    HumanLoopConfig: HumanLoopConfig | undefined;
+    
+    OutputConfig: FlowDefinitionOutputConfig | undefined;
+    
+    RoleArn: string | undefined;
+    
+    FailureReason?: string;
+}
+export declare namespace DescribeFlowDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: DescribeFlowDefinitionResponse) => any;
+}
+export interface DescribeHumanTaskUiRequest {
+    
+    HumanTaskUiName: string | undefined;
+}
+export declare namespace DescribeHumanTaskUiRequest {
+    
+    const filterSensitiveLog: (obj: DescribeHumanTaskUiRequest) => any;
+}
+export declare enum HumanTaskUiStatus {
+    ACTIVE = "Active",
+    DELETING = "Deleting"
+}
+
+export interface UiTemplateInfo {
+    
+    Url?: string;
+    
+    ContentSha256?: string;
+}
+export declare namespace UiTemplateInfo {
+    
+    const filterSensitiveLog: (obj: UiTemplateInfo) => any;
+}
+export interface DescribeHumanTaskUiResponse {
+    
+    HumanTaskUiArn: string | undefined;
+    
+    HumanTaskUiName: string | undefined;
+    
+    HumanTaskUiStatus?: HumanTaskUiStatus | string;
+    
+    CreationTime: Date | undefined;
+    
+    UiTemplate: UiTemplateInfo | undefined;
+}
+export declare namespace DescribeHumanTaskUiResponse {
+    
+    const filterSensitiveLog: (obj: DescribeHumanTaskUiResponse) => any;
+}
+export interface DescribeHyperParameterTuningJobRequest {
+    
+    HyperParameterTuningJobName: string | undefined;
+}
+export declare namespace DescribeHyperParameterTuningJobRequest {
+    
+    const filterSensitiveLog: (obj: DescribeHyperParameterTuningJobRequest) => any;
+}
+
+export interface FinalHyperParameterTuningJobObjectiveMetric {
+    
+    Type?: HyperParameterTuningJobObjectiveType | string;
+    
+    MetricName: string | undefined;
+    
+    Value: number | undefined;
+}
+export declare namespace FinalHyperParameterTuningJobObjectiveMetric {
+    
+    const filterSensitiveLog: (obj: FinalHyperParameterTuningJobObjectiveMetric) => any;
+}
+export declare enum TrainingJobStatus {
+    COMPLETED = "Completed",
+    FAILED = "Failed",
+    IN_PROGRESS = "InProgress",
+    STOPPED = "Stopped",
+    STOPPING = "Stopping"
+}
+
+export interface HyperParameterTrainingJobSummary {
+    
+    TrainingJobDefinitionName?: string;
+    
+    TrainingJobName: string | undefined;
+    
+    TrainingJobArn: string | undefined;
+    
+    TuningJobName?: string;
+    
+    CreationTime: Date | undefined;
+    
+    TrainingStartTime?: Date;
+    
+    TrainingEndTime?: Date;
+    
+    TrainingJobStatus: TrainingJobStatus | string | undefined;
+    
+    TunedHyperParameters: {
+        [key: string]: string;
+    } | undefined;
+    
+    FailureReason?: string;
+    
+    FinalHyperParameterTuningJobObjectiveMetric?: FinalHyperParameterTuningJobObjectiveMetric;
+    
+    ObjectiveStatus?: ObjectiveStatus | string;
+}
+export declare namespace HyperParameterTrainingJobSummary {
+    
+    const filterSensitiveLog: (obj: HyperParameterTrainingJobSummary) => any;
+}
+export declare enum HyperParameterTuningJobStatus {
+    COMPLETED = "Completed",
+    FAILED = "Failed",
+    IN_PROGRESS = "InProgress",
+    STOPPED = "Stopped",
+    STOPPING = "Stopping"
+}
+
+export interface ObjectiveStatusCounters {
+    
+    Succeeded?: number;
+    
+    Pending?: number;
+    
+    Failed?: number;
+}
+export declare namespace ObjectiveStatusCounters {
+    
+    const filterSensitiveLog: (obj: ObjectiveStatusCounters) => any;
+}
+
+export interface TrainingJobStatusCounters {
+    
+    Completed?: number;
+    
+    InProgress?: number;
+    
+    RetryableError?: number;
+    
+    NonRetryableError?: number;
+    
+    Stopped?: number;
+}
+export declare namespace TrainingJobStatusCounters {
+    
+    const filterSensitiveLog: (obj: TrainingJobStatusCounters) => any;
+}
+export interface DescribeHyperParameterTuningJobResponse {
+    
+    HyperParameterTuningJobName: string | undefined;
+    
+    HyperParameterTuningJobArn: string | undefined;
+    
+    HyperParameterTuningJobConfig: HyperParameterTuningJobConfig | undefined;
+    
+    TrainingJobDefinition?: HyperParameterTrainingJobDefinition;
+    
+    TrainingJobDefinitions?: HyperParameterTrainingJobDefinition[];
+    
+    HyperParameterTuningJobStatus: HyperParameterTuningJobStatus | string | undefined;
+    
+    CreationTime: Date | undefined;
+    
+    HyperParameterTuningEndTime?: Date;
+    
+    LastModifiedTime?: Date;
+    
+    TrainingJobStatusCounters: TrainingJobStatusCounters | undefined;
+    
+    ObjectiveStatusCounters: ObjectiveStatusCounters | undefined;
+    
+    BestTrainingJob?: HyperParameterTrainingJobSummary;
+    
+    OverallBestTrainingJob?: HyperParameterTrainingJobSummary;
+    
+    WarmStartConfig?: HyperParameterTuningJobWarmStartConfig;
+    
+    FailureReason?: string;
+}
+export declare namespace DescribeHyperParameterTuningJobResponse {
+    
+    const filterSensitiveLog: (obj: DescribeHyperParameterTuningJobResponse) => any;
+}
+export interface DescribeImageRequest {
+    
+    ImageName: string | undefined;
+}
+export declare namespace DescribeImageRequest {
+    
+    const filterSensitiveLog: (obj: DescribeImageRequest) => any;
+}
+export declare enum ImageStatus {
+    CREATED = "CREATED",
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATING = "CREATING",
+    DELETE_FAILED = "DELETE_FAILED",
+    DELETING = "DELETING",
+    UPDATE_FAILED = "UPDATE_FAILED",
+    UPDATING = "UPDATING"
+}
+export interface DescribeImageResponse {
+    
+    CreationTime?: Date;
+    
+    Description?: string;
+    
+    DisplayName?: string;
+    
+    FailureReason?: string;
+    
+    ImageArn?: string;
+    
+    ImageName?: string;
+    
+    ImageStatus?: ImageStatus | string;
+    
+    LastModifiedTime?: Date;
+    
+    RoleArn?: string;
+}
+export declare namespace DescribeImageResponse {
+    
+    const filterSensitiveLog: (obj: DescribeImageResponse) => any;
+}
+export interface DescribeImageVersionRequest {
+    
+    ImageName: string | undefined;
+    
+    Version?: number;
+}
+export declare namespace DescribeImageVersionRequest {
+    
+    const filterSensitiveLog: (obj: DescribeImageVersionRequest) => any;
+}
+export declare enum ImageVersionStatus {
+    CREATED = "CREATED",
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATING = "CREATING",
+    DELETE_FAILED = "DELETE_FAILED",
+    DELETING = "DELETING"
+}
+export interface DescribeImageVersionResponse {
+    
+    BaseImage?: string;
+    
+    ContainerImage?: string;
+    
+    CreationTime?: Date;
+    
+    FailureReason?: string;
+    
+    ImageArn?: string;
+    
+    ImageVersionArn?: string;
+    
+    ImageVersionStatus?: ImageVersionStatus | string;
+    
+    LastModifiedTime?: Date;
+    
+    Version?: number;
+}
+export declare namespace DescribeImageVersionResponse {
+    
+    const filterSensitiveLog: (obj: DescribeImageVersionResponse) => any;
+}
+export interface DescribeInferenceRecommendationsJobRequest {
+    
+    JobName: string | undefined;
+}
+export declare namespace DescribeInferenceRecommendationsJobRequest {
+    
+    const filterSensitiveLog: (obj: DescribeInferenceRecommendationsJobRequest) => any;
+}
+
+export interface EndpointOutputConfiguration {
+    
+    EndpointName: string | undefined;
+    
+    VariantName: string | undefined;
+    
+    InstanceType: ProductionVariantInstanceType | string | undefined;
+    
+    InitialInstanceCount: number | undefined;
+}
+export declare namespace EndpointOutputConfiguration {
+    
+    const filterSensitiveLog: (obj: EndpointOutputConfiguration) => any;
+}
+
+export interface RecommendationMetrics {
+    
+    CostPerHour: number | undefined;
+    
+    CostPerInference: number | undefined;
+    
+    MaxInvocations: number | undefined;
+    
+    ModelLatency: number | undefined;
+}
+export declare namespace RecommendationMetrics {
+    
+    const filterSensitiveLog: (obj: RecommendationMetrics) => any;
+}
+
+export interface EnvironmentParameter {
+    
+    Key: string | undefined;
+    
+    ValueType: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace EnvironmentParameter {
+    
+    const filterSensitiveLog: (obj: EnvironmentParameter) => any;
+}
+
+export interface ModelConfiguration {
+    
+    InferenceSpecificationName?: string;
+    
+    EnvironmentParameters?: EnvironmentParameter[];
+}
+export declare namespace ModelConfiguration {
+    
+    const filterSensitiveLog: (obj: ModelConfiguration) => any;
+}
+
+export interface InferenceRecommendation {
+    
+    Metrics: RecommendationMetrics | undefined;
+    
+    EndpointConfiguration: EndpointOutputConfiguration | undefined;
+    
+    ModelConfiguration: ModelConfiguration | undefined;
+}
+export declare namespace InferenceRecommendation {
+    
+    const filterSensitiveLog: (obj: InferenceRecommendation) => any;
+}
+export declare enum RecommendationJobStatus {
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    PENDING = "PENDING",
+    STOPPED = "STOPPED",
+    STOPPING = "STOPPING"
+}
+export interface DescribeInferenceRecommendationsJobResponse {
+    
+    JobName: string | undefined;
+    
+    JobDescription?: string;
+    
+    JobType: RecommendationJobType | string | undefined;
+    
+    JobArn: string | undefined;
+    
+    RoleArn: string | undefined;
+    
+    Status: RecommendationJobStatus | string | undefined;
+    
+    CreationTime: Date | undefined;
+    
+    CompletionTime?: Date;
+    
+    LastModifiedTime: Date | undefined;
+    
+    FailureReason?: string;
+    
+    InputConfig: RecommendationJobInputConfig | undefined;
+    
+    StoppingConditions?: RecommendationJobStoppingConditions;
+    
+    InferenceRecommendations?: InferenceRecommendation[];
+}
+export declare namespace DescribeInferenceRecommendationsJobResponse {
+    
+    const filterSensitiveLog: (obj: DescribeInferenceRecommendationsJobResponse) => any;
+}
+export interface DescribeLabelingJobRequest {
+    
+    LabelingJobName: string | undefined;
+}
+export declare namespace DescribeLabelingJobRequest {
+    
+    const filterSensitiveLog: (obj: DescribeLabelingJobRequest) => any;
+}
+
+export interface LabelCounters {
+    
+    TotalLabeled?: number;
+    
+    HumanLabeled?: number;
+    
+    MachineLabeled?: number;
+    
+    FailedNonRetryableError?: number;
+    
+    Unlabeled?: number;
+}
+export declare namespace LabelCounters {
+    
+    const filterSensitiveLog: (obj: LabelCounters) => any;
+}
+
+export interface LabelingJobOutput {
+    
+    OutputDatasetS3Uri: string | undefined;
+    
+    FinalActiveLearningModelArn?: string;
+}
+export declare namespace LabelingJobOutput {
+    
+    const filterSensitiveLog: (obj: LabelingJobOutput) => any;
+}
+export declare enum LabelingJobStatus {
+    COMPLETED = "Completed",
+    FAILED = "Failed",
+    INITIALIZING = "Initializing",
+    IN_PROGRESS = "InProgress",
+    STOPPED = "Stopped",
+    STOPPING = "Stopping"
+}
+export interface DescribeLabelingJobResponse {
+    
+    LabelingJobStatus: LabelingJobStatus | string | undefined;
+    
+    LabelCounters: LabelCounters | undefined;
+    
+    FailureReason?: string;
+    
+    CreationTime: Date | undefined;
+    
+    LastModifiedTime: Date | undefined;
+    
+    JobReferenceCode: string | undefined;
+    
+    LabelingJobName: string | undefined;
+    
+    LabelingJobArn: string | undefined;
+    
+    LabelAttributeName?: string;
+    
+    InputConfig: LabelingJobInputConfig | undefined;
+    
+    OutputConfig: LabelingJobOutputConfig | undefined;
+    
+    RoleArn: string | undefined;
+    
+    LabelCategoryConfigS3Uri?: string;
+    
+    StoppingConditions?: LabelingJobStoppingConditions;
+    
+    LabelingJobAlgorithmsConfig?: LabelingJobAlgorithmsConfig;
+    
+    HumanTaskConfig: HumanTaskConfig | undefined;
+    
+    Tags?: Tag[];
+    
+    LabelingJobOutput?: LabelingJobOutput;
+}
+export declare namespace DescribeLabelingJobResponse {
+    
+    const filterSensitiveLog: (obj: DescribeLabelingJobResponse) => any;
+}
+export interface DescribeLineageGroupRequest {
+    
+    LineageGroupName: string | undefined;
+}
+export declare namespace DescribeLineageGroupRequest {
+    
+    const filterSensitiveLog: (obj: DescribeLineageGroupRequest) => any;
+}
+export interface DescribeLineageGroupResponse {
+    
+    LineageGroupName?: string;
+    
+    LineageGroupArn?: string;
+    
+    DisplayName?: string;
+    
+    Description?: string;
+    
+    CreationTime?: Date;
+    
+    CreatedBy?: UserContext;
+    
+    LastModifiedTime?: Date;
+    
+    LastModifiedBy?: UserContext;
+}
+export declare namespace DescribeLineageGroupResponse {
+    
+    const filterSensitiveLog: (obj: DescribeLineageGroupResponse) => any;
+}
+export interface DescribeModelInput {
+    
+    ModelName: string | undefined;
+}
+export declare namespace DescribeModelInput {
+    
+    const filterSensitiveLog: (obj: DescribeModelInput) => any;
+}