@aws-sdk/client-greengrass 3.31.0 → 3.35.0

package/dist-types/commands/GetGroupCertificateConfigurationCommand.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 { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetGroupCertificateConfigurationRequest, GetGroupCertificateConfigurationResponse } from "../models/models_0";
+export interface GetGroupCertificateConfigurationCommandInput extends GetGroupCertificateConfigurationRequest {
+}
+export interface GetGroupCertificateConfigurationCommandOutput extends GetGroupCertificateConfigurationResponse, __MetadataBearer {
+}
+/**
+ * Retrieves the current configuration for the CA used by the group.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetGroupCertificateConfigurationCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetGroupCertificateConfigurationCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetGroupCertificateConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetGroupCertificateConfigurationCommandInput} for command's `input` shape.
+ * @see {@link GetGroupCertificateConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetGroupCertificateConfigurationCommand extends $Command<GetGroupCertificateConfigurationCommandInput, GetGroupCertificateConfigurationCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetGroupCertificateConfigurationCommandInput;
+    constructor(input: GetGroupCertificateConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetGroupCertificateConfigurationCommandInput, GetGroupCertificateConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetGroupCommand.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 { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetGroupRequest, GetGroupResponse } from "../models/models_0";
+export interface GetGroupCommandInput extends GetGroupRequest {
+}
+export interface GetGroupCommandOutput extends GetGroupResponse, __MetadataBearer {
+}
+/**
+ * Retrieves information about a group.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetGroupCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetGroupCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetGroupCommandInput} for command's `input` shape.
+ * @see {@link GetGroupCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetGroupCommand extends $Command<GetGroupCommandInput, GetGroupCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetGroupCommandInput;
+    constructor(input: GetGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetGroupCommandInput, GetGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetGroupVersionCommand.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 { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetGroupVersionRequest, GetGroupVersionResponse } from "../models/models_0";
+export interface GetGroupVersionCommandInput extends GetGroupVersionRequest {
+}
+export interface GetGroupVersionCommandOutput extends GetGroupVersionResponse, __MetadataBearer {
+}
+/**
+ * Retrieves information about a group version.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetGroupVersionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetGroupVersionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetGroupVersionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetGroupVersionCommandInput} for command's `input` shape.
+ * @see {@link GetGroupVersionCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetGroupVersionCommand extends $Command<GetGroupVersionCommandInput, GetGroupVersionCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetGroupVersionCommandInput;
+    constructor(input: GetGroupVersionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetGroupVersionCommandInput, GetGroupVersionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetLoggerDefinitionCommand.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 { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetLoggerDefinitionRequest, GetLoggerDefinitionResponse } from "../models/models_0";
+export interface GetLoggerDefinitionCommandInput extends GetLoggerDefinitionRequest {
+}
+export interface GetLoggerDefinitionCommandOutput extends GetLoggerDefinitionResponse, __MetadataBearer {
+}
+/**
+ * Retrieves information about a logger definition.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetLoggerDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetLoggerDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetLoggerDefinitionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetLoggerDefinitionCommandInput} for command's `input` shape.
+ * @see {@link GetLoggerDefinitionCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetLoggerDefinitionCommand extends $Command<GetLoggerDefinitionCommandInput, GetLoggerDefinitionCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetLoggerDefinitionCommandInput;
+    constructor(input: GetLoggerDefinitionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLoggerDefinitionCommandInput, GetLoggerDefinitionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetLoggerDefinitionVersionCommand.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 { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetLoggerDefinitionVersionRequest, GetLoggerDefinitionVersionResponse } from "../models/models_0";
+export interface GetLoggerDefinitionVersionCommandInput extends GetLoggerDefinitionVersionRequest {
+}
+export interface GetLoggerDefinitionVersionCommandOutput extends GetLoggerDefinitionVersionResponse, __MetadataBearer {
+}
+/**
+ * Retrieves information about a logger definition version.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetLoggerDefinitionVersionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetLoggerDefinitionVersionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetLoggerDefinitionVersionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetLoggerDefinitionVersionCommandInput} for command's `input` shape.
+ * @see {@link GetLoggerDefinitionVersionCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetLoggerDefinitionVersionCommand extends $Command<GetLoggerDefinitionVersionCommandInput, GetLoggerDefinitionVersionCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetLoggerDefinitionVersionCommandInput;
+    constructor(input: GetLoggerDefinitionVersionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetLoggerDefinitionVersionCommandInput, GetLoggerDefinitionVersionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetResourceDefinitionCommand.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 { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetResourceDefinitionRequest, GetResourceDefinitionResponse } from "../models/models_0";
+export interface GetResourceDefinitionCommandInput extends GetResourceDefinitionRequest {
+}
+export interface GetResourceDefinitionCommandOutput extends GetResourceDefinitionResponse, __MetadataBearer {
+}
+/**
+ * Retrieves information about a resource definition, including its creation time and latest version.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetResourceDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetResourceDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetResourceDefinitionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetResourceDefinitionCommandInput} for command's `input` shape.
+ * @see {@link GetResourceDefinitionCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetResourceDefinitionCommand extends $Command<GetResourceDefinitionCommandInput, GetResourceDefinitionCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetResourceDefinitionCommandInput;
+    constructor(input: GetResourceDefinitionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetResourceDefinitionCommandInput, GetResourceDefinitionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetResourceDefinitionVersionCommand.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 { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetResourceDefinitionVersionRequest, GetResourceDefinitionVersionResponse } from "../models/models_0";
+export interface GetResourceDefinitionVersionCommandInput extends GetResourceDefinitionVersionRequest {
+}
+export interface GetResourceDefinitionVersionCommandOutput extends GetResourceDefinitionVersionResponse, __MetadataBearer {
+}
+/**
+ * Retrieves information about a resource definition version, including which resources are included in the version.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetResourceDefinitionVersionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetResourceDefinitionVersionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetResourceDefinitionVersionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetResourceDefinitionVersionCommandInput} for command's `input` shape.
+ * @see {@link GetResourceDefinitionVersionCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetResourceDefinitionVersionCommand extends $Command<GetResourceDefinitionVersionCommandInput, GetResourceDefinitionVersionCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetResourceDefinitionVersionCommandInput;
+    constructor(input: GetResourceDefinitionVersionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetResourceDefinitionVersionCommandInput, GetResourceDefinitionVersionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetServiceRoleForAccountCommand.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 { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetServiceRoleForAccountRequest, GetServiceRoleForAccountResponse } from "../models/models_0";
+export interface GetServiceRoleForAccountCommandInput extends GetServiceRoleForAccountRequest {
+}
+export interface GetServiceRoleForAccountCommandOutput extends GetServiceRoleForAccountResponse, __MetadataBearer {
+}
+/**
+ * Retrieves the service role that is attached to your account.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetServiceRoleForAccountCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetServiceRoleForAccountCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetServiceRoleForAccountCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetServiceRoleForAccountCommandInput} for command's `input` shape.
+ * @see {@link GetServiceRoleForAccountCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetServiceRoleForAccountCommand extends $Command<GetServiceRoleForAccountCommandInput, GetServiceRoleForAccountCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetServiceRoleForAccountCommandInput;
+    constructor(input: GetServiceRoleForAccountCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetServiceRoleForAccountCommandInput, GetServiceRoleForAccountCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetSubscriptionDefinitionCommand.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 { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetSubscriptionDefinitionRequest, GetSubscriptionDefinitionResponse } from "../models/models_0";
+export interface GetSubscriptionDefinitionCommandInput extends GetSubscriptionDefinitionRequest {
+}
+export interface GetSubscriptionDefinitionCommandOutput extends GetSubscriptionDefinitionResponse, __MetadataBearer {
+}
+/**
+ * Retrieves information about a subscription definition.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetSubscriptionDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetSubscriptionDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetSubscriptionDefinitionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSubscriptionDefinitionCommandInput} for command's `input` shape.
+ * @see {@link GetSubscriptionDefinitionCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetSubscriptionDefinitionCommand extends $Command<GetSubscriptionDefinitionCommandInput, GetSubscriptionDefinitionCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetSubscriptionDefinitionCommandInput;
+    constructor(input: GetSubscriptionDefinitionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSubscriptionDefinitionCommandInput, GetSubscriptionDefinitionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetSubscriptionDefinitionVersionCommand.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 { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetSubscriptionDefinitionVersionRequest, GetSubscriptionDefinitionVersionResponse } from "../models/models_0";
+export interface GetSubscriptionDefinitionVersionCommandInput extends GetSubscriptionDefinitionVersionRequest {
+}
+export interface GetSubscriptionDefinitionVersionCommandOutput extends GetSubscriptionDefinitionVersionResponse, __MetadataBearer {
+}
+/**
+ * Retrieves information about a subscription definition version.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetSubscriptionDefinitionVersionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetSubscriptionDefinitionVersionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetSubscriptionDefinitionVersionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSubscriptionDefinitionVersionCommandInput} for command's `input` shape.
+ * @see {@link GetSubscriptionDefinitionVersionCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetSubscriptionDefinitionVersionCommand extends $Command<GetSubscriptionDefinitionVersionCommandInput, GetSubscriptionDefinitionVersionCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetSubscriptionDefinitionVersionCommandInput;
+    constructor(input: GetSubscriptionDefinitionVersionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSubscriptionDefinitionVersionCommandInput, GetSubscriptionDefinitionVersionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetThingRuntimeConfigurationCommand.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 { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { GetThingRuntimeConfigurationRequest, GetThingRuntimeConfigurationResponse } from "../models/models_0";
+export interface GetThingRuntimeConfigurationCommandInput extends GetThingRuntimeConfigurationRequest {
+}
+export interface GetThingRuntimeConfigurationCommandOutput extends GetThingRuntimeConfigurationResponse, __MetadataBearer {
+}
+/**
+ * Get the runtime configuration of a thing.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, GetThingRuntimeConfigurationCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, GetThingRuntimeConfigurationCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new GetThingRuntimeConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetThingRuntimeConfigurationCommandInput} for command's `input` shape.
+ * @see {@link GetThingRuntimeConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetThingRuntimeConfigurationCommand extends $Command<GetThingRuntimeConfigurationCommandInput, GetThingRuntimeConfigurationCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: GetThingRuntimeConfigurationCommandInput;
+    constructor(input: GetThingRuntimeConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetThingRuntimeConfigurationCommandInput, GetThingRuntimeConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListBulkDeploymentDetailedReportsCommand.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 { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { ListBulkDeploymentDetailedReportsRequest, ListBulkDeploymentDetailedReportsResponse } from "../models/models_0";
+export interface ListBulkDeploymentDetailedReportsCommandInput extends ListBulkDeploymentDetailedReportsRequest {
+}
+export interface ListBulkDeploymentDetailedReportsCommandOutput extends ListBulkDeploymentDetailedReportsResponse, __MetadataBearer {
+}
+/**
+ * Gets a paginated list of the deployments that have been started in a bulk deployment operation, and their current deployment status.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, ListBulkDeploymentDetailedReportsCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, ListBulkDeploymentDetailedReportsCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new ListBulkDeploymentDetailedReportsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListBulkDeploymentDetailedReportsCommandInput} for command's `input` shape.
+ * @see {@link ListBulkDeploymentDetailedReportsCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListBulkDeploymentDetailedReportsCommand extends $Command<ListBulkDeploymentDetailedReportsCommandInput, ListBulkDeploymentDetailedReportsCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: ListBulkDeploymentDetailedReportsCommandInput;
+    constructor(input: ListBulkDeploymentDetailedReportsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListBulkDeploymentDetailedReportsCommandInput, ListBulkDeploymentDetailedReportsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListBulkDeploymentsCommand.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 { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { ListBulkDeploymentsRequest, ListBulkDeploymentsResponse } from "../models/models_0";
+export interface ListBulkDeploymentsCommandInput extends ListBulkDeploymentsRequest {
+}
+export interface ListBulkDeploymentsCommandOutput extends ListBulkDeploymentsResponse, __MetadataBearer {
+}
+/**
+ * Returns a list of bulk deployments.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, ListBulkDeploymentsCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, ListBulkDeploymentsCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new ListBulkDeploymentsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListBulkDeploymentsCommandInput} for command's `input` shape.
+ * @see {@link ListBulkDeploymentsCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListBulkDeploymentsCommand extends $Command<ListBulkDeploymentsCommandInput, ListBulkDeploymentsCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: ListBulkDeploymentsCommandInput;
+    constructor(input: ListBulkDeploymentsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListBulkDeploymentsCommandInput, ListBulkDeploymentsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListConnectorDefinitionVersionsCommand.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 { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { ListConnectorDefinitionVersionsRequest, ListConnectorDefinitionVersionsResponse } from "../models/models_0";
+export interface ListConnectorDefinitionVersionsCommandInput extends ListConnectorDefinitionVersionsRequest {
+}
+export interface ListConnectorDefinitionVersionsCommandOutput extends ListConnectorDefinitionVersionsResponse, __MetadataBearer {
+}
+/**
+ * Lists the versions of a connector definition, which are containers for connectors. Connectors run on the Greengrass core and contain built-in integration with local infrastructure, device protocols, AWS, and other cloud services.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, ListConnectorDefinitionVersionsCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, ListConnectorDefinitionVersionsCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new ListConnectorDefinitionVersionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListConnectorDefinitionVersionsCommandInput} for command's `input` shape.
+ * @see {@link ListConnectorDefinitionVersionsCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListConnectorDefinitionVersionsCommand extends $Command<ListConnectorDefinitionVersionsCommandInput, ListConnectorDefinitionVersionsCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: ListConnectorDefinitionVersionsCommandInput;
+    constructor(input: ListConnectorDefinitionVersionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListConnectorDefinitionVersionsCommandInput, ListConnectorDefinitionVersionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListConnectorDefinitionsCommand.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 { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { ListConnectorDefinitionsRequest, ListConnectorDefinitionsResponse } from "../models/models_0";
+export interface ListConnectorDefinitionsCommandInput extends ListConnectorDefinitionsRequest {
+}
+export interface ListConnectorDefinitionsCommandOutput extends ListConnectorDefinitionsResponse, __MetadataBearer {
+}
+/**
+ * Retrieves a list of connector definitions.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, ListConnectorDefinitionsCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, ListConnectorDefinitionsCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new ListConnectorDefinitionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListConnectorDefinitionsCommandInput} for command's `input` shape.
+ * @see {@link ListConnectorDefinitionsCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListConnectorDefinitionsCommand extends $Command<ListConnectorDefinitionsCommandInput, ListConnectorDefinitionsCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: ListConnectorDefinitionsCommandInput;
+    constructor(input: ListConnectorDefinitionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListConnectorDefinitionsCommandInput, ListConnectorDefinitionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListCoreDefinitionVersionsCommand.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 { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { ListCoreDefinitionVersionsRequest, ListCoreDefinitionVersionsResponse } from "../models/models_0";
+export interface ListCoreDefinitionVersionsCommandInput extends ListCoreDefinitionVersionsRequest {
+}
+export interface ListCoreDefinitionVersionsCommandOutput extends ListCoreDefinitionVersionsResponse, __MetadataBearer {
+}
+/**
+ * Lists the versions of a core definition.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, ListCoreDefinitionVersionsCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, ListCoreDefinitionVersionsCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new ListCoreDefinitionVersionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListCoreDefinitionVersionsCommandInput} for command's `input` shape.
+ * @see {@link ListCoreDefinitionVersionsCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListCoreDefinitionVersionsCommand extends $Command<ListCoreDefinitionVersionsCommandInput, ListCoreDefinitionVersionsCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: ListCoreDefinitionVersionsCommandInput;
+    constructor(input: ListCoreDefinitionVersionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListCoreDefinitionVersionsCommandInput, ListCoreDefinitionVersionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListCoreDefinitionsCommand.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 { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
+import { ListCoreDefinitionsRequest, ListCoreDefinitionsResponse } from "../models/models_0";
+export interface ListCoreDefinitionsCommandInput extends ListCoreDefinitionsRequest {
+}
+export interface ListCoreDefinitionsCommandOutput extends ListCoreDefinitionsResponse, __MetadataBearer {
+}
+/**
+ * Retrieves a list of core definitions.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, ListCoreDefinitionsCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, ListCoreDefinitionsCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new ListCoreDefinitionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListCoreDefinitionsCommandInput} for command's `input` shape.
+ * @see {@link ListCoreDefinitionsCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListCoreDefinitionsCommand extends $Command<ListCoreDefinitionsCommandInput, ListCoreDefinitionsCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: ListCoreDefinitionsCommandInput;
+    constructor(input: ListCoreDefinitionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListCoreDefinitionsCommandInput, ListCoreDefinitionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}