@aws-sdk/client-sagemaker 3.40.0 → 3.44.0

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

@@ -1,6 +1,1073 @@
-import { ActionStatus, BooleanOperator, EdgeOutputConfig, KernelGatewayImageConfig, ModelApprovalStatus, Tag, UserSettings } from "./models_0";
-import { _InstanceType, DeploymentConfig, MemberDefinition, MonitoringScheduleConfig, NotebookInstanceAcceleratorType, NotebookInstanceLifecycleHook, NotificationConfiguration, OidcConfig, ProfilerRuleConfiguration, ProvisioningParameter, RootAccess, SourceIpConfig, TrialComponentArtifact, TrialComponentParameterValue, TrialComponentStatus } from "./models_1";
-import { DesiredWeightAndCapacity, Device, DomainSettingsForUpdate, Filter, GitConfigForUpdate, NestedFilters, ProfilerConfigForUpdate, ResourceType, SearchSortOrder, Workforce, Workteam } from "./models_2";
+import { ActionStatus, AdditionalInferenceSpecificationDefinition, AlgorithmSpecification, AppSpecification, BatchStrategy, BooleanOperator, Channel, CheckpointConfig, DeploymentConfig, EdgeOutputConfig, InferenceSpecification, KernelGatewayImageConfig, MetadataProperties, ModelApprovalStatus, ModelPackageStatus, OutputDataConfig, OutputParameter, ResourceConfig, RetryStrategy, StoppingCondition, Tag, TransformInput, TransformOutput, TransformResources, UiTemplate, UserContext, UserSettings, VpcConfig } from "./models_0";
+import { _InstanceType, DataProcessing, DebugHookConfig, DebugRuleConfiguration, DebugRuleEvaluationStatus, DriftCheckBaselines, ExperimentConfig, MemberDefinition, ModelArtifacts, ModelClientConfig, ModelMetrics, ModelPackageValidationSpecification, MonitoringScheduleConfig, NetworkConfig, NotebookInstanceAcceleratorType, NotebookInstanceLifecycleHook, NotificationConfiguration, OidcConfig, ProcessingInput, ProcessingOutputConfig, ProcessingResources, ProcessingStoppingCondition, ProfilerRuleConfiguration, ProvisioningParameter, RootAccess, ServiceCatalogProvisioningDetails, SourceAlgorithmSpecification, SourceIpConfig, TensorBoardOutputConfig, TrainingJobStatus, TrialComponentArtifact, TrialComponentParameterValue, TrialComponentStatus } from "./models_1";
+import { DesiredWeightAndCapacity, Device, Direction, DomainSettingsForUpdate, Edge, Endpoint, Experiment, FeatureGroup, Filter, GitConfigForUpdate, LineageType, MetricData, ModelPackageGroupStatus, ModelPackageStatusDetails, Parameter, PipelineExecutionStatus, PipelineExperimentConfig, PipelineStatus, ProcessingJobStatus, ProjectStatus, ResourceType, SecondaryStatus, SecondaryStatusTransition, ServiceCatalogProvisionedProductDetails, SortOrder, TransformJobStatus, TransformJobSummary, TrialComponentMetricSummary, TrialComponentSource, TrialSource, UserProfileStatus, Workforce, Workteam } from "./models_2";
+export interface ListTransformJobsResponse {
+    
+    TransformJobSummaries: TransformJobSummary[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListTransformJobsResponse {
+    
+    const filterSensitiveLog: (obj: ListTransformJobsResponse) => any;
+}
+export declare enum SortTrialComponentsBy {
+    CREATION_TIME = "CreationTime",
+    NAME = "Name"
+}
+export interface ListTrialComponentsRequest {
+    
+    ExperimentName?: string;
+    
+    TrialName?: string;
+    
+    SourceArn?: string;
+    
+    CreatedAfter?: Date;
+    
+    CreatedBefore?: Date;
+    
+    SortBy?: SortTrialComponentsBy | string;
+    
+    SortOrder?: SortOrder | string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListTrialComponentsRequest {
+    
+    const filterSensitiveLog: (obj: ListTrialComponentsRequest) => any;
+}
+
+export interface TrialComponentSummary {
+    
+    TrialComponentName?: string;
+    
+    TrialComponentArn?: string;
+    
+    DisplayName?: string;
+    
+    TrialComponentSource?: TrialComponentSource;
+    
+    Status?: TrialComponentStatus;
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    CreationTime?: Date;
+    
+    CreatedBy?: UserContext;
+    
+    LastModifiedTime?: Date;
+    
+    LastModifiedBy?: UserContext;
+}
+export declare namespace TrialComponentSummary {
+    
+    const filterSensitiveLog: (obj: TrialComponentSummary) => any;
+}
+export interface ListTrialComponentsResponse {
+    
+    TrialComponentSummaries?: TrialComponentSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTrialComponentsResponse {
+    
+    const filterSensitiveLog: (obj: ListTrialComponentsResponse) => any;
+}
+export declare enum SortTrialsBy {
+    CREATION_TIME = "CreationTime",
+    NAME = "Name"
+}
+export interface ListTrialsRequest {
+    
+    ExperimentName?: string;
+    
+    TrialComponentName?: string;
+    
+    CreatedAfter?: Date;
+    
+    CreatedBefore?: Date;
+    
+    SortBy?: SortTrialsBy | string;
+    
+    SortOrder?: SortOrder | string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListTrialsRequest {
+    
+    const filterSensitiveLog: (obj: ListTrialsRequest) => any;
+}
+
+export interface TrialSummary {
+    
+    TrialArn?: string;
+    
+    TrialName?: string;
+    
+    DisplayName?: string;
+    
+    TrialSource?: TrialSource;
+    
+    CreationTime?: Date;
+    
+    LastModifiedTime?: Date;
+}
+export declare namespace TrialSummary {
+    
+    const filterSensitiveLog: (obj: TrialSummary) => any;
+}
+export interface ListTrialsResponse {
+    
+    TrialSummaries?: TrialSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTrialsResponse {
+    
+    const filterSensitiveLog: (obj: ListTrialsResponse) => any;
+}
+export declare enum UserProfileSortKey {
+    CreationTime = "CreationTime",
+    LastModifiedTime = "LastModifiedTime"
+}
+export interface ListUserProfilesRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    SortOrder?: SortOrder | string;
+    
+    SortBy?: UserProfileSortKey | string;
+    
+    DomainIdEquals?: string;
+    
+    UserProfileNameContains?: string;
+}
+export declare namespace ListUserProfilesRequest {
+    
+    const filterSensitiveLog: (obj: ListUserProfilesRequest) => any;
+}
+
+export interface UserProfileDetails {
+    
+    DomainId?: string;
+    
+    UserProfileName?: string;
+    
+    Status?: UserProfileStatus | string;
+    
+    CreationTime?: Date;
+    
+    LastModifiedTime?: Date;
+}
+export declare namespace UserProfileDetails {
+    
+    const filterSensitiveLog: (obj: UserProfileDetails) => any;
+}
+export interface ListUserProfilesResponse {
+    
+    UserProfiles?: UserProfileDetails[];
+    
+    NextToken?: string;
+}
+export declare namespace ListUserProfilesResponse {
+    
+    const filterSensitiveLog: (obj: ListUserProfilesResponse) => any;
+}
+export declare enum ListWorkforcesSortByOptions {
+    CreateDate = "CreateDate",
+    Name = "Name"
+}
+export interface ListWorkforcesRequest {
+    
+    SortBy?: ListWorkforcesSortByOptions | string;
+    
+    SortOrder?: SortOrder | string;
+    
+    NameContains?: string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListWorkforcesRequest {
+    
+    const filterSensitiveLog: (obj: ListWorkforcesRequest) => any;
+}
+export interface ListWorkforcesResponse {
+    
+    Workforces: Workforce[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListWorkforcesResponse {
+    
+    const filterSensitiveLog: (obj: ListWorkforcesResponse) => any;
+}
+export declare enum ListWorkteamsSortByOptions {
+    CreateDate = "CreateDate",
+    Name = "Name"
+}
+export interface ListWorkteamsRequest {
+    
+    SortBy?: ListWorkteamsSortByOptions | string;
+    
+    SortOrder?: SortOrder | string;
+    
+    NameContains?: string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListWorkteamsRequest {
+    
+    const filterSensitiveLog: (obj: ListWorkteamsRequest) => any;
+}
+export interface ListWorkteamsResponse {
+    
+    Workteams: Workteam[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListWorkteamsResponse {
+    
+    const filterSensitiveLog: (obj: ListWorkteamsResponse) => any;
+}
+
+export interface ModelPackage {
+    
+    ModelPackageName?: string;
+    
+    ModelPackageGroupName?: string;
+    
+    ModelPackageVersion?: number;
+    
+    ModelPackageArn?: string;
+    
+    ModelPackageDescription?: string;
+    
+    CreationTime?: Date;
+    
+    InferenceSpecification?: InferenceSpecification;
+    
+    SourceAlgorithmSpecification?: SourceAlgorithmSpecification;
+    
+    ValidationSpecification?: ModelPackageValidationSpecification;
+    
+    ModelPackageStatus?: ModelPackageStatus | string;
+    
+    ModelPackageStatusDetails?: ModelPackageStatusDetails;
+    
+    CertifyForMarketplace?: boolean;
+    
+    ModelApprovalStatus?: ModelApprovalStatus | string;
+    
+    CreatedBy?: UserContext;
+    
+    MetadataProperties?: MetadataProperties;
+    
+    ModelMetrics?: ModelMetrics;
+    
+    LastModifiedTime?: Date;
+    
+    LastModifiedBy?: UserContext;
+    
+    ApprovalDescription?: string;
+    
+    Domain?: string;
+    
+    Task?: string;
+    
+    SamplePayloadUrl?: string;
+    
+    AdditionalInferenceSpecifications?: AdditionalInferenceSpecificationDefinition[];
+    
+    Tags?: Tag[];
+    
+    CustomerMetadataProperties?: {
+        [key: string]: string;
+    };
+    
+    DriftCheckBaselines?: DriftCheckBaselines;
+}
+export declare namespace ModelPackage {
+    
+    const filterSensitiveLog: (obj: ModelPackage) => any;
+}
+
+export interface ModelPackageGroup {
+    
+    ModelPackageGroupName?: string;
+    
+    ModelPackageGroupArn?: string;
+    
+    ModelPackageGroupDescription?: string;
+    
+    CreationTime?: Date;
+    
+    CreatedBy?: UserContext;
+    
+    ModelPackageGroupStatus?: ModelPackageGroupStatus | string;
+    
+    Tags?: Tag[];
+}
+export declare namespace ModelPackageGroup {
+    
+    const filterSensitiveLog: (obj: ModelPackageGroup) => any;
+}
+
+export interface NestedFilters {
+    
+    NestedPropertyName: string | undefined;
+    
+    Filters: Filter[] | undefined;
+}
+export declare namespace NestedFilters {
+    
+    const filterSensitiveLog: (obj: NestedFilters) => any;
+}
+
+export interface Parent {
+    
+    TrialName?: string;
+    
+    ExperimentName?: string;
+}
+export declare namespace Parent {
+    
+    const filterSensitiveLog: (obj: Parent) => any;
+}
+
+export interface Pipeline {
+    
+    PipelineArn?: string;
+    
+    PipelineName?: string;
+    
+    PipelineDisplayName?: string;
+    
+    PipelineDescription?: string;
+    
+    RoleArn?: string;
+    
+    PipelineStatus?: PipelineStatus | string;
+    
+    CreationTime?: Date;
+    
+    LastModifiedTime?: Date;
+    
+    LastRunTime?: Date;
+    
+    CreatedBy?: UserContext;
+    
+    LastModifiedBy?: UserContext;
+    
+    Tags?: Tag[];
+}
+export declare namespace Pipeline {
+    
+    const filterSensitiveLog: (obj: Pipeline) => any;
+}
+
+export interface PipelineExecution {
+    
+    PipelineArn?: string;
+    
+    PipelineExecutionArn?: string;
+    
+    PipelineExecutionDisplayName?: string;
+    
+    PipelineExecutionStatus?: PipelineExecutionStatus | string;
+    
+    PipelineExecutionDescription?: string;
+    
+    PipelineExperimentConfig?: PipelineExperimentConfig;
+    
+    FailureReason?: string;
+    
+    CreationTime?: Date;
+    
+    LastModifiedTime?: Date;
+    
+    CreatedBy?: UserContext;
+    
+    LastModifiedBy?: UserContext;
+    
+    PipelineParameters?: Parameter[];
+}
+export declare namespace PipelineExecution {
+    
+    const filterSensitiveLog: (obj: PipelineExecution) => any;
+}
+
+export interface ProcessingJob {
+    
+    ProcessingInputs?: ProcessingInput[];
+    
+    ProcessingOutputConfig?: ProcessingOutputConfig;
+    
+    ProcessingJobName?: string;
+    
+    ProcessingResources?: ProcessingResources;
+    
+    StoppingCondition?: ProcessingStoppingCondition;
+    
+    AppSpecification?: AppSpecification;
+    
+    Environment?: {
+        [key: string]: string;
+    };
+    
+    NetworkConfig?: NetworkConfig;
+    
+    RoleArn?: string;
+    
+    ExperimentConfig?: ExperimentConfig;
+    
+    ProcessingJobArn?: string;
+    
+    ProcessingJobStatus?: ProcessingJobStatus | string;
+    
+    ExitMessage?: string;
+    
+    FailureReason?: string;
+    
+    ProcessingEndTime?: Date;
+    
+    ProcessingStartTime?: Date;
+    
+    LastModifiedTime?: Date;
+    
+    CreationTime?: Date;
+    
+    MonitoringScheduleArn?: string;
+    
+    AutoMLJobArn?: string;
+    
+    TrainingJobArn?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace ProcessingJob {
+    
+    const filterSensitiveLog: (obj: ProcessingJob) => any;
+}
+
+export interface ProfilerConfigForUpdate {
+    
+    S3OutputPath?: string;
+    
+    ProfilingIntervalInMilliseconds?: number;
+    
+    ProfilingParameters?: {
+        [key: string]: string;
+    };
+    
+    DisableProfiler?: boolean;
+}
+export declare namespace ProfilerConfigForUpdate {
+    
+    const filterSensitiveLog: (obj: ProfilerConfigForUpdate) => any;
+}
+
+export interface Project {
+    
+    ProjectArn?: string;
+    
+    ProjectName?: string;
+    
+    ProjectId?: string;
+    
+    ProjectDescription?: string;
+    
+    ServiceCatalogProvisioningDetails?: ServiceCatalogProvisioningDetails;
+    
+    ServiceCatalogProvisionedProductDetails?: ServiceCatalogProvisionedProductDetails;
+    
+    ProjectStatus?: ProjectStatus | string;
+    
+    CreatedBy?: UserContext;
+    
+    CreationTime?: Date;
+    
+    Tags?: Tag[];
+    
+    LastModifiedTime?: Date;
+    
+    LastModifiedBy?: UserContext;
+}
+export declare namespace Project {
+    
+    const filterSensitiveLog: (obj: Project) => any;
+}
+export interface PutModelPackageGroupPolicyInput {
+    
+    ModelPackageGroupName: string | undefined;
+    
+    ResourcePolicy: string | undefined;
+}
+export declare namespace PutModelPackageGroupPolicyInput {
+    
+    const filterSensitiveLog: (obj: PutModelPackageGroupPolicyInput) => any;
+}
+export interface PutModelPackageGroupPolicyOutput {
+    
+    ModelPackageGroupArn: string | undefined;
+}
+export declare namespace PutModelPackageGroupPolicyOutput {
+    
+    const filterSensitiveLog: (obj: PutModelPackageGroupPolicyOutput) => any;
+}
+
+export interface QueryFilters {
+    
+    Types?: string[];
+    
+    LineageTypes?: (LineageType | string)[];
+    
+    CreatedBefore?: Date;
+    
+    CreatedAfter?: Date;
+    
+    ModifiedBefore?: Date;
+    
+    ModifiedAfter?: Date;
+    
+    Properties?: {
+        [key: string]: string;
+    };
+}
+export declare namespace QueryFilters {
+    
+    const filterSensitiveLog: (obj: QueryFilters) => any;
+}
+export interface QueryLineageRequest {
+    
+    StartArns: string[] | undefined;
+    
+    Direction?: Direction | string;
+    
+    IncludeEdges?: boolean;
+    
+    Filters?: QueryFilters;
+    
+    MaxDepth?: number;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace QueryLineageRequest {
+    
+    const filterSensitiveLog: (obj: QueryLineageRequest) => any;
+}
+
+export interface Vertex {
+    
+    Arn?: string;
+    
+    Type?: string;
+    
+    LineageType?: LineageType | string;
+}
+export declare namespace Vertex {
+    
+    const filterSensitiveLog: (obj: Vertex) => any;
+}
+export interface QueryLineageResponse {
+    
+    Vertices?: Vertex[];
+    
+    Edges?: Edge[];
+    
+    NextToken?: string;
+}
+export declare namespace QueryLineageResponse {
+    
+    const filterSensitiveLog: (obj: QueryLineageResponse) => any;
+}
+export interface RegisterDevicesRequest {
+    
+    DeviceFleetName: string | undefined;
+    
+    Devices: Device[] | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace RegisterDevicesRequest {
+    
+    const filterSensitiveLog: (obj: RegisterDevicesRequest) => any;
+}
+
+export interface RenderableTask {
+    
+    Input: string | undefined;
+}
+export declare namespace RenderableTask {
+    
+    const filterSensitiveLog: (obj: RenderableTask) => any;
+}
+
+export interface RenderingError {
+    
+    Code: string | undefined;
+    
+    Message: string | undefined;
+}
+export declare namespace RenderingError {
+    
+    const filterSensitiveLog: (obj: RenderingError) => any;
+}
+export interface RenderUiTemplateRequest {
+    
+    UiTemplate?: UiTemplate;
+    
+    Task: RenderableTask | undefined;
+    
+    RoleArn: string | undefined;
+    
+    HumanTaskUiArn?: string;
+}
+export declare namespace RenderUiTemplateRequest {
+    
+    const filterSensitiveLog: (obj: RenderUiTemplateRequest) => any;
+}
+export interface RenderUiTemplateResponse {
+    
+    RenderedContent: string | undefined;
+    
+    Errors: RenderingError[] | undefined;
+}
+export declare namespace RenderUiTemplateResponse {
+    
+    const filterSensitiveLog: (obj: RenderUiTemplateResponse) => any;
+}
+export interface RetryPipelineExecutionRequest {
+    
+    PipelineExecutionArn: string | undefined;
+    
+    ClientRequestToken?: string;
+}
+export declare namespace RetryPipelineExecutionRequest {
+    
+    const filterSensitiveLog: (obj: RetryPipelineExecutionRequest) => any;
+}
+export interface RetryPipelineExecutionResponse {
+    
+    PipelineExecutionArn?: string;
+}
+export declare namespace RetryPipelineExecutionResponse {
+    
+    const filterSensitiveLog: (obj: RetryPipelineExecutionResponse) => any;
+}
+export declare enum SearchSortOrder {
+    ASCENDING = "Ascending",
+    DESCENDING = "Descending"
+}
+
+export interface TrainingJob {
+    
+    TrainingJobName?: string;
+    
+    TrainingJobArn?: string;
+    
+    TuningJobArn?: string;
+    
+    LabelingJobArn?: string;
+    
+    AutoMLJobArn?: string;
+    
+    ModelArtifacts?: ModelArtifacts;
+    
+    TrainingJobStatus?: TrainingJobStatus | string;
+    
+    SecondaryStatus?: SecondaryStatus | string;
+    
+    FailureReason?: string;
+    
+    HyperParameters?: {
+        [key: string]: string;
+    };
+    
+    AlgorithmSpecification?: AlgorithmSpecification;
+    
+    RoleArn?: string;
+    
+    InputDataConfig?: Channel[];
+    
+    OutputDataConfig?: OutputDataConfig;
+    
+    ResourceConfig?: ResourceConfig;
+    
+    VpcConfig?: VpcConfig;
+    
+    StoppingCondition?: StoppingCondition;
+    
+    CreationTime?: Date;
+    
+    TrainingStartTime?: Date;
+    
+    TrainingEndTime?: Date;
+    
+    LastModifiedTime?: Date;
+    
+    SecondaryStatusTransitions?: SecondaryStatusTransition[];
+    
+    FinalMetricDataList?: MetricData[];
+    
+    EnableNetworkIsolation?: boolean;
+    
+    EnableInterContainerTrafficEncryption?: boolean;
+    
+    EnableManagedSpotTraining?: boolean;
+    
+    CheckpointConfig?: CheckpointConfig;
+    
+    TrainingTimeInSeconds?: number;
+    
+    BillableTimeInSeconds?: number;
+    
+    DebugHookConfig?: DebugHookConfig;
+    
+    ExperimentConfig?: ExperimentConfig;
+    
+    DebugRuleConfigurations?: DebugRuleConfiguration[];
+    
+    TensorBoardOutputConfig?: TensorBoardOutputConfig;
+    
+    DebugRuleEvaluationStatuses?: DebugRuleEvaluationStatus[];
+    
+    Environment?: {
+        [key: string]: string;
+    };
+    
+    RetryStrategy?: RetryStrategy;
+    
+    Tags?: Tag[];
+}
+export declare namespace TrainingJob {
+    
+    const filterSensitiveLog: (obj: TrainingJob) => any;
+}
+
+export interface TrialComponentSimpleSummary {
+    
+    TrialComponentName?: string;
+    
+    TrialComponentArn?: string;
+    
+    TrialComponentSource?: TrialComponentSource;
+    
+    CreationTime?: Date;
+    
+    CreatedBy?: UserContext;
+}
+export declare namespace TrialComponentSimpleSummary {
+    
+    const filterSensitiveLog: (obj: TrialComponentSimpleSummary) => any;
+}
+
+export interface Trial {
+    
+    TrialName?: string;
+    
+    TrialArn?: string;
+    
+    DisplayName?: string;
+    
+    ExperimentName?: string;
+    
+    Source?: TrialSource;
+    
+    CreationTime?: Date;
+    
+    CreatedBy?: UserContext;
+    
+    LastModifiedTime?: Date;
+    
+    LastModifiedBy?: UserContext;
+    
+    MetadataProperties?: MetadataProperties;
+    
+    Tags?: Tag[];
+    
+    TrialComponentSummaries?: TrialComponentSimpleSummary[];
+}
+export declare namespace Trial {
+    
+    const filterSensitiveLog: (obj: Trial) => any;
+}
+
+export interface TransformJob {
+    
+    TransformJobName?: string;
+    
+    TransformJobArn?: string;
+    
+    TransformJobStatus?: TransformJobStatus | string;
+    
+    FailureReason?: string;
+    
+    ModelName?: string;
+    
+    MaxConcurrentTransforms?: number;
+    
+    ModelClientConfig?: ModelClientConfig;
+    
+    MaxPayloadInMB?: number;
+    
+    BatchStrategy?: BatchStrategy | string;
+    
+    Environment?: {
+        [key: string]: string;
+    };
+    
+    TransformInput?: TransformInput;
+    
+    TransformOutput?: TransformOutput;
+    
+    TransformResources?: TransformResources;
+    
+    CreationTime?: Date;
+    
+    TransformStartTime?: Date;
+    
+    TransformEndTime?: Date;
+    
+    LabelingJobArn?: string;
+    
+    AutoMLJobArn?: string;
+    
+    DataProcessing?: DataProcessing;
+    
+    ExperimentConfig?: ExperimentConfig;
+    
+    Tags?: Tag[];
+}
+export declare namespace TransformJob {
+    
+    const filterSensitiveLog: (obj: TransformJob) => any;
+}
+
+export interface TrialComponentSourceDetail {
+    
+    SourceArn?: string;
+    
+    TrainingJob?: TrainingJob;
+    
+    ProcessingJob?: ProcessingJob;
+    
+    TransformJob?: TransformJob;
+}
+export declare namespace TrialComponentSourceDetail {
+    
+    const filterSensitiveLog: (obj: TrialComponentSourceDetail) => any;
+}
+
+export interface TrialComponent {
+    
+    TrialComponentName?: string;
+    
+    DisplayName?: string;
+    
+    TrialComponentArn?: string;
+    
+    Source?: TrialComponentSource;
+    
+    Status?: TrialComponentStatus;
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    CreationTime?: Date;
+    
+    CreatedBy?: UserContext;
+    
+    LastModifiedTime?: Date;
+    
+    LastModifiedBy?: UserContext;
+    
+    Parameters?: {
+        [key: string]: TrialComponentParameterValue;
+    };
+    
+    InputArtifacts?: {
+        [key: string]: TrialComponentArtifact;
+    };
+    
+    OutputArtifacts?: {
+        [key: string]: TrialComponentArtifact;
+    };
+    
+    Metrics?: TrialComponentMetricSummary[];
+    
+    MetadataProperties?: MetadataProperties;
+    
+    SourceDetail?: TrialComponentSourceDetail;
+    
+    LineageGroupArn?: string;
+    
+    Tags?: Tag[];
+    
+    Parents?: Parent[];
+}
+export declare namespace TrialComponent {
+    
+    const filterSensitiveLog: (obj: TrialComponent) => any;
+}
+
+export interface SearchRecord {
+    
+    TrainingJob?: TrainingJob;
+    
+    Experiment?: Experiment;
+    
+    Trial?: Trial;
+    
+    TrialComponent?: TrialComponent;
+    
+    Endpoint?: Endpoint;
+    
+    ModelPackage?: ModelPackage;
+    
+    ModelPackageGroup?: ModelPackageGroup;
+    
+    Pipeline?: Pipeline;
+    
+    PipelineExecution?: PipelineExecution;
+    
+    FeatureGroup?: FeatureGroup;
+    
+    Project?: Project;
+}
+export declare namespace SearchRecord {
+    
+    const filterSensitiveLog: (obj: SearchRecord) => any;
+}
+export interface SearchResponse {
+    
+    Results?: SearchRecord[];
+    
+    NextToken?: string;
+}
+export declare namespace SearchResponse {
+    
+    const filterSensitiveLog: (obj: SearchResponse) => any;
+}
+export interface SendPipelineExecutionStepFailureRequest {
+    
+    CallbackToken: string | undefined;
+    
+    FailureReason?: string;
+    
+    ClientRequestToken?: string;
+}
+export declare namespace SendPipelineExecutionStepFailureRequest {
+    
+    const filterSensitiveLog: (obj: SendPipelineExecutionStepFailureRequest) => any;
+}
+export interface SendPipelineExecutionStepFailureResponse {
+    
+    PipelineExecutionArn?: string;
+}
+export declare namespace SendPipelineExecutionStepFailureResponse {
+    
+    const filterSensitiveLog: (obj: SendPipelineExecutionStepFailureResponse) => any;
+}
+export interface SendPipelineExecutionStepSuccessRequest {
+    
+    CallbackToken: string | undefined;
+    
+    OutputParameters?: OutputParameter[];
+    
+    ClientRequestToken?: string;
+}
+export declare namespace SendPipelineExecutionStepSuccessRequest {
+    
+    const filterSensitiveLog: (obj: SendPipelineExecutionStepSuccessRequest) => any;
+}
+export interface SendPipelineExecutionStepSuccessResponse {
+    
+    PipelineExecutionArn?: string;
+}
+export declare namespace SendPipelineExecutionStepSuccessResponse {
+    
+    const filterSensitiveLog: (obj: SendPipelineExecutionStepSuccessResponse) => any;
+}
+export interface StartMonitoringScheduleRequest {
+    
+    MonitoringScheduleName: string | undefined;
+}
+export declare namespace StartMonitoringScheduleRequest {
+    
+    const filterSensitiveLog: (obj: StartMonitoringScheduleRequest) => any;
+}
+export interface StartNotebookInstanceInput {
+    
+    NotebookInstanceName: string | undefined;
+}
+export declare namespace StartNotebookInstanceInput {
+    
+    const filterSensitiveLog: (obj: StartNotebookInstanceInput) => any;
+}
+export interface StartPipelineExecutionRequest {
+    
+    PipelineName: string | undefined;
+    
+    PipelineExecutionDisplayName?: string;
+    
+    PipelineParameters?: Parameter[];
+    
+    PipelineExecutionDescription?: string;
+    
+    ClientRequestToken?: string;
+}
+export declare namespace StartPipelineExecutionRequest {
+    
+    const filterSensitiveLog: (obj: StartPipelineExecutionRequest) => any;
+}
+export interface StartPipelineExecutionResponse {
+    
+    PipelineExecutionArn?: string;
+}
+export declare namespace StartPipelineExecutionResponse {
+    
+    const filterSensitiveLog: (obj: StartPipelineExecutionResponse) => any;
+}
+export interface StopAutoMLJobRequest {
+    
+    AutoMLJobName: string | undefined;
+}
+export declare namespace StopAutoMLJobRequest {
+    
+    const filterSensitiveLog: (obj: StopAutoMLJobRequest) => any;
+}
+export interface StopCompilationJobRequest {
+    
+    CompilationJobName: string | undefined;
+}
+export declare namespace StopCompilationJobRequest {
+    
+    const filterSensitiveLog: (obj: StopCompilationJobRequest) => any;
+}
+export interface StopEdgePackagingJobRequest {
+    
+    EdgePackagingJobName: string | undefined;
+}
+export declare namespace StopEdgePackagingJobRequest {
+    
+    const filterSensitiveLog: (obj: StopEdgePackagingJobRequest) => any;
+}
 export interface StopHyperParameterTuningJobRequest {
     
     HyperParameterTuningJobName: string | undefined;
@@ -9,6 +1076,14 @@ export declare namespace StopHyperParameterTuningJobRequest {
     
     const filterSensitiveLog: (obj: StopHyperParameterTuningJobRequest) => any;
 }
+export interface StopInferenceRecommendationsJobRequest {
+    
+    JobName: string | undefined;
+}
+export declare namespace StopInferenceRecommendationsJobRequest {
+    
+    const filterSensitiveLog: (obj: StopInferenceRecommendationsJobRequest) => any;
+}
 export interface StopLabelingJobRequest {
     
     LabelingJobName: string | undefined;
@@ -256,6 +1331,8 @@ export interface UpdateEndpointInput {
     ExcludeRetainedVariantProperties?: VariantProperty[];
     
     DeploymentConfig?: DeploymentConfig;
+    
+    RetainDeploymentConfig?: boolean;
 }
 export declare namespace UpdateEndpointInput {
     
@@ -344,6 +1421,8 @@ export interface UpdateModelPackageInput {
     };
     
     CustomerMetadataPropertiesToRemove?: string[];
+    
+    AdditionalInferenceSpecificationsToAdd?: AdditionalInferenceSpecificationDefinition[];
 }
 export declare namespace UpdateModelPackageInput {