@aws-sdk/client-sagemaker 3.50.0 → 3.53.0

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

@@ -0,0 +1,1853 @@
+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, HyperParameterTrainingJobSummary, MemberDefinition, ModelArtifacts, ModelClientConfig, ModelMetrics, ModelPackageValidationSpecification, MonitoringScheduleConfig, NetworkConfig, NotebookInstanceAcceleratorType, NotebookInstanceLifecycleHook, NotificationConfiguration, OidcConfig, ParallelismConfiguration, PipelineDefinitionS3Location, 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, SortBy, SortOrder, TrainingJobSortByOptions, TransformJobStatus, TrialComponentMetricSummary, TrialComponentSource, TrialSource, UserProfileStatus, Workforce, Workteam } from "./models_2";
+export interface ListTrainingJobsForHyperParameterTuningJobRequest {
+    
+    HyperParameterTuningJobName: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    StatusEquals?: TrainingJobStatus | string;
+    
+    SortBy?: TrainingJobSortByOptions | string;
+    
+    SortOrder?: SortOrder | string;
+}
+export declare namespace ListTrainingJobsForHyperParameterTuningJobRequest {
+    
+    const filterSensitiveLog: (obj: ListTrainingJobsForHyperParameterTuningJobRequest) => any;
+}
+export interface ListTrainingJobsForHyperParameterTuningJobResponse {
+    
+    TrainingJobSummaries: HyperParameterTrainingJobSummary[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListTrainingJobsForHyperParameterTuningJobResponse {
+    
+    const filterSensitiveLog: (obj: ListTrainingJobsForHyperParameterTuningJobResponse) => any;
+}
+export interface ListTransformJobsRequest {
+    
+    CreationTimeAfter?: Date;
+    
+    CreationTimeBefore?: Date;
+    
+    LastModifiedTimeAfter?: Date;
+    
+    LastModifiedTimeBefore?: Date;
+    
+    NameContains?: string;
+    
+    StatusEquals?: TransformJobStatus | string;
+    
+    SortBy?: SortBy | string;
+    
+    SortOrder?: SortOrder | string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListTransformJobsRequest {
+    
+    const filterSensitiveLog: (obj: ListTransformJobsRequest) => any;
+}
+
+export interface TransformJobSummary {
+    
+    TransformJobName: string | undefined;
+    
+    TransformJobArn: string | undefined;
+    
+    CreationTime: Date | undefined;
+    
+    TransformEndTime?: Date;
+    
+    LastModifiedTime?: Date;
+    
+    TransformJobStatus: TransformJobStatus | string | undefined;
+    
+    FailureReason?: string;
+}
+export declare namespace TransformJobSummary {
+    
+    const filterSensitiveLog: (obj: TransformJobSummary) => any;
+}
+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;
+    
+    ParallelismConfiguration?: ParallelismConfiguration;
+    
+    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;
+    
+    ParallelismConfiguration?: ParallelismConfiguration;
+    
+    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;
+    
+    ParallelismConfiguration?: ParallelismConfiguration;
+}
+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;
+    
+    ParallelismConfiguration?: ParallelismConfiguration;
+}
+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;
+}
+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;
+}
+export declare namespace StopLabelingJobRequest {
+    
+    const filterSensitiveLog: (obj: StopLabelingJobRequest) => any;
+}
+export interface StopMonitoringScheduleRequest {
+    
+    MonitoringScheduleName: string | undefined;
+}
+export declare namespace StopMonitoringScheduleRequest {
+    
+    const filterSensitiveLog: (obj: StopMonitoringScheduleRequest) => any;
+}
+export interface StopNotebookInstanceInput {
+    
+    NotebookInstanceName: string | undefined;
+}
+export declare namespace StopNotebookInstanceInput {
+    
+    const filterSensitiveLog: (obj: StopNotebookInstanceInput) => any;
+}
+export interface StopPipelineExecutionRequest {
+    
+    PipelineExecutionArn: string | undefined;
+    
+    ClientRequestToken?: string;
+}
+export declare namespace StopPipelineExecutionRequest {
+    
+    const filterSensitiveLog: (obj: StopPipelineExecutionRequest) => any;
+}
+export interface StopPipelineExecutionResponse {
+    
+    PipelineExecutionArn?: string;
+}
+export declare namespace StopPipelineExecutionResponse {
+    
+    const filterSensitiveLog: (obj: StopPipelineExecutionResponse) => any;
+}
+export interface StopProcessingJobRequest {
+    
+    ProcessingJobName: string | undefined;
+}
+export declare namespace StopProcessingJobRequest {
+    
+    const filterSensitiveLog: (obj: StopProcessingJobRequest) => any;
+}
+export interface StopTrainingJobRequest {
+    
+    TrainingJobName: string | undefined;
+}
+export declare namespace StopTrainingJobRequest {
+    
+    const filterSensitiveLog: (obj: StopTrainingJobRequest) => any;
+}
+export interface StopTransformJobRequest {
+    
+    TransformJobName: string | undefined;
+}
+export declare namespace StopTransformJobRequest {
+    
+    const filterSensitiveLog: (obj: StopTransformJobRequest) => any;
+}
+export interface UpdateActionRequest {
+    
+    ActionName: string | undefined;
+    
+    Description?: string;
+    
+    Status?: ActionStatus | string;
+    
+    Properties?: {
+        [key: string]: string;
+    };
+    
+    PropertiesToRemove?: string[];
+}
+export declare namespace UpdateActionRequest {
+    
+    const filterSensitiveLog: (obj: UpdateActionRequest) => any;
+}
+export interface UpdateActionResponse {
+    
+    ActionArn?: string;
+}
+export declare namespace UpdateActionResponse {
+    
+    const filterSensitiveLog: (obj: UpdateActionResponse) => any;
+}
+export interface UpdateAppImageConfigRequest {
+    
+    AppImageConfigName: string | undefined;
+    
+    KernelGatewayImageConfig?: KernelGatewayImageConfig;
+}
+export declare namespace UpdateAppImageConfigRequest {
+    
+    const filterSensitiveLog: (obj: UpdateAppImageConfigRequest) => any;
+}
+export interface UpdateAppImageConfigResponse {
+    
+    AppImageConfigArn?: string;
+}
+export declare namespace UpdateAppImageConfigResponse {
+    
+    const filterSensitiveLog: (obj: UpdateAppImageConfigResponse) => any;
+}
+export interface UpdateArtifactRequest {
+    
+    ArtifactArn: string | undefined;
+    
+    ArtifactName?: string;
+    
+    Properties?: {
+        [key: string]: string;
+    };
+    
+    PropertiesToRemove?: string[];
+}
+export declare namespace UpdateArtifactRequest {
+    
+    const filterSensitiveLog: (obj: UpdateArtifactRequest) => any;
+}
+export interface UpdateArtifactResponse {
+    
+    ArtifactArn?: string;
+}
+export declare namespace UpdateArtifactResponse {
+    
+    const filterSensitiveLog: (obj: UpdateArtifactResponse) => any;
+}
+export interface UpdateCodeRepositoryInput {
+    
+    CodeRepositoryName: string | undefined;
+    
+    GitConfig?: GitConfigForUpdate;
+}
+export declare namespace UpdateCodeRepositoryInput {
+    
+    const filterSensitiveLog: (obj: UpdateCodeRepositoryInput) => any;
+}
+export interface UpdateCodeRepositoryOutput {
+    
+    CodeRepositoryArn: string | undefined;
+}
+export declare namespace UpdateCodeRepositoryOutput {
+    
+    const filterSensitiveLog: (obj: UpdateCodeRepositoryOutput) => any;
+}
+export interface UpdateContextRequest {
+    
+    ContextName: string | undefined;
+    
+    Description?: string;
+    
+    Properties?: {
+        [key: string]: string;
+    };
+    
+    PropertiesToRemove?: string[];
+}
+export declare namespace UpdateContextRequest {
+    
+    const filterSensitiveLog: (obj: UpdateContextRequest) => any;
+}
+export interface UpdateContextResponse {
+    
+    ContextArn?: string;
+}
+export declare namespace UpdateContextResponse {
+    
+    const filterSensitiveLog: (obj: UpdateContextResponse) => any;
+}
+export interface UpdateDeviceFleetRequest {
+    
+    DeviceFleetName: string | undefined;
+    
+    RoleArn?: string;
+    
+    Description?: string;
+    
+    OutputConfig: EdgeOutputConfig | undefined;
+    
+    EnableIotRoleAlias?: boolean;
+}
+export declare namespace UpdateDeviceFleetRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDeviceFleetRequest) => any;
+}
+export interface UpdateDevicesRequest {
+    
+    DeviceFleetName: string | undefined;
+    
+    Devices: Device[] | undefined;
+}
+export declare namespace UpdateDevicesRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDevicesRequest) => any;
+}
+export interface UpdateDomainRequest {
+    
+    DomainId: string | undefined;
+    
+    DefaultUserSettings?: UserSettings;
+    
+    DomainSettingsForUpdate?: DomainSettingsForUpdate;
+}
+export declare namespace UpdateDomainRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDomainRequest) => any;
+}
+export interface UpdateDomainResponse {
+    
+    DomainArn?: string;
+}
+export declare namespace UpdateDomainResponse {
+    
+    const filterSensitiveLog: (obj: UpdateDomainResponse) => any;
+}
+export declare enum VariantPropertyType {
+    DataCaptureConfig = "DataCaptureConfig",
+    DesiredInstanceCount = "DesiredInstanceCount",
+    DesiredWeight = "DesiredWeight"
+}
+
+export interface VariantProperty {
+    
+    VariantPropertyType: VariantPropertyType | string | undefined;
+}
+export declare namespace VariantProperty {
+    
+    const filterSensitiveLog: (obj: VariantProperty) => any;
+}
+export interface UpdateEndpointInput {
+    
+    EndpointName: string | undefined;
+    
+    EndpointConfigName: string | undefined;
+    
+    RetainAllVariantProperties?: boolean;
+    
+    ExcludeRetainedVariantProperties?: VariantProperty[];
+    
+    DeploymentConfig?: DeploymentConfig;
+    
+    RetainDeploymentConfig?: boolean;
+}
+export declare namespace UpdateEndpointInput {
+    
+    const filterSensitiveLog: (obj: UpdateEndpointInput) => any;
+}
+export interface UpdateEndpointOutput {
+    
+    EndpointArn: string | undefined;
+}
+export declare namespace UpdateEndpointOutput {
+    
+    const filterSensitiveLog: (obj: UpdateEndpointOutput) => any;
+}
+export interface UpdateEndpointWeightsAndCapacitiesInput {
+    
+    EndpointName: string | undefined;
+    
+    DesiredWeightsAndCapacities: DesiredWeightAndCapacity[] | undefined;
+}
+export declare namespace UpdateEndpointWeightsAndCapacitiesInput {
+    
+    const filterSensitiveLog: (obj: UpdateEndpointWeightsAndCapacitiesInput) => any;
+}
+export interface UpdateEndpointWeightsAndCapacitiesOutput {
+    
+    EndpointArn: string | undefined;
+}
+export declare namespace UpdateEndpointWeightsAndCapacitiesOutput {
+    
+    const filterSensitiveLog: (obj: UpdateEndpointWeightsAndCapacitiesOutput) => any;
+}
+export interface UpdateExperimentRequest {
+    
+    ExperimentName: string | undefined;
+    
+    DisplayName?: string;
+    
+    Description?: string;
+}
+export declare namespace UpdateExperimentRequest {
+    
+    const filterSensitiveLog: (obj: UpdateExperimentRequest) => any;
+}
+export interface UpdateExperimentResponse {
+    
+    ExperimentArn?: string;
+}
+export declare namespace UpdateExperimentResponse {
+    
+    const filterSensitiveLog: (obj: UpdateExperimentResponse) => any;
+}
+export interface UpdateImageRequest {
+    
+    DeleteProperties?: string[];
+    
+    Description?: string;
+    
+    DisplayName?: string;
+    
+    ImageName: string | undefined;
+    
+    RoleArn?: string;
+}
+export declare namespace UpdateImageRequest {
+    
+    const filterSensitiveLog: (obj: UpdateImageRequest) => any;
+}
+export interface UpdateImageResponse {
+    
+    ImageArn?: string;
+}
+export declare namespace UpdateImageResponse {
+    
+    const filterSensitiveLog: (obj: UpdateImageResponse) => any;
+}
+export interface UpdateModelPackageInput {
+    
+    ModelPackageArn: string | undefined;
+    
+    ModelApprovalStatus?: ModelApprovalStatus | string;
+    
+    ApprovalDescription?: string;
+    
+    CustomerMetadataProperties?: {
+        [key: string]: string;
+    };
+    
+    CustomerMetadataPropertiesToRemove?: string[];
+    
+    AdditionalInferenceSpecificationsToAdd?: AdditionalInferenceSpecificationDefinition[];
+}
+export declare namespace UpdateModelPackageInput {
+    
+    const filterSensitiveLog: (obj: UpdateModelPackageInput) => any;
+}
+export interface UpdateModelPackageOutput {
+    
+    ModelPackageArn: string | undefined;
+}
+export declare namespace UpdateModelPackageOutput {
+    
+    const filterSensitiveLog: (obj: UpdateModelPackageOutput) => any;
+}
+export interface UpdateMonitoringScheduleRequest {
+    
+    MonitoringScheduleName: string | undefined;
+    
+    MonitoringScheduleConfig: MonitoringScheduleConfig | undefined;
+}
+export declare namespace UpdateMonitoringScheduleRequest {
+    
+    const filterSensitiveLog: (obj: UpdateMonitoringScheduleRequest) => any;
+}
+export interface UpdateMonitoringScheduleResponse {
+    
+    MonitoringScheduleArn: string | undefined;
+}
+export declare namespace UpdateMonitoringScheduleResponse {
+    
+    const filterSensitiveLog: (obj: UpdateMonitoringScheduleResponse) => any;
+}
+export interface UpdateNotebookInstanceInput {
+    
+    NotebookInstanceName: string | undefined;
+    
+    InstanceType?: _InstanceType | string;
+    
+    RoleArn?: string;
+    
+    LifecycleConfigName?: string;
+    
+    DisassociateLifecycleConfig?: boolean;
+    
+    VolumeSizeInGB?: number;
+    
+    DefaultCodeRepository?: string;
+    
+    AdditionalCodeRepositories?: string[];
+    
+    AcceleratorTypes?: (NotebookInstanceAcceleratorType | string)[];
+    
+    DisassociateAcceleratorTypes?: boolean;
+    
+    DisassociateDefaultCodeRepository?: boolean;
+    
+    DisassociateAdditionalCodeRepositories?: boolean;
+    
+    RootAccess?: RootAccess | string;
+}
+export declare namespace UpdateNotebookInstanceInput {
+    
+    const filterSensitiveLog: (obj: UpdateNotebookInstanceInput) => any;
+}
+export interface UpdateNotebookInstanceOutput {
+}
+export declare namespace UpdateNotebookInstanceOutput {
+    
+    const filterSensitiveLog: (obj: UpdateNotebookInstanceOutput) => any;
+}
+export interface UpdateNotebookInstanceLifecycleConfigInput {
+    
+    NotebookInstanceLifecycleConfigName: string | undefined;
+    
+    OnCreate?: NotebookInstanceLifecycleHook[];
+    
+    OnStart?: NotebookInstanceLifecycleHook[];
+}
+export declare namespace UpdateNotebookInstanceLifecycleConfigInput {
+    
+    const filterSensitiveLog: (obj: UpdateNotebookInstanceLifecycleConfigInput) => any;
+}
+export interface UpdateNotebookInstanceLifecycleConfigOutput {
+}
+export declare namespace UpdateNotebookInstanceLifecycleConfigOutput {
+    
+    const filterSensitiveLog: (obj: UpdateNotebookInstanceLifecycleConfigOutput) => any;
+}
+export interface UpdatePipelineRequest {
+    
+    PipelineName: string | undefined;
+    
+    PipelineDisplayName?: string;
+    
+    PipelineDefinition?: string;
+    
+    PipelineDefinitionS3Location?: PipelineDefinitionS3Location;
+    
+    PipelineDescription?: string;
+    
+    RoleArn?: string;
+    
+    ParallelismConfiguration?: ParallelismConfiguration;
+}
+export declare namespace UpdatePipelineRequest {
+    
+    const filterSensitiveLog: (obj: UpdatePipelineRequest) => any;
+}
+export interface UpdatePipelineResponse {
+    
+    PipelineArn?: string;
+}
+export declare namespace UpdatePipelineResponse {
+    
+    const filterSensitiveLog: (obj: UpdatePipelineResponse) => any;
+}
+export interface UpdatePipelineExecutionRequest {
+    
+    PipelineExecutionArn: string | undefined;
+    
+    PipelineExecutionDescription?: string;
+    
+    PipelineExecutionDisplayName?: string;
+    
+    ParallelismConfiguration?: ParallelismConfiguration;
+}
+export declare namespace UpdatePipelineExecutionRequest {
+    
+    const filterSensitiveLog: (obj: UpdatePipelineExecutionRequest) => any;
+}
+export interface UpdatePipelineExecutionResponse {
+    
+    PipelineExecutionArn?: string;
+}
+export declare namespace UpdatePipelineExecutionResponse {
+    
+    const filterSensitiveLog: (obj: UpdatePipelineExecutionResponse) => any;
+}
+
+export interface ServiceCatalogProvisioningUpdateDetails {
+    
+    ProvisioningArtifactId?: string;
+    
+    ProvisioningParameters?: ProvisioningParameter[];
+}
+export declare namespace ServiceCatalogProvisioningUpdateDetails {
+    
+    const filterSensitiveLog: (obj: ServiceCatalogProvisioningUpdateDetails) => any;
+}
+export interface UpdateProjectInput {
+    
+    ProjectName: string | undefined;
+    
+    ProjectDescription?: string;
+    
+    ServiceCatalogProvisioningUpdateDetails?: ServiceCatalogProvisioningUpdateDetails;
+    
+    Tags?: Tag[];
+}
+export declare namespace UpdateProjectInput {
+    
+    const filterSensitiveLog: (obj: UpdateProjectInput) => any;
+}
+export interface UpdateProjectOutput {
+    
+    ProjectArn: string | undefined;
+}
+export declare namespace UpdateProjectOutput {
+    
+    const filterSensitiveLog: (obj: UpdateProjectOutput) => any;
+}
+export interface UpdateTrainingJobRequest {
+    
+    TrainingJobName: string | undefined;
+    
+    ProfilerConfig?: ProfilerConfigForUpdate;
+    
+    ProfilerRuleConfigurations?: ProfilerRuleConfiguration[];
+}
+export declare namespace UpdateTrainingJobRequest {
+    
+    const filterSensitiveLog: (obj: UpdateTrainingJobRequest) => any;
+}
+export interface UpdateTrainingJobResponse {
+    
+    TrainingJobArn: string | undefined;
+}
+export declare namespace UpdateTrainingJobResponse {
+    
+    const filterSensitiveLog: (obj: UpdateTrainingJobResponse) => any;
+}
+export interface UpdateTrialRequest {
+    
+    TrialName: string | undefined;
+    
+    DisplayName?: string;
+}
+export declare namespace UpdateTrialRequest {
+    
+    const filterSensitiveLog: (obj: UpdateTrialRequest) => any;
+}
+export interface UpdateTrialResponse {
+    
+    TrialArn?: string;
+}
+export declare namespace UpdateTrialResponse {
+    
+    const filterSensitiveLog: (obj: UpdateTrialResponse) => any;
+}
+export interface UpdateTrialComponentRequest {
+    
+    TrialComponentName: string | undefined;
+    
+    DisplayName?: string;
+    
+    Status?: TrialComponentStatus;
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    Parameters?: {
+        [key: string]: TrialComponentParameterValue;
+    };
+    
+    ParametersToRemove?: string[];
+    
+    InputArtifacts?: {
+        [key: string]: TrialComponentArtifact;
+    };
+    
+    InputArtifactsToRemove?: string[];
+    
+    OutputArtifacts?: {
+        [key: string]: TrialComponentArtifact;
+    };
+    
+    OutputArtifactsToRemove?: string[];
+}
+export declare namespace UpdateTrialComponentRequest {
+    
+    const filterSensitiveLog: (obj: UpdateTrialComponentRequest) => any;
+}
+export interface UpdateTrialComponentResponse {
+    
+    TrialComponentArn?: string;
+}
+export declare namespace UpdateTrialComponentResponse {
+    
+    const filterSensitiveLog: (obj: UpdateTrialComponentResponse) => any;
+}
+export interface UpdateUserProfileRequest {
+    
+    DomainId: string | undefined;
+    
+    UserProfileName: string | undefined;
+    
+    UserSettings?: UserSettings;
+}
+export declare namespace UpdateUserProfileRequest {
+    
+    const filterSensitiveLog: (obj: UpdateUserProfileRequest) => any;
+}
+export interface UpdateUserProfileResponse {
+    
+    UserProfileArn?: string;
+}
+export declare namespace UpdateUserProfileResponse {
+    
+    const filterSensitiveLog: (obj: UpdateUserProfileResponse) => any;
+}
+export interface UpdateWorkforceRequest {
+    
+    WorkforceName: string | undefined;
+    
+    SourceIpConfig?: SourceIpConfig;
+    
+    OidcConfig?: OidcConfig;
+}
+export declare namespace UpdateWorkforceRequest {
+    
+    const filterSensitiveLog: (obj: UpdateWorkforceRequest) => any;
+}
+export interface UpdateWorkforceResponse {
+    
+    Workforce: Workforce | undefined;
+}
+export declare namespace UpdateWorkforceResponse {
+    
+    const filterSensitiveLog: (obj: UpdateWorkforceResponse) => any;
+}
+export interface UpdateWorkteamRequest {
+    
+    WorkteamName: string | undefined;
+    
+    MemberDefinitions?: MemberDefinition[];
+    
+    Description?: string;
+    
+    NotificationConfiguration?: NotificationConfiguration;
+}
+export declare namespace UpdateWorkteamRequest {
+    
+    const filterSensitiveLog: (obj: UpdateWorkteamRequest) => any;
+}
+export interface UpdateWorkteamResponse {
+    
+    Workteam: Workteam | undefined;
+}
+export declare namespace UpdateWorkteamResponse {
+    
+    const filterSensitiveLog: (obj: UpdateWorkteamResponse) => any;
+}
+
+export interface SearchExpression {
+    
+    Filters?: Filter[];
+    
+    NestedFilters?: NestedFilters[];
+    
+    SubExpressions?: SearchExpression[];
+    
+    Operator?: BooleanOperator | string;
+}
+export declare namespace SearchExpression {
+    
+    const filterSensitiveLog: (obj: SearchExpression) => any;
+}
+export interface SearchRequest {
+    
+    Resource: ResourceType | string | undefined;
+    
+    SearchExpression?: SearchExpression;
+    
+    SortBy?: string;
+    
+    SortOrder?: SearchSortOrder | string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace SearchRequest {
+    
+    const filterSensitiveLog: (obj: SearchRequest) => any;
+}