@aws-sdk/client-lookoutequipment 3.50.0 → 3.53.0

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

@@ -0,0 +1,894 @@
+import { ExceptionOptionType as __ExceptionOptionType, LazyJsonString as __LazyJsonString } from "@aws-sdk/smithy-client";
+import { LookoutEquipmentServiceException as __BaseException } from "./LookoutEquipmentServiceException";
+
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+
+export interface DatasetSchema {
+    
+    InlineDataSchema?: __LazyJsonString | string;
+}
+export declare namespace DatasetSchema {
+    
+    const filterSensitiveLog: (obj: DatasetSchema) => any;
+}
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface CreateDatasetRequest {
+    
+    DatasetName: string | undefined;
+    
+    DatasetSchema: DatasetSchema | undefined;
+    
+    ServerSideKmsKeyId?: string;
+    
+    ClientToken?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateDatasetRequest {
+    
+    const filterSensitiveLog: (obj: CreateDatasetRequest) => any;
+}
+export declare enum DatasetStatus {
+    ACTIVE = "ACTIVE",
+    CREATED = "CREATED",
+    INGESTION_IN_PROGRESS = "INGESTION_IN_PROGRESS"
+}
+export interface CreateDatasetResponse {
+    
+    DatasetName?: string;
+    
+    DatasetArn?: string;
+    
+    Status?: DatasetStatus | string;
+}
+export declare namespace CreateDatasetResponse {
+    
+    const filterSensitiveLog: (obj: CreateDatasetResponse) => any;
+}
+
+export declare class InternalServerException extends __BaseException {
+    readonly name: "InternalServerException";
+    readonly $fault: "server";
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<InternalServerException, __BaseException>);
+}
+
+export declare class ServiceQuotaExceededException extends __BaseException {
+    readonly name: "ServiceQuotaExceededException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<ServiceQuotaExceededException, __BaseException>);
+}
+
+export declare class ThrottlingException extends __BaseException {
+    readonly name: "ThrottlingException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<ThrottlingException, __BaseException>);
+}
+
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+
+export interface InferenceInputNameConfiguration {
+    
+    TimestampFormat?: string;
+    
+    ComponentTimestampDelimiter?: string;
+}
+export declare namespace InferenceInputNameConfiguration {
+    
+    const filterSensitiveLog: (obj: InferenceInputNameConfiguration) => any;
+}
+
+export interface InferenceS3InputConfiguration {
+    
+    Bucket: string | undefined;
+    
+    Prefix?: string;
+}
+export declare namespace InferenceS3InputConfiguration {
+    
+    const filterSensitiveLog: (obj: InferenceS3InputConfiguration) => any;
+}
+
+export interface InferenceInputConfiguration {
+    
+    S3InputConfiguration?: InferenceS3InputConfiguration;
+    
+    InputTimeZoneOffset?: string;
+    
+    InferenceInputNameConfiguration?: InferenceInputNameConfiguration;
+}
+export declare namespace InferenceInputConfiguration {
+    
+    const filterSensitiveLog: (obj: InferenceInputConfiguration) => any;
+}
+
+export interface InferenceS3OutputConfiguration {
+    
+    Bucket: string | undefined;
+    
+    Prefix?: string;
+}
+export declare namespace InferenceS3OutputConfiguration {
+    
+    const filterSensitiveLog: (obj: InferenceS3OutputConfiguration) => any;
+}
+
+export interface InferenceOutputConfiguration {
+    
+    S3OutputConfiguration: InferenceS3OutputConfiguration | undefined;
+    
+    KmsKeyId?: string;
+}
+export declare namespace InferenceOutputConfiguration {
+    
+    const filterSensitiveLog: (obj: InferenceOutputConfiguration) => any;
+}
+export declare enum DataUploadFrequency {
+    PT10M = "PT10M",
+    PT15M = "PT15M",
+    PT1H = "PT1H",
+    PT30M = "PT30M",
+    PT5M = "PT5M"
+}
+export interface CreateInferenceSchedulerRequest {
+    
+    ModelName: string | undefined;
+    
+    InferenceSchedulerName: string | undefined;
+    
+    DataDelayOffsetInMinutes?: number;
+    
+    DataUploadFrequency: DataUploadFrequency | string | undefined;
+    
+    DataInputConfiguration: InferenceInputConfiguration | undefined;
+    
+    DataOutputConfiguration: InferenceOutputConfiguration | undefined;
+    
+    RoleArn: string | undefined;
+    
+    ServerSideKmsKeyId?: string;
+    
+    ClientToken?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateInferenceSchedulerRequest {
+    
+    const filterSensitiveLog: (obj: CreateInferenceSchedulerRequest) => any;
+}
+export declare enum InferenceSchedulerStatus {
+    PENDING = "PENDING",
+    RUNNING = "RUNNING",
+    STOPPED = "STOPPED",
+    STOPPING = "STOPPING"
+}
+export interface CreateInferenceSchedulerResponse {
+    
+    InferenceSchedulerArn?: string;
+    
+    InferenceSchedulerName?: string;
+    
+    Status?: InferenceSchedulerStatus | string;
+}
+export declare namespace CreateInferenceSchedulerResponse {
+    
+    const filterSensitiveLog: (obj: CreateInferenceSchedulerResponse) => any;
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    Message: string | undefined;
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+export declare enum TargetSamplingRate {
+    PT10M = "PT10M",
+    PT10S = "PT10S",
+    PT15M = "PT15M",
+    PT15S = "PT15S",
+    PT1H = "PT1H",
+    PT1M = "PT1M",
+    PT1S = "PT1S",
+    PT30M = "PT30M",
+    PT30S = "PT30S",
+    PT5M = "PT5M",
+    PT5S = "PT5S"
+}
+
+export interface DataPreProcessingConfiguration {
+    
+    TargetSamplingRate?: TargetSamplingRate | string;
+}
+export declare namespace DataPreProcessingConfiguration {
+    
+    const filterSensitiveLog: (obj: DataPreProcessingConfiguration) => any;
+}
+
+export interface LabelsS3InputConfiguration {
+    
+    Bucket: string | undefined;
+    
+    Prefix?: string;
+}
+export declare namespace LabelsS3InputConfiguration {
+    
+    const filterSensitiveLog: (obj: LabelsS3InputConfiguration) => any;
+}
+
+export interface LabelsInputConfiguration {
+    
+    S3InputConfiguration: LabelsS3InputConfiguration | undefined;
+}
+export declare namespace LabelsInputConfiguration {
+    
+    const filterSensitiveLog: (obj: LabelsInputConfiguration) => any;
+}
+export interface CreateModelRequest {
+    
+    ModelName: string | undefined;
+    
+    DatasetName: string | undefined;
+    
+    DatasetSchema?: DatasetSchema;
+    
+    LabelsInputConfiguration?: LabelsInputConfiguration;
+    
+    ClientToken?: string;
+    
+    TrainingDataStartTime?: Date;
+    
+    TrainingDataEndTime?: Date;
+    
+    EvaluationDataStartTime?: Date;
+    
+    EvaluationDataEndTime?: Date;
+    
+    RoleArn?: string;
+    
+    DataPreProcessingConfiguration?: DataPreProcessingConfiguration;
+    
+    ServerSideKmsKeyId?: string;
+    
+    Tags?: Tag[];
+    
+    OffCondition?: string;
+}
+export declare namespace CreateModelRequest {
+    
+    const filterSensitiveLog: (obj: CreateModelRequest) => any;
+}
+export declare enum ModelStatus {
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    SUCCESS = "SUCCESS"
+}
+export interface CreateModelResponse {
+    
+    ModelArn?: string;
+    
+    Status?: ModelStatus | string;
+}
+export declare namespace CreateModelResponse {
+    
+    const filterSensitiveLog: (obj: CreateModelResponse) => any;
+}
+export interface DeleteDatasetRequest {
+    
+    DatasetName: string | undefined;
+}
+export declare namespace DeleteDatasetRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDatasetRequest) => any;
+}
+export interface DeleteInferenceSchedulerRequest {
+    
+    InferenceSchedulerName: string | undefined;
+}
+export declare namespace DeleteInferenceSchedulerRequest {
+    
+    const filterSensitiveLog: (obj: DeleteInferenceSchedulerRequest) => any;
+}
+export interface DeleteModelRequest {
+    
+    ModelName: string | undefined;
+}
+export declare namespace DeleteModelRequest {
+    
+    const filterSensitiveLog: (obj: DeleteModelRequest) => any;
+}
+export interface DescribeDataIngestionJobRequest {
+    
+    JobId: string | undefined;
+}
+export declare namespace DescribeDataIngestionJobRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDataIngestionJobRequest) => any;
+}
+
+export interface IngestionS3InputConfiguration {
+    
+    Bucket: string | undefined;
+    
+    Prefix?: string;
+}
+export declare namespace IngestionS3InputConfiguration {
+    
+    const filterSensitiveLog: (obj: IngestionS3InputConfiguration) => any;
+}
+
+export interface IngestionInputConfiguration {
+    
+    S3InputConfiguration: IngestionS3InputConfiguration | undefined;
+}
+export declare namespace IngestionInputConfiguration {
+    
+    const filterSensitiveLog: (obj: IngestionInputConfiguration) => any;
+}
+export declare enum IngestionJobStatus {
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    SUCCESS = "SUCCESS"
+}
+export interface DescribeDataIngestionJobResponse {
+    
+    JobId?: string;
+    
+    DatasetArn?: string;
+    
+    IngestionInputConfiguration?: IngestionInputConfiguration;
+    
+    RoleArn?: string;
+    
+    CreatedAt?: Date;
+    
+    Status?: IngestionJobStatus | string;
+    
+    FailedReason?: string;
+}
+export declare namespace DescribeDataIngestionJobResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDataIngestionJobResponse) => any;
+}
+export interface DescribeDatasetRequest {
+    
+    DatasetName: string | undefined;
+}
+export declare namespace DescribeDatasetRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDatasetRequest) => any;
+}
+export interface DescribeDatasetResponse {
+    
+    DatasetName?: string;
+    
+    DatasetArn?: string;
+    
+    CreatedAt?: Date;
+    
+    LastUpdatedAt?: Date;
+    
+    Status?: DatasetStatus | string;
+    
+    Schema?: __LazyJsonString | string;
+    
+    ServerSideKmsKeyId?: string;
+    
+    IngestionInputConfiguration?: IngestionInputConfiguration;
+}
+export declare namespace DescribeDatasetResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDatasetResponse) => any;
+}
+export interface DescribeInferenceSchedulerRequest {
+    
+    InferenceSchedulerName: string | undefined;
+}
+export declare namespace DescribeInferenceSchedulerRequest {
+    
+    const filterSensitiveLog: (obj: DescribeInferenceSchedulerRequest) => any;
+}
+export interface DescribeInferenceSchedulerResponse {
+    
+    ModelArn?: string;
+    
+    ModelName?: string;
+    
+    InferenceSchedulerName?: string;
+    
+    InferenceSchedulerArn?: string;
+    
+    Status?: InferenceSchedulerStatus | string;
+    
+    DataDelayOffsetInMinutes?: number;
+    
+    DataUploadFrequency?: DataUploadFrequency | string;
+    
+    CreatedAt?: Date;
+    
+    UpdatedAt?: Date;
+    
+    DataInputConfiguration?: InferenceInputConfiguration;
+    
+    DataOutputConfiguration?: InferenceOutputConfiguration;
+    
+    RoleArn?: string;
+    
+    ServerSideKmsKeyId?: string;
+}
+export declare namespace DescribeInferenceSchedulerResponse {
+    
+    const filterSensitiveLog: (obj: DescribeInferenceSchedulerResponse) => any;
+}
+export interface DescribeModelRequest {
+    
+    ModelName: string | undefined;
+}
+export declare namespace DescribeModelRequest {
+    
+    const filterSensitiveLog: (obj: DescribeModelRequest) => any;
+}
+export interface DescribeModelResponse {
+    
+    ModelName?: string;
+    
+    ModelArn?: string;
+    
+    DatasetName?: string;
+    
+    DatasetArn?: string;
+    
+    Schema?: __LazyJsonString | string;
+    
+    LabelsInputConfiguration?: LabelsInputConfiguration;
+    
+    TrainingDataStartTime?: Date;
+    
+    TrainingDataEndTime?: Date;
+    
+    EvaluationDataStartTime?: Date;
+    
+    EvaluationDataEndTime?: Date;
+    
+    RoleArn?: string;
+    
+    DataPreProcessingConfiguration?: DataPreProcessingConfiguration;
+    
+    Status?: ModelStatus | string;
+    
+    TrainingExecutionStartTime?: Date;
+    
+    TrainingExecutionEndTime?: Date;
+    
+    FailedReason?: string;
+    
+    ModelMetrics?: __LazyJsonString | string;
+    
+    LastUpdatedTime?: Date;
+    
+    CreatedAt?: Date;
+    
+    ServerSideKmsKeyId?: string;
+    
+    OffCondition?: string;
+}
+export declare namespace DescribeModelResponse {
+    
+    const filterSensitiveLog: (obj: DescribeModelResponse) => any;
+}
+export interface ListDataIngestionJobsRequest {
+    
+    DatasetName?: string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    Status?: IngestionJobStatus | string;
+}
+export declare namespace ListDataIngestionJobsRequest {
+    
+    const filterSensitiveLog: (obj: ListDataIngestionJobsRequest) => any;
+}
+
+export interface DataIngestionJobSummary {
+    
+    JobId?: string;
+    
+    DatasetName?: string;
+    
+    DatasetArn?: string;
+    
+    IngestionInputConfiguration?: IngestionInputConfiguration;
+    
+    Status?: IngestionJobStatus | string;
+}
+export declare namespace DataIngestionJobSummary {
+    
+    const filterSensitiveLog: (obj: DataIngestionJobSummary) => any;
+}
+export interface ListDataIngestionJobsResponse {
+    
+    NextToken?: string;
+    
+    DataIngestionJobSummaries?: DataIngestionJobSummary[];
+}
+export declare namespace ListDataIngestionJobsResponse {
+    
+    const filterSensitiveLog: (obj: ListDataIngestionJobsResponse) => any;
+}
+export interface ListDatasetsRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    DatasetNameBeginsWith?: string;
+}
+export declare namespace ListDatasetsRequest {
+    
+    const filterSensitiveLog: (obj: ListDatasetsRequest) => any;
+}
+
+export interface DatasetSummary {
+    
+    DatasetName?: string;
+    
+    DatasetArn?: string;
+    
+    Status?: DatasetStatus | string;
+    
+    CreatedAt?: Date;
+}
+export declare namespace DatasetSummary {
+    
+    const filterSensitiveLog: (obj: DatasetSummary) => any;
+}
+export interface ListDatasetsResponse {
+    
+    NextToken?: string;
+    
+    DatasetSummaries?: DatasetSummary[];
+}
+export declare namespace ListDatasetsResponse {
+    
+    const filterSensitiveLog: (obj: ListDatasetsResponse) => any;
+}
+export declare enum InferenceExecutionStatus {
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    SUCCESS = "SUCCESS"
+}
+export interface ListInferenceExecutionsRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    InferenceSchedulerName: string | undefined;
+    
+    DataStartTimeAfter?: Date;
+    
+    DataEndTimeBefore?: Date;
+    
+    Status?: InferenceExecutionStatus | string;
+}
+export declare namespace ListInferenceExecutionsRequest {
+    
+    const filterSensitiveLog: (obj: ListInferenceExecutionsRequest) => any;
+}
+
+export interface S3Object {
+    
+    Bucket: string | undefined;
+    
+    Key: string | undefined;
+}
+export declare namespace S3Object {
+    
+    const filterSensitiveLog: (obj: S3Object) => any;
+}
+
+export interface InferenceExecutionSummary {
+    
+    ModelName?: string;
+    
+    ModelArn?: string;
+    
+    InferenceSchedulerName?: string;
+    
+    InferenceSchedulerArn?: string;
+    
+    ScheduledStartTime?: Date;
+    
+    DataStartTime?: Date;
+    
+    DataEndTime?: Date;
+    
+    DataInputConfiguration?: InferenceInputConfiguration;
+    
+    DataOutputConfiguration?: InferenceOutputConfiguration;
+    
+    CustomerResultObject?: S3Object;
+    
+    Status?: InferenceExecutionStatus | string;
+    
+    FailedReason?: string;
+}
+export declare namespace InferenceExecutionSummary {
+    
+    const filterSensitiveLog: (obj: InferenceExecutionSummary) => any;
+}
+export interface ListInferenceExecutionsResponse {
+    
+    NextToken?: string;
+    
+    InferenceExecutionSummaries?: InferenceExecutionSummary[];
+}
+export declare namespace ListInferenceExecutionsResponse {
+    
+    const filterSensitiveLog: (obj: ListInferenceExecutionsResponse) => any;
+}
+export interface ListInferenceSchedulersRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    InferenceSchedulerNameBeginsWith?: string;
+    
+    ModelName?: string;
+}
+export declare namespace ListInferenceSchedulersRequest {
+    
+    const filterSensitiveLog: (obj: ListInferenceSchedulersRequest) => any;
+}
+
+export interface InferenceSchedulerSummary {
+    
+    ModelName?: string;
+    
+    ModelArn?: string;
+    
+    InferenceSchedulerName?: string;
+    
+    InferenceSchedulerArn?: string;
+    
+    Status?: InferenceSchedulerStatus | string;
+    
+    DataDelayOffsetInMinutes?: number;
+    
+    DataUploadFrequency?: DataUploadFrequency | string;
+}
+export declare namespace InferenceSchedulerSummary {
+    
+    const filterSensitiveLog: (obj: InferenceSchedulerSummary) => any;
+}
+export interface ListInferenceSchedulersResponse {
+    
+    NextToken?: string;
+    
+    InferenceSchedulerSummaries?: InferenceSchedulerSummary[];
+}
+export declare namespace ListInferenceSchedulersResponse {
+    
+    const filterSensitiveLog: (obj: ListInferenceSchedulersResponse) => any;
+}
+export interface ListModelsRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    Status?: ModelStatus | string;
+    
+    ModelNameBeginsWith?: string;
+    
+    DatasetNameBeginsWith?: string;
+}
+export declare namespace ListModelsRequest {
+    
+    const filterSensitiveLog: (obj: ListModelsRequest) => any;
+}
+
+export interface ModelSummary {
+    
+    ModelName?: string;
+    
+    ModelArn?: string;
+    
+    DatasetName?: string;
+    
+    DatasetArn?: string;
+    
+    Status?: ModelStatus | string;
+    
+    CreatedAt?: Date;
+}
+export declare namespace ModelSummary {
+    
+    const filterSensitiveLog: (obj: ModelSummary) => any;
+}
+export interface ListModelsResponse {
+    
+    NextToken?: string;
+    
+    ModelSummaries?: ModelSummary[];
+}
+export declare namespace ListModelsResponse {
+    
+    const filterSensitiveLog: (obj: ListModelsResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: Tag[];
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface StartDataIngestionJobRequest {
+    
+    DatasetName: string | undefined;
+    
+    IngestionInputConfiguration: IngestionInputConfiguration | undefined;
+    
+    RoleArn: string | undefined;
+    
+    ClientToken?: string;
+}
+export declare namespace StartDataIngestionJobRequest {
+    
+    const filterSensitiveLog: (obj: StartDataIngestionJobRequest) => any;
+}
+export interface StartDataIngestionJobResponse {
+    
+    JobId?: string;
+    
+    Status?: IngestionJobStatus | string;
+}
+export declare namespace StartDataIngestionJobResponse {
+    
+    const filterSensitiveLog: (obj: StartDataIngestionJobResponse) => any;
+}
+export interface StartInferenceSchedulerRequest {
+    
+    InferenceSchedulerName: string | undefined;
+}
+export declare namespace StartInferenceSchedulerRequest {
+    
+    const filterSensitiveLog: (obj: StartInferenceSchedulerRequest) => any;
+}
+export interface StartInferenceSchedulerResponse {
+    
+    ModelArn?: string;
+    
+    ModelName?: string;
+    
+    InferenceSchedulerName?: string;
+    
+    InferenceSchedulerArn?: string;
+    
+    Status?: InferenceSchedulerStatus | string;
+}
+export declare namespace StartInferenceSchedulerResponse {
+    
+    const filterSensitiveLog: (obj: StartInferenceSchedulerResponse) => any;
+}
+export interface StopInferenceSchedulerRequest {
+    
+    InferenceSchedulerName: string | undefined;
+}
+export declare namespace StopInferenceSchedulerRequest {
+    
+    const filterSensitiveLog: (obj: StopInferenceSchedulerRequest) => any;
+}
+export interface StopInferenceSchedulerResponse {
+    
+    ModelArn?: string;
+    
+    ModelName?: string;
+    
+    InferenceSchedulerName?: string;
+    
+    InferenceSchedulerArn?: string;
+    
+    Status?: InferenceSchedulerStatus | string;
+}
+export declare namespace StopInferenceSchedulerResponse {
+    
+    const filterSensitiveLog: (obj: StopInferenceSchedulerResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateInferenceSchedulerRequest {
+    
+    InferenceSchedulerName: string | undefined;
+    
+    DataDelayOffsetInMinutes?: number;
+    
+    DataUploadFrequency?: DataUploadFrequency | string;
+    
+    DataInputConfiguration?: InferenceInputConfiguration;
+    
+    DataOutputConfiguration?: InferenceOutputConfiguration;
+    
+    RoleArn?: string;
+}
+export declare namespace UpdateInferenceSchedulerRequest {
+    
+    const filterSensitiveLog: (obj: UpdateInferenceSchedulerRequest) => any;
+}