@aws-sdk/client-greengrass 3.36.0 → 3.36.1

package/dist-types/ts3.4/commands/GetConnectivityInfoCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetConnectivityInfoCommandInput extends GetConnectivityInfoRequ
 }
 export interface GetConnectivityInfoCommandOutput extends GetConnectivityInfoResponse, __MetadataBearer {
 }
-/**
- * Retrieves the connectivity information for a core.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, GetConnectivityInfoCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, GetConnectivityInfoCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new GetConnectivityInfoCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetConnectivityInfoCommandInput} for command's `input` shape.
- * @see {@link GetConnectivityInfoCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetConnectivityInfoCommand extends $Command<GetConnectivityInfoCommandInput, GetConnectivityInfoCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: GetConnectivityInfoCommandInput;
     constructor(input: GetConnectivityInfoCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetConnectivityInfoCommandInput, GetConnectivityInfoCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetConnectorDefinitionCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetConnectorDefinitionCommandInput extends GetConnectorDefiniti
 }
 export interface GetConnectorDefinitionCommandOutput extends GetConnectorDefinitionResponse, __MetadataBearer {
 }
-/**
- * Retrieves information about a connector definition.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, GetConnectorDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, GetConnectorDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new GetConnectorDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetConnectorDefinitionCommandInput} for command's `input` shape.
- * @see {@link GetConnectorDefinitionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetConnectorDefinitionCommand extends $Command<GetConnectorDefinitionCommandInput, GetConnectorDefinitionCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: GetConnectorDefinitionCommandInput;
     constructor(input: GetConnectorDefinitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetConnectorDefinitionCommandInput, GetConnectorDefinitionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetConnectorDefinitionVersionCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetConnectorDefinitionVersionCommandInput extends GetConnectorD
 }
 export interface GetConnectorDefinitionVersionCommandOutput extends GetConnectorDefinitionVersionResponse, __MetadataBearer {
 }
-/**
- * Retrieves information about a connector definition version, including the connectors that the version contains. Connectors are prebuilt modules that interact 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, GetConnectorDefinitionVersionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, GetConnectorDefinitionVersionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new GetConnectorDefinitionVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetConnectorDefinitionVersionCommandInput} for command's `input` shape.
- * @see {@link GetConnectorDefinitionVersionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetConnectorDefinitionVersionCommand extends $Command<GetConnectorDefinitionVersionCommandInput, GetConnectorDefinitionVersionCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: GetConnectorDefinitionVersionCommandInput;
     constructor(input: GetConnectorDefinitionVersionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetConnectorDefinitionVersionCommandInput, GetConnectorDefinitionVersionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetCoreDefinitionCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetCoreDefinitionCommandInput extends GetCoreDefinitionRequest
 }
 export interface GetCoreDefinitionCommandOutput extends GetCoreDefinitionResponse, __MetadataBearer {
 }
-/**
- * Retrieves information about a core definition version.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, GetCoreDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, GetCoreDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new GetCoreDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetCoreDefinitionCommandInput} for command's `input` shape.
- * @see {@link GetCoreDefinitionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetCoreDefinitionCommand extends $Command<GetCoreDefinitionCommandInput, GetCoreDefinitionCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: GetCoreDefinitionCommandInput;
     constructor(input: GetCoreDefinitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCoreDefinitionCommandInput, GetCoreDefinitionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetCoreDefinitionVersionCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetCoreDefinitionVersionCommandInput extends GetCoreDefinitionV
 }
 export interface GetCoreDefinitionVersionCommandOutput extends GetCoreDefinitionVersionResponse, __MetadataBearer {
 }
-/**
- * Retrieves information about a core definition version.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, GetCoreDefinitionVersionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, GetCoreDefinitionVersionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new GetCoreDefinitionVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetCoreDefinitionVersionCommandInput} for command's `input` shape.
- * @see {@link GetCoreDefinitionVersionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetCoreDefinitionVersionCommand extends $Command<GetCoreDefinitionVersionCommandInput, GetCoreDefinitionVersionCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: GetCoreDefinitionVersionCommandInput;
     constructor(input: GetCoreDefinitionVersionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCoreDefinitionVersionCommandInput, GetCoreDefinitionVersionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetDeploymentStatusCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetDeploymentStatusCommandInput extends GetDeploymentStatusRequ
 }
 export interface GetDeploymentStatusCommandOutput extends GetDeploymentStatusResponse, __MetadataBearer {
 }
-/**
- * Returns the status of a deployment.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, GetDeploymentStatusCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, GetDeploymentStatusCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new GetDeploymentStatusCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDeploymentStatusCommandInput} for command's `input` shape.
- * @see {@link GetDeploymentStatusCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDeploymentStatusCommand extends $Command<GetDeploymentStatusCommandInput, GetDeploymentStatusCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: GetDeploymentStatusCommandInput;
     constructor(input: GetDeploymentStatusCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDeploymentStatusCommandInput, GetDeploymentStatusCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetDeviceDefinitionCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetDeviceDefinitionCommandInput extends GetDeviceDefinitionRequ
 }
 export interface GetDeviceDefinitionCommandOutput extends GetDeviceDefinitionResponse, __MetadataBearer {
 }
-/**
- * Retrieves information about a device definition.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, GetDeviceDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, GetDeviceDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new GetDeviceDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDeviceDefinitionCommandInput} for command's `input` shape.
- * @see {@link GetDeviceDefinitionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDeviceDefinitionCommand extends $Command<GetDeviceDefinitionCommandInput, GetDeviceDefinitionCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: GetDeviceDefinitionCommandInput;
     constructor(input: GetDeviceDefinitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDeviceDefinitionCommandInput, GetDeviceDefinitionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetDeviceDefinitionVersionCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetDeviceDefinitionVersionCommandInput extends GetDeviceDefinit
 }
 export interface GetDeviceDefinitionVersionCommandOutput extends GetDeviceDefinitionVersionResponse, __MetadataBearer {
 }
-/**
- * Retrieves information about a device definition version.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, GetDeviceDefinitionVersionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, GetDeviceDefinitionVersionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new GetDeviceDefinitionVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDeviceDefinitionVersionCommandInput} for command's `input` shape.
- * @see {@link GetDeviceDefinitionVersionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDeviceDefinitionVersionCommand extends $Command<GetDeviceDefinitionVersionCommandInput, GetDeviceDefinitionVersionCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: GetDeviceDefinitionVersionCommandInput;
     constructor(input: GetDeviceDefinitionVersionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDeviceDefinitionVersionCommandInput, GetDeviceDefinitionVersionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetFunctionDefinitionCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetFunctionDefinitionCommandInput extends GetFunctionDefinition
 }
 export interface GetFunctionDefinitionCommandOutput extends GetFunctionDefinitionResponse, __MetadataBearer {
 }
-/**
- * Retrieves information about a Lambda function 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, GetFunctionDefinitionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, GetFunctionDefinitionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new GetFunctionDefinitionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetFunctionDefinitionCommandInput} for command's `input` shape.
- * @see {@link GetFunctionDefinitionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetFunctionDefinitionCommand extends $Command<GetFunctionDefinitionCommandInput, GetFunctionDefinitionCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: GetFunctionDefinitionCommandInput;
     constructor(input: GetFunctionDefinitionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFunctionDefinitionCommandInput, GetFunctionDefinitionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetFunctionDefinitionVersionCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetFunctionDefinitionVersionCommandInput extends GetFunctionDef
 }
 export interface GetFunctionDefinitionVersionCommandOutput extends GetFunctionDefinitionVersionResponse, __MetadataBearer {
 }
-/**
- * Retrieves information about a Lambda function definition version, including which Lambda functions are included in the version and their configurations.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, GetFunctionDefinitionVersionCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, GetFunctionDefinitionVersionCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new GetFunctionDefinitionVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetFunctionDefinitionVersionCommandInput} for command's `input` shape.
- * @see {@link GetFunctionDefinitionVersionCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetFunctionDefinitionVersionCommand extends $Command<GetFunctionDefinitionVersionCommandInput, GetFunctionDefinitionVersionCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: GetFunctionDefinitionVersionCommandInput;
     constructor(input: GetFunctionDefinitionVersionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetFunctionDefinitionVersionCommandInput, GetFunctionDefinitionVersionCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetGroupCertificateAuthorityCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetGroupCertificateAuthorityCommandInput extends GetGroupCertif
 }
 export interface GetGroupCertificateAuthorityCommandOutput extends GetGroupCertificateAuthorityResponse, __MetadataBearer {
 }
-/**
- * Retreives the CA associated with a group. Returns the public key of the CA.
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { GreengrassClient, GetGroupCertificateAuthorityCommand } from "@aws-sdk/client-greengrass"; // ES Modules import
- * // const { GreengrassClient, GetGroupCertificateAuthorityCommand } = require("@aws-sdk/client-greengrass"); // CommonJS import
- * const client = new GreengrassClient(config);
- * const command = new GetGroupCertificateAuthorityCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetGroupCertificateAuthorityCommandInput} for command's `input` shape.
- * @see {@link GetGroupCertificateAuthorityCommandOutput} for command's `response` shape.
- * @see {@link GreengrassClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetGroupCertificateAuthorityCommand extends $Command<GetGroupCertificateAuthorityCommandInput, GetGroupCertificateAuthorityCommandOutput, GreengrassClientResolvedConfig> {
     readonly input: GetGroupCertificateAuthorityCommandInput;
     constructor(input: GetGroupCertificateAuthorityCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GreengrassClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetGroupCertificateAuthorityCommandInput, GetGroupCertificateAuthorityCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/GetGroupCertificateConfigurationCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetGroupCertificateConfigurationCommandInput extends GetGroupCe
 }
 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/ts3.4/commands/GetGroupCommand.d.ts

@@ -6,29 +6,11 @@ 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/ts3.4/commands/GetGroupVersionCommand.d.ts

@@ -6,29 +6,11 @@ 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/ts3.4/commands/GetLoggerDefinitionCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetLoggerDefinitionCommandInput extends GetLoggerDefinitionRequ
 }
 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/ts3.4/commands/GetLoggerDefinitionVersionCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetLoggerDefinitionVersionCommandInput extends GetLoggerDefinit
 }
 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/ts3.4/commands/GetResourceDefinitionCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetResourceDefinitionCommandInput extends GetResourceDefinition
 }
 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/ts3.4/commands/GetResourceDefinitionVersionCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetResourceDefinitionVersionCommandInput extends GetResourceDef
 }
 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/ts3.4/commands/GetServiceRoleForAccountCommand.d.ts

@@ -6,29 +6,11 @@ export interface GetServiceRoleForAccountCommandInput extends GetServiceRoleForA
 }
 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;