@aws-sdk/client-iotfleetwise 3.179.0

package/dist-types/commands/ImportSignalCatalogCommand.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 { ImportSignalCatalogRequest, ImportSignalCatalogResponse } from "../models/models_0";
+export interface ImportSignalCatalogCommandInput extends ImportSignalCatalogRequest {
+}
+export interface ImportSignalCatalogCommandOutput extends ImportSignalCatalogResponse, __MetadataBearer {
+}
+/**
+ * <p> Creates a signal catalog using your existing VSS formatted content from your local
+ *             device. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, ImportSignalCatalogCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, ImportSignalCatalogCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new ImportSignalCatalogCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ImportSignalCatalogCommandInput} for command's `input` shape.
+ * @see {@link ImportSignalCatalogCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class ImportSignalCatalogCommand extends $Command<ImportSignalCatalogCommandInput, ImportSignalCatalogCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: ImportSignalCatalogCommandInput;
+    constructor(input: ImportSignalCatalogCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportSignalCatalogCommandInput, ImportSignalCatalogCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+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 { ListCampaignsRequest, ListCampaignsResponse } from "../models/models_0";
+export interface ListCampaignsCommandInput extends ListCampaignsRequest {
+}
+export interface ListCampaignsCommandOutput extends ListCampaignsResponse, __MetadataBearer {
+}
+/**
+ * <p> Lists information about created campaigns. </p>
+ *         <note>
+ *             <p>This API operation uses pagination. Specify the <code>nextToken</code> parameter in the request to return more results.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, ListCampaignsCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, ListCampaignsCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new ListCampaignsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListCampaignsCommandInput} for command's `input` shape.
+ * @see {@link ListCampaignsCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class ListCampaignsCommand extends $Command<ListCampaignsCommandInput, ListCampaignsCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: ListCampaignsCommandInput;
+    constructor(input: ListCampaignsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListCampaignsCommandInput, ListCampaignsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+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 { ListDecoderManifestNetworkInterfacesRequest, ListDecoderManifestNetworkInterfacesResponse } from "../models/models_0";
+export interface ListDecoderManifestNetworkInterfacesCommandInput extends ListDecoderManifestNetworkInterfacesRequest {
+}
+export interface ListDecoderManifestNetworkInterfacesCommandOutput extends ListDecoderManifestNetworkInterfacesResponse, __MetadataBearer {
+}
+/**
+ * <p> Lists the network interfaces specified in a decoder manifest. </p>
+ *         <note>
+ *             <p>This API operation uses pagination. Specify the <code>nextToken</code> parameter in the request to return more results.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, ListDecoderManifestNetworkInterfacesCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, ListDecoderManifestNetworkInterfacesCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new ListDecoderManifestNetworkInterfacesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListDecoderManifestNetworkInterfacesCommandInput} for command's `input` shape.
+ * @see {@link ListDecoderManifestNetworkInterfacesCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class ListDecoderManifestNetworkInterfacesCommand extends $Command<ListDecoderManifestNetworkInterfacesCommandInput, ListDecoderManifestNetworkInterfacesCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: ListDecoderManifestNetworkInterfacesCommandInput;
+    constructor(input: ListDecoderManifestNetworkInterfacesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDecoderManifestNetworkInterfacesCommandInput, ListDecoderManifestNetworkInterfacesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+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 { ListDecoderManifestSignalsRequest, ListDecoderManifestSignalsResponse } from "../models/models_0";
+export interface ListDecoderManifestSignalsCommandInput extends ListDecoderManifestSignalsRequest {
+}
+export interface ListDecoderManifestSignalsCommandOutput extends ListDecoderManifestSignalsResponse, __MetadataBearer {
+}
+/**
+ * <p> A list of information about signal decoders specified in a decoder manifest. </p>
+ *         <note>
+ *             <p>This API operation uses pagination. Specify the <code>nextToken</code> parameter in the request to return more results.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, ListDecoderManifestSignalsCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, ListDecoderManifestSignalsCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new ListDecoderManifestSignalsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListDecoderManifestSignalsCommandInput} for command's `input` shape.
+ * @see {@link ListDecoderManifestSignalsCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class ListDecoderManifestSignalsCommand extends $Command<ListDecoderManifestSignalsCommandInput, ListDecoderManifestSignalsCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: ListDecoderManifestSignalsCommandInput;
+    constructor(input: ListDecoderManifestSignalsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDecoderManifestSignalsCommandInput, ListDecoderManifestSignalsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+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 { ListDecoderManifestsRequest, ListDecoderManifestsResponse } from "../models/models_0";
+export interface ListDecoderManifestsCommandInput extends ListDecoderManifestsRequest {
+}
+export interface ListDecoderManifestsCommandOutput extends ListDecoderManifestsResponse, __MetadataBearer {
+}
+/**
+ * <p> Lists decoder manifests. </p>
+ *         <note>
+ *             <p>This API operation uses pagination. Specify the <code>nextToken</code> parameter in the request to return more results.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, ListDecoderManifestsCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, ListDecoderManifestsCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new ListDecoderManifestsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListDecoderManifestsCommandInput} for command's `input` shape.
+ * @see {@link ListDecoderManifestsCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class ListDecoderManifestsCommand extends $Command<ListDecoderManifestsCommandInput, ListDecoderManifestsCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: ListDecoderManifestsCommandInput;
+    constructor(input: ListDecoderManifestsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDecoderManifestsCommandInput, ListDecoderManifestsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+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 { ListFleetsRequest, ListFleetsResponse } from "../models/models_0";
+export interface ListFleetsCommandInput extends ListFleetsRequest {
+}
+export interface ListFleetsCommandOutput extends ListFleetsResponse, __MetadataBearer {
+}
+/**
+ * <p> Retrieves information for each created fleet in an Amazon Web Services account. </p>
+ *         <note>
+ *             <p>This API operation uses pagination. Specify the <code>nextToken</code> parameter in the request to return more results.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, ListFleetsCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, ListFleetsCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new ListFleetsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListFleetsCommandInput} for command's `input` shape.
+ * @see {@link ListFleetsCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class ListFleetsCommand extends $Command<ListFleetsCommandInput, ListFleetsCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: ListFleetsCommandInput;
+    constructor(input: ListFleetsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFleetsCommandInput, ListFleetsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+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 { ListFleetsForVehicleRequest, ListFleetsForVehicleResponse } from "../models/models_0";
+export interface ListFleetsForVehicleCommandInput extends ListFleetsForVehicleRequest {
+}
+export interface ListFleetsForVehicleCommandOutput extends ListFleetsForVehicleResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves a list of IDs for all fleets that the vehicle is associated with.</p>
+ *         <note>
+ *             <p>This API operation uses pagination. Specify the <code>nextToken</code> parameter in the request to return more results.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, ListFleetsForVehicleCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, ListFleetsForVehicleCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new ListFleetsForVehicleCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListFleetsForVehicleCommandInput} for command's `input` shape.
+ * @see {@link ListFleetsForVehicleCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class ListFleetsForVehicleCommand extends $Command<ListFleetsForVehicleCommandInput, ListFleetsForVehicleCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: ListFleetsForVehicleCommandInput;
+    constructor(input: ListFleetsForVehicleCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFleetsForVehicleCommandInput, ListFleetsForVehicleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+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 { ListModelManifestNodesRequest, ListModelManifestNodesResponse } from "../models/models_0";
+export interface ListModelManifestNodesCommandInput extends ListModelManifestNodesRequest {
+}
+export interface ListModelManifestNodesCommandOutput extends ListModelManifestNodesResponse, __MetadataBearer {
+}
+/**
+ * <p> Lists information about nodes specified in a vehicle model (model manifest). </p>
+ *         <note>
+ *             <p>This API operation uses pagination. Specify the <code>nextToken</code> parameter in the request to return more results.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, ListModelManifestNodesCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, ListModelManifestNodesCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new ListModelManifestNodesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListModelManifestNodesCommandInput} for command's `input` shape.
+ * @see {@link ListModelManifestNodesCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class ListModelManifestNodesCommand extends $Command<ListModelManifestNodesCommandInput, ListModelManifestNodesCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: ListModelManifestNodesCommandInput;
+    constructor(input: ListModelManifestNodesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListModelManifestNodesCommandInput, ListModelManifestNodesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+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 { ListModelManifestsRequest, ListModelManifestsResponse } from "../models/models_0";
+export interface ListModelManifestsCommandInput extends ListModelManifestsRequest {
+}
+export interface ListModelManifestsCommandOutput extends ListModelManifestsResponse, __MetadataBearer {
+}
+/**
+ * <p> Retrieves a list of vehicle models (model manifests). </p>
+ *         <note>
+ *             <p>This API operation uses pagination. Specify the <code>nextToken</code> parameter in the request to return more results.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, ListModelManifestsCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, ListModelManifestsCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new ListModelManifestsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListModelManifestsCommandInput} for command's `input` shape.
+ * @see {@link ListModelManifestsCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class ListModelManifestsCommand extends $Command<ListModelManifestsCommandInput, ListModelManifestsCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: ListModelManifestsCommandInput;
+    constructor(input: ListModelManifestsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListModelManifestsCommandInput, ListModelManifestsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+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 { ListSignalCatalogNodesRequest, ListSignalCatalogNodesResponse } from "../models/models_0";
+export interface ListSignalCatalogNodesCommandInput extends ListSignalCatalogNodesRequest {
+}
+export interface ListSignalCatalogNodesCommandOutput extends ListSignalCatalogNodesResponse, __MetadataBearer {
+}
+/**
+ * <p> Lists of information about the signals (nodes) specified in a signal catalog. </p>
+ *         <note>
+ *             <p>This API operation uses pagination. Specify the <code>nextToken</code> parameter in the request to return more results.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, ListSignalCatalogNodesCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, ListSignalCatalogNodesCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new ListSignalCatalogNodesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListSignalCatalogNodesCommandInput} for command's `input` shape.
+ * @see {@link ListSignalCatalogNodesCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class ListSignalCatalogNodesCommand extends $Command<ListSignalCatalogNodesCommandInput, ListSignalCatalogNodesCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: ListSignalCatalogNodesCommandInput;
+    constructor(input: ListSignalCatalogNodesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSignalCatalogNodesCommandInput, ListSignalCatalogNodesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListSignalCatalogsCommand.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 { ListSignalCatalogsRequest, ListSignalCatalogsResponse } from "../models/models_0";
+export interface ListSignalCatalogsCommandInput extends ListSignalCatalogsRequest {
+}
+export interface ListSignalCatalogsCommandOutput extends ListSignalCatalogsResponse, __MetadataBearer {
+}
+/**
+ * <p> Lists all the created signal catalogs in an Amazon Web Services account. </p>
+ *         <p>You can use  to list information about
+ *             each signal (node) specified in a signal catalog.</p>
+ *         <note>
+ *             <p>This API operation uses pagination. Specify the <code>nextToken</code> parameter in the request to return more results.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, ListSignalCatalogsCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, ListSignalCatalogsCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new ListSignalCatalogsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListSignalCatalogsCommandInput} for command's `input` shape.
+ * @see {@link ListSignalCatalogsCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class ListSignalCatalogsCommand extends $Command<ListSignalCatalogsCommandInput, ListSignalCatalogsCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: ListSignalCatalogsCommandInput;
+    constructor(input: ListSignalCatalogsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSignalCatalogsCommandInput, ListSignalCatalogsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListTagsForResourceCommand.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 { ListTagsForResourceRequest, ListTagsForResourceResponse } from "../models/models_0";
+export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequest {
+}
+export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the tags (metadata) you have assigned to the resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, ListTagsForResourceCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, ListTagsForResourceCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new ListTagsForResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
+ * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: ListTagsForResourceCommandInput;
+    constructor(input: ListTagsForResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+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 { ListVehiclesRequest, ListVehiclesResponse } from "../models/models_0";
+export interface ListVehiclesCommandInput extends ListVehiclesRequest {
+}
+export interface ListVehiclesCommandOutput extends ListVehiclesResponse, __MetadataBearer {
+}
+/**
+ * <p> Retrieves a list of summaries of created vehicles. </p>
+ *         <note>
+ *             <p>This API operation uses pagination. Specify the <code>nextToken</code> parameter in the request to return more results.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, ListVehiclesCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, ListVehiclesCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new ListVehiclesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListVehiclesCommandInput} for command's `input` shape.
+ * @see {@link ListVehiclesCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class ListVehiclesCommand extends $Command<ListVehiclesCommandInput, ListVehiclesCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: ListVehiclesCommandInput;
+    constructor(input: ListVehiclesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListVehiclesCommandInput, ListVehiclesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+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 { ListVehiclesInFleetRequest, ListVehiclesInFleetResponse } from "../models/models_0";
+export interface ListVehiclesInFleetCommandInput extends ListVehiclesInFleetRequest {
+}
+export interface ListVehiclesInFleetCommandOutput extends ListVehiclesInFleetResponse, __MetadataBearer {
+}
+/**
+ * <p> Retrieves a list of summaries of all vehicles associated with a fleet. </p>
+ *         <note>
+ *             <p>This API operation uses pagination. Specify the <code>nextToken</code> parameter in the request to return more results.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, ListVehiclesInFleetCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, ListVehiclesInFleetCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new ListVehiclesInFleetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListVehiclesInFleetCommandInput} for command's `input` shape.
+ * @see {@link ListVehiclesInFleetCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class ListVehiclesInFleetCommand extends $Command<ListVehiclesInFleetCommandInput, ListVehiclesInFleetCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: ListVehiclesInFleetCommandInput;
+    constructor(input: ListVehiclesInFleetCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListVehiclesInFleetCommandInput, ListVehiclesInFleetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/PutLoggingOptionsCommand.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 { PutLoggingOptionsRequest, PutLoggingOptionsResponse } from "../models/models_0";
+export interface PutLoggingOptionsCommandInput extends PutLoggingOptionsRequest {
+}
+export interface PutLoggingOptionsCommandOutput extends PutLoggingOptionsResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates or updates the logging option.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, PutLoggingOptionsCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, PutLoggingOptionsCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new PutLoggingOptionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link PutLoggingOptionsCommandInput} for command's `input` shape.
+ * @see {@link PutLoggingOptionsCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class PutLoggingOptionsCommand extends $Command<PutLoggingOptionsCommandInput, PutLoggingOptionsCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: PutLoggingOptionsCommandInput;
+    constructor(input: PutLoggingOptionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutLoggingOptionsCommandInput, PutLoggingOptionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,45 @@
+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 { RegisterAccountRequest, RegisterAccountResponse } from "../models/models_0";
+export interface RegisterAccountCommandInput extends RegisterAccountRequest {
+}
+export interface RegisterAccountCommandOutput extends RegisterAccountResponse, __MetadataBearer {
+}
+/**
+ * <p>Registers your Amazon Web Services account, IAM, and Amazon Timestream resources so Amazon Web Services IoT FleetWise can
+ *             transfer your vehicle data to the Amazon Web Services Cloud. 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>An Amazon Web Services account is <b>not</b> the same thing as a "user
+ *                 account". An <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_identity-management.html#intro-identity-users">Amazon Web Services user</a> is an identity that you create using Identity and Access Management (IAM) and
+ *                 takes the form of either an <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html">IAM user</a> or an <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html">IAM role, both
+ *                     with credentials</a>. A single Amazon Web Services account can, and typically does,
+ *                 contain many users and roles.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { IoTFleetWiseClient, RegisterAccountCommand } from "@aws-sdk/client-iotfleetwise"; // ES Modules import
+ * // const { IoTFleetWiseClient, RegisterAccountCommand } = require("@aws-sdk/client-iotfleetwise"); // CommonJS import
+ * const client = new IoTFleetWiseClient(config);
+ * const command = new RegisterAccountCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RegisterAccountCommandInput} for command's `input` shape.
+ * @see {@link RegisterAccountCommandOutput} for command's `response` shape.
+ * @see {@link IoTFleetWiseClientResolvedConfig | config} for IoTFleetWiseClient's `config` shape.
+ *
+ */
+export declare class RegisterAccountCommand extends $Command<RegisterAccountCommandInput, RegisterAccountCommandOutput, IoTFleetWiseClientResolvedConfig> {
+    readonly input: RegisterAccountCommandInput;
+    constructor(input: RegisterAccountCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: IoTFleetWiseClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RegisterAccountCommandInput, RegisterAccountCommandOutput>;
+    private serialize;
+    private deserialize;
+}