@aws-sdk/client-kinesis-analytics-v2 3.35.0 → 3.38.0

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

@@ -6,41 +6,11 @@ export interface AddApplicationOutputCommandInput extends AddApplicationOutputRe
 }
 export interface AddApplicationOutputCommandOutput extends AddApplicationOutputResponse, __MetadataBearer {
 }
-/**
- * <p>Adds an external destination to your SQL-based Kinesis Data Analytics application.</p>
- *          <p>If you want Kinesis Data Analytics to deliver data from an in-application stream within
- *       your application to an external destination (such as an Kinesis data stream, a Kinesis Data
- *       Firehose delivery stream, or an AWS Lambda function), you add the relevant configuration to
- *       your application using this operation. You can configure one or more outputs for your
- *       application. Each output configuration maps an in-application stream and an external
- *       destination.</p>
- *          <p> You can use one of the output configurations to deliver data from your
- *       in-application error stream to an external destination so that you can analyze the
- *       errors.  </p>
- *          <p> Any configuration update, including adding a streaming source using this
- *       operation, results in a new version of the application. You can use the <a>DescribeApplication</a> operation to find the current application
- *       version.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisAnalyticsV2Client, AddApplicationOutputCommand } from "@aws-sdk/client-kinesis-analytics-v2"; // ES Modules import
- * // const { KinesisAnalyticsV2Client, AddApplicationOutputCommand } = require("@aws-sdk/client-kinesis-analytics-v2"); // CommonJS import
- * const client = new KinesisAnalyticsV2Client(config);
- * const command = new AddApplicationOutputCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AddApplicationOutputCommandInput} for command's `input` shape.
- * @see {@link AddApplicationOutputCommandOutput} for command's `response` shape.
- * @see {@link KinesisAnalyticsV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AddApplicationOutputCommand extends $Command<AddApplicationOutputCommandInput, AddApplicationOutputCommandOutput, KinesisAnalyticsV2ClientResolvedConfig> {
     readonly input: AddApplicationOutputCommandInput;
     constructor(input: AddApplicationOutputCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisAnalyticsV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AddApplicationOutputCommandInput, AddApplicationOutputCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,34 +6,11 @@ export interface AddApplicationReferenceDataSourceCommandInput extends AddApplic
 }
 export interface AddApplicationReferenceDataSourceCommandOutput extends AddApplicationReferenceDataSourceResponse, __MetadataBearer {
 }
-/**
- * <p>Adds a reference data source to an existing SQL-based Kinesis Data Analytics application.</p>
- *          <p>Kinesis Data Analytics reads reference data (that is, an Amazon S3 object) and creates an
- *       in-application table within your application. In the request, you provide the source (S3
- *       bucket name and object key name), name of the in-application table to create, and the
- *       necessary mapping information that describes how data in an Amazon S3 object maps to columns
- *       in the resulting in-application table.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisAnalyticsV2Client, AddApplicationReferenceDataSourceCommand } from "@aws-sdk/client-kinesis-analytics-v2"; // ES Modules import
- * // const { KinesisAnalyticsV2Client, AddApplicationReferenceDataSourceCommand } = require("@aws-sdk/client-kinesis-analytics-v2"); // CommonJS import
- * const client = new KinesisAnalyticsV2Client(config);
- * const command = new AddApplicationReferenceDataSourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AddApplicationReferenceDataSourceCommandInput} for command's `input` shape.
- * @see {@link AddApplicationReferenceDataSourceCommandOutput} for command's `response` shape.
- * @see {@link KinesisAnalyticsV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AddApplicationReferenceDataSourceCommand extends $Command<AddApplicationReferenceDataSourceCommandInput, AddApplicationReferenceDataSourceCommandOutput, KinesisAnalyticsV2ClientResolvedConfig> {
     readonly input: AddApplicationReferenceDataSourceCommandInput;
     constructor(input: AddApplicationReferenceDataSourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisAnalyticsV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AddApplicationReferenceDataSourceCommandInput, AddApplicationReferenceDataSourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,40 +6,11 @@ export interface AddApplicationVpcConfigurationCommandInput extends AddApplicati
 }
 export interface AddApplicationVpcConfigurationCommandOutput extends AddApplicationVpcConfigurationResponse, __MetadataBearer {
 }
-/**
- * <p>Adds a Virtual Private Cloud (VPC) configuration to the application. Applications can use VPCs to store
- *         and access resources securely.</p>
- *          <p>Note the following about VPC configurations for Kinesis Data Analytics applications:</p>
- *          <ul>
- *             <li>
- *                <p>VPC configurations are not supported for SQL applications.</p>
- *             </li>
- *             <li>
- *                <p>When a VPC is added to a Kinesis Data Analytics application, the application can no longer be accessed from the
- *            Internet directly. To enable Internet access to the application, add an Internet gateway to your VPC.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisAnalyticsV2Client, AddApplicationVpcConfigurationCommand } from "@aws-sdk/client-kinesis-analytics-v2"; // ES Modules import
- * // const { KinesisAnalyticsV2Client, AddApplicationVpcConfigurationCommand } = require("@aws-sdk/client-kinesis-analytics-v2"); // CommonJS import
- * const client = new KinesisAnalyticsV2Client(config);
- * const command = new AddApplicationVpcConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link AddApplicationVpcConfigurationCommandInput} for command's `input` shape.
- * @see {@link AddApplicationVpcConfigurationCommandOutput} for command's `response` shape.
- * @see {@link KinesisAnalyticsV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class AddApplicationVpcConfigurationCommand extends $Command<AddApplicationVpcConfigurationCommandInput, AddApplicationVpcConfigurationCommandOutput, KinesisAnalyticsV2ClientResolvedConfig> {
     readonly input: AddApplicationVpcConfigurationCommandInput;
     constructor(input: AddApplicationVpcConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisAnalyticsV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AddApplicationVpcConfigurationCommandInput, AddApplicationVpcConfigurationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface CreateApplicationCommandInput extends CreateApplicationRequest
 }
 export interface CreateApplicationCommandOutput extends CreateApplicationResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a Kinesis Data Analytics application. For information about creating a
- *           Kinesis Data Analytics application, see <a href="https://docs.aws.amazon.com/kinesisanalytics/latest/java/getting-started.html">Creating an
- *         Application</a>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisAnalyticsV2Client, CreateApplicationCommand } from "@aws-sdk/client-kinesis-analytics-v2"; // ES Modules import
- * // const { KinesisAnalyticsV2Client, CreateApplicationCommand } = require("@aws-sdk/client-kinesis-analytics-v2"); // CommonJS import
- * const client = new KinesisAnalyticsV2Client(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 KinesisAnalyticsV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateApplicationCommand extends $Command<CreateApplicationCommandInput, CreateApplicationCommandOutput, KinesisAnalyticsV2ClientResolvedConfig> {
     readonly input: CreateApplicationCommandInput;
     constructor(input: CreateApplicationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisAnalyticsV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateApplicationCommandInput, CreateApplicationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,42 +6,11 @@ export interface CreateApplicationPresignedUrlCommandInput extends CreateApplica
 }
 export interface CreateApplicationPresignedUrlCommandOutput extends CreateApplicationPresignedUrlResponse, __MetadataBearer {
 }
-/**
- * <p>Creates and returns a URL that you can use to connect to
- *             an application's extension. Currently, the only
- *             available extension is the Apache Flink dashboard.</p>
- *         <p>The IAM role or user used to call this API defines the permissions to access the
- *       extension. After the presigned URL is created, no additional permission is required to access
- *       this URL. IAM authorization policies for this API are also enforced for every HTTP request
- *       that attempts to connect to the extension. </p>
- *         <p>You    control the amount of time that the URL will be valid using the <code>SessionExpirationDurationInSeconds</code>
- *         parameter. If you do not provide this parameter, the returned URL is valid for twelve hours.</p>
- *         <note>
- *             <p>The URL that you get from a call to CreateApplicationPresignedUrl must be used within 3 minutes
- *             to be valid.
- *             If you first try to use the URL after the 3-minute limit expires, the service returns an HTTP 403 Forbidden error.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisAnalyticsV2Client, CreateApplicationPresignedUrlCommand } from "@aws-sdk/client-kinesis-analytics-v2"; // ES Modules import
- * // const { KinesisAnalyticsV2Client, CreateApplicationPresignedUrlCommand } = require("@aws-sdk/client-kinesis-analytics-v2"); // CommonJS import
- * const client = new KinesisAnalyticsV2Client(config);
- * const command = new CreateApplicationPresignedUrlCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateApplicationPresignedUrlCommandInput} for command's `input` shape.
- * @see {@link CreateApplicationPresignedUrlCommandOutput} for command's `response` shape.
- * @see {@link KinesisAnalyticsV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateApplicationPresignedUrlCommand extends $Command<CreateApplicationPresignedUrlCommandInput, CreateApplicationPresignedUrlCommandOutput, KinesisAnalyticsV2ClientResolvedConfig> {
     readonly input: CreateApplicationPresignedUrlCommandInput;
     constructor(input: CreateApplicationPresignedUrlCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisAnalyticsV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateApplicationPresignedUrlCommandInput, CreateApplicationPresignedUrlCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CreateApplicationSnapshotCommandInput extends CreateApplication
 }
 export interface CreateApplicationSnapshotCommandOutput extends CreateApplicationSnapshotResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a snapshot of the application's state data.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisAnalyticsV2Client, CreateApplicationSnapshotCommand } from "@aws-sdk/client-kinesis-analytics-v2"; // ES Modules import
- * // const { KinesisAnalyticsV2Client, CreateApplicationSnapshotCommand } = require("@aws-sdk/client-kinesis-analytics-v2"); // CommonJS import
- * const client = new KinesisAnalyticsV2Client(config);
- * const command = new CreateApplicationSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateApplicationSnapshotCommandInput} for command's `input` shape.
- * @see {@link CreateApplicationSnapshotCommandOutput} for command's `response` shape.
- * @see {@link KinesisAnalyticsV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateApplicationSnapshotCommand extends $Command<CreateApplicationSnapshotCommandInput, CreateApplicationSnapshotCommandOutput, KinesisAnalyticsV2ClientResolvedConfig> {
     readonly input: CreateApplicationSnapshotCommandInput;
     constructor(input: CreateApplicationSnapshotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisAnalyticsV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateApplicationSnapshotCommandInput, CreateApplicationSnapshotCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteApplicationCloudWatchLoggingOptionCommandInput extends De
 }
 export interface DeleteApplicationCloudWatchLoggingOptionCommandOutput extends DeleteApplicationCloudWatchLoggingOptionResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes an Amazon CloudWatch log stream from an Kinesis Data Analytics application. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisAnalyticsV2Client, DeleteApplicationCloudWatchLoggingOptionCommand } from "@aws-sdk/client-kinesis-analytics-v2"; // ES Modules import
- * // const { KinesisAnalyticsV2Client, DeleteApplicationCloudWatchLoggingOptionCommand } = require("@aws-sdk/client-kinesis-analytics-v2"); // CommonJS import
- * const client = new KinesisAnalyticsV2Client(config);
- * const command = new DeleteApplicationCloudWatchLoggingOptionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteApplicationCloudWatchLoggingOptionCommandInput} for command's `input` shape.
- * @see {@link DeleteApplicationCloudWatchLoggingOptionCommandOutput} for command's `response` shape.
- * @see {@link KinesisAnalyticsV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteApplicationCloudWatchLoggingOptionCommand extends $Command<DeleteApplicationCloudWatchLoggingOptionCommandInput, DeleteApplicationCloudWatchLoggingOptionCommandOutput, KinesisAnalyticsV2ClientResolvedConfig> {
     readonly input: DeleteApplicationCloudWatchLoggingOptionCommandInput;
     constructor(input: DeleteApplicationCloudWatchLoggingOptionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisAnalyticsV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteApplicationCloudWatchLoggingOptionCommandInput, DeleteApplicationCloudWatchLoggingOptionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteApplicationCommandInput extends DeleteApplicationRequest
 }
 export interface DeleteApplicationCommandOutput extends DeleteApplicationResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes the specified application. Kinesis Data Analytics halts application execution and deletes the application.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisAnalyticsV2Client, DeleteApplicationCommand } from "@aws-sdk/client-kinesis-analytics-v2"; // ES Modules import
- * // const { KinesisAnalyticsV2Client, DeleteApplicationCommand } = require("@aws-sdk/client-kinesis-analytics-v2"); // CommonJS import
- * const client = new KinesisAnalyticsV2Client(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 KinesisAnalyticsV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteApplicationCommand extends $Command<DeleteApplicationCommandInput, DeleteApplicationCommandOutput, KinesisAnalyticsV2ClientResolvedConfig> {
     readonly input: DeleteApplicationCommandInput;
     constructor(input: DeleteApplicationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisAnalyticsV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteApplicationCommandInput, DeleteApplicationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteApplicationInputProcessingConfigurationCommandInput exten
 }
 export interface DeleteApplicationInputProcessingConfigurationCommandOutput extends DeleteApplicationInputProcessingConfigurationResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes an <a>InputProcessingConfiguration</a> from an input.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisAnalyticsV2Client, DeleteApplicationInputProcessingConfigurationCommand } from "@aws-sdk/client-kinesis-analytics-v2"; // ES Modules import
- * // const { KinesisAnalyticsV2Client, DeleteApplicationInputProcessingConfigurationCommand } = require("@aws-sdk/client-kinesis-analytics-v2"); // CommonJS import
- * const client = new KinesisAnalyticsV2Client(config);
- * const command = new DeleteApplicationInputProcessingConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteApplicationInputProcessingConfigurationCommandInput} for command's `input` shape.
- * @see {@link DeleteApplicationInputProcessingConfigurationCommandOutput} for command's `response` shape.
- * @see {@link KinesisAnalyticsV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteApplicationInputProcessingConfigurationCommand extends $Command<DeleteApplicationInputProcessingConfigurationCommandInput, DeleteApplicationInputProcessingConfigurationCommandOutput, KinesisAnalyticsV2ClientResolvedConfig> {
     readonly input: DeleteApplicationInputProcessingConfigurationCommandInput;
     constructor(input: DeleteApplicationInputProcessingConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisAnalyticsV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteApplicationInputProcessingConfigurationCommandInput, DeleteApplicationInputProcessingConfigurationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DeleteApplicationOutputCommandInput extends DeleteApplicationOu
 }
 export interface DeleteApplicationOutputCommandOutput extends DeleteApplicationOutputResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes the output destination configuration from your SQL-based Kinesis Data Analytics application's configuration.
- *       Kinesis Data Analytics will no longer write data from
- *       the corresponding in-application stream to the external output destination.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisAnalyticsV2Client, DeleteApplicationOutputCommand } from "@aws-sdk/client-kinesis-analytics-v2"; // ES Modules import
- * // const { KinesisAnalyticsV2Client, DeleteApplicationOutputCommand } = require("@aws-sdk/client-kinesis-analytics-v2"); // CommonJS import
- * const client = new KinesisAnalyticsV2Client(config);
- * const command = new DeleteApplicationOutputCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteApplicationOutputCommandInput} for command's `input` shape.
- * @see {@link DeleteApplicationOutputCommandOutput} for command's `response` shape.
- * @see {@link KinesisAnalyticsV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteApplicationOutputCommand extends $Command<DeleteApplicationOutputCommandInput, DeleteApplicationOutputCommandOutput, KinesisAnalyticsV2ClientResolvedConfig> {
     readonly input: DeleteApplicationOutputCommandInput;
     constructor(input: DeleteApplicationOutputCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisAnalyticsV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteApplicationOutputCommandInput, DeleteApplicationOutputCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DeleteApplicationReferenceDataSourceCommandInput extends Delete
 }
 export interface DeleteApplicationReferenceDataSourceCommandOutput extends DeleteApplicationReferenceDataSourceResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a reference data source configuration from the specified SQL-based Kinesis Data Analytics application's configuration.</p>
- *          <p>If the application is running, Kinesis Data Analytics immediately removes the in-application table
- *       that you created using the <a>AddApplicationReferenceDataSource</a> operation.  </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisAnalyticsV2Client, DeleteApplicationReferenceDataSourceCommand } from "@aws-sdk/client-kinesis-analytics-v2"; // ES Modules import
- * // const { KinesisAnalyticsV2Client, DeleteApplicationReferenceDataSourceCommand } = require("@aws-sdk/client-kinesis-analytics-v2"); // CommonJS import
- * const client = new KinesisAnalyticsV2Client(config);
- * const command = new DeleteApplicationReferenceDataSourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteApplicationReferenceDataSourceCommandInput} for command's `input` shape.
- * @see {@link DeleteApplicationReferenceDataSourceCommandOutput} for command's `response` shape.
- * @see {@link KinesisAnalyticsV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteApplicationReferenceDataSourceCommand extends $Command<DeleteApplicationReferenceDataSourceCommandInput, DeleteApplicationReferenceDataSourceCommandOutput, KinesisAnalyticsV2ClientResolvedConfig> {
     readonly input: DeleteApplicationReferenceDataSourceCommandInput;
     constructor(input: DeleteApplicationReferenceDataSourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisAnalyticsV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteApplicationReferenceDataSourceCommandInput, DeleteApplicationReferenceDataSourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteApplicationSnapshotCommandInput extends DeleteApplication
 }
 export interface DeleteApplicationSnapshotCommandOutput extends DeleteApplicationSnapshotResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes a snapshot of application state.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisAnalyticsV2Client, DeleteApplicationSnapshotCommand } from "@aws-sdk/client-kinesis-analytics-v2"; // ES Modules import
- * // const { KinesisAnalyticsV2Client, DeleteApplicationSnapshotCommand } = require("@aws-sdk/client-kinesis-analytics-v2"); // CommonJS import
- * const client = new KinesisAnalyticsV2Client(config);
- * const command = new DeleteApplicationSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteApplicationSnapshotCommandInput} for command's `input` shape.
- * @see {@link DeleteApplicationSnapshotCommandOutput} for command's `response` shape.
- * @see {@link KinesisAnalyticsV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteApplicationSnapshotCommand extends $Command<DeleteApplicationSnapshotCommandInput, DeleteApplicationSnapshotCommandOutput, KinesisAnalyticsV2ClientResolvedConfig> {
     readonly input: DeleteApplicationSnapshotCommandInput;
     constructor(input: DeleteApplicationSnapshotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisAnalyticsV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteApplicationSnapshotCommandInput, DeleteApplicationSnapshotCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteApplicationVpcConfigurationCommandInput extends DeleteApp
 }
 export interface DeleteApplicationVpcConfigurationCommandOutput extends DeleteApplicationVpcConfigurationResponse, __MetadataBearer {
 }
-/**
- * <p>Removes a VPC configuration from a Kinesis Data Analytics application.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisAnalyticsV2Client, DeleteApplicationVpcConfigurationCommand } from "@aws-sdk/client-kinesis-analytics-v2"; // ES Modules import
- * // const { KinesisAnalyticsV2Client, DeleteApplicationVpcConfigurationCommand } = require("@aws-sdk/client-kinesis-analytics-v2"); // CommonJS import
- * const client = new KinesisAnalyticsV2Client(config);
- * const command = new DeleteApplicationVpcConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteApplicationVpcConfigurationCommandInput} for command's `input` shape.
- * @see {@link DeleteApplicationVpcConfigurationCommandOutput} for command's `response` shape.
- * @see {@link KinesisAnalyticsV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteApplicationVpcConfigurationCommand extends $Command<DeleteApplicationVpcConfigurationCommandInput, DeleteApplicationVpcConfigurationCommandOutput, KinesisAnalyticsV2ClientResolvedConfig> {
     readonly input: DeleteApplicationVpcConfigurationCommandInput;
     constructor(input: DeleteApplicationVpcConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisAnalyticsV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteApplicationVpcConfigurationCommandInput, DeleteApplicationVpcConfigurationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface DescribeApplicationCommandInput extends DescribeApplicationRequ
 }
 export interface DescribeApplicationCommandOutput extends DescribeApplicationResponse, __MetadataBearer {
 }
-/**
- * <p>Returns information about a specific Kinesis Data Analytics application.</p>
- *          <p>If you want to retrieve a list of all applications in your account,
- *       use the <a>ListApplications</a> operation.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisAnalyticsV2Client, DescribeApplicationCommand } from "@aws-sdk/client-kinesis-analytics-v2"; // ES Modules import
- * // const { KinesisAnalyticsV2Client, DescribeApplicationCommand } = require("@aws-sdk/client-kinesis-analytics-v2"); // CommonJS import
- * const client = new KinesisAnalyticsV2Client(config);
- * const command = new DescribeApplicationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeApplicationCommandInput} for command's `input` shape.
- * @see {@link DescribeApplicationCommandOutput} for command's `response` shape.
- * @see {@link KinesisAnalyticsV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeApplicationCommand extends $Command<DescribeApplicationCommandInput, DescribeApplicationCommandOutput, KinesisAnalyticsV2ClientResolvedConfig> {
     readonly input: DescribeApplicationCommandInput;
     constructor(input: DescribeApplicationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisAnalyticsV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeApplicationCommandInput, DescribeApplicationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DescribeApplicationSnapshotCommandInput extends DescribeApplica
 }
 export interface DescribeApplicationSnapshotCommandOutput extends DescribeApplicationSnapshotResponse, __MetadataBearer {
 }
-/**
- * <p>Returns information about a snapshot of application state data.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisAnalyticsV2Client, DescribeApplicationSnapshotCommand } from "@aws-sdk/client-kinesis-analytics-v2"; // ES Modules import
- * // const { KinesisAnalyticsV2Client, DescribeApplicationSnapshotCommand } = require("@aws-sdk/client-kinesis-analytics-v2"); // CommonJS import
- * const client = new KinesisAnalyticsV2Client(config);
- * const command = new DescribeApplicationSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeApplicationSnapshotCommandInput} for command's `input` shape.
- * @see {@link DescribeApplicationSnapshotCommandOutput} for command's `response` shape.
- * @see {@link KinesisAnalyticsV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeApplicationSnapshotCommand extends $Command<DescribeApplicationSnapshotCommandInput, DescribeApplicationSnapshotCommandOutput, KinesisAnalyticsV2ClientResolvedConfig> {
     readonly input: DescribeApplicationSnapshotCommandInput;
     constructor(input: DescribeApplicationSnapshotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisAnalyticsV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeApplicationSnapshotCommandInput, DescribeApplicationSnapshotCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface DescribeApplicationVersionCommandInput extends DescribeApplicat
 }
 export interface DescribeApplicationVersionCommandOutput extends DescribeApplicationVersionResponse, __MetadataBearer {
 }
-/**
- * <p>Provides a detailed description of a specified version of the application. To see a list of all the versions of an application, invoke the <a>ListApplicationVersions</a> operation.</p>
- *          <note>
- *             <p>This operation is supported only for Amazon Kinesis Data Analytics for Apache Flink.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisAnalyticsV2Client, DescribeApplicationVersionCommand } from "@aws-sdk/client-kinesis-analytics-v2"; // ES Modules import
- * // const { KinesisAnalyticsV2Client, DescribeApplicationVersionCommand } = require("@aws-sdk/client-kinesis-analytics-v2"); // CommonJS import
- * const client = new KinesisAnalyticsV2Client(config);
- * const command = new DescribeApplicationVersionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DescribeApplicationVersionCommandInput} for command's `input` shape.
- * @see {@link DescribeApplicationVersionCommandOutput} for command's `response` shape.
- * @see {@link KinesisAnalyticsV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DescribeApplicationVersionCommand extends $Command<DescribeApplicationVersionCommandInput, DescribeApplicationVersionCommandOutput, KinesisAnalyticsV2ClientResolvedConfig> {
     readonly input: DescribeApplicationVersionCommandInput;
     constructor(input: DescribeApplicationVersionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisAnalyticsV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DescribeApplicationVersionCommandInput, DescribeApplicationVersionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,35 +6,11 @@ export interface DiscoverInputSchemaCommandInput extends DiscoverInputSchemaRequ
 }
 export interface DiscoverInputSchemaCommandOutput extends DiscoverInputSchemaResponse, __MetadataBearer {
 }
-/**
- * <p>Infers a schema for a SQL-based Kinesis Data Analytics application by evaluating
- *       sample records on the specified streaming source (Kinesis data stream or Kinesis Data Firehose
- *       delivery stream) or Amazon S3 object. In the response, the operation returns the inferred
- *       schema and also the sample records that the operation used to infer the schema.</p>
- *          <p> You can use the inferred schema when configuring a streaming source for your application.
- *       When you create an application using the Kinesis Data Analytics console, the console uses this
- *       operation to infer a schema and show it in the console user interface. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { KinesisAnalyticsV2Client, DiscoverInputSchemaCommand } from "@aws-sdk/client-kinesis-analytics-v2"; // ES Modules import
- * // const { KinesisAnalyticsV2Client, DiscoverInputSchemaCommand } = require("@aws-sdk/client-kinesis-analytics-v2"); // CommonJS import
- * const client = new KinesisAnalyticsV2Client(config);
- * const command = new DiscoverInputSchemaCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DiscoverInputSchemaCommandInput} for command's `input` shape.
- * @see {@link DiscoverInputSchemaCommandOutput} for command's `response` shape.
- * @see {@link KinesisAnalyticsV2ClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DiscoverInputSchemaCommand extends $Command<DiscoverInputSchemaCommandInput, DiscoverInputSchemaCommandOutput, KinesisAnalyticsV2ClientResolvedConfig> {
     readonly input: DiscoverInputSchemaCommandInput;
     constructor(input: DiscoverInputSchemaCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: KinesisAnalyticsV2ClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DiscoverInputSchemaCommandInput, DiscoverInputSchemaCommandOutput>;
     private serialize;
     private deserialize;