@aws-sdk/client-appconfig 3.35.0 → 3.38.0

package/dist-types/ts3.4/AppConfigClient.d.ts

@@ -42,172 +42,59 @@ import { ValidateConfigurationCommandInput, ValidateConfigurationCommandOutput }
 export declare type ServiceInputTypes = CreateApplicationCommandInput | CreateConfigurationProfileCommandInput | CreateDeploymentStrategyCommandInput | CreateEnvironmentCommandInput | CreateHostedConfigurationVersionCommandInput | DeleteApplicationCommandInput | DeleteConfigurationProfileCommandInput | DeleteDeploymentStrategyCommandInput | DeleteEnvironmentCommandInput | DeleteHostedConfigurationVersionCommandInput | GetApplicationCommandInput | GetConfigurationCommandInput | GetConfigurationProfileCommandInput | GetDeploymentCommandInput | GetDeploymentStrategyCommandInput | GetEnvironmentCommandInput | GetHostedConfigurationVersionCommandInput | ListApplicationsCommandInput | ListConfigurationProfilesCommandInput | ListDeploymentStrategiesCommandInput | ListDeploymentsCommandInput | ListEnvironmentsCommandInput | ListHostedConfigurationVersionsCommandInput | ListTagsForResourceCommandInput | StartDeploymentCommandInput | StopDeploymentCommandInput | TagResourceCommandInput | UntagResourceCommandInput | UpdateApplicationCommandInput | UpdateConfigurationProfileCommandInput | UpdateDeploymentStrategyCommandInput | UpdateEnvironmentCommandInput | ValidateConfigurationCommandInput;
 export declare type ServiceOutputTypes = CreateApplicationCommandOutput | CreateConfigurationProfileCommandOutput | CreateDeploymentStrategyCommandOutput | CreateEnvironmentCommandOutput | CreateHostedConfigurationVersionCommandOutput | DeleteApplicationCommandOutput | DeleteConfigurationProfileCommandOutput | DeleteDeploymentStrategyCommandOutput | DeleteEnvironmentCommandOutput | DeleteHostedConfigurationVersionCommandOutput | GetApplicationCommandOutput | GetConfigurationCommandOutput | GetConfigurationProfileCommandOutput | GetDeploymentCommandOutput | GetDeploymentStrategyCommandOutput | GetEnvironmentCommandOutput | GetHostedConfigurationVersionCommandOutput | ListApplicationsCommandOutput | ListConfigurationProfilesCommandOutput | ListDeploymentStrategiesCommandOutput | ListDeploymentsCommandOutput | ListEnvironmentsCommandOutput | ListHostedConfigurationVersionsCommandOutput | ListTagsForResourceCommandOutput | StartDeploymentCommandOutput | StopDeploymentCommandOutput | TagResourceCommandOutput | UntagResourceCommandOutput | UpdateApplicationCommandOutput | UpdateConfigurationProfileCommandOutput | UpdateDeploymentStrategyCommandOutput | UpdateEnvironmentCommandOutput | ValidateConfigurationCommandOutput;
 export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
-    /**
-     * The HTTP handler to use. Fetch in browser and Https in Nodejs.
-     */
+    
     requestHandler?: __HttpHandler;
-    /**
-     * A constructor for a class implementing the {@link __Hash} interface
-     * that computes the SHA-256 HMAC or checksum of a string or binary buffer.
-     * @internal
-     */
+    
     sha256?: __HashConstructor;
-    /**
-     * The function that will be used to convert strings into HTTP endpoints.
-     * @internal
-     */
+    
     urlParser?: __UrlParser;
-    /**
-     * A function that can calculate the length of a request body.
-     * @internal
-     */
+    
     bodyLengthChecker?: (body: any) => number | undefined;
-    /**
-     * A function that converts a stream into an array of bytes.
-     * @internal
-     */
+    
     streamCollector?: __StreamCollector;
-    /**
-     * The function that will be used to convert a base64-encoded string to a byte array.
-     * @internal
-     */
+    
     base64Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a base64-encoded string.
-     * @internal
-     */
+    
     base64Encoder?: __Encoder;
-    /**
-     * The function that will be used to convert a UTF8-encoded string to a byte array.
-     * @internal
-     */
+    
     utf8Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a UTF-8 encoded string.
-     * @internal
-     */
+    
     utf8Encoder?: __Encoder;
-    /**
-     * The runtime environment.
-     * @internal
-     */
+    
     runtime?: string;
-    /**
-     * Disable dyanamically changing the endpoint of the client based on the hostPrefix
-     * trait of an operation.
-     */
+    
     disableHostPrefix?: boolean;
-    /**
-     * Value for how many times a request will be made at most in case of retry.
-     */
+    
     maxAttempts?: number | __Provider<number>;
-    /**
-     * Specifies which retry algorithm to use.
-     */
+    
     retryMode?: string | __Provider<string>;
-    /**
-     * Optional logger for logging debug/info/warn/error.
-     */
+    
     logger?: __Logger;
-    /**
-     * Unique service identifier.
-     * @internal
-     */
+    
     serviceId?: string;
-    /**
-     * The AWS region to which this client will send requests
-     */
+    
     region?: string | __Provider<string>;
-    /**
-     * Default credentials provider; Not available in browser runtime.
-     * @internal
-     */
+    
     credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
-    /**
-     * Fetch related hostname, signing name or signing region with given region.
-     * @internal
-     */
+    
     regionInfoProvider?: RegionInfoProvider;
-    /**
-     * The provider populating default tracking information to be sent with `user-agent`, `x-amz-user-agent` header
-     * @internal
-     */
+    
     defaultUserAgentProvider?: Provider<__UserAgent>;
 }
 declare type AppConfigClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointsInputConfig & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig;
-/**
- * The configuration interface of AppConfigClient class constructor that set the region, credentials and other options.
- */
+
 export interface AppConfigClientConfig extends AppConfigClientConfigType {
 }
 declare type AppConfigClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RegionResolvedConfig & EndpointsResolvedConfig & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig;
-/**
- * The resolved configuration interface of AppConfigClient class. This is resolved and normalized from the {@link AppConfigClientConfig | constructor configuration interface}.
- */
+
 export interface AppConfigClientResolvedConfig extends AppConfigClientResolvedConfigType {
 }
-/**
- * <fullname>AWS AppConfig</fullname>
- *          <p>Use AWS AppConfig, a capability of AWS Systems Manager, to create, manage, and quickly deploy
- *          application configurations. AppConfig supports controlled deployments to applications of any
- *          size and includes built-in validation checks and monitoring. You can use AppConfig with
- *          applications hosted on Amazon EC2 instances, AWS Lambda, containers, mobile applications, or IoT
- *          devices.</p>
- *
- *          <p>To prevent errors when deploying application configurations, especially for production
- *          systems where a simple typo could cause an unexpected outage, AppConfig includes validators.
- *          A validator provides a syntactic or semantic check to ensure that the configuration you
- *          want to deploy works as intended. To validate your application configuration data, you
- *          provide a schema or a Lambda function that runs against the configuration. The
- *          configuration deployment or update can only proceed when the configuration data is
- *          valid.</p>
- *
- *          <p>During a configuration deployment, AppConfig monitors the application to ensure that the
- *          deployment is successful. If the system encounters an error, AppConfig rolls back the change
- *          to minimize impact for your application users. You can configure a deployment strategy for
- *          each application or environment that includes deployment criteria, including velocity, bake
- *          time, and alarms to monitor. Similar to error monitoring, if a deployment triggers an
- *          alarm, AppConfig automatically rolls back to the previous version. </p>
- *
- *          <p>AppConfig supports multiple use cases. Here are some examples.</p>
- *          <ul>
- *             <li>
- *                <p>
- *                   <b>Application tuning</b>: Use AppConfig to carefully
- *                introduce changes to your application that can only be tested with production
- *                traffic.</p>
- *             </li>
- *             <li>
- *                <p>
- *                   <b>Feature toggle</b>: Use AppConfig to turn on new
- *                features that require a timely deployment, such as a product launch or announcement.
- *             </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <b>Allow list</b>: Use AppConfig to allow premium
- *                subscribers to access paid content. </p>
- *             </li>
- *             <li>
- *                <p>
- *                   <b>Operational issues</b>: Use AppConfig to reduce stress
- *                on your application when a dependency or other external factor impacts the
- *                system.</p>
- *             </li>
- *          </ul>
- *          <p>This reference is intended to be used with the <a href="http://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig.html">AWS AppConfig User Guide</a>.</p>
- */
+
 export declare class AppConfigClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, AppConfigClientResolvedConfig> {
-    /**
-     * The resolved configuration of AppConfigClient class. This is resolved and normalized from the {@link AppConfigClientConfig | constructor configuration interface}.
-     */
+    
     readonly config: AppConfigClientResolvedConfig;
     constructor(configuration: AppConfigClientConfig);
-    /**
-     * Destroy underlying resources, like sockets. It's usually not necessary to do this.
-     * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
-     * Otherwise, sockets might stay open for quite a long time before the server terminates them.
-     */
+    
     destroy(): void;
 }
 export {};

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

@@ -6,32 +6,11 @@ export interface CreateApplicationCommandInput extends CreateApplicationRequest
 }
 export interface CreateApplicationCommandOutput extends Application, __MetadataBearer {
 }
-/**
- * <p>An application in AppConfig is a logical unit of code that provides capabilities for your
- *          customers. For example, an application can be a microservice that runs on Amazon EC2 instances,
- *          a mobile application installed by your users, a serverless application using Amazon API
- *          Gateway and AWS Lambda, or any system you run on behalf of others.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppConfigClient, CreateApplicationCommand } from "@aws-sdk/client-appconfig"; // ES Modules import
- * // const { AppConfigClient, CreateApplicationCommand } = require("@aws-sdk/client-appconfig"); // CommonJS import
- * const client = new AppConfigClient(config);
- * const command = new CreateApplicationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateApplicationCommandInput} for command's `input` shape.
- * @see {@link CreateApplicationCommandOutput} for command's `response` shape.
- * @see {@link AppConfigClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateApplicationCommand extends $Command<CreateApplicationCommandInput, CreateApplicationCommandOutput, AppConfigClientResolvedConfig> {
     readonly input: CreateApplicationCommandInput;
     constructor(input: CreateApplicationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppConfigClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateApplicationCommandInput, CreateApplicationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,46 +6,11 @@ export interface CreateConfigurationProfileCommandInput extends CreateConfigurat
 }
 export interface CreateConfigurationProfileCommandOutput extends ConfigurationProfile, __MetadataBearer {
 }
-/**
- * <p>Information that enables AppConfig to access the configuration source. Valid
- *          configuration sources include Systems Manager (SSM) documents, SSM Parameter Store parameters, and
- *          Amazon S3 objects. A configuration profile includes the following information.</p>
- *          <ul>
- *             <li>
- *                <p>The Uri location of the configuration data.</p>
- *             </li>
- *             <li>
- *                <p>The AWS Identity and Access Management (IAM) role that provides access to the configuration data.</p>
- *             </li>
- *             <li>
- *                <p>A validator for the configuration data. Available validators include either a JSON
- *                Schema or an AWS Lambda function.</p>
- *             </li>
- *          </ul>
- *          <p>For more information, see <a href="http://docs.aws.amazon.com/systems-manager/latest/userguide/appconfig-creating-configuration-and-profile.html">Create a
- *             Configuration and a Configuration Profile</a> in the
- *             <i>AWS AppConfig User Guide</i>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppConfigClient, CreateConfigurationProfileCommand } from "@aws-sdk/client-appconfig"; // ES Modules import
- * // const { AppConfigClient, CreateConfigurationProfileCommand } = require("@aws-sdk/client-appconfig"); // CommonJS import
- * const client = new AppConfigClient(config);
- * const command = new CreateConfigurationProfileCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateConfigurationProfileCommandInput} for command's `input` shape.
- * @see {@link CreateConfigurationProfileCommandOutput} for command's `response` shape.
- * @see {@link AppConfigClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateConfigurationProfileCommand extends $Command<CreateConfigurationProfileCommandInput, CreateConfigurationProfileCommandOutput, AppConfigClientResolvedConfig> {
     readonly input: CreateConfigurationProfileCommandInput;
     constructor(input: CreateConfigurationProfileCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppConfigClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateConfigurationProfileCommandInput, CreateConfigurationProfileCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface CreateDeploymentStrategyCommandInput extends CreateDeploymentSt
 }
 export interface CreateDeploymentStrategyCommandOutput extends DeploymentStrategy, __MetadataBearer {
 }
-/**
- * <p>A deployment strategy defines important criteria for rolling out your configuration to
- *          the designated targets. A deployment strategy includes: the overall duration required, a
- *          percentage of targets to receive the deployment during each interval, an algorithm that
- *          defines how percentage grows, and bake time.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppConfigClient, CreateDeploymentStrategyCommand } from "@aws-sdk/client-appconfig"; // ES Modules import
- * // const { AppConfigClient, CreateDeploymentStrategyCommand } = require("@aws-sdk/client-appconfig"); // CommonJS import
- * const client = new AppConfigClient(config);
- * const command = new CreateDeploymentStrategyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateDeploymentStrategyCommandInput} for command's `input` shape.
- * @see {@link CreateDeploymentStrategyCommandOutput} for command's `response` shape.
- * @see {@link AppConfigClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateDeploymentStrategyCommand extends $Command<CreateDeploymentStrategyCommandInput, CreateDeploymentStrategyCommandOutput, AppConfigClientResolvedConfig> {
     readonly input: CreateDeploymentStrategyCommandInput;
     constructor(input: CreateDeploymentStrategyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppConfigClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateDeploymentStrategyCommandInput, CreateDeploymentStrategyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface CreateEnvironmentCommandInput extends CreateEnvironmentRequest
 }
 export interface CreateEnvironmentCommandOutput extends Environment, __MetadataBearer {
 }
-/**
- * <p>For each application, you define one or more environments. An environment is a logical
- *          deployment group of AppConfig targets, such as applications in a <code>Beta</code> or
- *             <code>Production</code> environment. You can also define environments for application
- *          subcomponents such as the <code>Web</code>, <code>Mobile</code> and <code>Back-end</code>
- *          components for your application. You can configure Amazon CloudWatch alarms for each environment.
- *          The system monitors alarms during a configuration deployment. If an alarm is triggered, the
- *          system rolls back the configuration.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppConfigClient, CreateEnvironmentCommand } from "@aws-sdk/client-appconfig"; // ES Modules import
- * // const { AppConfigClient, CreateEnvironmentCommand } = require("@aws-sdk/client-appconfig"); // CommonJS import
- * const client = new AppConfigClient(config);
- * const command = new CreateEnvironmentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateEnvironmentCommandInput} for command's `input` shape.
- * @see {@link CreateEnvironmentCommandOutput} for command's `response` shape.
- * @see {@link AppConfigClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateEnvironmentCommand extends $Command<CreateEnvironmentCommandInput, CreateEnvironmentCommandOutput, AppConfigClientResolvedConfig> {
     readonly input: CreateEnvironmentCommandInput;
     constructor(input: CreateEnvironmentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppConfigClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateEnvironmentCommandInput, CreateEnvironmentCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CreateHostedConfigurationVersionCommandInput extends CreateHost
 }
 export interface CreateHostedConfigurationVersionCommandOutput extends HostedConfigurationVersion, __MetadataBearer {
 }
-/**
- * <p>Create a new configuration in the AppConfig configuration store.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppConfigClient, CreateHostedConfigurationVersionCommand } from "@aws-sdk/client-appconfig"; // ES Modules import
- * // const { AppConfigClient, CreateHostedConfigurationVersionCommand } = require("@aws-sdk/client-appconfig"); // CommonJS import
- * const client = new AppConfigClient(config);
- * const command = new CreateHostedConfigurationVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateHostedConfigurationVersionCommandInput} for command's `input` shape.
- * @see {@link CreateHostedConfigurationVersionCommandOutput} for command's `response` shape.
- * @see {@link AppConfigClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateHostedConfigurationVersionCommand extends $Command<CreateHostedConfigurationVersionCommandInput, CreateHostedConfigurationVersionCommandOutput, AppConfigClientResolvedConfig> {
     readonly input: CreateHostedConfigurationVersionCommandInput;
     constructor(input: CreateHostedConfigurationVersionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppConfigClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateHostedConfigurationVersionCommandInput, CreateHostedConfigurationVersionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DeleteApplicationCommandInput extends DeleteApplicationRequest
 }
 export interface DeleteApplicationCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Delete an application. Deleting an application does not delete a configuration from a
- *          host.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppConfigClient, DeleteApplicationCommand } from "@aws-sdk/client-appconfig"; // ES Modules import
- * // const { AppConfigClient, DeleteApplicationCommand } = require("@aws-sdk/client-appconfig"); // CommonJS import
- * const client = new AppConfigClient(config);
- * const command = new DeleteApplicationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteApplicationCommandInput} for command's `input` shape.
- * @see {@link DeleteApplicationCommandOutput} for command's `response` shape.
- * @see {@link AppConfigClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteApplicationCommand extends $Command<DeleteApplicationCommandInput, DeleteApplicationCommandOutput, AppConfigClientResolvedConfig> {
     readonly input: DeleteApplicationCommandInput;
     constructor(input: DeleteApplicationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppConfigClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteApplicationCommandInput, DeleteApplicationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DeleteConfigurationProfileCommandInput extends DeleteConfigurat
 }
 export interface DeleteConfigurationProfileCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Delete a configuration profile. Deleting a configuration profile does not delete a
- *          configuration from a host.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppConfigClient, DeleteConfigurationProfileCommand } from "@aws-sdk/client-appconfig"; // ES Modules import
- * // const { AppConfigClient, DeleteConfigurationProfileCommand } = require("@aws-sdk/client-appconfig"); // CommonJS import
- * const client = new AppConfigClient(config);
- * const command = new DeleteConfigurationProfileCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteConfigurationProfileCommandInput} for command's `input` shape.
- * @see {@link DeleteConfigurationProfileCommandOutput} for command's `response` shape.
- * @see {@link AppConfigClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteConfigurationProfileCommand extends $Command<DeleteConfigurationProfileCommandInput, DeleteConfigurationProfileCommandOutput, AppConfigClientResolvedConfig> {
     readonly input: DeleteConfigurationProfileCommandInput;
     constructor(input: DeleteConfigurationProfileCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppConfigClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteConfigurationProfileCommandInput, DeleteConfigurationProfileCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DeleteDeploymentStrategyCommandInput extends DeleteDeploymentSt
 }
 export interface DeleteDeploymentStrategyCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Delete a deployment strategy. Deleting a deployment strategy does not delete a
- *          configuration from a host.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppConfigClient, DeleteDeploymentStrategyCommand } from "@aws-sdk/client-appconfig"; // ES Modules import
- * // const { AppConfigClient, DeleteDeploymentStrategyCommand } = require("@aws-sdk/client-appconfig"); // CommonJS import
- * const client = new AppConfigClient(config);
- * const command = new DeleteDeploymentStrategyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDeploymentStrategyCommandInput} for command's `input` shape.
- * @see {@link DeleteDeploymentStrategyCommandOutput} for command's `response` shape.
- * @see {@link AppConfigClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDeploymentStrategyCommand extends $Command<DeleteDeploymentStrategyCommandInput, DeleteDeploymentStrategyCommandOutput, AppConfigClientResolvedConfig> {
     readonly input: DeleteDeploymentStrategyCommandInput;
     constructor(input: DeleteDeploymentStrategyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppConfigClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDeploymentStrategyCommandInput, DeleteDeploymentStrategyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface DeleteEnvironmentCommandInput extends DeleteEnvironmentRequest
 }
 export interface DeleteEnvironmentCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Delete an environment. Deleting an environment does not delete a configuration from a
- *          host.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppConfigClient, DeleteEnvironmentCommand } from "@aws-sdk/client-appconfig"; // ES Modules import
- * // const { AppConfigClient, DeleteEnvironmentCommand } = require("@aws-sdk/client-appconfig"); // CommonJS import
- * const client = new AppConfigClient(config);
- * const command = new DeleteEnvironmentCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteEnvironmentCommandInput} for command's `input` shape.
- * @see {@link DeleteEnvironmentCommandOutput} for command's `response` shape.
- * @see {@link AppConfigClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteEnvironmentCommand extends $Command<DeleteEnvironmentCommandInput, DeleteEnvironmentCommandOutput, AppConfigClientResolvedConfig> {
     readonly input: DeleteEnvironmentCommandInput;
     constructor(input: DeleteEnvironmentCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppConfigClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteEnvironmentCommandInput, DeleteEnvironmentCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteHostedConfigurationVersionCommandInput extends DeleteHost
 }
 export interface DeleteHostedConfigurationVersionCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Delete a version of a configuration from the AppConfig configuration store.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppConfigClient, DeleteHostedConfigurationVersionCommand } from "@aws-sdk/client-appconfig"; // ES Modules import
- * // const { AppConfigClient, DeleteHostedConfigurationVersionCommand } = require("@aws-sdk/client-appconfig"); // CommonJS import
- * const client = new AppConfigClient(config);
- * const command = new DeleteHostedConfigurationVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteHostedConfigurationVersionCommandInput} for command's `input` shape.
- * @see {@link DeleteHostedConfigurationVersionCommandOutput} for command's `response` shape.
- * @see {@link AppConfigClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteHostedConfigurationVersionCommand extends $Command<DeleteHostedConfigurationVersionCommandInput, DeleteHostedConfigurationVersionCommandOutput, AppConfigClientResolvedConfig> {
     readonly input: DeleteHostedConfigurationVersionCommandInput;
     constructor(input: DeleteHostedConfigurationVersionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppConfigClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteHostedConfigurationVersionCommandInput, DeleteHostedConfigurationVersionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetApplicationCommandInput extends GetApplicationRequest {
 }
 export interface GetApplicationCommandOutput extends Application, __MetadataBearer {
 }
-/**
- * <p>Retrieve information about an application.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppConfigClient, GetApplicationCommand } from "@aws-sdk/client-appconfig"; // ES Modules import
- * // const { AppConfigClient, GetApplicationCommand } = require("@aws-sdk/client-appconfig"); // CommonJS import
- * const client = new AppConfigClient(config);
- * const command = new GetApplicationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetApplicationCommandInput} for command's `input` shape.
- * @see {@link GetApplicationCommandOutput} for command's `response` shape.
- * @see {@link AppConfigClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetApplicationCommand extends $Command<GetApplicationCommandInput, GetApplicationCommandOutput, AppConfigClientResolvedConfig> {
     readonly input: GetApplicationCommandInput;
     constructor(input: GetApplicationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppConfigClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetApplicationCommandInput, GetApplicationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,41 +6,11 @@ export interface GetConfigurationCommandInput extends GetConfigurationRequest {
 }
 export interface GetConfigurationCommandOutput extends Configuration, __MetadataBearer {
 }
-/**
- * <p>Receive information about a configuration.</p>
- *          <important>
- *             <p>AWS AppConfig uses the value of the <code>ClientConfigurationVersion</code> parameter
- *             to identify the configuration version on your clients. If you don’t send
- *                <code>ClientConfigurationVersion</code> with each call to
- *                <code>GetConfiguration</code>, your clients receive the current configuration. You
- *             are charged each time your clients receive a configuration.</p>
- *             <p>To avoid excess charges, we recommend that you include the
- *                <code>ClientConfigurationVersion</code> value with every call to
- *                <code>GetConfiguration</code>. This value must be saved on your client. Subsequent
- *             calls to <code>GetConfiguration</code> must pass this value by using the
- *                <code>ClientConfigurationVersion</code> parameter. </p>
- *          </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppConfigClient, GetConfigurationCommand } from "@aws-sdk/client-appconfig"; // ES Modules import
- * // const { AppConfigClient, GetConfigurationCommand } = require("@aws-sdk/client-appconfig"); // CommonJS import
- * const client = new AppConfigClient(config);
- * const command = new GetConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetConfigurationCommandInput} for command's `input` shape.
- * @see {@link GetConfigurationCommandOutput} for command's `response` shape.
- * @see {@link AppConfigClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetConfigurationCommand extends $Command<GetConfigurationCommandInput, GetConfigurationCommandOutput, AppConfigClientResolvedConfig> {
     readonly input: GetConfigurationCommandInput;
     constructor(input: GetConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppConfigClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetConfigurationCommandInput, GetConfigurationCommandOutput>;
     private serialize;
     private deserialize;