@aws-sdk/client-iotfleetwise 3.934.0 → 3.936.0

package/dist-types/models/enums.d.ts

@@ -0,0 +1,480 @@
+/**
+ * @public
+ * @enum
+ */
+export declare const NodeDataType: {
+    readonly BOOLEAN: "BOOLEAN";
+    readonly BOOLEAN_ARRAY: "BOOLEAN_ARRAY";
+    readonly DOUBLE: "DOUBLE";
+    readonly DOUBLE_ARRAY: "DOUBLE_ARRAY";
+    readonly FLOAT: "FLOAT";
+    readonly FLOAT_ARRAY: "FLOAT_ARRAY";
+    readonly INT16: "INT16";
+    readonly INT16_ARRAY: "INT16_ARRAY";
+    readonly INT32: "INT32";
+    readonly INT32_ARRAY: "INT32_ARRAY";
+    readonly INT64: "INT64";
+    readonly INT64_ARRAY: "INT64_ARRAY";
+    readonly INT8: "INT8";
+    readonly INT8_ARRAY: "INT8_ARRAY";
+    readonly STRING: "STRING";
+    readonly STRING_ARRAY: "STRING_ARRAY";
+    readonly STRUCT: "STRUCT";
+    readonly STRUCT_ARRAY: "STRUCT_ARRAY";
+    readonly UINT16: "UINT16";
+    readonly UINT16_ARRAY: "UINT16_ARRAY";
+    readonly UINT32: "UINT32";
+    readonly UINT32_ARRAY: "UINT32_ARRAY";
+    readonly UINT64: "UINT64";
+    readonly UINT64_ARRAY: "UINT64_ARRAY";
+    readonly UINT8: "UINT8";
+    readonly UINT8_ARRAY: "UINT8_ARRAY";
+    readonly UNIX_TIMESTAMP: "UNIX_TIMESTAMP";
+    readonly UNIX_TIMESTAMP_ARRAY: "UNIX_TIMESTAMP_ARRAY";
+    readonly UNKNOWN: "UNKNOWN";
+};
+/**
+ * @public
+ */
+export type NodeDataType = (typeof NodeDataType)[keyof typeof NodeDataType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ValidationExceptionReason: {
+    readonly CANNOT_PARSE: "cannotParse";
+    readonly FIELD_VALIDATION_FAILED: "fieldValidationFailed";
+    readonly OTHER: "other";
+    readonly UNKNOWN_OPERATION: "unknownOperation";
+};
+/**
+ * @public
+ */
+export type ValidationExceptionReason = (typeof ValidationExceptionReason)[keyof typeof ValidationExceptionReason];
+/**
+ * @public
+ * @enum
+ */
+export declare const VehicleAssociationBehavior: {
+    readonly CREATE_IOT_THING: "CreateIotThing";
+    readonly VALIDATE_IOT_THING_EXISTS: "ValidateIotThingExists";
+};
+/**
+ * @public
+ */
+export type VehicleAssociationBehavior = (typeof VehicleAssociationBehavior)[keyof typeof VehicleAssociationBehavior];
+/**
+ * @public
+ * @enum
+ */
+export declare const TimeUnit: {
+    readonly HOUR: "HOUR";
+    readonly MILLISECOND: "MILLISECOND";
+    readonly MINUTE: "MINUTE";
+    readonly SECOND: "SECOND";
+};
+/**
+ * @public
+ */
+export type TimeUnit = (typeof TimeUnit)[keyof typeof TimeUnit];
+/**
+ * @public
+ * @enum
+ */
+export declare const UpdateMode: {
+    readonly MERGE: "Merge";
+    readonly OVERWRITE: "Overwrite";
+};
+/**
+ * @public
+ */
+export type UpdateMode = (typeof UpdateMode)[keyof typeof UpdateMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const TriggerMode: {
+    readonly ALWAYS: "ALWAYS";
+    readonly RISING_EDGE: "RISING_EDGE";
+};
+/**
+ * @public
+ */
+export type TriggerMode = (typeof TriggerMode)[keyof typeof TriggerMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const Compression: {
+    readonly OFF: "OFF";
+    readonly SNAPPY: "SNAPPY";
+};
+/**
+ * @public
+ */
+export type Compression = (typeof Compression)[keyof typeof Compression];
+/**
+ * @public
+ * @enum
+ */
+export declare const DataFormat: {
+    readonly JSON: "JSON";
+    readonly PARQUET: "PARQUET";
+};
+/**
+ * @public
+ */
+export type DataFormat = (typeof DataFormat)[keyof typeof DataFormat];
+/**
+ * @public
+ * @enum
+ */
+export declare const StorageCompressionFormat: {
+    readonly GZIP: "GZIP";
+    readonly NONE: "NONE";
+};
+/**
+ * @public
+ */
+export type StorageCompressionFormat = (typeof StorageCompressionFormat)[keyof typeof StorageCompressionFormat];
+/**
+ * @public
+ * @enum
+ */
+export declare const StorageMaximumSizeUnit: {
+    readonly GB: "GB";
+    readonly MB: "MB";
+    readonly TB: "TB";
+};
+/**
+ * @public
+ */
+export type StorageMaximumSizeUnit = (typeof StorageMaximumSizeUnit)[keyof typeof StorageMaximumSizeUnit];
+/**
+ * @public
+ * @enum
+ */
+export declare const StorageMinimumTimeToLiveUnit: {
+    readonly DAYS: "DAYS";
+    readonly HOURS: "HOURS";
+    readonly WEEKS: "WEEKS";
+};
+/**
+ * @public
+ */
+export type StorageMinimumTimeToLiveUnit = (typeof StorageMinimumTimeToLiveUnit)[keyof typeof StorageMinimumTimeToLiveUnit];
+/**
+ * @public
+ * @enum
+ */
+export declare const DiagnosticsMode: {
+    readonly OFF: "OFF";
+    readonly SEND_ACTIVE_DTCS: "SEND_ACTIVE_DTCS";
+};
+/**
+ * @public
+ */
+export type DiagnosticsMode = (typeof DiagnosticsMode)[keyof typeof DiagnosticsMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const SpoolingMode: {
+    readonly OFF: "OFF";
+    readonly TO_DISK: "TO_DISK";
+};
+/**
+ * @public
+ */
+export type SpoolingMode = (typeof SpoolingMode)[keyof typeof SpoolingMode];
+/**
+ * @public
+ * @enum
+ */
+export declare const CampaignStatus: {
+    readonly CREATING: "CREATING";
+    readonly RUNNING: "RUNNING";
+    readonly SUSPENDED: "SUSPENDED";
+    readonly WAITING_FOR_APPROVAL: "WAITING_FOR_APPROVAL";
+};
+/**
+ * @public
+ */
+export type CampaignStatus = (typeof CampaignStatus)[keyof typeof CampaignStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const ListResponseScope: {
+    readonly METADATA_ONLY: "METADATA_ONLY";
+};
+/**
+ * @public
+ */
+export type ListResponseScope = (typeof ListResponseScope)[keyof typeof ListResponseScope];
+/**
+ * @public
+ * @enum
+ */
+export declare const UpdateCampaignAction: {
+    readonly APPROVE: "APPROVE";
+    readonly RESUME: "RESUME";
+    readonly SUSPEND: "SUSPEND";
+    readonly UPDATE: "UPDATE";
+};
+/**
+ * @public
+ */
+export type UpdateCampaignAction = (typeof UpdateCampaignAction)[keyof typeof UpdateCampaignAction];
+/**
+ * @public
+ * @enum
+ */
+export declare const SignalValueType: {
+    readonly FLOATING_POINT: "FLOATING_POINT";
+    readonly INTEGER: "INTEGER";
+};
+/**
+ * @public
+ */
+export type SignalValueType = (typeof SignalValueType)[keyof typeof SignalValueType];
+/**
+ * @public
+ * @enum
+ */
+export declare const LogType: {
+    readonly ERROR: "ERROR";
+    readonly OFF: "OFF";
+};
+/**
+ * @public
+ */
+export type LogType = (typeof LogType)[keyof typeof LogType];
+/**
+ * @public
+ * @enum
+ */
+export declare const DefaultForUnmappedSignalsType: {
+    readonly CUSTOM_DECODING: "CUSTOM_DECODING";
+};
+/**
+ * @public
+ */
+export type DefaultForUnmappedSignalsType = (typeof DefaultForUnmappedSignalsType)[keyof typeof DefaultForUnmappedSignalsType];
+/**
+ * @public
+ * @enum
+ */
+export declare const NetworkInterfaceType: {
+    readonly CAN_INTERFACE: "CAN_INTERFACE";
+    readonly CUSTOM_DECODING_INTERFACE: "CUSTOM_DECODING_INTERFACE";
+    readonly OBD_INTERFACE: "OBD_INTERFACE";
+    readonly VEHICLE_MIDDLEWARE: "VEHICLE_MIDDLEWARE";
+};
+/**
+ * @public
+ */
+export type NetworkInterfaceType = (typeof NetworkInterfaceType)[keyof typeof NetworkInterfaceType];
+/**
+ * @public
+ * @enum
+ */
+export declare const VehicleMiddlewareProtocol: {
+    readonly ROS_2: "ROS_2";
+};
+/**
+ * @public
+ */
+export type VehicleMiddlewareProtocol = (typeof VehicleMiddlewareProtocol)[keyof typeof VehicleMiddlewareProtocol];
+/**
+ * @public
+ * @enum
+ */
+export declare const ROS2PrimitiveType: {
+    readonly BOOL: "BOOL";
+    readonly BYTE: "BYTE";
+    readonly CHAR: "CHAR";
+    readonly FLOAT32: "FLOAT32";
+    readonly FLOAT64: "FLOAT64";
+    readonly INT16: "INT16";
+    readonly INT32: "INT32";
+    readonly INT64: "INT64";
+    readonly INT8: "INT8";
+    readonly STRING: "STRING";
+    readonly UINT16: "UINT16";
+    readonly UINT32: "UINT32";
+    readonly UINT64: "UINT64";
+    readonly UINT8: "UINT8";
+    readonly WSTRING: "WSTRING";
+};
+/**
+ * @public
+ */
+export type ROS2PrimitiveType = (typeof ROS2PrimitiveType)[keyof typeof ROS2PrimitiveType];
+/**
+ * @public
+ * @enum
+ */
+export declare const StructuredMessageListType: {
+    readonly DYNAMIC_BOUNDED_CAPACITY: "DYNAMIC_BOUNDED_CAPACITY";
+    readonly DYNAMIC_UNBOUNDED_CAPACITY: "DYNAMIC_UNBOUNDED_CAPACITY";
+    readonly FIXED_CAPACITY: "FIXED_CAPACITY";
+};
+/**
+ * @public
+ */
+export type StructuredMessageListType = (typeof StructuredMessageListType)[keyof typeof StructuredMessageListType];
+/**
+ * @public
+ * @enum
+ */
+export declare const SignalDecoderType: {
+    readonly CAN_SIGNAL: "CAN_SIGNAL";
+    readonly CUSTOM_DECODING_SIGNAL: "CUSTOM_DECODING_SIGNAL";
+    readonly MESSAGE_SIGNAL: "MESSAGE_SIGNAL";
+    readonly OBD_SIGNAL: "OBD_SIGNAL";
+};
+/**
+ * @public
+ */
+export type SignalDecoderType = (typeof SignalDecoderType)[keyof typeof SignalDecoderType];
+/**
+ * @public
+ * @enum
+ */
+export declare const NetworkInterfaceFailureReason: {
+    readonly CAN_NETWORK_INTERFACE_INFO_IS_NULL: "CAN_NETWORK_INTERFACE_INFO_IS_NULL";
+    readonly CONFLICTING_NETWORK_INTERFACE: "CONFLICTING_NETWORK_INTERFACE";
+    readonly CUSTOM_DECODING_SIGNAL_NETWORK_INTERFACE_INFO_IS_NULL: "CUSTOM_DECODING_SIGNAL_NETWORK_INTERFACE_INFO_IS_NULL";
+    readonly DUPLICATE_INTERFACE: "DUPLICATE_NETWORK_INTERFACE";
+    readonly NETWORK_INTERFACE_TO_ADD_ALREADY_EXISTS: "NETWORK_INTERFACE_TO_ADD_ALREADY_EXISTS";
+    readonly NETWORK_INTERFACE_TO_REMOVE_ASSOCIATED_WITH_SIGNALS: "NETWORK_INTERFACE_TO_REMOVE_ASSOCIATED_WITH_SIGNALS";
+    readonly OBD_NETWORK_INTERFACE_INFO_IS_NULL: "OBD_NETWORK_INTERFACE_INFO_IS_NULL";
+    readonly VEHICLE_MIDDLEWARE_NETWORK_INTERFACE_INFO_IS_NULL: "VEHICLE_MIDDLEWARE_NETWORK_INTERFACE_INFO_IS_NULL";
+};
+/**
+ * @public
+ */
+export type NetworkInterfaceFailureReason = (typeof NetworkInterfaceFailureReason)[keyof typeof NetworkInterfaceFailureReason];
+/**
+ * @public
+ * @enum
+ */
+export declare const SignalDecoderFailureReason: {
+    readonly CAN_SIGNAL_INFO_IS_NULL: "CAN_SIGNAL_INFO_IS_NULL";
+    readonly CONFLICTING_SIGNAL: "CONFLICTING_SIGNAL";
+    readonly CUSTOM_DECODING_SIGNAL_INFO_IS_NULL: "CUSTOM_DECODING_SIGNAL_INFO_IS_NULL";
+    readonly DUPLICATE_SIGNAL: "DUPLICATE_SIGNAL";
+    readonly EMPTY_MESSAGE_SIGNAL: "EMPTY_MESSAGE_SIGNAL";
+    readonly MESSAGE_SIGNAL_INFO_IS_NULL: "MESSAGE_SIGNAL_INFO_IS_NULL";
+    readonly NETWORK_INTERFACE_TYPE_INCOMPATIBLE_WITH_SIGNAL_DECODER_TYPE: "NETWORK_INTERFACE_TYPE_INCOMPATIBLE_WITH_SIGNAL_DECODER_TYPE";
+    readonly NO_DECODER_INFO_FOR_SIGNAL_IN_MODEL: "NO_DECODER_INFO_FOR_SIGNAL_IN_MODEL";
+    readonly NO_SIGNAL_IN_CATALOG_FOR_DECODER_SIGNAL: "NO_SIGNAL_IN_CATALOG_FOR_DECODER_SIGNAL";
+    readonly OBD_SIGNAL_INFO_IS_NULL: "OBD_SIGNAL_INFO_IS_NULL";
+    readonly SIGNAL_DECODER_INCOMPATIBLE_WITH_SIGNAL_CATALOG: "SIGNAL_DECODER_INCOMPATIBLE_WITH_SIGNAL_CATALOG";
+    readonly SIGNAL_DECODER_TYPE_INCOMPATIBLE_WITH_MESSAGE_SIGNAL_TYPE: "SIGNAL_DECODER_TYPE_INCOMPATIBLE_WITH_MESSAGE_SIGNAL_TYPE";
+    readonly SIGNAL_NOT_ASSOCIATED_WITH_NETWORK_INTERFACE: "SIGNAL_NOT_ASSOCIATED_WITH_NETWORK_INTERFACE";
+    readonly SIGNAL_NOT_IN_MODEL: "SIGNAL_NOT_IN_MODEL";
+    readonly SIGNAL_TO_ADD_ALREADY_EXISTS: "SIGNAL_TO_ADD_ALREADY_EXISTS";
+    readonly STRUCT_SIZE_MISMATCH: "STRUCT_SIZE_MISMATCH";
+};
+/**
+ * @public
+ */
+export type SignalDecoderFailureReason = (typeof SignalDecoderFailureReason)[keyof typeof SignalDecoderFailureReason];
+/**
+ * @public
+ * @enum
+ */
+export declare const NodeDataEncoding: {
+    readonly BINARY: "BINARY";
+    readonly TYPED: "TYPED";
+};
+/**
+ * @public
+ */
+export type NodeDataEncoding = (typeof NodeDataEncoding)[keyof typeof NodeDataEncoding];
+/**
+ * @public
+ * @enum
+ */
+export declare const ManifestStatus: {
+    readonly ACTIVE: "ACTIVE";
+    readonly DRAFT: "DRAFT";
+    readonly INVALID: "INVALID";
+    readonly VALIDATING: "VALIDATING";
+};
+/**
+ * @public
+ */
+export type ManifestStatus = (typeof ManifestStatus)[keyof typeof ManifestStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const EncryptionStatus: {
+    readonly FAILURE: "FAILURE";
+    readonly PENDING: "PENDING";
+    readonly SUCCESS: "SUCCESS";
+};
+/**
+ * @public
+ */
+export type EncryptionStatus = (typeof EncryptionStatus)[keyof typeof EncryptionStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const EncryptionType: {
+    readonly FLEETWISE_DEFAULT_ENCRYPTION: "FLEETWISE_DEFAULT_ENCRYPTION";
+    readonly KMS_BASED_ENCRYPTION: "KMS_BASED_ENCRYPTION";
+};
+/**
+ * @public
+ */
+export type EncryptionType = (typeof EncryptionType)[keyof typeof EncryptionType];
+/**
+ * @public
+ * @enum
+ */
+export declare const RegistrationStatus: {
+    readonly REGISTRATION_FAILURE: "REGISTRATION_FAILURE";
+    readonly REGISTRATION_PENDING: "REGISTRATION_PENDING";
+    readonly REGISTRATION_SUCCESS: "REGISTRATION_SUCCESS";
+};
+/**
+ * @public
+ */
+export type RegistrationStatus = (typeof RegistrationStatus)[keyof typeof RegistrationStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const VehicleState: {
+    readonly CREATED: "CREATED";
+    readonly DELETING: "DELETING";
+    readonly HEALTHY: "HEALTHY";
+    readonly READY: "READY";
+    readonly READY_FOR_CHECKIN: "READY_FOR_CHECKIN";
+    readonly SUSPENDED: "SUSPENDED";
+};
+/**
+ * @public
+ */
+export type VehicleState = (typeof VehicleState)[keyof typeof VehicleState];
+/**
+ * @public
+ * @enum
+ */
+export declare const SignalNodeType: {
+    readonly ACTUATOR: "ACTUATOR";
+    readonly ATTRIBUTE: "ATTRIBUTE";
+    readonly BRANCH: "BRANCH";
+    readonly CUSTOM_PROPERTY: "CUSTOM_PROPERTY";
+    readonly CUSTOM_STRUCT: "CUSTOM_STRUCT";
+    readonly SENSOR: "SENSOR";
+};
+/**
+ * @public
+ */
+export type SignalNodeType = (typeof SignalNodeType)[keyof typeof SignalNodeType];

package/dist-types/models/errors.d.ts

@@ -0,0 +1,216 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { ValidationExceptionReason } from "./enums";
+import { IoTFleetWiseServiceException as __BaseException } from "./IoTFleetWiseServiceException";
+import { InvalidNetworkInterface, InvalidSignal, InvalidSignalDecoder, Node, ValidationExceptionField } from "./models_0";
+/**
+ * <p>You don't have sufficient permission to perform this action.</p>
+ * @public
+ */
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+/**
+ * <p>The request couldn't be completed because the server temporarily failed.</p>
+ * @public
+ */
+export declare class InternalServerException extends __BaseException {
+    readonly name: "InternalServerException";
+    readonly $fault: "server";
+    /**
+     * <p>The number of seconds to wait before retrying the command.</p>
+     * @public
+     */
+    retryAfterSeconds?: number | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InternalServerException, __BaseException>);
+}
+/**
+ * <p>A service quota was exceeded. </p>
+ * @public
+ */
+export declare class LimitExceededException extends __BaseException {
+    readonly name: "LimitExceededException";
+    readonly $fault: "client";
+    /**
+     * <p>The identifier of the resource that was exceeded.</p>
+     * @public
+     */
+    resourceId: string | undefined;
+    /**
+     * <p>The type of resource that was exceeded.</p>
+     * @public
+     */
+    resourceType: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<LimitExceededException, __BaseException>);
+}
+/**
+ * <p>The resource wasn't found.</p>
+ * @public
+ */
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    /**
+     * <p>The identifier of the resource that wasn't found.</p>
+     * @public
+     */
+    resourceId: string | undefined;
+    /**
+     * <p>The type of resource that wasn't found.</p>
+     * @public
+     */
+    resourceType: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+/**
+ * <p>The request couldn't be completed due to throttling.</p>
+ * @public
+ */
+export declare class ThrottlingException extends __BaseException {
+    readonly name: "ThrottlingException";
+    readonly $fault: "client";
+    /**
+     * <p>The quota identifier of the applied throttling rules for this request.</p>
+     * @public
+     */
+    quotaCode?: string | undefined;
+    /**
+     * <p>The code for the service that couldn't be completed due to throttling.</p>
+     * @public
+     */
+    serviceCode?: string | undefined;
+    /**
+     * <p>The number of seconds to wait before retrying the command.</p>
+     * @public
+     */
+    retryAfterSeconds?: number | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ThrottlingException, __BaseException>);
+}
+/**
+ * <p>The input fails to satisfy the constraints specified by an Amazon Web Services service.</p>
+ * @public
+ */
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    /**
+     * <p>The reason the input failed to satisfy the constraints specified by an Amazon Web Services
+     *             service.</p>
+     * @public
+     */
+    reason?: ValidationExceptionReason | undefined;
+    /**
+     * <p>The list of fields that fail to satisfy the constraints specified by an Amazon Web Services
+     *             service.</p>
+     * @public
+     */
+    fieldList?: ValidationExceptionField[] | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+/**
+ * <p>The request has conflicting operations. This can occur if you're trying to perform
+ *             more than one operation on the same resource at the same time.</p>
+ * @public
+ */
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    /**
+     * <p>The resource on which there are conflicting operations.</p>
+     * @public
+     */
+    resource: string | undefined;
+    /**
+     * <p>The type of resource on which there are conflicting operations..</p>
+     * @public
+     */
+    resourceType: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
+/**
+ * <p>The request couldn't be completed because it contains signal decoders with one or more
+ *             validation errors.</p>
+ * @public
+ */
+export declare class DecoderManifestValidationException extends __BaseException {
+    readonly name: "DecoderManifestValidationException";
+    readonly $fault: "client";
+    /**
+     * <p>The request couldn't be completed because of invalid signals in the request.</p>
+     * @public
+     */
+    invalidSignals?: InvalidSignalDecoder[] | undefined;
+    /**
+     * <p>The request couldn't be completed because of invalid network interfaces in the
+     *             request.</p>
+     * @public
+     */
+    invalidNetworkInterfaces?: InvalidNetworkInterface[] | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<DecoderManifestValidationException, __BaseException>);
+}
+/**
+ * <p>The request couldn't be completed because it contains signals that aren't
+ *             valid.</p>
+ * @public
+ */
+export declare class InvalidSignalsException extends __BaseException {
+    readonly name: "InvalidSignalsException";
+    readonly $fault: "client";
+    /**
+     * <p>The signals which caused the exception.</p>
+     * @public
+     */
+    invalidSignals?: InvalidSignal[] | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidSignalsException, __BaseException>);
+}
+/**
+ * <p>The specified node type doesn't match the expected node type for a node. You can
+ *             specify the node type as branch, sensor, actuator, or attribute.</p>
+ * @public
+ */
+export declare class InvalidNodeException extends __BaseException {
+    readonly name: "InvalidNodeException";
+    readonly $fault: "client";
+    /**
+     * <p>The specified node type isn't valid.</p>
+     * @public
+     */
+    invalidNodes?: Node[] | undefined;
+    /**
+     * <p>The reason the node validation failed.</p>
+     * @public
+     */
+    reason?: string | undefined;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<InvalidNodeException, __BaseException>);
+}