@aws-sdk/client-appsync 3.35.0 → 3.38.0

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

@@ -6,35 +6,11 @@ export interface ListApiKeysCommandInput extends ListApiKeysRequest {
 }
 export interface ListApiKeysCommandOutput extends ListApiKeysResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the API keys for a given API.</p>
- *          <note>
- *             <p>API keys are deleted automatically 60 days after they expire. However, they may still
- *             be included in the response until they have actually been deleted. You can safely call
- *                <code>DeleteApiKey</code> to manually delete a key before it's automatically
- *             deleted.</p>
- *          </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppSyncClient, ListApiKeysCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, ListApiKeysCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new ListApiKeysCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListApiKeysCommandInput} for command's `input` shape.
- * @see {@link ListApiKeysCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListApiKeysCommand extends $Command<ListApiKeysCommandInput, ListApiKeysCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: ListApiKeysCommandInput;
     constructor(input: ListApiKeysCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListApiKeysCommandInput, ListApiKeysCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListDataSourcesCommandInput extends ListDataSourcesRequest {
 }
 export interface ListDataSourcesCommandOutput extends ListDataSourcesResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the data sources for a given API.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppSyncClient, ListDataSourcesCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, ListDataSourcesCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new ListDataSourcesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListDataSourcesCommandInput} for command's `input` shape.
- * @see {@link ListDataSourcesCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListDataSourcesCommand extends $Command<ListDataSourcesCommandInput, ListDataSourcesCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: ListDataSourcesCommandInput;
     constructor(input: ListDataSourcesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDataSourcesCommandInput, ListDataSourcesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListFunctionsCommandInput extends ListFunctionsRequest {
 }
 export interface ListFunctionsCommandOutput extends ListFunctionsResponse, __MetadataBearer {
 }
-/**
- * <p>List multiple functions.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppSyncClient, ListFunctionsCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, ListFunctionsCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new ListFunctionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListFunctionsCommandInput} for command's `input` shape.
- * @see {@link ListFunctionsCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListFunctionsCommand extends $Command<ListFunctionsCommandInput, ListFunctionsCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: ListFunctionsCommandInput;
     constructor(input: ListFunctionsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFunctionsCommandInput, ListFunctionsCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListGraphqlApisCommandInput extends ListGraphqlApisRequest {
 }
 export interface ListGraphqlApisCommandOutput extends ListGraphqlApisResponse, __MetadataBearer {
 }
-/**
- * <p>Lists your GraphQL APIs.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppSyncClient, ListGraphqlApisCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, ListGraphqlApisCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new ListGraphqlApisCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListGraphqlApisCommandInput} for command's `input` shape.
- * @see {@link ListGraphqlApisCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListGraphqlApisCommand extends $Command<ListGraphqlApisCommandInput, ListGraphqlApisCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: ListGraphqlApisCommandInput;
     constructor(input: ListGraphqlApisCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListGraphqlApisCommandInput, ListGraphqlApisCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListResolversByFunctionCommandInput extends ListResolversByFunc
 }
 export interface ListResolversByFunctionCommandOutput extends ListResolversByFunctionResponse, __MetadataBearer {
 }
-/**
- * <p>List the resolvers that are associated with a specific function.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppSyncClient, ListResolversByFunctionCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, ListResolversByFunctionCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new ListResolversByFunctionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListResolversByFunctionCommandInput} for command's `input` shape.
- * @see {@link ListResolversByFunctionCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListResolversByFunctionCommand extends $Command<ListResolversByFunctionCommandInput, ListResolversByFunctionCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: ListResolversByFunctionCommandInput;
     constructor(input: ListResolversByFunctionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListResolversByFunctionCommandInput, ListResolversByFunctionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListResolversCommandInput extends ListResolversRequest {
 }
 export interface ListResolversCommandOutput extends ListResolversResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the resolvers for a given API and type.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppSyncClient, ListResolversCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, ListResolversCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new ListResolversCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListResolversCommandInput} for command's `input` shape.
- * @see {@link ListResolversCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListResolversCommand extends $Command<ListResolversCommandInput, ListResolversCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: ListResolversCommandInput;
     constructor(input: ListResolversCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListResolversCommandInput, ListResolversCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequ
 }
 export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the tags for a resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppSyncClient, ListTagsForResourceCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, ListTagsForResourceCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new ListTagsForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
- * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListTypesCommandInput extends ListTypesRequest {
 }
 export interface ListTypesCommandOutput extends ListTypesResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the types for a given API.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppSyncClient, ListTypesCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, ListTypesCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new ListTypesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTypesCommandInput} for command's `input` shape.
- * @see {@link ListTypesCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTypesCommand extends $Command<ListTypesCommandInput, ListTypesCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: ListTypesCommandInput;
     constructor(input: ListTypesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTypesCommandInput, ListTypesCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface StartSchemaCreationCommandInput extends StartSchemaCreationRequ
 }
 export interface StartSchemaCreationCommandOutput extends StartSchemaCreationResponse, __MetadataBearer {
 }
-/**
- * <p>Adds a new schema to your GraphQL API.</p>
- *          <p>This operation is asynchronous. Use  to
- *          determine when it has completed.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppSyncClient, StartSchemaCreationCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, StartSchemaCreationCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new StartSchemaCreationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartSchemaCreationCommandInput} for command's `input` shape.
- * @see {@link StartSchemaCreationCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartSchemaCreationCommand extends $Command<StartSchemaCreationCommandInput, StartSchemaCreationCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: StartSchemaCreationCommandInput;
     constructor(input: StartSchemaCreationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartSchemaCreationCommandInput, StartSchemaCreationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface TagResourceCommandInput extends TagResourceRequest {
 }
 export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Tags a resource with user-supplied tags.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppSyncClient, TagResourceCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, TagResourceCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UntagResourceCommandInput extends UntagResourceRequest {
 }
 export interface UntagResourceCommandOutput extends UntagResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Untags a resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppSyncClient, UntagResourceCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, UntagResourceCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new UntagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UntagResourceCommandInput} for command's `input` shape.
- * @see {@link UntagResourceCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: UntagResourceCommandInput;
     constructor(input: UntagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateApiCacheCommandInput extends UpdateApiCacheRequest {
 }
 export interface UpdateApiCacheCommandOutput extends UpdateApiCacheResponse, __MetadataBearer {
 }
-/**
- * <p>Updates the cache for the GraphQL API.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppSyncClient, UpdateApiCacheCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, UpdateApiCacheCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new UpdateApiCacheCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateApiCacheCommandInput} for command's `input` shape.
- * @see {@link UpdateApiCacheCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateApiCacheCommand extends $Command<UpdateApiCacheCommandInput, UpdateApiCacheCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: UpdateApiCacheCommandInput;
     constructor(input: UpdateApiCacheCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateApiCacheCommandInput, UpdateApiCacheCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateApiKeyCommandInput extends UpdateApiKeyRequest {
 }
 export interface UpdateApiKeyCommandOutput extends UpdateApiKeyResponse, __MetadataBearer {
 }
-/**
- * <p>Updates an API key. The key can be updated while it is not deleted.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppSyncClient, UpdateApiKeyCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, UpdateApiKeyCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new UpdateApiKeyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateApiKeyCommandInput} for command's `input` shape.
- * @see {@link UpdateApiKeyCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateApiKeyCommand extends $Command<UpdateApiKeyCommandInput, UpdateApiKeyCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: UpdateApiKeyCommandInput;
     constructor(input: UpdateApiKeyCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateApiKeyCommandInput, UpdateApiKeyCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateDataSourceCommandInput extends UpdateDataSourceRequest {
 }
 export interface UpdateDataSourceCommandOutput extends UpdateDataSourceResponse, __MetadataBearer {
 }
-/**
- * <p>Updates a <code>DataSource</code> object.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppSyncClient, UpdateDataSourceCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, UpdateDataSourceCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new UpdateDataSourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateDataSourceCommandInput} for command's `input` shape.
- * @see {@link UpdateDataSourceCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateDataSourceCommand extends $Command<UpdateDataSourceCommandInput, UpdateDataSourceCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: UpdateDataSourceCommandInput;
     constructor(input: UpdateDataSourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateDataSourceCommandInput, UpdateDataSourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateFunctionCommandInput extends UpdateFunctionRequest {
 }
 export interface UpdateFunctionCommandOutput extends UpdateFunctionResponse, __MetadataBearer {
 }
-/**
- * <p>Updates a <code>Function</code> object.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppSyncClient, UpdateFunctionCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, UpdateFunctionCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new UpdateFunctionCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateFunctionCommandInput} for command's `input` shape.
- * @see {@link UpdateFunctionCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateFunctionCommand extends $Command<UpdateFunctionCommandInput, UpdateFunctionCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: UpdateFunctionCommandInput;
     constructor(input: UpdateFunctionCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateFunctionCommandInput, UpdateFunctionCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateGraphqlApiCommandInput extends UpdateGraphqlApiRequest {
 }
 export interface UpdateGraphqlApiCommandOutput extends UpdateGraphqlApiResponse, __MetadataBearer {
 }
-/**
- * <p>Updates a <code>GraphqlApi</code> object.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppSyncClient, UpdateGraphqlApiCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, UpdateGraphqlApiCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new UpdateGraphqlApiCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateGraphqlApiCommandInput} for command's `input` shape.
- * @see {@link UpdateGraphqlApiCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateGraphqlApiCommand extends $Command<UpdateGraphqlApiCommandInput, UpdateGraphqlApiCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: UpdateGraphqlApiCommandInput;
     constructor(input: UpdateGraphqlApiCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateGraphqlApiCommandInput, UpdateGraphqlApiCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateResolverCommandInput extends UpdateResolverRequest {
 }
 export interface UpdateResolverCommandOutput extends UpdateResolverResponse, __MetadataBearer {
 }
-/**
- * <p>Updates a <code>Resolver</code> object.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppSyncClient, UpdateResolverCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, UpdateResolverCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new UpdateResolverCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateResolverCommandInput} for command's `input` shape.
- * @see {@link UpdateResolverCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateResolverCommand extends $Command<UpdateResolverCommandInput, UpdateResolverCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: UpdateResolverCommandInput;
     constructor(input: UpdateResolverCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateResolverCommandInput, UpdateResolverCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface UpdateTypeCommandInput extends UpdateTypeRequest {
 }
 export interface UpdateTypeCommandOutput extends UpdateTypeResponse, __MetadataBearer {
 }
-/**
- * <p>Updates a <code>Type</code> object.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppSyncClient, UpdateTypeCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, UpdateTypeCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new UpdateTypeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateTypeCommandInput} for command's `input` shape.
- * @see {@link UpdateTypeCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateTypeCommand extends $Command<UpdateTypeCommandInput, UpdateTypeCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: UpdateTypeCommandInput;
     constructor(input: UpdateTypeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateTypeCommandInput, UpdateTypeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +1,41 @@
+export * from "./CreateApiCacheCommand";
+export * from "./CreateApiKeyCommand";
+export * from "./CreateDataSourceCommand";
+export * from "./CreateFunctionCommand";
+export * from "./CreateGraphqlApiCommand";
+export * from "./CreateResolverCommand";
+export * from "./CreateTypeCommand";
+export * from "./DeleteApiCacheCommand";
+export * from "./DeleteApiKeyCommand";
+export * from "./DeleteDataSourceCommand";
+export * from "./DeleteFunctionCommand";
+export * from "./DeleteGraphqlApiCommand";
+export * from "./DeleteResolverCommand";
+export * from "./DeleteTypeCommand";
+export * from "./FlushApiCacheCommand";
+export * from "./GetApiCacheCommand";
+export * from "./GetDataSourceCommand";
+export * from "./GetFunctionCommand";
+export * from "./GetGraphqlApiCommand";
+export * from "./GetIntrospectionSchemaCommand";
+export * from "./GetResolverCommand";
+export * from "./GetSchemaCreationStatusCommand";
+export * from "./GetTypeCommand";
+export * from "./ListApiKeysCommand";
+export * from "./ListDataSourcesCommand";
+export * from "./ListFunctionsCommand";
+export * from "./ListGraphqlApisCommand";
+export * from "./ListResolversByFunctionCommand";
+export * from "./ListResolversCommand";
+export * from "./ListTagsForResourceCommand";
+export * from "./ListTypesCommand";
+export * from "./StartSchemaCreationCommand";
+export * from "./TagResourceCommand";
+export * from "./UntagResourceCommand";
+export * from "./UpdateApiCacheCommand";
+export * from "./UpdateApiKeyCommand";
+export * from "./UpdateDataSourceCommand";
+export * from "./UpdateFunctionCommand";
+export * from "./UpdateGraphqlApiCommand";
+export * from "./UpdateResolverCommand";
+export * from "./UpdateTypeCommand";