@aws-sdk/client-iotfleetwise 3.179.0

package/dist-types/commands/DeleteDecoderManifestCommand.d.ts

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTFleetWiseClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTFleetWiseClient";
+import { DeleteDecoderManifestRequest, DeleteDecoderManifestResponse } from "../models/models_0";
+export interface DeleteDecoderManifestCommandInput extends DeleteDecoderManifestRequest {
+}
+export interface DeleteDecoderManifestCommandOutput extends DeleteDecoderManifestResponse, __MetadataBearer {
+}
+/**
+ * <p> Deletes a decoder manifest. You can't delete a decoder manifest if it has vehicles
+ *             associated with it. </p>
+ *         <note>
+ *             <p>If the decoder manifest is successfully deleted, Amazon Web Services IoT FleetWise sends back an HTTP 200
+ *                 response with an empty body.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, DeleteDecoderManifestCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, DeleteDecoderManifestCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new DeleteDecoderManifestCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteDecoderManifestCommandInput} for command's `input` shape.
+ * @see {@link DeleteDecoderManifestCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class DeleteDecoderManifestCommand extends $Command<DeleteDecoderManifestCommandInput, DeleteDecoderManifestCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: DeleteDecoderManifestCommandInput;
+    constructor(input: DeleteDecoderManifestCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDecoderManifestCommandInput, DeleteDecoderManifestCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteFleetCommand.d.ts

@@ -0,0 +1,41 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTFleetWiseClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTFleetWiseClient";
+import { DeleteFleetRequest, DeleteFleetResponse } from "../models/models_0";
+export interface DeleteFleetCommandInput extends DeleteFleetRequest {
+}
+export interface DeleteFleetCommandOutput extends DeleteFleetResponse, __MetadataBearer {
+}
+/**
+ * <p> Deletes a fleet. Before you delete a fleet, all vehicles must be
+ *             dissociated from the fleet. For more information, see <a href="https://docs.aws.amazon.com/iot-fleetwise/latest/developerguide/delete-fleet-cli.html">Delete a fleet (AWS
+ *                 CLI)</a> in the <i>Amazon Web Services IoT FleetWise Developer Guide</i>.</p>
+ *         <note>
+ *             <p>If the fleet is successfully deleted, Amazon Web Services IoT FleetWise sends back an HTTP 200 response
+ *                 with an empty body.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, DeleteFleetCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, DeleteFleetCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new DeleteFleetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteFleetCommandInput} for command's `input` shape.
+ * @see {@link DeleteFleetCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class DeleteFleetCommand extends $Command<DeleteFleetCommandInput, DeleteFleetCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: DeleteFleetCommandInput;
+    constructor(input: DeleteFleetCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFleetCommandInput, DeleteFleetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteModelManifestCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTFleetWiseClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTFleetWiseClient";
+import { DeleteModelManifestRequest, DeleteModelManifestResponse } from "../models/models_0";
+export interface DeleteModelManifestCommandInput extends DeleteModelManifestRequest {
+}
+export interface DeleteModelManifestCommandOutput extends DeleteModelManifestResponse, __MetadataBearer {
+}
+/**
+ * <p> Deletes a vehicle model (model manifest).</p>
+ *         <note>
+ *             <p>If the vehicle model is successfully deleted, Amazon Web Services IoT FleetWise sends back an HTTP 200
+ *                 response with an empty body.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, DeleteModelManifestCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, DeleteModelManifestCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new DeleteModelManifestCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteModelManifestCommandInput} for command's `input` shape.
+ * @see {@link DeleteModelManifestCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class DeleteModelManifestCommand extends $Command<DeleteModelManifestCommandInput, DeleteModelManifestCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: DeleteModelManifestCommandInput;
+    constructor(input: DeleteModelManifestCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteModelManifestCommandInput, DeleteModelManifestCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteSignalCatalogCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTFleetWiseClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTFleetWiseClient";
+import { DeleteSignalCatalogRequest, DeleteSignalCatalogResponse } from "../models/models_0";
+export interface DeleteSignalCatalogCommandInput extends DeleteSignalCatalogRequest {
+}
+export interface DeleteSignalCatalogCommandOutput extends DeleteSignalCatalogResponse, __MetadataBearer {
+}
+/**
+ * <p> Deletes a signal catalog. </p>
+ *         <note>
+ *             <p>If the signal catalog is successfully deleted, Amazon Web Services IoT FleetWise sends back an HTTP 200
+ *                 response with an empty body.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, DeleteSignalCatalogCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, DeleteSignalCatalogCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new DeleteSignalCatalogCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteSignalCatalogCommandInput} for command's `input` shape.
+ * @see {@link DeleteSignalCatalogCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class DeleteSignalCatalogCommand extends $Command<DeleteSignalCatalogCommandInput, DeleteSignalCatalogCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: DeleteSignalCatalogCommandInput;
+    constructor(input: DeleteSignalCatalogCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteSignalCatalogCommandInput, DeleteSignalCatalogCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteVehicleCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTFleetWiseClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTFleetWiseClient";
+import { DeleteVehicleRequest, DeleteVehicleResponse } from "../models/models_0";
+export interface DeleteVehicleCommandInput extends DeleteVehicleRequest {
+}
+export interface DeleteVehicleCommandOutput extends DeleteVehicleResponse, __MetadataBearer {
+}
+/**
+ * <p> Deletes a vehicle and removes it from any campaigns.</p>
+ *         <note>
+ *             <p>If the vehicle is successfully deleted, Amazon Web Services IoT FleetWise sends back an HTTP 200 response
+ *                 with an empty body.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, DeleteVehicleCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, DeleteVehicleCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new DeleteVehicleCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteVehicleCommandInput} for command's `input` shape.
+ * @see {@link DeleteVehicleCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class DeleteVehicleCommand extends $Command<DeleteVehicleCommandInput, DeleteVehicleCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: DeleteVehicleCommandInput;
+    constructor(input: DeleteVehicleCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteVehicleCommandInput, DeleteVehicleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DisassociateVehicleFleetCommand.d.ts

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTFleetWiseClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTFleetWiseClient";
+import { DisassociateVehicleFleetRequest, DisassociateVehicleFleetResponse } from "../models/models_0";
+export interface DisassociateVehicleFleetCommandInput extends DisassociateVehicleFleetRequest {
+}
+export interface DisassociateVehicleFleetCommandOutput extends DisassociateVehicleFleetResponse, __MetadataBearer {
+}
+/**
+ * <p>Removes, or disassociates, a vehicle from a fleet. Disassociating a vehicle from a
+ *             fleet doesn't delete the vehicle.</p>
+ *         <note>
+ *             <p>If the vehicle is successfully dissociated from a fleet, Amazon Web Services IoT FleetWise sends back an
+ *                 HTTP 200 response with an empty body.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, DisassociateVehicleFleetCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, DisassociateVehicleFleetCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new DisassociateVehicleFleetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DisassociateVehicleFleetCommandInput} for command's `input` shape.
+ * @see {@link DisassociateVehicleFleetCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class DisassociateVehicleFleetCommand extends $Command<DisassociateVehicleFleetCommandInput, DisassociateVehicleFleetCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: DisassociateVehicleFleetCommandInput;
+    constructor(input: DisassociateVehicleFleetCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisassociateVehicleFleetCommandInput, DisassociateVehicleFleetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetCampaignCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTFleetWiseClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTFleetWiseClient";
+import { GetCampaignRequest, GetCampaignResponse } from "../models/models_0";
+export interface GetCampaignCommandInput extends GetCampaignRequest {
+}
+export interface GetCampaignCommandOutput extends GetCampaignResponse, __MetadataBearer {
+}
+/**
+ * <p> Retrieves information about a campaign. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, GetCampaignCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, GetCampaignCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new GetCampaignCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCampaignCommandInput} for command's `input` shape.
+ * @see {@link GetCampaignCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class GetCampaignCommand extends $Command<GetCampaignCommandInput, GetCampaignCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: GetCampaignCommandInput;
+    constructor(input: GetCampaignCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCampaignCommandInput, GetCampaignCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetDecoderManifestCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTFleetWiseClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTFleetWiseClient";
+import { GetDecoderManifestRequest, GetDecoderManifestResponse } from "../models/models_0";
+export interface GetDecoderManifestCommandInput extends GetDecoderManifestRequest {
+}
+export interface GetDecoderManifestCommandOutput extends GetDecoderManifestResponse, __MetadataBearer {
+}
+/**
+ * <p> Retrieves information about a created decoder manifest. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, GetDecoderManifestCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, GetDecoderManifestCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new GetDecoderManifestCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDecoderManifestCommandInput} for command's `input` shape.
+ * @see {@link GetDecoderManifestCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class GetDecoderManifestCommand extends $Command<GetDecoderManifestCommandInput, GetDecoderManifestCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: GetDecoderManifestCommandInput;
+    constructor(input: GetDecoderManifestCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDecoderManifestCommandInput, GetDecoderManifestCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetFleetCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTFleetWiseClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTFleetWiseClient";
+import { GetFleetRequest, GetFleetResponse } from "../models/models_0";
+export interface GetFleetCommandInput extends GetFleetRequest {
+}
+export interface GetFleetCommandOutput extends GetFleetResponse, __MetadataBearer {
+}
+/**
+ * <p> Retrieves information about a fleet. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, GetFleetCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, GetFleetCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new GetFleetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetFleetCommandInput} for command's `input` shape.
+ * @see {@link GetFleetCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class GetFleetCommand extends $Command<GetFleetCommandInput, GetFleetCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: GetFleetCommandInput;
+    constructor(input: GetFleetCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFleetCommandInput, GetFleetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetLoggingOptionsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTFleetWiseClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTFleetWiseClient";
+import { GetLoggingOptionsRequest, GetLoggingOptionsResponse } from "../models/models_0";
+export interface GetLoggingOptionsCommandInput extends GetLoggingOptionsRequest {
+}
+export interface GetLoggingOptionsCommandOutput extends GetLoggingOptionsResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves the logging options.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, GetLoggingOptionsCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, GetLoggingOptionsCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new GetLoggingOptionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetLoggingOptionsCommandInput} for command's `input` shape.
+ * @see {@link GetLoggingOptionsCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class GetLoggingOptionsCommand extends $Command<GetLoggingOptionsCommandInput, GetLoggingOptionsCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: GetLoggingOptionsCommandInput;
+    constructor(input: GetLoggingOptionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLoggingOptionsCommandInput, GetLoggingOptionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetModelManifestCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTFleetWiseClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTFleetWiseClient";
+import { GetModelManifestRequest, GetModelManifestResponse } from "../models/models_0";
+export interface GetModelManifestCommandInput extends GetModelManifestRequest {
+}
+export interface GetModelManifestCommandOutput extends GetModelManifestResponse, __MetadataBearer {
+}
+/**
+ * <p> Retrieves information about a vehicle model (model manifest). </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, GetModelManifestCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, GetModelManifestCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new GetModelManifestCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetModelManifestCommandInput} for command's `input` shape.
+ * @see {@link GetModelManifestCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class GetModelManifestCommand extends $Command<GetModelManifestCommandInput, GetModelManifestCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: GetModelManifestCommandInput;
+    constructor(input: GetModelManifestCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetModelManifestCommandInput, GetModelManifestCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetRegisterAccountStatusCommand.d.ts

@@ -0,0 +1,41 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTFleetWiseClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTFleetWiseClient";
+import { GetRegisterAccountStatusRequest, GetRegisterAccountStatusResponse } from "../models/models_0";
+export interface GetRegisterAccountStatusCommandInput extends GetRegisterAccountStatusRequest {
+}
+export interface GetRegisterAccountStatusCommandOutput extends GetRegisterAccountStatusResponse, __MetadataBearer {
+}
+/**
+ * <p> Retrieves information about the status of registering your Amazon Web Services account, IAM, and
+ *             Amazon Timestream resources so that Amazon Web Services IoT FleetWise can transfer your vehicle data to the Amazon Web Services
+ *             Cloud. </p>
+ *         <p>For more information, including step-by-step procedures, see <a href="https://docs.aws.amazon.com/iot-fleetwise/latest/developerguide/setting-up.html">Setting up Amazon Web Services IoT FleetWise</a>. </p>
+ *         <note>
+ *             <p>This API operation doesn't require input parameters.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, GetRegisterAccountStatusCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, GetRegisterAccountStatusCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new GetRegisterAccountStatusCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetRegisterAccountStatusCommandInput} for command's `input` shape.
+ * @see {@link GetRegisterAccountStatusCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class GetRegisterAccountStatusCommand extends $Command<GetRegisterAccountStatusCommandInput, GetRegisterAccountStatusCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: GetRegisterAccountStatusCommandInput;
+    constructor(input: GetRegisterAccountStatusCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRegisterAccountStatusCommandInput, GetRegisterAccountStatusCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetSignalCatalogCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTFleetWiseClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTFleetWiseClient";
+import { GetSignalCatalogRequest, GetSignalCatalogResponse } from "../models/models_0";
+export interface GetSignalCatalogCommandInput extends GetSignalCatalogRequest {
+}
+export interface GetSignalCatalogCommandOutput extends GetSignalCatalogResponse, __MetadataBearer {
+}
+/**
+ * <p> Retrieves information about a signal catalog. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, GetSignalCatalogCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, GetSignalCatalogCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new GetSignalCatalogCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSignalCatalogCommandInput} for command's `input` shape.
+ * @see {@link GetSignalCatalogCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class GetSignalCatalogCommand extends $Command<GetSignalCatalogCommandInput, GetSignalCatalogCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: GetSignalCatalogCommandInput;
+    constructor(input: GetSignalCatalogCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSignalCatalogCommandInput, GetSignalCatalogCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetVehicleCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTFleetWiseClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTFleetWiseClient";
+import { GetVehicleRequest, GetVehicleResponse } from "../models/models_0";
+export interface GetVehicleCommandInput extends GetVehicleRequest {
+}
+export interface GetVehicleCommandOutput extends GetVehicleResponse, __MetadataBearer {
+}
+/**
+ * <p> Retrieves information about a vehicle. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, GetVehicleCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, GetVehicleCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new GetVehicleCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetVehicleCommandInput} for command's `input` shape.
+ * @see {@link GetVehicleCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class GetVehicleCommand extends $Command<GetVehicleCommandInput, GetVehicleCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: GetVehicleCommandInput;
+    constructor(input: GetVehicleCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetVehicleCommandInput, GetVehicleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetVehicleStatusCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTFleetWiseClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTFleetWiseClient";
+import { GetVehicleStatusRequest, GetVehicleStatusResponse } from "../models/models_0";
+export interface GetVehicleStatusCommandInput extends GetVehicleStatusRequest {
+}
+export interface GetVehicleStatusCommandOutput extends GetVehicleStatusResponse, __MetadataBearer {
+}
+/**
+ * <p> Retrieves information about the status of a vehicle with any associated campaigns.
+ *         </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, GetVehicleStatusCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, GetVehicleStatusCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new GetVehicleStatusCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetVehicleStatusCommandInput} for command's `input` shape.
+ * @see {@link GetVehicleStatusCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class GetVehicleStatusCommand extends $Command<GetVehicleStatusCommandInput, GetVehicleStatusCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: GetVehicleStatusCommandInput;
+    constructor(input: GetVehicleStatusCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetVehicleStatusCommandInput, GetVehicleStatusCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ImportDecoderManifestCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { IoTFleetWiseClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../IoTFleetWiseClient";
+import { ImportDecoderManifestRequest, ImportDecoderManifestResponse } from "../models/models_0";
+export interface ImportDecoderManifestCommandInput extends ImportDecoderManifestRequest {
+}
+export interface ImportDecoderManifestCommandOutput extends ImportDecoderManifestResponse, __MetadataBearer {
+}
+/**
+ * <p> Creates a decoder manifest using your existing CAN DBC file from your local device.
+ *         </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, ImportDecoderManifestCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, ImportDecoderManifestCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new ImportDecoderManifestCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ImportDecoderManifestCommandInput} for command's `input` shape.
+ * @see {@link ImportDecoderManifestCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class ImportDecoderManifestCommand extends $Command<ImportDecoderManifestCommandInput, ImportDecoderManifestCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: ImportDecoderManifestCommandInput;
+    constructor(input: ImportDecoderManifestCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportDecoderManifestCommandInput, ImportDecoderManifestCommandOutput>;
+    private serialize;
+    private deserialize;
+}