@aws-sdk/client-greengrass 3.33.0 → 3.36.1

package/dist/types/ts3.4/commands/CreateFunctionDefinitionVersionCommand.d.ts

@@ -1,35 +0,0 @@
-import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
-import { CreateFunctionDefinitionVersionRequest, CreateFunctionDefinitionVersionResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateFunctionDefinitionVersionCommandInput extends CreateFunctionDefinitionVersionRequest {
-}
-export interface CreateFunctionDefinitionVersionCommandOutput extends CreateFunctionDefinitionVersionResponse, __MetadataBearer {
-}
-/**
- * Creates a version of a Lambda function definition that has already been defined.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, CreateFunctionDefinitionVersionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, CreateFunctionDefinitionVersionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new CreateFunctionDefinitionVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateFunctionDefinitionVersionCommandInput} for command's `input` shape.
- * @see {@link CreateFunctionDefinitionVersionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateFunctionDefinitionVersionCommand extends $Command<CreateFunctionDefinitionVersionCommandInput, CreateFunctionDefinitionVersionCommandOutput, GreengrassClientResolvedConfig> {
-    readonly input: CreateFunctionDefinitionVersionCommandInput;
-    constructor(input: CreateFunctionDefinitionVersionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateFunctionDefinitionVersionCommandInput, CreateFunctionDefinitionVersionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateGroupCertificateAuthorityCommand.d.ts

@@ -1,35 +0,0 @@
-import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
-import { CreateGroupCertificateAuthorityRequest, CreateGroupCertificateAuthorityResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateGroupCertificateAuthorityCommandInput extends CreateGroupCertificateAuthorityRequest {
-}
-export interface CreateGroupCertificateAuthorityCommandOutput extends CreateGroupCertificateAuthorityResponse, __MetadataBearer {
-}
-/**
- * Creates a CA for the group. If a CA already exists, it will rotate the existing CA.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, CreateGroupCertificateAuthorityCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, CreateGroupCertificateAuthorityCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new CreateGroupCertificateAuthorityCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateGroupCertificateAuthorityCommandInput} for command's `input` shape.
- * @see {@link CreateGroupCertificateAuthorityCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateGroupCertificateAuthorityCommand extends $Command<CreateGroupCertificateAuthorityCommandInput, CreateGroupCertificateAuthorityCommandOutput, GreengrassClientResolvedConfig> {
-    readonly input: CreateGroupCertificateAuthorityCommandInput;
-    constructor(input: CreateGroupCertificateAuthorityCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateGroupCertificateAuthorityCommandInput, CreateGroupCertificateAuthorityCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateGroupCommand.d.ts

@@ -1,35 +0,0 @@
-import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
-import { CreateGroupRequest, CreateGroupResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateGroupCommandInput extends CreateGroupRequest {
-}
-export interface CreateGroupCommandOutput extends CreateGroupResponse, __MetadataBearer {
-}
-/**
- * Creates a group. You may provide the initial version of the group or use ''CreateGroupVersion'' at a later time. Tip: You can use the ''gg_group_setup'' package (https://github.com/awslabs/aws-greengrass-group-setup) as a library or command-line application to create and deploy Greengrass groups.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, CreateGroupCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, CreateGroupCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new CreateGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateGroupCommandInput} for command's `input` shape.
- * @see {@link CreateGroupCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateGroupCommand extends $Command<CreateGroupCommandInput, CreateGroupCommandOutput, GreengrassClientResolvedConfig> {
-    readonly input: CreateGroupCommandInput;
-    constructor(input: CreateGroupCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateGroupCommandInput, CreateGroupCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateGroupVersionCommand.d.ts

@@ -1,35 +0,0 @@
-import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
-import { CreateGroupVersionRequest, CreateGroupVersionResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateGroupVersionCommandInput extends CreateGroupVersionRequest {
-}
-export interface CreateGroupVersionCommandOutput extends CreateGroupVersionResponse, __MetadataBearer {
-}
-/**
- * Creates a version of a group which has already been defined.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, CreateGroupVersionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, CreateGroupVersionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new CreateGroupVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateGroupVersionCommandInput} for command's `input` shape.
- * @see {@link CreateGroupVersionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateGroupVersionCommand extends $Command<CreateGroupVersionCommandInput, CreateGroupVersionCommandOutput, GreengrassClientResolvedConfig> {
-    readonly input: CreateGroupVersionCommandInput;
-    constructor(input: CreateGroupVersionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateGroupVersionCommandInput, CreateGroupVersionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateLoggerDefinitionCommand.d.ts

@@ -1,35 +0,0 @@
-import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
-import { CreateLoggerDefinitionRequest, CreateLoggerDefinitionResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateLoggerDefinitionCommandInput extends CreateLoggerDefinitionRequest {
-}
-export interface CreateLoggerDefinitionCommandOutput extends CreateLoggerDefinitionResponse, __MetadataBearer {
-}
-/**
- * Creates a logger definition. You may provide the initial version of the logger definition now or use ''CreateLoggerDefinitionVersion'' at a later time.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, CreateLoggerDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, CreateLoggerDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new CreateLoggerDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLoggerDefinitionCommandInput} for command's `input` shape.
- * @see {@link CreateLoggerDefinitionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateLoggerDefinitionCommand extends $Command<CreateLoggerDefinitionCommandInput, CreateLoggerDefinitionCommandOutput, GreengrassClientResolvedConfig> {
-    readonly input: CreateLoggerDefinitionCommandInput;
-    constructor(input: CreateLoggerDefinitionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLoggerDefinitionCommandInput, CreateLoggerDefinitionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateLoggerDefinitionVersionCommand.d.ts

@@ -1,35 +0,0 @@
-import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
-import { CreateLoggerDefinitionVersionRequest, CreateLoggerDefinitionVersionResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateLoggerDefinitionVersionCommandInput extends CreateLoggerDefinitionVersionRequest {
-}
-export interface CreateLoggerDefinitionVersionCommandOutput extends CreateLoggerDefinitionVersionResponse, __MetadataBearer {
-}
-/**
- * Creates a version of a logger definition that has already been defined.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, CreateLoggerDefinitionVersionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, CreateLoggerDefinitionVersionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new CreateLoggerDefinitionVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateLoggerDefinitionVersionCommandInput} for command's `input` shape.
- * @see {@link CreateLoggerDefinitionVersionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateLoggerDefinitionVersionCommand extends $Command<CreateLoggerDefinitionVersionCommandInput, CreateLoggerDefinitionVersionCommandOutput, GreengrassClientResolvedConfig> {
-    readonly input: CreateLoggerDefinitionVersionCommandInput;
-    constructor(input: CreateLoggerDefinitionVersionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateLoggerDefinitionVersionCommandInput, CreateLoggerDefinitionVersionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateResourceDefinitionCommand.d.ts

@@ -1,35 +0,0 @@
-import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
-import { CreateResourceDefinitionRequest, CreateResourceDefinitionResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateResourceDefinitionCommandInput extends CreateResourceDefinitionRequest {
-}
-export interface CreateResourceDefinitionCommandOutput extends CreateResourceDefinitionResponse, __MetadataBearer {
-}
-/**
- * Creates a resource definition which contains a list of resources to be used in a group. You can create an initial version of the definition by providing a list of resources now, or use ''CreateResourceDefinitionVersion'' later.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, CreateResourceDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, CreateResourceDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new CreateResourceDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateResourceDefinitionCommandInput} for command's `input` shape.
- * @see {@link CreateResourceDefinitionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateResourceDefinitionCommand extends $Command<CreateResourceDefinitionCommandInput, CreateResourceDefinitionCommandOutput, GreengrassClientResolvedConfig> {
-    readonly input: CreateResourceDefinitionCommandInput;
-    constructor(input: CreateResourceDefinitionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateResourceDefinitionCommandInput, CreateResourceDefinitionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateResourceDefinitionVersionCommand.d.ts

@@ -1,35 +0,0 @@
-import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
-import { CreateResourceDefinitionVersionRequest, CreateResourceDefinitionVersionResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateResourceDefinitionVersionCommandInput extends CreateResourceDefinitionVersionRequest {
-}
-export interface CreateResourceDefinitionVersionCommandOutput extends CreateResourceDefinitionVersionResponse, __MetadataBearer {
-}
-/**
- * Creates a version of a resource definition that has already been defined.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, CreateResourceDefinitionVersionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, CreateResourceDefinitionVersionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new CreateResourceDefinitionVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateResourceDefinitionVersionCommandInput} for command's `input` shape.
- * @see {@link CreateResourceDefinitionVersionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateResourceDefinitionVersionCommand extends $Command<CreateResourceDefinitionVersionCommandInput, CreateResourceDefinitionVersionCommandOutput, GreengrassClientResolvedConfig> {
-    readonly input: CreateResourceDefinitionVersionCommandInput;
-    constructor(input: CreateResourceDefinitionVersionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateResourceDefinitionVersionCommandInput, CreateResourceDefinitionVersionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateSoftwareUpdateJobCommand.d.ts

@@ -1,35 +0,0 @@
-import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
-import { CreateSoftwareUpdateJobRequest, CreateSoftwareUpdateJobResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateSoftwareUpdateJobCommandInput extends CreateSoftwareUpdateJobRequest {
-}
-export interface CreateSoftwareUpdateJobCommandOutput extends CreateSoftwareUpdateJobResponse, __MetadataBearer {
-}
-/**
- * Creates a software update for a core or group of cores (specified as an IoT thing group.) Use this to update the OTA Agent as well as the Greengrass core software. It makes use of the IoT Jobs feature which provides additional commands to manage a Greengrass core software update job.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, CreateSoftwareUpdateJobCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, CreateSoftwareUpdateJobCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new CreateSoftwareUpdateJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateSoftwareUpdateJobCommandInput} for command's `input` shape.
- * @see {@link CreateSoftwareUpdateJobCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateSoftwareUpdateJobCommand extends $Command<CreateSoftwareUpdateJobCommandInput, CreateSoftwareUpdateJobCommandOutput, GreengrassClientResolvedConfig> {
-    readonly input: CreateSoftwareUpdateJobCommandInput;
-    constructor(input: CreateSoftwareUpdateJobCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSoftwareUpdateJobCommandInput, CreateSoftwareUpdateJobCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateSubscriptionDefinitionCommand.d.ts

@@ -1,35 +0,0 @@
-import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
-import { CreateSubscriptionDefinitionRequest, CreateSubscriptionDefinitionResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateSubscriptionDefinitionCommandInput extends CreateSubscriptionDefinitionRequest {
-}
-export interface CreateSubscriptionDefinitionCommandOutput extends CreateSubscriptionDefinitionResponse, __MetadataBearer {
-}
-/**
- * Creates a subscription definition. You may provide the initial version of the subscription definition now or use ''CreateSubscriptionDefinitionVersion'' at a later time.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, CreateSubscriptionDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, CreateSubscriptionDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new CreateSubscriptionDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateSubscriptionDefinitionCommandInput} for command's `input` shape.
- * @see {@link CreateSubscriptionDefinitionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateSubscriptionDefinitionCommand extends $Command<CreateSubscriptionDefinitionCommandInput, CreateSubscriptionDefinitionCommandOutput, GreengrassClientResolvedConfig> {
-    readonly input: CreateSubscriptionDefinitionCommandInput;
-    constructor(input: CreateSubscriptionDefinitionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSubscriptionDefinitionCommandInput, CreateSubscriptionDefinitionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/CreateSubscriptionDefinitionVersionCommand.d.ts

@@ -1,35 +0,0 @@
-import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
-import { CreateSubscriptionDefinitionVersionRequest, CreateSubscriptionDefinitionVersionResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface CreateSubscriptionDefinitionVersionCommandInput extends CreateSubscriptionDefinitionVersionRequest {
-}
-export interface CreateSubscriptionDefinitionVersionCommandOutput extends CreateSubscriptionDefinitionVersionResponse, __MetadataBearer {
-}
-/**
- * Creates a version of a subscription definition which has already been defined.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, CreateSubscriptionDefinitionVersionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, CreateSubscriptionDefinitionVersionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new CreateSubscriptionDefinitionVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateSubscriptionDefinitionVersionCommandInput} for command's `input` shape.
- * @see {@link CreateSubscriptionDefinitionVersionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class CreateSubscriptionDefinitionVersionCommand extends $Command<CreateSubscriptionDefinitionVersionCommandInput, CreateSubscriptionDefinitionVersionCommandOutput, GreengrassClientResolvedConfig> {
-    readonly input: CreateSubscriptionDefinitionVersionCommandInput;
-    constructor(input: CreateSubscriptionDefinitionVersionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateSubscriptionDefinitionVersionCommandInput, CreateSubscriptionDefinitionVersionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteConnectorDefinitionCommand.d.ts

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

package/dist/types/ts3.4/commands/DeleteCoreDefinitionCommand.d.ts

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

package/dist/types/ts3.4/commands/DeleteDeviceDefinitionCommand.d.ts

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

package/dist/types/ts3.4/commands/DeleteFunctionDefinitionCommand.d.ts

@@ -1,35 +0,0 @@
-import { GreengrassClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GreengrassClient";
-import { DeleteFunctionDefinitionRequest, DeleteFunctionDefinitionResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteFunctionDefinitionCommandInput extends DeleteFunctionDefinitionRequest {
-}
-export interface DeleteFunctionDefinitionCommandOutput extends DeleteFunctionDefinitionResponse, __MetadataBearer {
-}
-/**
- * Deletes a Lambda function definition.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, DeleteFunctionDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, DeleteFunctionDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new DeleteFunctionDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteFunctionDefinitionCommandInput} for command's `input` shape.
- * @see {@link DeleteFunctionDefinitionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteFunctionDefinitionCommand extends $Command<DeleteFunctionDefinitionCommandInput, DeleteFunctionDefinitionCommandOutput, GreengrassClientResolvedConfig> {
-    readonly input: DeleteFunctionDefinitionCommandInput;
-    constructor(input: DeleteFunctionDefinitionCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteFunctionDefinitionCommandInput, DeleteFunctionDefinitionCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteGroupCommand.d.ts

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

package/dist/types/ts3.4/commands/DeleteLoggerDefinitionCommand.d.ts

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