@aws-sdk/client-greengrass 3.31.0 → 3.35.0

package/dist-types/commands/StopBulkDeploymentCommand.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 { StopBulkDeploymentRequest, StopBulkDeploymentResponse } from "../models/models_0";
+export interface StopBulkDeploymentCommandInput extends StopBulkDeploymentRequest {
+}
+export interface StopBulkDeploymentCommandOutput extends StopBulkDeploymentResponse, __MetadataBearer {
+}
+/**
+ * Stops the execution of a bulk deployment. This action returns a status of ''Stopping'' until the deployment is stopped. You cannot start a new bulk deployment while a previous deployment is in the ''Stopping'' state. This action doesn't rollback completed deployments or cancel pending deployments.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, StopBulkDeploymentCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, StopBulkDeploymentCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new StopBulkDeploymentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StopBulkDeploymentCommandInput} for command's `input` shape.
+ * @see {@link StopBulkDeploymentCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class StopBulkDeploymentCommand extends $Command<StopBulkDeploymentCommandInput, StopBulkDeploymentCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: StopBulkDeploymentCommandInput;
+    constructor(input: StopBulkDeploymentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopBulkDeploymentCommandInput, StopBulkDeploymentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/TagResourceCommand.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 { TagResourceRequest } from "../models/models_0";
+export interface TagResourceCommandInput extends TagResourceRequest {
+}
+export interface TagResourceCommandOutput extends __MetadataBearer {
+}
+/**
+ * Adds tags to a Greengrass resource. Valid resources are 'Group', 'ConnectorDefinition', 'CoreDefinition', 'DeviceDefinition', 'FunctionDefinition', 'LoggerDefinition', 'SubscriptionDefinition', 'ResourceDefinition', and 'BulkDeployment'.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, TagResourceCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, TagResourceCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new TagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TagResourceCommandInput} for command's `input` shape.
+ * @see {@link TagResourceCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: TagResourceCommandInput;
+    constructor(input: TagResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

package/dist-types/commands/UpdateConnectivityInfoCommand.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 { UpdateConnectivityInfoRequest, UpdateConnectivityInfoResponse } from "../models/models_0";
+export interface UpdateConnectivityInfoCommandInput extends UpdateConnectivityInfoRequest {
+}
+export interface UpdateConnectivityInfoCommandOutput extends UpdateConnectivityInfoResponse, __MetadataBearer {
+}
+/**
+ * Updates the connectivity information for the core. Any devices that belong to the group which has this core will receive this information in order to find the location of the core and connect to it.
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GreengrassClient, UpdateConnectivityInfoCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, UpdateConnectivityInfoCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new UpdateConnectivityInfoCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateConnectivityInfoCommandInput} for command's `input` shape.
+ * @see {@link UpdateConnectivityInfoCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateConnectivityInfoCommand extends $Command<UpdateConnectivityInfoCommandInput, UpdateConnectivityInfoCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: UpdateConnectivityInfoCommandInput;
+    constructor(input: UpdateConnectivityInfoCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateConnectivityInfoCommandInput, UpdateConnectivityInfoCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

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

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

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

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

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

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

package/dist-types/commands/UpdateThingRuntimeConfigurationCommand.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 { UpdateThingRuntimeConfigurationRequest, UpdateThingRuntimeConfigurationResponse } from "../models/models_0";
+export interface UpdateThingRuntimeConfigurationCommandInput extends UpdateThingRuntimeConfigurationRequest {
+}
+export interface UpdateThingRuntimeConfigurationCommandOutput extends UpdateThingRuntimeConfigurationResponse, __MetadataBearer {
+}
+/**
+ * Updates 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, UpdateThingRuntimeConfigurationCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
+ * // const { GreengrassClient, UpdateThingRuntimeConfigurationCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
+ * const client = new GreengrassClient(config);
+ * const command = new UpdateThingRuntimeConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateThingRuntimeConfigurationCommandInput} for command's `input` shape.
+ * @see {@link UpdateThingRuntimeConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateThingRuntimeConfigurationCommand extends $Command<UpdateThingRuntimeConfigurationCommandInput, UpdateThingRuntimeConfigurationCommandOutput, GreengrassClientResolvedConfig> {
+    readonly input: UpdateThingRuntimeConfigurationCommandInput;
+    constructor(input: UpdateThingRuntimeConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateThingRuntimeConfigurationCommandInput, UpdateThingRuntimeConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}