@aws-sdk/client-device-farm 3.34.0 → 3.37.0

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

@@ -0,0 +1,2926 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface TrialMinutes {
+    
+    total?: number;
+    
+    remaining?: number;
+}
+export declare namespace TrialMinutes {
+    
+    const filterSensitiveLog: (obj: TrialMinutes) => any;
+}
+export declare enum DevicePlatform {
+    ANDROID = "ANDROID",
+    IOS = "IOS"
+}
+
+export interface AccountSettings {
+    
+    awsAccountNumber?: string;
+    
+    unmeteredDevices?: {
+        [key: string]: number;
+    };
+    
+    unmeteredRemoteAccessDevices?: {
+        [key: string]: number;
+    };
+    
+    maxJobTimeoutMinutes?: number;
+    
+    trialMinutes?: TrialMinutes;
+    
+    maxSlots?: {
+        [key: string]: number;
+    };
+    
+    defaultJobTimeoutMinutes?: number;
+    
+    skipAppResign?: boolean;
+}
+export declare namespace AccountSettings {
+    
+    const filterSensitiveLog: (obj: AccountSettings) => any;
+}
+
+export interface ArgumentException extends __SmithyException, $MetadataBearer {
+    name: "ArgumentException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace ArgumentException {
+    
+    const filterSensitiveLog: (obj: ArgumentException) => any;
+}
+export declare enum ArtifactType {
+    APPIUM_JAVA_OUTPUT = "APPIUM_JAVA_OUTPUT",
+    APPIUM_JAVA_XML_OUTPUT = "APPIUM_JAVA_XML_OUTPUT",
+    APPIUM_PYTHON_OUTPUT = "APPIUM_PYTHON_OUTPUT",
+    APPIUM_PYTHON_XML_OUTPUT = "APPIUM_PYTHON_XML_OUTPUT",
+    APPIUM_SERVER_OUTPUT = "APPIUM_SERVER_OUTPUT",
+    APPLICATION_CRASH_REPORT = "APPLICATION_CRASH_REPORT",
+    AUTOMATION_OUTPUT = "AUTOMATION_OUTPUT",
+    CALABASH_JAVA_XML_OUTPUT = "CALABASH_JAVA_XML_OUTPUT",
+    CALABASH_JSON_OUTPUT = "CALABASH_JSON_OUTPUT",
+    CALABASH_PRETTY_OUTPUT = "CALABASH_PRETTY_OUTPUT",
+    CALABASH_STANDARD_OUTPUT = "CALABASH_STANDARD_OUTPUT",
+    CUSTOMER_ARTIFACT = "CUSTOMER_ARTIFACT",
+    CUSTOMER_ARTIFACT_LOG = "CUSTOMER_ARTIFACT_LOG",
+    DEVICE_LOG = "DEVICE_LOG",
+    EXERCISER_MONKEY_OUTPUT = "EXERCISER_MONKEY_OUTPUT",
+    EXPLORER_EVENT_LOG = "EXPLORER_EVENT_LOG",
+    EXPLORER_SUMMARY_LOG = "EXPLORER_SUMMARY_LOG",
+    INSTRUMENTATION_OUTPUT = "INSTRUMENTATION_OUTPUT",
+    MESSAGE_LOG = "MESSAGE_LOG",
+    RESULT_LOG = "RESULT_LOG",
+    SCREENSHOT = "SCREENSHOT",
+    SERVICE_LOG = "SERVICE_LOG",
+    TESTSPEC_OUTPUT = "TESTSPEC_OUTPUT",
+    UNKNOWN = "UNKNOWN",
+    VIDEO = "VIDEO",
+    VIDEO_LOG = "VIDEO_LOG",
+    WEBKIT_LOG = "WEBKIT_LOG",
+    XCTEST_LOG = "XCTEST_LOG"
+}
+
+export interface Artifact {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    type?: ArtifactType | string;
+    
+    extension?: string;
+    
+    url?: string;
+}
+export declare namespace Artifact {
+    
+    const filterSensitiveLog: (obj: Artifact) => any;
+}
+export declare enum ArtifactCategory {
+    FILE = "FILE",
+    LOG = "LOG",
+    SCREENSHOT = "SCREENSHOT"
+}
+export declare enum BillingMethod {
+    METERED = "METERED",
+    UNMETERED = "UNMETERED"
+}
+
+export interface CannotDeleteException extends __SmithyException, $MetadataBearer {
+    name: "CannotDeleteException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace CannotDeleteException {
+    
+    const filterSensitiveLog: (obj: CannotDeleteException) => any;
+}
+
+export interface Counters {
+    
+    total?: number;
+    
+    passed?: number;
+    
+    failed?: number;
+    
+    warned?: number;
+    
+    errored?: number;
+    
+    stopped?: number;
+    
+    skipped?: number;
+}
+export declare namespace Counters {
+    
+    const filterSensitiveLog: (obj: Counters) => any;
+}
+
+export interface CPU {
+    
+    frequency?: string;
+    
+    architecture?: string;
+    
+    clock?: number;
+}
+export declare namespace CPU {
+    
+    const filterSensitiveLog: (obj: CPU) => any;
+}
+export declare enum DeviceAttribute {
+    APPIUM_VERSION = "APPIUM_VERSION",
+    ARN = "ARN",
+    AVAILABILITY = "AVAILABILITY",
+    FLEET_TYPE = "FLEET_TYPE",
+    FORM_FACTOR = "FORM_FACTOR",
+    INSTANCE_ARN = "INSTANCE_ARN",
+    INSTANCE_LABELS = "INSTANCE_LABELS",
+    MANUFACTURER = "MANUFACTURER",
+    MODEL = "MODEL",
+    OS_VERSION = "OS_VERSION",
+    PLATFORM = "PLATFORM",
+    REMOTE_ACCESS_ENABLED = "REMOTE_ACCESS_ENABLED",
+    REMOTE_DEBUG_ENABLED = "REMOTE_DEBUG_ENABLED"
+}
+export declare enum RuleOperator {
+    CONTAINS = "CONTAINS",
+    EQUALS = "EQUALS",
+    GREATER_THAN = "GREATER_THAN",
+    GREATER_THAN_OR_EQUALS = "GREATER_THAN_OR_EQUALS",
+    IN = "IN",
+    LESS_THAN = "LESS_THAN",
+    LESS_THAN_OR_EQUALS = "LESS_THAN_OR_EQUALS",
+    NOT_IN = "NOT_IN"
+}
+
+export interface Rule {
+    
+    attribute?: DeviceAttribute | string;
+    
+    operator?: RuleOperator | string;
+    
+    value?: string;
+}
+export declare namespace Rule {
+    
+    const filterSensitiveLog: (obj: Rule) => any;
+}
+
+export interface CreateDevicePoolRequest {
+    
+    projectArn: string | undefined;
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    rules: Rule[] | undefined;
+    
+    maxDevices?: number;
+}
+export declare namespace CreateDevicePoolRequest {
+    
+    const filterSensitiveLog: (obj: CreateDevicePoolRequest) => any;
+}
+export declare enum DevicePoolType {
+    CURATED = "CURATED",
+    PRIVATE = "PRIVATE"
+}
+
+export interface DevicePool {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    description?: string;
+    
+    type?: DevicePoolType | string;
+    
+    rules?: Rule[];
+    
+    maxDevices?: number;
+}
+export declare namespace DevicePool {
+    
+    const filterSensitiveLog: (obj: DevicePool) => any;
+}
+
+export interface CreateDevicePoolResult {
+    
+    devicePool?: DevicePool;
+}
+export declare namespace CreateDevicePoolResult {
+    
+    const filterSensitiveLog: (obj: CreateDevicePoolResult) => any;
+}
+
+export interface LimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "LimitExceededException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace LimitExceededException {
+    
+    const filterSensitiveLog: (obj: LimitExceededException) => any;
+}
+
+export interface NotFoundException extends __SmithyException, $MetadataBearer {
+    name: "NotFoundException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace NotFoundException {
+    
+    const filterSensitiveLog: (obj: NotFoundException) => any;
+}
+
+export interface ServiceAccountException extends __SmithyException, $MetadataBearer {
+    name: "ServiceAccountException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace ServiceAccountException {
+    
+    const filterSensitiveLog: (obj: ServiceAccountException) => any;
+}
+export interface CreateInstanceProfileRequest {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    packageCleanup?: boolean;
+    
+    excludeAppPackagesFromCleanup?: string[];
+    
+    rebootAfterUse?: boolean;
+}
+export declare namespace CreateInstanceProfileRequest {
+    
+    const filterSensitiveLog: (obj: CreateInstanceProfileRequest) => any;
+}
+
+export interface InstanceProfile {
+    
+    arn?: string;
+    
+    packageCleanup?: boolean;
+    
+    excludeAppPackagesFromCleanup?: string[];
+    
+    rebootAfterUse?: boolean;
+    
+    name?: string;
+    
+    description?: string;
+}
+export declare namespace InstanceProfile {
+    
+    const filterSensitiveLog: (obj: InstanceProfile) => any;
+}
+export interface CreateInstanceProfileResult {
+    
+    instanceProfile?: InstanceProfile;
+}
+export declare namespace CreateInstanceProfileResult {
+    
+    const filterSensitiveLog: (obj: CreateInstanceProfileResult) => any;
+}
+export declare enum NetworkProfileType {
+    CURATED = "CURATED",
+    PRIVATE = "PRIVATE"
+}
+export interface CreateNetworkProfileRequest {
+    
+    projectArn: string | undefined;
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    type?: NetworkProfileType | string;
+    
+    uplinkBandwidthBits?: number;
+    
+    downlinkBandwidthBits?: number;
+    
+    uplinkDelayMs?: number;
+    
+    downlinkDelayMs?: number;
+    
+    uplinkJitterMs?: number;
+    
+    downlinkJitterMs?: number;
+    
+    uplinkLossPercent?: number;
+    
+    downlinkLossPercent?: number;
+}
+export declare namespace CreateNetworkProfileRequest {
+    
+    const filterSensitiveLog: (obj: CreateNetworkProfileRequest) => any;
+}
+
+export interface NetworkProfile {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    description?: string;
+    
+    type?: NetworkProfileType | string;
+    
+    uplinkBandwidthBits?: number;
+    
+    downlinkBandwidthBits?: number;
+    
+    uplinkDelayMs?: number;
+    
+    downlinkDelayMs?: number;
+    
+    uplinkJitterMs?: number;
+    
+    downlinkJitterMs?: number;
+    
+    uplinkLossPercent?: number;
+    
+    downlinkLossPercent?: number;
+}
+export declare namespace NetworkProfile {
+    
+    const filterSensitiveLog: (obj: NetworkProfile) => any;
+}
+export interface CreateNetworkProfileResult {
+    
+    networkProfile?: NetworkProfile;
+}
+export declare namespace CreateNetworkProfileResult {
+    
+    const filterSensitiveLog: (obj: CreateNetworkProfileResult) => any;
+}
+
+export interface CreateProjectRequest {
+    
+    name: string | undefined;
+    
+    defaultJobTimeoutMinutes?: number;
+}
+export declare namespace CreateProjectRequest {
+    
+    const filterSensitiveLog: (obj: CreateProjectRequest) => any;
+}
+
+export interface Project {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    defaultJobTimeoutMinutes?: number;
+    
+    created?: Date;
+}
+export declare namespace Project {
+    
+    const filterSensitiveLog: (obj: Project) => any;
+}
+
+export interface CreateProjectResult {
+    
+    project?: Project;
+}
+export declare namespace CreateProjectResult {
+    
+    const filterSensitiveLog: (obj: CreateProjectResult) => any;
+}
+
+export interface TagOperationException extends __SmithyException, $MetadataBearer {
+    name: "TagOperationException";
+    $fault: "client";
+    message?: string;
+    resourceName?: string;
+}
+export declare namespace TagOperationException {
+    
+    const filterSensitiveLog: (obj: TagOperationException) => any;
+}
+
+export interface CreateRemoteAccessSessionConfiguration {
+    
+    billingMethod?: BillingMethod | string;
+    
+    vpceConfigurationArns?: string[];
+}
+export declare namespace CreateRemoteAccessSessionConfiguration {
+    
+    const filterSensitiveLog: (obj: CreateRemoteAccessSessionConfiguration) => any;
+}
+export declare enum InteractionMode {
+    INTERACTIVE = "INTERACTIVE",
+    NO_VIDEO = "NO_VIDEO",
+    VIDEO_ONLY = "VIDEO_ONLY"
+}
+
+export interface CreateRemoteAccessSessionRequest {
+    
+    projectArn: string | undefined;
+    
+    deviceArn: string | undefined;
+    
+    instanceArn?: string;
+    
+    sshPublicKey?: string;
+    
+    remoteDebugEnabled?: boolean;
+    
+    remoteRecordEnabled?: boolean;
+    
+    remoteRecordAppArn?: string;
+    
+    name?: string;
+    
+    clientId?: string;
+    
+    configuration?: CreateRemoteAccessSessionConfiguration;
+    
+    interactionMode?: InteractionMode | string;
+    
+    skipAppResign?: boolean;
+}
+export declare namespace CreateRemoteAccessSessionRequest {
+    
+    const filterSensitiveLog: (obj: CreateRemoteAccessSessionRequest) => any;
+}
+export declare enum DeviceAvailability {
+    AVAILABLE = "AVAILABLE",
+    BUSY = "BUSY",
+    HIGHLY_AVAILABLE = "HIGHLY_AVAILABLE",
+    TEMPORARY_NOT_AVAILABLE = "TEMPORARY_NOT_AVAILABLE"
+}
+export declare enum DeviceFormFactor {
+    PHONE = "PHONE",
+    TABLET = "TABLET"
+}
+export declare enum InstanceStatus {
+    AVAILABLE = "AVAILABLE",
+    IN_USE = "IN_USE",
+    NOT_AVAILABLE = "NOT_AVAILABLE",
+    PREPARING = "PREPARING"
+}
+
+export interface DeviceInstance {
+    
+    arn?: string;
+    
+    deviceArn?: string;
+    
+    labels?: string[];
+    
+    status?: InstanceStatus | string;
+    
+    udid?: string;
+    
+    instanceProfile?: InstanceProfile;
+}
+export declare namespace DeviceInstance {
+    
+    const filterSensitiveLog: (obj: DeviceInstance) => any;
+}
+
+export interface Resolution {
+    
+    width?: number;
+    
+    height?: number;
+}
+export declare namespace Resolution {
+    
+    const filterSensitiveLog: (obj: Resolution) => any;
+}
+
+export interface Device {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    manufacturer?: string;
+    
+    model?: string;
+    
+    modelId?: string;
+    
+    formFactor?: DeviceFormFactor | string;
+    
+    platform?: DevicePlatform | string;
+    
+    os?: string;
+    
+    cpu?: CPU;
+    
+    resolution?: Resolution;
+    
+    heapSize?: number;
+    
+    memory?: number;
+    
+    image?: string;
+    
+    carrier?: string;
+    
+    radio?: string;
+    
+    remoteAccessEnabled?: boolean;
+    
+    remoteDebugEnabled?: boolean;
+    
+    fleetType?: string;
+    
+    fleetName?: string;
+    
+    instances?: DeviceInstance[];
+    
+    availability?: DeviceAvailability | string;
+}
+export declare namespace Device {
+    
+    const filterSensitiveLog: (obj: Device) => any;
+}
+
+export interface DeviceMinutes {
+    
+    total?: number;
+    
+    metered?: number;
+    
+    unmetered?: number;
+}
+export declare namespace DeviceMinutes {
+    
+    const filterSensitiveLog: (obj: DeviceMinutes) => any;
+}
+export declare enum ExecutionResult {
+    ERRORED = "ERRORED",
+    FAILED = "FAILED",
+    PASSED = "PASSED",
+    PENDING = "PENDING",
+    SKIPPED = "SKIPPED",
+    STOPPED = "STOPPED",
+    WARNED = "WARNED"
+}
+export declare enum ExecutionStatus {
+    COMPLETED = "COMPLETED",
+    PENDING = "PENDING",
+    PENDING_CONCURRNECY = "PENDING_CONCURRENCY",
+    PENDING_DEVICE = "PENDING_DEVICE",
+    PREPARING = "PREPARING",
+    PROCESSING = "PROCESSING",
+    RUNNING = "RUNNING",
+    SCHEDULING = "SCHEDULING",
+    STOPPING = "STOPPING"
+}
+
+export interface RemoteAccessSession {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    created?: Date;
+    
+    status?: ExecutionStatus | string;
+    
+    result?: ExecutionResult | string;
+    
+    message?: string;
+    
+    started?: Date;
+    
+    stopped?: Date;
+    
+    device?: Device;
+    
+    instanceArn?: string;
+    
+    remoteDebugEnabled?: boolean;
+    
+    remoteRecordEnabled?: boolean;
+    
+    remoteRecordAppArn?: string;
+    
+    hostAddress?: string;
+    
+    clientId?: string;
+    
+    billingMethod?: BillingMethod | string;
+    
+    deviceMinutes?: DeviceMinutes;
+    
+    endpoint?: string;
+    
+    deviceUdid?: string;
+    
+    interactionMode?: InteractionMode | string;
+    
+    skipAppResign?: boolean;
+}
+export declare namespace RemoteAccessSession {
+    
+    const filterSensitiveLog: (obj: RemoteAccessSession) => any;
+}
+
+export interface CreateRemoteAccessSessionResult {
+    
+    remoteAccessSession?: RemoteAccessSession;
+}
+export declare namespace CreateRemoteAccessSessionResult {
+    
+    const filterSensitiveLog: (obj: CreateRemoteAccessSessionResult) => any;
+}
+
+export interface TestGridVpcConfig {
+    
+    securityGroupIds: string[] | undefined;
+    
+    subnetIds: string[] | undefined;
+    
+    vpcId: string | undefined;
+}
+export declare namespace TestGridVpcConfig {
+    
+    const filterSensitiveLog: (obj: TestGridVpcConfig) => any;
+}
+export interface CreateTestGridProjectRequest {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    vpcConfig?: TestGridVpcConfig;
+}
+export declare namespace CreateTestGridProjectRequest {
+    
+    const filterSensitiveLog: (obj: CreateTestGridProjectRequest) => any;
+}
+
+export interface TestGridProject {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    description?: string;
+    
+    vpcConfig?: TestGridVpcConfig;
+    
+    created?: Date;
+}
+export declare namespace TestGridProject {
+    
+    const filterSensitiveLog: (obj: TestGridProject) => any;
+}
+export interface CreateTestGridProjectResult {
+    
+    testGridProject?: TestGridProject;
+}
+export declare namespace CreateTestGridProjectResult {
+    
+    const filterSensitiveLog: (obj: CreateTestGridProjectResult) => any;
+}
+
+export interface InternalServiceException extends __SmithyException, $MetadataBearer {
+    name: "InternalServiceException";
+    $fault: "server";
+    message?: string;
+}
+export declare namespace InternalServiceException {
+    
+    const filterSensitiveLog: (obj: InternalServiceException) => any;
+}
+export interface CreateTestGridUrlRequest {
+    
+    projectArn: string | undefined;
+    
+    expiresInSeconds: number | undefined;
+}
+export declare namespace CreateTestGridUrlRequest {
+    
+    const filterSensitiveLog: (obj: CreateTestGridUrlRequest) => any;
+}
+export interface CreateTestGridUrlResult {
+    
+    url?: string;
+    
+    expires?: Date;
+}
+export declare namespace CreateTestGridUrlResult {
+    
+    const filterSensitiveLog: (obj: CreateTestGridUrlResult) => any;
+}
+export declare enum UploadType {
+    ANDROID_APP = "ANDROID_APP",
+    APPIUM_JAVA_JUNIT_TEST_PACKAGE = "APPIUM_JAVA_JUNIT_TEST_PACKAGE",
+    APPIUM_JAVA_JUNIT_TEST_SPEC = "APPIUM_JAVA_JUNIT_TEST_SPEC",
+    APPIUM_JAVA_TESTNG_TEST_PACKAGE = "APPIUM_JAVA_TESTNG_TEST_PACKAGE",
+    APPIUM_JAVA_TESTNG_TEST_SPEC = "APPIUM_JAVA_TESTNG_TEST_SPEC",
+    APPIUM_NODE_TEST_PACKAGE = "APPIUM_NODE_TEST_PACKAGE",
+    APPIUM_NODE_TEST_SPEC = "APPIUM_NODE_TEST_SPEC",
+    APPIUM_PYTHON_TEST_PACKAGE = "APPIUM_PYTHON_TEST_PACKAGE",
+    APPIUM_PYTHON_TEST_SPEC = "APPIUM_PYTHON_TEST_SPEC",
+    APPIUM_RUBY_TEST_PACKAGE = "APPIUM_RUBY_TEST_PACKAGE",
+    APPIUM_RUBY_TEST_SPEC = "APPIUM_RUBY_TEST_SPEC",
+    APPIUM_WEB_JAVA_JUNIT_TEST_PACKAGE = "APPIUM_WEB_JAVA_JUNIT_TEST_PACKAGE",
+    APPIUM_WEB_JAVA_JUNIT_TEST_SPEC = "APPIUM_WEB_JAVA_JUNIT_TEST_SPEC",
+    APPIUM_WEB_JAVA_TESTNG_TEST_PACKAGE = "APPIUM_WEB_JAVA_TESTNG_TEST_PACKAGE",
+    APPIUM_WEB_JAVA_TESTNG_TEST_SPEC = "APPIUM_WEB_JAVA_TESTNG_TEST_SPEC",
+    APPIUM_WEB_NODE_TEST_PACKAGE = "APPIUM_WEB_NODE_TEST_PACKAGE",
+    APPIUM_WEB_NODE_TEST_SPEC = "APPIUM_WEB_NODE_TEST_SPEC",
+    APPIUM_WEB_PYTHON_TEST_PACKAGE = "APPIUM_WEB_PYTHON_TEST_PACKAGE",
+    APPIUM_WEB_PYTHON_TEST_SPEC = "APPIUM_WEB_PYTHON_TEST_SPEC",
+    APPIUM_WEB_RUBY_TEST_PACKAGE = "APPIUM_WEB_RUBY_TEST_PACKAGE",
+    APPIUM_WEB_RUBY_TEST_SPEC = "APPIUM_WEB_RUBY_TEST_SPEC",
+    CALABASH_TEST_PACKAGE = "CALABASH_TEST_PACKAGE",
+    EXTERNAL_DATA = "EXTERNAL_DATA",
+    INSTRUMENTATION_TEST_PACKAGE = "INSTRUMENTATION_TEST_PACKAGE",
+    INSTRUMENTATION_TEST_SPEC = "INSTRUMENTATION_TEST_SPEC",
+    IOS_APP = "IOS_APP",
+    UIAUTOMATION_TEST_PACKAGE = "UIAUTOMATION_TEST_PACKAGE",
+    UIAUTOMATOR_TEST_PACKAGE = "UIAUTOMATOR_TEST_PACKAGE",
+    WEB_APP = "WEB_APP",
+    XCTEST_TEST_PACKAGE = "XCTEST_TEST_PACKAGE",
+    XCTEST_UI_TEST_PACKAGE = "XCTEST_UI_TEST_PACKAGE",
+    XCTEST_UI_TEST_SPEC = "XCTEST_UI_TEST_SPEC"
+}
+
+export interface CreateUploadRequest {
+    
+    projectArn: string | undefined;
+    
+    name: string | undefined;
+    
+    type: UploadType | string | undefined;
+    
+    contentType?: string;
+}
+export declare namespace CreateUploadRequest {
+    
+    const filterSensitiveLog: (obj: CreateUploadRequest) => any;
+}
+export declare enum UploadCategory {
+    CURATED = "CURATED",
+    PRIVATE = "PRIVATE"
+}
+export declare enum UploadStatus {
+    FAILED = "FAILED",
+    INITIALIZED = "INITIALIZED",
+    PROCESSING = "PROCESSING",
+    SUCCEEDED = "SUCCEEDED"
+}
+
+export interface Upload {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    created?: Date;
+    
+    type?: UploadType | string;
+    
+    status?: UploadStatus | string;
+    
+    url?: string;
+    
+    metadata?: string;
+    
+    contentType?: string;
+    
+    message?: string;
+    
+    category?: UploadCategory | string;
+}
+export declare namespace Upload {
+    
+    const filterSensitiveLog: (obj: Upload) => any;
+}
+
+export interface CreateUploadResult {
+    
+    upload?: Upload;
+}
+export declare namespace CreateUploadResult {
+    
+    const filterSensitiveLog: (obj: CreateUploadResult) => any;
+}
+export interface CreateVPCEConfigurationRequest {
+    
+    vpceConfigurationName: string | undefined;
+    
+    vpceServiceName: string | undefined;
+    
+    serviceDnsName: string | undefined;
+    
+    vpceConfigurationDescription?: string;
+}
+export declare namespace CreateVPCEConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: CreateVPCEConfigurationRequest) => any;
+}
+
+export interface VPCEConfiguration {
+    
+    arn?: string;
+    
+    vpceConfigurationName?: string;
+    
+    vpceServiceName?: string;
+    
+    serviceDnsName?: string;
+    
+    vpceConfigurationDescription?: string;
+}
+export declare namespace VPCEConfiguration {
+    
+    const filterSensitiveLog: (obj: VPCEConfiguration) => any;
+}
+export interface CreateVPCEConfigurationResult {
+    
+    vpceConfiguration?: VPCEConfiguration;
+}
+export declare namespace CreateVPCEConfigurationResult {
+    
+    const filterSensitiveLog: (obj: CreateVPCEConfigurationResult) => any;
+}
+export declare enum CurrencyCode {
+    USD = "USD"
+}
+
+export interface CustomerArtifactPaths {
+    
+    iosPaths?: string[];
+    
+    androidPaths?: string[];
+    
+    deviceHostPaths?: string[];
+}
+export declare namespace CustomerArtifactPaths {
+    
+    const filterSensitiveLog: (obj: CustomerArtifactPaths) => any;
+}
+
+export interface DeleteDevicePoolRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace DeleteDevicePoolRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDevicePoolRequest) => any;
+}
+
+export interface DeleteDevicePoolResult {
+}
+export declare namespace DeleteDevicePoolResult {
+    
+    const filterSensitiveLog: (obj: DeleteDevicePoolResult) => any;
+}
+export interface DeleteInstanceProfileRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace DeleteInstanceProfileRequest {
+    
+    const filterSensitiveLog: (obj: DeleteInstanceProfileRequest) => any;
+}
+export interface DeleteInstanceProfileResult {
+}
+export declare namespace DeleteInstanceProfileResult {
+    
+    const filterSensitiveLog: (obj: DeleteInstanceProfileResult) => any;
+}
+export interface DeleteNetworkProfileRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace DeleteNetworkProfileRequest {
+    
+    const filterSensitiveLog: (obj: DeleteNetworkProfileRequest) => any;
+}
+export interface DeleteNetworkProfileResult {
+}
+export declare namespace DeleteNetworkProfileResult {
+    
+    const filterSensitiveLog: (obj: DeleteNetworkProfileResult) => any;
+}
+
+export interface DeleteProjectRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace DeleteProjectRequest {
+    
+    const filterSensitiveLog: (obj: DeleteProjectRequest) => any;
+}
+
+export interface DeleteProjectResult {
+}
+export declare namespace DeleteProjectResult {
+    
+    const filterSensitiveLog: (obj: DeleteProjectResult) => any;
+}
+
+export interface DeleteRemoteAccessSessionRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace DeleteRemoteAccessSessionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteRemoteAccessSessionRequest) => any;
+}
+
+export interface DeleteRemoteAccessSessionResult {
+}
+export declare namespace DeleteRemoteAccessSessionResult {
+    
+    const filterSensitiveLog: (obj: DeleteRemoteAccessSessionResult) => any;
+}
+
+export interface DeleteRunRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace DeleteRunRequest {
+    
+    const filterSensitiveLog: (obj: DeleteRunRequest) => any;
+}
+
+export interface DeleteRunResult {
+}
+export declare namespace DeleteRunResult {
+    
+    const filterSensitiveLog: (obj: DeleteRunResult) => any;
+}
+export interface DeleteTestGridProjectRequest {
+    
+    projectArn: string | undefined;
+}
+export declare namespace DeleteTestGridProjectRequest {
+    
+    const filterSensitiveLog: (obj: DeleteTestGridProjectRequest) => any;
+}
+export interface DeleteTestGridProjectResult {
+}
+export declare namespace DeleteTestGridProjectResult {
+    
+    const filterSensitiveLog: (obj: DeleteTestGridProjectResult) => any;
+}
+
+export interface DeleteUploadRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace DeleteUploadRequest {
+    
+    const filterSensitiveLog: (obj: DeleteUploadRequest) => any;
+}
+
+export interface DeleteUploadResult {
+}
+export declare namespace DeleteUploadResult {
+    
+    const filterSensitiveLog: (obj: DeleteUploadResult) => any;
+}
+export interface DeleteVPCEConfigurationRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace DeleteVPCEConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteVPCEConfigurationRequest) => any;
+}
+export interface DeleteVPCEConfigurationResult {
+}
+export declare namespace DeleteVPCEConfigurationResult {
+    
+    const filterSensitiveLog: (obj: DeleteVPCEConfigurationResult) => any;
+}
+
+export interface InvalidOperationException extends __SmithyException, $MetadataBearer {
+    name: "InvalidOperationException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace InvalidOperationException {
+    
+    const filterSensitiveLog: (obj: InvalidOperationException) => any;
+}
+
+export interface GetAccountSettingsRequest {
+}
+export declare namespace GetAccountSettingsRequest {
+    
+    const filterSensitiveLog: (obj: GetAccountSettingsRequest) => any;
+}
+
+export interface GetAccountSettingsResult {
+    
+    accountSettings?: AccountSettings;
+}
+export declare namespace GetAccountSettingsResult {
+    
+    const filterSensitiveLog: (obj: GetAccountSettingsResult) => any;
+}
+
+export interface GetDeviceRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace GetDeviceRequest {
+    
+    const filterSensitiveLog: (obj: GetDeviceRequest) => any;
+}
+
+export interface GetDeviceResult {
+    
+    device?: Device;
+}
+export declare namespace GetDeviceResult {
+    
+    const filterSensitiveLog: (obj: GetDeviceResult) => any;
+}
+export interface GetDeviceInstanceRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace GetDeviceInstanceRequest {
+    
+    const filterSensitiveLog: (obj: GetDeviceInstanceRequest) => any;
+}
+export interface GetDeviceInstanceResult {
+    
+    deviceInstance?: DeviceInstance;
+}
+export declare namespace GetDeviceInstanceResult {
+    
+    const filterSensitiveLog: (obj: GetDeviceInstanceResult) => any;
+}
+
+export interface GetDevicePoolRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace GetDevicePoolRequest {
+    
+    const filterSensitiveLog: (obj: GetDevicePoolRequest) => any;
+}
+
+export interface GetDevicePoolResult {
+    
+    devicePool?: DevicePool;
+}
+export declare namespace GetDevicePoolResult {
+    
+    const filterSensitiveLog: (obj: GetDevicePoolResult) => any;
+}
+
+export interface Location {
+    
+    latitude: number | undefined;
+    
+    longitude: number | undefined;
+}
+export declare namespace Location {
+    
+    const filterSensitiveLog: (obj: Location) => any;
+}
+
+export interface Radios {
+    
+    wifi?: boolean;
+    
+    bluetooth?: boolean;
+    
+    nfc?: boolean;
+    
+    gps?: boolean;
+}
+export declare namespace Radios {
+    
+    const filterSensitiveLog: (obj: Radios) => any;
+}
+
+export interface ScheduleRunConfiguration {
+    
+    extraDataPackageArn?: string;
+    
+    networkProfileArn?: string;
+    
+    locale?: string;
+    
+    location?: Location;
+    
+    vpceConfigurationArns?: string[];
+    
+    customerArtifactPaths?: CustomerArtifactPaths;
+    
+    radios?: Radios;
+    
+    auxiliaryApps?: string[];
+    
+    billingMethod?: BillingMethod | string;
+}
+export declare namespace ScheduleRunConfiguration {
+    
+    const filterSensitiveLog: (obj: ScheduleRunConfiguration) => any;
+}
+export declare enum TestType {
+    APPIUM_JAVA_JUNIT = "APPIUM_JAVA_JUNIT",
+    APPIUM_JAVA_TESTNG = "APPIUM_JAVA_TESTNG",
+    APPIUM_NODE = "APPIUM_NODE",
+    APPIUM_PYTHON = "APPIUM_PYTHON",
+    APPIUM_RUBY = "APPIUM_RUBY",
+    APPIUM_WEB_JAVA_JUNIT = "APPIUM_WEB_JAVA_JUNIT",
+    APPIUM_WEB_JAVA_TESTNG = "APPIUM_WEB_JAVA_TESTNG",
+    APPIUM_WEB_NODE = "APPIUM_WEB_NODE",
+    APPIUM_WEB_PYTHON = "APPIUM_WEB_PYTHON",
+    APPIUM_WEB_RUBY = "APPIUM_WEB_RUBY",
+    BUILTIN_EXPLORER = "BUILTIN_EXPLORER",
+    BUILTIN_FUZZ = "BUILTIN_FUZZ",
+    CALABASH = "CALABASH",
+    INSTRUMENTATION = "INSTRUMENTATION",
+    REMOTE_ACCESS_RECORD = "REMOTE_ACCESS_RECORD",
+    REMOTE_ACCESS_REPLAY = "REMOTE_ACCESS_REPLAY",
+    UIAUTOMATION = "UIAUTOMATION",
+    UIAUTOMATOR = "UIAUTOMATOR",
+    WEB_PERFORMANCE_PROFILE = "WEB_PERFORMANCE_PROFILE",
+    XCTEST = "XCTEST",
+    XCTEST_UI = "XCTEST_UI"
+}
+
+export interface ScheduleRunTest {
+    
+    type: TestType | string | undefined;
+    
+    testPackageArn?: string;
+    
+    testSpecArn?: string;
+    
+    filter?: string;
+    
+    parameters?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ScheduleRunTest {
+    
+    const filterSensitiveLog: (obj: ScheduleRunTest) => any;
+}
+
+export interface GetDevicePoolCompatibilityRequest {
+    
+    devicePoolArn: string | undefined;
+    
+    appArn?: string;
+    
+    testType?: TestType | string;
+    
+    test?: ScheduleRunTest;
+    
+    configuration?: ScheduleRunConfiguration;
+}
+export declare namespace GetDevicePoolCompatibilityRequest {
+    
+    const filterSensitiveLog: (obj: GetDevicePoolCompatibilityRequest) => any;
+}
+
+export interface IncompatibilityMessage {
+    
+    message?: string;
+    
+    type?: DeviceAttribute | string;
+}
+export declare namespace IncompatibilityMessage {
+    
+    const filterSensitiveLog: (obj: IncompatibilityMessage) => any;
+}
+
+export interface DevicePoolCompatibilityResult {
+    
+    device?: Device;
+    
+    compatible?: boolean;
+    
+    incompatibilityMessages?: IncompatibilityMessage[];
+}
+export declare namespace DevicePoolCompatibilityResult {
+    
+    const filterSensitiveLog: (obj: DevicePoolCompatibilityResult) => any;
+}
+
+export interface GetDevicePoolCompatibilityResult {
+    
+    compatibleDevices?: DevicePoolCompatibilityResult[];
+    
+    incompatibleDevices?: DevicePoolCompatibilityResult[];
+}
+export declare namespace GetDevicePoolCompatibilityResult {
+    
+    const filterSensitiveLog: (obj: GetDevicePoolCompatibilityResult) => any;
+}
+export interface GetInstanceProfileRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace GetInstanceProfileRequest {
+    
+    const filterSensitiveLog: (obj: GetInstanceProfileRequest) => any;
+}
+export interface GetInstanceProfileResult {
+    
+    instanceProfile?: InstanceProfile;
+}
+export declare namespace GetInstanceProfileResult {
+    
+    const filterSensitiveLog: (obj: GetInstanceProfileResult) => any;
+}
+
+export interface GetJobRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace GetJobRequest {
+    
+    const filterSensitiveLog: (obj: GetJobRequest) => any;
+}
+
+export interface Job {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    type?: TestType | string;
+    
+    created?: Date;
+    
+    status?: ExecutionStatus | string;
+    
+    result?: ExecutionResult | string;
+    
+    started?: Date;
+    
+    stopped?: Date;
+    
+    counters?: Counters;
+    
+    message?: string;
+    
+    device?: Device;
+    
+    instanceArn?: string;
+    
+    deviceMinutes?: DeviceMinutes;
+    
+    videoEndpoint?: string;
+    
+    videoCapture?: boolean;
+}
+export declare namespace Job {
+    
+    const filterSensitiveLog: (obj: Job) => any;
+}
+
+export interface GetJobResult {
+    
+    job?: Job;
+}
+export declare namespace GetJobResult {
+    
+    const filterSensitiveLog: (obj: GetJobResult) => any;
+}
+export interface GetNetworkProfileRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace GetNetworkProfileRequest {
+    
+    const filterSensitiveLog: (obj: GetNetworkProfileRequest) => any;
+}
+export interface GetNetworkProfileResult {
+    
+    networkProfile?: NetworkProfile;
+}
+export declare namespace GetNetworkProfileResult {
+    
+    const filterSensitiveLog: (obj: GetNetworkProfileResult) => any;
+}
+
+export interface GetOfferingStatusRequest {
+    
+    nextToken?: string;
+}
+export declare namespace GetOfferingStatusRequest {
+    
+    const filterSensitiveLog: (obj: GetOfferingStatusRequest) => any;
+}
+
+export interface MonetaryAmount {
+    
+    amount?: number;
+    
+    currencyCode?: CurrencyCode | string;
+}
+export declare namespace MonetaryAmount {
+    
+    const filterSensitiveLog: (obj: MonetaryAmount) => any;
+}
+export declare enum RecurringChargeFrequency {
+    MONTHLY = "MONTHLY"
+}
+
+export interface RecurringCharge {
+    
+    cost?: MonetaryAmount;
+    
+    frequency?: RecurringChargeFrequency | string;
+}
+export declare namespace RecurringCharge {
+    
+    const filterSensitiveLog: (obj: RecurringCharge) => any;
+}
+export declare enum OfferingType {
+    RECURRING = "RECURRING"
+}
+
+export interface Offering {
+    
+    id?: string;
+    
+    description?: string;
+    
+    type?: OfferingType | string;
+    
+    platform?: DevicePlatform | string;
+    
+    recurringCharges?: RecurringCharge[];
+}
+export declare namespace Offering {
+    
+    const filterSensitiveLog: (obj: Offering) => any;
+}
+export declare enum OfferingTransactionType {
+    PURCHASE = "PURCHASE",
+    RENEW = "RENEW",
+    SYSTEM = "SYSTEM"
+}
+
+export interface OfferingStatus {
+    
+    type?: OfferingTransactionType | string;
+    
+    offering?: Offering;
+    
+    quantity?: number;
+    
+    effectiveOn?: Date;
+}
+export declare namespace OfferingStatus {
+    
+    const filterSensitiveLog: (obj: OfferingStatus) => any;
+}
+
+export interface GetOfferingStatusResult {
+    
+    current?: {
+        [key: string]: OfferingStatus;
+    };
+    
+    nextPeriod?: {
+        [key: string]: OfferingStatus;
+    };
+    
+    nextToken?: string;
+}
+export declare namespace GetOfferingStatusResult {
+    
+    const filterSensitiveLog: (obj: GetOfferingStatusResult) => any;
+}
+
+export interface NotEligibleException extends __SmithyException, $MetadataBearer {
+    name: "NotEligibleException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace NotEligibleException {
+    
+    const filterSensitiveLog: (obj: NotEligibleException) => any;
+}
+
+export interface GetProjectRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace GetProjectRequest {
+    
+    const filterSensitiveLog: (obj: GetProjectRequest) => any;
+}
+
+export interface GetProjectResult {
+    
+    project?: Project;
+}
+export declare namespace GetProjectResult {
+    
+    const filterSensitiveLog: (obj: GetProjectResult) => any;
+}
+
+export interface GetRemoteAccessSessionRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace GetRemoteAccessSessionRequest {
+    
+    const filterSensitiveLog: (obj: GetRemoteAccessSessionRequest) => any;
+}
+
+export interface GetRemoteAccessSessionResult {
+    
+    remoteAccessSession?: RemoteAccessSession;
+}
+export declare namespace GetRemoteAccessSessionResult {
+    
+    const filterSensitiveLog: (obj: GetRemoteAccessSessionResult) => any;
+}
+
+export interface GetRunRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace GetRunRequest {
+    
+    const filterSensitiveLog: (obj: GetRunRequest) => any;
+}
+export declare enum DeviceFilterAttribute {
+    ARN = "ARN",
+    AVAILABILITY = "AVAILABILITY",
+    FLEET_TYPE = "FLEET_TYPE",
+    FORM_FACTOR = "FORM_FACTOR",
+    INSTANCE_ARN = "INSTANCE_ARN",
+    INSTANCE_LABELS = "INSTANCE_LABELS",
+    MANUFACTURER = "MANUFACTURER",
+    MODEL = "MODEL",
+    OS_VERSION = "OS_VERSION",
+    PLATFORM = "PLATFORM",
+    REMOTE_ACCESS_ENABLED = "REMOTE_ACCESS_ENABLED",
+    REMOTE_DEBUG_ENABLED = "REMOTE_DEBUG_ENABLED"
+}
+
+export interface DeviceFilter {
+    
+    attribute: DeviceFilterAttribute | string | undefined;
+    
+    operator: RuleOperator | string | undefined;
+    
+    values: string[] | undefined;
+}
+export declare namespace DeviceFilter {
+    
+    const filterSensitiveLog: (obj: DeviceFilter) => any;
+}
+
+export interface DeviceSelectionResult {
+    
+    filters?: DeviceFilter[];
+    
+    matchedDevicesCount?: number;
+    
+    maxDevices?: number;
+}
+export declare namespace DeviceSelectionResult {
+    
+    const filterSensitiveLog: (obj: DeviceSelectionResult) => any;
+}
+export declare enum ExecutionResultCode {
+    PARSING_FAILED = "PARSING_FAILED",
+    VPC_ENDPOINT_SETUP_FAILED = "VPC_ENDPOINT_SETUP_FAILED"
+}
+
+export interface Run {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    type?: TestType | string;
+    
+    platform?: DevicePlatform | string;
+    
+    created?: Date;
+    
+    status?: ExecutionStatus | string;
+    
+    result?: ExecutionResult | string;
+    
+    started?: Date;
+    
+    stopped?: Date;
+    
+    counters?: Counters;
+    
+    message?: string;
+    
+    totalJobs?: number;
+    
+    completedJobs?: number;
+    
+    billingMethod?: BillingMethod | string;
+    
+    deviceMinutes?: DeviceMinutes;
+    
+    networkProfile?: NetworkProfile;
+    
+    parsingResultUrl?: string;
+    
+    resultCode?: ExecutionResultCode | string;
+    
+    seed?: number;
+    
+    appUpload?: string;
+    
+    eventCount?: number;
+    
+    jobTimeoutMinutes?: number;
+    
+    devicePoolArn?: string;
+    
+    locale?: string;
+    
+    radios?: Radios;
+    
+    location?: Location;
+    
+    customerArtifactPaths?: CustomerArtifactPaths;
+    
+    webUrl?: string;
+    
+    skipAppResign?: boolean;
+    
+    testSpecArn?: string;
+    
+    deviceSelectionResult?: DeviceSelectionResult;
+}
+export declare namespace Run {
+    
+    const filterSensitiveLog: (obj: Run) => any;
+}
+
+export interface GetRunResult {
+    
+    run?: Run;
+}
+export declare namespace GetRunResult {
+    
+    const filterSensitiveLog: (obj: GetRunResult) => any;
+}
+
+export interface GetSuiteRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace GetSuiteRequest {
+    
+    const filterSensitiveLog: (obj: GetSuiteRequest) => any;
+}
+
+export interface Suite {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    type?: TestType | string;
+    
+    created?: Date;
+    
+    status?: ExecutionStatus | string;
+    
+    result?: ExecutionResult | string;
+    
+    started?: Date;
+    
+    stopped?: Date;
+    
+    counters?: Counters;
+    
+    message?: string;
+    
+    deviceMinutes?: DeviceMinutes;
+}
+export declare namespace Suite {
+    
+    const filterSensitiveLog: (obj: Suite) => any;
+}
+
+export interface GetSuiteResult {
+    
+    suite?: Suite;
+}
+export declare namespace GetSuiteResult {
+    
+    const filterSensitiveLog: (obj: GetSuiteResult) => any;
+}
+
+export interface GetTestRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace GetTestRequest {
+    
+    const filterSensitiveLog: (obj: GetTestRequest) => any;
+}
+
+export interface Test {
+    
+    arn?: string;
+    
+    name?: string;
+    
+    type?: TestType | string;
+    
+    created?: Date;
+    
+    status?: ExecutionStatus | string;
+    
+    result?: ExecutionResult | string;
+    
+    started?: Date;
+    
+    stopped?: Date;
+    
+    counters?: Counters;
+    
+    message?: string;
+    
+    deviceMinutes?: DeviceMinutes;
+}
+export declare namespace Test {
+    
+    const filterSensitiveLog: (obj: Test) => any;
+}
+
+export interface GetTestResult {
+    
+    test?: Test;
+}
+export declare namespace GetTestResult {
+    
+    const filterSensitiveLog: (obj: GetTestResult) => any;
+}
+export interface GetTestGridProjectRequest {
+    
+    projectArn: string | undefined;
+}
+export declare namespace GetTestGridProjectRequest {
+    
+    const filterSensitiveLog: (obj: GetTestGridProjectRequest) => any;
+}
+export interface GetTestGridProjectResult {
+    
+    testGridProject?: TestGridProject;
+}
+export declare namespace GetTestGridProjectResult {
+    
+    const filterSensitiveLog: (obj: GetTestGridProjectResult) => any;
+}
+export interface GetTestGridSessionRequest {
+    
+    projectArn?: string;
+    
+    sessionId?: string;
+    
+    sessionArn?: string;
+}
+export declare namespace GetTestGridSessionRequest {
+    
+    const filterSensitiveLog: (obj: GetTestGridSessionRequest) => any;
+}
+export declare enum TestGridSessionStatus {
+    ACTIVE = "ACTIVE",
+    CLOSED = "CLOSED",
+    ERRORED = "ERRORED"
+}
+
+export interface TestGridSession {
+    
+    arn?: string;
+    
+    status?: TestGridSessionStatus | string;
+    
+    created?: Date;
+    
+    ended?: Date;
+    
+    billingMinutes?: number;
+    
+    seleniumProperties?: string;
+}
+export declare namespace TestGridSession {
+    
+    const filterSensitiveLog: (obj: TestGridSession) => any;
+}
+export interface GetTestGridSessionResult {
+    
+    testGridSession?: TestGridSession;
+}
+export declare namespace GetTestGridSessionResult {
+    
+    const filterSensitiveLog: (obj: GetTestGridSessionResult) => any;
+}
+
+export interface GetUploadRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace GetUploadRequest {
+    
+    const filterSensitiveLog: (obj: GetUploadRequest) => any;
+}
+
+export interface GetUploadResult {
+    
+    upload?: Upload;
+}
+export declare namespace GetUploadResult {
+    
+    const filterSensitiveLog: (obj: GetUploadResult) => any;
+}
+export interface GetVPCEConfigurationRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace GetVPCEConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: GetVPCEConfigurationRequest) => any;
+}
+export interface GetVPCEConfigurationResult {
+    
+    vpceConfiguration?: VPCEConfiguration;
+}
+export declare namespace GetVPCEConfigurationResult {
+    
+    const filterSensitiveLog: (obj: GetVPCEConfigurationResult) => any;
+}
+
+export interface InstallToRemoteAccessSessionRequest {
+    
+    remoteAccessSessionArn: string | undefined;
+    
+    appArn: string | undefined;
+}
+export declare namespace InstallToRemoteAccessSessionRequest {
+    
+    const filterSensitiveLog: (obj: InstallToRemoteAccessSessionRequest) => any;
+}
+
+export interface InstallToRemoteAccessSessionResult {
+    
+    appUpload?: Upload;
+}
+export declare namespace InstallToRemoteAccessSessionResult {
+    
+    const filterSensitiveLog: (obj: InstallToRemoteAccessSessionResult) => any;
+}
+
+export interface ListArtifactsRequest {
+    
+    arn: string | undefined;
+    
+    type: ArtifactCategory | string | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListArtifactsRequest {
+    
+    const filterSensitiveLog: (obj: ListArtifactsRequest) => any;
+}
+
+export interface ListArtifactsResult {
+    
+    artifacts?: Artifact[];
+    
+    nextToken?: string;
+}
+export declare namespace ListArtifactsResult {
+    
+    const filterSensitiveLog: (obj: ListArtifactsResult) => any;
+}
+export interface ListDeviceInstancesRequest {
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListDeviceInstancesRequest {
+    
+    const filterSensitiveLog: (obj: ListDeviceInstancesRequest) => any;
+}
+export interface ListDeviceInstancesResult {
+    
+    deviceInstances?: DeviceInstance[];
+    
+    nextToken?: string;
+}
+export declare namespace ListDeviceInstancesResult {
+    
+    const filterSensitiveLog: (obj: ListDeviceInstancesResult) => any;
+}
+
+export interface ListDevicePoolsRequest {
+    
+    arn: string | undefined;
+    
+    type?: DevicePoolType | string;
+    
+    nextToken?: string;
+}
+export declare namespace ListDevicePoolsRequest {
+    
+    const filterSensitiveLog: (obj: ListDevicePoolsRequest) => any;
+}
+
+export interface ListDevicePoolsResult {
+    
+    devicePools?: DevicePool[];
+    
+    nextToken?: string;
+}
+export declare namespace ListDevicePoolsResult {
+    
+    const filterSensitiveLog: (obj: ListDevicePoolsResult) => any;
+}
+
+export interface ListDevicesRequest {
+    
+    arn?: string;
+    
+    nextToken?: string;
+    
+    filters?: DeviceFilter[];
+}
+export declare namespace ListDevicesRequest {
+    
+    const filterSensitiveLog: (obj: ListDevicesRequest) => any;
+}
+
+export interface ListDevicesResult {
+    
+    devices?: Device[];
+    
+    nextToken?: string;
+}
+export declare namespace ListDevicesResult {
+    
+    const filterSensitiveLog: (obj: ListDevicesResult) => any;
+}
+export interface ListInstanceProfilesRequest {
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListInstanceProfilesRequest {
+    
+    const filterSensitiveLog: (obj: ListInstanceProfilesRequest) => any;
+}
+export interface ListInstanceProfilesResult {
+    
+    instanceProfiles?: InstanceProfile[];
+    
+    nextToken?: string;
+}
+export declare namespace ListInstanceProfilesResult {
+    
+    const filterSensitiveLog: (obj: ListInstanceProfilesResult) => any;
+}
+
+export interface ListJobsRequest {
+    
+    arn: string | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListJobsRequest {
+    
+    const filterSensitiveLog: (obj: ListJobsRequest) => any;
+}
+
+export interface ListJobsResult {
+    
+    jobs?: Job[];
+    
+    nextToken?: string;
+}
+export declare namespace ListJobsResult {
+    
+    const filterSensitiveLog: (obj: ListJobsResult) => any;
+}
+export interface ListNetworkProfilesRequest {
+    
+    arn: string | undefined;
+    
+    type?: NetworkProfileType | string;
+    
+    nextToken?: string;
+}
+export declare namespace ListNetworkProfilesRequest {
+    
+    const filterSensitiveLog: (obj: ListNetworkProfilesRequest) => any;
+}
+export interface ListNetworkProfilesResult {
+    
+    networkProfiles?: NetworkProfile[];
+    
+    nextToken?: string;
+}
+export declare namespace ListNetworkProfilesResult {
+    
+    const filterSensitiveLog: (obj: ListNetworkProfilesResult) => any;
+}
+export interface ListOfferingPromotionsRequest {
+    
+    nextToken?: string;
+}
+export declare namespace ListOfferingPromotionsRequest {
+    
+    const filterSensitiveLog: (obj: ListOfferingPromotionsRequest) => any;
+}
+
+export interface OfferingPromotion {
+    
+    id?: string;
+    
+    description?: string;
+}
+export declare namespace OfferingPromotion {
+    
+    const filterSensitiveLog: (obj: OfferingPromotion) => any;
+}
+export interface ListOfferingPromotionsResult {
+    
+    offeringPromotions?: OfferingPromotion[];
+    
+    nextToken?: string;
+}
+export declare namespace ListOfferingPromotionsResult {
+    
+    const filterSensitiveLog: (obj: ListOfferingPromotionsResult) => any;
+}
+
+export interface ListOfferingsRequest {
+    
+    nextToken?: string;
+}
+export declare namespace ListOfferingsRequest {
+    
+    const filterSensitiveLog: (obj: ListOfferingsRequest) => any;
+}
+
+export interface ListOfferingsResult {
+    
+    offerings?: Offering[];
+    
+    nextToken?: string;
+}
+export declare namespace ListOfferingsResult {
+    
+    const filterSensitiveLog: (obj: ListOfferingsResult) => any;
+}
+
+export interface ListOfferingTransactionsRequest {
+    
+    nextToken?: string;
+}
+export declare namespace ListOfferingTransactionsRequest {
+    
+    const filterSensitiveLog: (obj: ListOfferingTransactionsRequest) => any;
+}
+
+export interface OfferingTransaction {
+    
+    offeringStatus?: OfferingStatus;
+    
+    transactionId?: string;
+    
+    offeringPromotionId?: string;
+    
+    createdOn?: Date;
+    
+    cost?: MonetaryAmount;
+}
+export declare namespace OfferingTransaction {
+    
+    const filterSensitiveLog: (obj: OfferingTransaction) => any;
+}
+
+export interface ListOfferingTransactionsResult {
+    
+    offeringTransactions?: OfferingTransaction[];
+    
+    nextToken?: string;
+}
+export declare namespace ListOfferingTransactionsResult {
+    
+    const filterSensitiveLog: (obj: ListOfferingTransactionsResult) => any;
+}
+
+export interface ListProjectsRequest {
+    
+    arn?: string;
+    
+    nextToken?: string;
+}
+export declare namespace ListProjectsRequest {
+    
+    const filterSensitiveLog: (obj: ListProjectsRequest) => any;
+}
+
+export interface ListProjectsResult {
+    
+    projects?: Project[];
+    
+    nextToken?: string;
+}
+export declare namespace ListProjectsResult {
+    
+    const filterSensitiveLog: (obj: ListProjectsResult) => any;
+}
+
+export interface ListRemoteAccessSessionsRequest {
+    
+    arn: string | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListRemoteAccessSessionsRequest {
+    
+    const filterSensitiveLog: (obj: ListRemoteAccessSessionsRequest) => any;
+}
+
+export interface ListRemoteAccessSessionsResult {
+    
+    remoteAccessSessions?: RemoteAccessSession[];
+    
+    nextToken?: string;
+}
+export declare namespace ListRemoteAccessSessionsResult {
+    
+    const filterSensitiveLog: (obj: ListRemoteAccessSessionsResult) => any;
+}
+
+export interface ListRunsRequest {
+    
+    arn: string | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListRunsRequest {
+    
+    const filterSensitiveLog: (obj: ListRunsRequest) => any;
+}
+
+export interface ListRunsResult {
+    
+    runs?: Run[];
+    
+    nextToken?: string;
+}
+export declare namespace ListRunsResult {
+    
+    const filterSensitiveLog: (obj: ListRunsResult) => any;
+}
+
+export interface ListSamplesRequest {
+    
+    arn: string | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListSamplesRequest {
+    
+    const filterSensitiveLog: (obj: ListSamplesRequest) => any;
+}
+export declare enum SampleType {
+    CPU = "CPU",
+    MEMORY = "MEMORY",
+    NATIVE_AVG_DRAWTIME = "NATIVE_AVG_DRAWTIME",
+    NATIVE_FPS = "NATIVE_FPS",
+    NATIVE_FRAMES = "NATIVE_FRAMES",
+    NATIVE_MAX_DRAWTIME = "NATIVE_MAX_DRAWTIME",
+    NATIVE_MIN_DRAWTIME = "NATIVE_MIN_DRAWTIME",
+    OPENGL_AVG_DRAWTIME = "OPENGL_AVG_DRAWTIME",
+    OPENGL_FPS = "OPENGL_FPS",
+    OPENGL_FRAMES = "OPENGL_FRAMES",
+    OPENGL_MAX_DRAWTIME = "OPENGL_MAX_DRAWTIME",
+    OPENGL_MIN_DRAWTIME = "OPENGL_MIN_DRAWTIME",
+    RX = "RX",
+    RX_RATE = "RX_RATE",
+    THREADS = "THREADS",
+    TX = "TX",
+    TX_RATE = "TX_RATE"
+}
+
+export interface Sample {
+    
+    arn?: string;
+    
+    type?: SampleType | string;
+    
+    url?: string;
+}
+export declare namespace Sample {
+    
+    const filterSensitiveLog: (obj: Sample) => any;
+}
+
+export interface ListSamplesResult {
+    
+    samples?: Sample[];
+    
+    nextToken?: string;
+}
+export declare namespace ListSamplesResult {
+    
+    const filterSensitiveLog: (obj: ListSamplesResult) => any;
+}
+
+export interface ListSuitesRequest {
+    
+    arn: string | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListSuitesRequest {
+    
+    const filterSensitiveLog: (obj: ListSuitesRequest) => any;
+}
+
+export interface ListSuitesResult {
+    
+    suites?: Suite[];
+    
+    nextToken?: string;
+}
+export declare namespace ListSuitesResult {
+    
+    const filterSensitiveLog: (obj: ListSuitesResult) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceARN: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: Tag[];
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface ListTestGridProjectsRequest {
+    
+    maxResult?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListTestGridProjectsRequest {
+    
+    const filterSensitiveLog: (obj: ListTestGridProjectsRequest) => any;
+}
+export interface ListTestGridProjectsResult {
+    
+    testGridProjects?: TestGridProject[];
+    
+    nextToken?: string;
+}
+export declare namespace ListTestGridProjectsResult {
+    
+    const filterSensitiveLog: (obj: ListTestGridProjectsResult) => any;
+}
+export interface ListTestGridSessionActionsRequest {
+    
+    sessionArn: string | undefined;
+    
+    maxResult?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListTestGridSessionActionsRequest {
+    
+    const filterSensitiveLog: (obj: ListTestGridSessionActionsRequest) => any;
+}
+
+export interface TestGridSessionAction {
+    
+    action?: string;
+    
+    started?: Date;
+    
+    duration?: number;
+    
+    statusCode?: string;
+    
+    requestMethod?: string;
+}
+export declare namespace TestGridSessionAction {
+    
+    const filterSensitiveLog: (obj: TestGridSessionAction) => any;
+}
+export interface ListTestGridSessionActionsResult {
+    
+    actions?: TestGridSessionAction[];
+    
+    nextToken?: string;
+}
+export declare namespace ListTestGridSessionActionsResult {
+    
+    const filterSensitiveLog: (obj: ListTestGridSessionActionsResult) => any;
+}
+export declare enum TestGridSessionArtifactCategory {
+    LOG = "LOG",
+    VIDEO = "VIDEO"
+}
+export interface ListTestGridSessionArtifactsRequest {
+    
+    sessionArn: string | undefined;
+    
+    type?: TestGridSessionArtifactCategory | string;
+    
+    maxResult?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListTestGridSessionArtifactsRequest {
+    
+    const filterSensitiveLog: (obj: ListTestGridSessionArtifactsRequest) => any;
+}
+export declare enum TestGridSessionArtifactType {
+    SELENIUM_LOG = "SELENIUM_LOG",
+    UNKNOWN = "UNKNOWN",
+    VIDEO = "VIDEO"
+}
+
+export interface TestGridSessionArtifact {
+    
+    filename?: string;
+    
+    type?: TestGridSessionArtifactType | string;
+    
+    url?: string;
+}
+export declare namespace TestGridSessionArtifact {
+    
+    const filterSensitiveLog: (obj: TestGridSessionArtifact) => any;
+}
+export interface ListTestGridSessionArtifactsResult {
+    
+    artifacts?: TestGridSessionArtifact[];
+    
+    nextToken?: string;
+}
+export declare namespace ListTestGridSessionArtifactsResult {
+    
+    const filterSensitiveLog: (obj: ListTestGridSessionArtifactsResult) => any;
+}
+export interface ListTestGridSessionsRequest {
+    
+    projectArn: string | undefined;
+    
+    status?: TestGridSessionStatus | string;
+    
+    creationTimeAfter?: Date;
+    
+    creationTimeBefore?: Date;
+    
+    endTimeAfter?: Date;
+    
+    endTimeBefore?: Date;
+    
+    maxResult?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListTestGridSessionsRequest {
+    
+    const filterSensitiveLog: (obj: ListTestGridSessionsRequest) => any;
+}
+export interface ListTestGridSessionsResult {
+    
+    testGridSessions?: TestGridSession[];
+    
+    nextToken?: string;
+}
+export declare namespace ListTestGridSessionsResult {
+    
+    const filterSensitiveLog: (obj: ListTestGridSessionsResult) => any;
+}
+
+export interface ListTestsRequest {
+    
+    arn: string | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListTestsRequest {
+    
+    const filterSensitiveLog: (obj: ListTestsRequest) => any;
+}
+
+export interface ListTestsResult {
+    
+    tests?: Test[];
+    
+    nextToken?: string;
+}
+export declare namespace ListTestsResult {
+    
+    const filterSensitiveLog: (obj: ListTestsResult) => any;
+}
+
+export interface ListUniqueProblemsRequest {
+    
+    arn: string | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListUniqueProblemsRequest {
+    
+    const filterSensitiveLog: (obj: ListUniqueProblemsRequest) => any;
+}
+
+export interface ProblemDetail {
+    
+    arn?: string;
+    
+    name?: string;
+}
+export declare namespace ProblemDetail {
+    
+    const filterSensitiveLog: (obj: ProblemDetail) => any;
+}
+
+export interface Problem {
+    
+    run?: ProblemDetail;
+    
+    job?: ProblemDetail;
+    
+    suite?: ProblemDetail;
+    
+    test?: ProblemDetail;
+    
+    device?: Device;
+    
+    result?: ExecutionResult | string;
+    
+    message?: string;
+}
+export declare namespace Problem {
+    
+    const filterSensitiveLog: (obj: Problem) => any;
+}
+
+export interface UniqueProblem {
+    
+    message?: string;
+    
+    problems?: Problem[];
+}
+export declare namespace UniqueProblem {
+    
+    const filterSensitiveLog: (obj: UniqueProblem) => any;
+}
+
+export interface ListUniqueProblemsResult {
+    
+    uniqueProblems?: {
+        [key: string]: UniqueProblem[];
+    };
+    
+    nextToken?: string;
+}
+export declare namespace ListUniqueProblemsResult {
+    
+    const filterSensitiveLog: (obj: ListUniqueProblemsResult) => any;
+}
+
+export interface ListUploadsRequest {
+    
+    arn: string | undefined;
+    
+    type?: UploadType | string;
+    
+    nextToken?: string;
+}
+export declare namespace ListUploadsRequest {
+    
+    const filterSensitiveLog: (obj: ListUploadsRequest) => any;
+}
+
+export interface ListUploadsResult {
+    
+    uploads?: Upload[];
+    
+    nextToken?: string;
+}
+export declare namespace ListUploadsResult {
+    
+    const filterSensitiveLog: (obj: ListUploadsResult) => any;
+}
+export interface ListVPCEConfigurationsRequest {
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace ListVPCEConfigurationsRequest {
+    
+    const filterSensitiveLog: (obj: ListVPCEConfigurationsRequest) => any;
+}
+export interface ListVPCEConfigurationsResult {
+    
+    vpceConfigurations?: VPCEConfiguration[];
+    
+    nextToken?: string;
+}
+export declare namespace ListVPCEConfigurationsResult {
+    
+    const filterSensitiveLog: (obj: ListVPCEConfigurationsResult) => any;
+}
+
+export interface PurchaseOfferingRequest {
+    
+    offeringId: string | undefined;
+    
+    quantity: number | undefined;
+    
+    offeringPromotionId?: string;
+}
+export declare namespace PurchaseOfferingRequest {
+    
+    const filterSensitiveLog: (obj: PurchaseOfferingRequest) => any;
+}
+
+export interface PurchaseOfferingResult {
+    
+    offeringTransaction?: OfferingTransaction;
+}
+export declare namespace PurchaseOfferingResult {
+    
+    const filterSensitiveLog: (obj: PurchaseOfferingResult) => any;
+}
+
+export interface RenewOfferingRequest {
+    
+    offeringId: string | undefined;
+    
+    quantity: number | undefined;
+}
+export declare namespace RenewOfferingRequest {
+    
+    const filterSensitiveLog: (obj: RenewOfferingRequest) => any;
+}
+
+export interface RenewOfferingResult {
+    
+    offeringTransaction?: OfferingTransaction;
+}
+export declare namespace RenewOfferingResult {
+    
+    const filterSensitiveLog: (obj: RenewOfferingResult) => any;
+}
+
+export interface IdempotencyException extends __SmithyException, $MetadataBearer {
+    name: "IdempotencyException";
+    $fault: "client";
+    
+    message?: string;
+}
+export declare namespace IdempotencyException {
+    
+    const filterSensitiveLog: (obj: IdempotencyException) => any;
+}
+
+export interface DeviceSelectionConfiguration {
+    
+    filters: DeviceFilter[] | undefined;
+    
+    maxDevices: number | undefined;
+}
+export declare namespace DeviceSelectionConfiguration {
+    
+    const filterSensitiveLog: (obj: DeviceSelectionConfiguration) => any;
+}
+
+export interface ExecutionConfiguration {
+    
+    jobTimeoutMinutes?: number;
+    
+    accountsCleanup?: boolean;
+    
+    appPackagesCleanup?: boolean;
+    
+    videoCapture?: boolean;
+    
+    skipAppResign?: boolean;
+}
+export declare namespace ExecutionConfiguration {
+    
+    const filterSensitiveLog: (obj: ExecutionConfiguration) => any;
+}
+
+export interface ScheduleRunRequest {
+    
+    projectArn: string | undefined;
+    
+    appArn?: string;
+    
+    devicePoolArn?: string;
+    
+    deviceSelectionConfiguration?: DeviceSelectionConfiguration;
+    
+    name?: string;
+    
+    test: ScheduleRunTest | undefined;
+    
+    configuration?: ScheduleRunConfiguration;
+    
+    executionConfiguration?: ExecutionConfiguration;
+}
+export declare namespace ScheduleRunRequest {
+    
+    const filterSensitiveLog: (obj: ScheduleRunRequest) => any;
+}
+
+export interface ScheduleRunResult {
+    
+    run?: Run;
+}
+export declare namespace ScheduleRunResult {
+    
+    const filterSensitiveLog: (obj: ScheduleRunResult) => any;
+}
+export interface StopJobRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace StopJobRequest {
+    
+    const filterSensitiveLog: (obj: StopJobRequest) => any;
+}
+export interface StopJobResult {
+    
+    job?: Job;
+}
+export declare namespace StopJobResult {
+    
+    const filterSensitiveLog: (obj: StopJobResult) => any;
+}
+
+export interface StopRemoteAccessSessionRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace StopRemoteAccessSessionRequest {
+    
+    const filterSensitiveLog: (obj: StopRemoteAccessSessionRequest) => any;
+}
+
+export interface StopRemoteAccessSessionResult {
+    
+    remoteAccessSession?: RemoteAccessSession;
+}
+export declare namespace StopRemoteAccessSessionResult {
+    
+    const filterSensitiveLog: (obj: StopRemoteAccessSessionResult) => any;
+}
+
+export interface StopRunRequest {
+    
+    arn: string | undefined;
+}
+export declare namespace StopRunRequest {
+    
+    const filterSensitiveLog: (obj: StopRunRequest) => any;
+}
+
+export interface StopRunResult {
+    
+    run?: Run;
+}
+export declare namespace StopRunResult {
+    
+    const filterSensitiveLog: (obj: StopRunResult) => any;
+}
+
+export interface TagPolicyException extends __SmithyException, $MetadataBearer {
+    name: "TagPolicyException";
+    $fault: "client";
+    message?: string;
+    resourceName?: string;
+}
+export declare namespace TagPolicyException {
+    
+    const filterSensitiveLog: (obj: TagPolicyException) => 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 TooManyTagsException extends __SmithyException, $MetadataBearer {
+    name: "TooManyTagsException";
+    $fault: "client";
+    message?: string;
+    resourceName?: string;
+}
+export declare namespace TooManyTagsException {
+    
+    const filterSensitiveLog: (obj: TooManyTagsException) => 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 UpdateDeviceInstanceRequest {
+    
+    arn: string | undefined;
+    
+    profileArn?: string;
+    
+    labels?: string[];
+}
+export declare namespace UpdateDeviceInstanceRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDeviceInstanceRequest) => any;
+}
+export interface UpdateDeviceInstanceResult {
+    
+    deviceInstance?: DeviceInstance;
+}
+export declare namespace UpdateDeviceInstanceResult {
+    
+    const filterSensitiveLog: (obj: UpdateDeviceInstanceResult) => any;
+}
+
+export interface UpdateDevicePoolRequest {
+    
+    arn: string | undefined;
+    
+    name?: string;
+    
+    description?: string;
+    
+    rules?: Rule[];
+    
+    maxDevices?: number;
+    
+    clearMaxDevices?: boolean;
+}
+export declare namespace UpdateDevicePoolRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDevicePoolRequest) => any;
+}
+
+export interface UpdateDevicePoolResult {
+    
+    devicePool?: DevicePool;
+}
+export declare namespace UpdateDevicePoolResult {
+    
+    const filterSensitiveLog: (obj: UpdateDevicePoolResult) => any;
+}
+export interface UpdateInstanceProfileRequest {
+    
+    arn: string | undefined;
+    
+    name?: string;
+    
+    description?: string;
+    
+    packageCleanup?: boolean;
+    
+    excludeAppPackagesFromCleanup?: string[];
+    
+    rebootAfterUse?: boolean;
+}
+export declare namespace UpdateInstanceProfileRequest {
+    
+    const filterSensitiveLog: (obj: UpdateInstanceProfileRequest) => any;
+}
+export interface UpdateInstanceProfileResult {
+    
+    instanceProfile?: InstanceProfile;
+}
+export declare namespace UpdateInstanceProfileResult {
+    
+    const filterSensitiveLog: (obj: UpdateInstanceProfileResult) => any;
+}
+export interface UpdateNetworkProfileRequest {
+    
+    arn: string | undefined;
+    
+    name?: string;
+    
+    description?: string;
+    
+    type?: NetworkProfileType | string;
+    
+    uplinkBandwidthBits?: number;
+    
+    downlinkBandwidthBits?: number;
+    
+    uplinkDelayMs?: number;
+    
+    downlinkDelayMs?: number;
+    
+    uplinkJitterMs?: number;
+    
+    downlinkJitterMs?: number;
+    
+    uplinkLossPercent?: number;
+    
+    downlinkLossPercent?: number;
+}
+export declare namespace UpdateNetworkProfileRequest {
+    
+    const filterSensitiveLog: (obj: UpdateNetworkProfileRequest) => any;
+}
+export interface UpdateNetworkProfileResult {
+    
+    networkProfile?: NetworkProfile;
+}
+export declare namespace UpdateNetworkProfileResult {
+    
+    const filterSensitiveLog: (obj: UpdateNetworkProfileResult) => any;
+}
+
+export interface UpdateProjectRequest {
+    
+    arn: string | undefined;
+    
+    name?: string;
+    
+    defaultJobTimeoutMinutes?: number;
+}
+export declare namespace UpdateProjectRequest {
+    
+    const filterSensitiveLog: (obj: UpdateProjectRequest) => any;
+}
+
+export interface UpdateProjectResult {
+    
+    project?: Project;
+}
+export declare namespace UpdateProjectResult {
+    
+    const filterSensitiveLog: (obj: UpdateProjectResult) => any;
+}
+export interface UpdateTestGridProjectRequest {
+    
+    projectArn: string | undefined;
+    
+    name?: string;
+    
+    description?: string;
+    
+    vpcConfig?: TestGridVpcConfig;
+}
+export declare namespace UpdateTestGridProjectRequest {
+    
+    const filterSensitiveLog: (obj: UpdateTestGridProjectRequest) => any;
+}
+export interface UpdateTestGridProjectResult {
+    
+    testGridProject?: TestGridProject;
+}
+export declare namespace UpdateTestGridProjectResult {
+    
+    const filterSensitiveLog: (obj: UpdateTestGridProjectResult) => any;
+}
+export interface UpdateUploadRequest {
+    
+    arn: string | undefined;
+    
+    name?: string;
+    
+    contentType?: string;
+    
+    editContent?: boolean;
+}
+export declare namespace UpdateUploadRequest {
+    
+    const filterSensitiveLog: (obj: UpdateUploadRequest) => any;
+}
+export interface UpdateUploadResult {
+    
+    upload?: Upload;
+}
+export declare namespace UpdateUploadResult {
+    
+    const filterSensitiveLog: (obj: UpdateUploadResult) => any;
+}
+export interface UpdateVPCEConfigurationRequest {
+    
+    arn: string | undefined;
+    
+    vpceConfigurationName?: string;
+    
+    vpceServiceName?: string;
+    
+    serviceDnsName?: string;
+    
+    vpceConfigurationDescription?: string;
+}
+export declare namespace UpdateVPCEConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: UpdateVPCEConfigurationRequest) => any;
+}
+export interface UpdateVPCEConfigurationResult {
+    
+    vpceConfiguration?: VPCEConfiguration;
+}
+export declare namespace UpdateVPCEConfigurationResult {
+    
+    const filterSensitiveLog: (obj: UpdateVPCEConfigurationResult) => any;
+}