@aws-sdk/client-appsync 3.35.0 → 3.38.0

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

@@ -6,29 +6,11 @@ export interface CreateGraphqlApiCommandInput extends CreateGraphqlApiRequest {
 }
 export interface CreateGraphqlApiCommandOutput extends CreateGraphqlApiResponse, __MetadataBearer {
 }
-/**
- * <p>Creates 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, CreateGraphqlApiCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, CreateGraphqlApiCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new CreateGraphqlApiCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateGraphqlApiCommandInput} for command's `input` shape.
- * @see {@link CreateGraphqlApiCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateGraphqlApiCommand extends $Command<CreateGraphqlApiCommandInput, CreateGraphqlApiCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: CreateGraphqlApiCommandInput;
     constructor(input: CreateGraphqlApiCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateGraphqlApiCommandInput, CreateGraphqlApiCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface CreateResolverCommandInput extends CreateResolverRequest {
 }
 export interface CreateResolverCommandOutput extends CreateResolverResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a <code>Resolver</code> object.</p>
- *          <p>A resolver converts incoming requests into a format that a data source can understand
- *          and converts the data source's responses into GraphQL.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { AppSyncClient, CreateResolverCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, CreateResolverCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new CreateResolverCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateResolverCommandInput} for command's `input` shape.
- * @see {@link CreateResolverCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateResolverCommand extends $Command<CreateResolverCommandInput, CreateResolverCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: CreateResolverCommandInput;
     constructor(input: CreateResolverCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateResolverCommandInput, CreateResolverCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface CreateTypeCommandInput extends CreateTypeRequest {
 }
 export interface CreateTypeCommandOutput extends CreateTypeResponse, __MetadataBearer {
 }
-/**
- * <p>Creates 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, CreateTypeCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, CreateTypeCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new CreateTypeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CreateTypeCommandInput} for command's `input` shape.
- * @see {@link CreateTypeCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CreateTypeCommand extends $Command<CreateTypeCommandInput, CreateTypeCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: CreateTypeCommandInput;
     constructor(input: CreateTypeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTypeCommandInput, CreateTypeCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface DeleteDataSourceCommandInput extends DeleteDataSourceRequest {
 }
 export interface DeleteDataSourceCommandOutput extends DeleteDataSourceResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes 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, DeleteDataSourceCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, DeleteDataSourceCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new DeleteDataSourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteDataSourceCommandInput} for command's `input` shape.
- * @see {@link DeleteDataSourceCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteDataSourceCommand extends $Command<DeleteDataSourceCommandInput, DeleteDataSourceCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: DeleteDataSourceCommandInput;
     constructor(input: DeleteDataSourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteDataSourceCommandInput, DeleteDataSourceCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface DeleteGraphqlApiCommandInput extends DeleteGraphqlApiRequest {
 }
 export interface DeleteGraphqlApiCommandOutput extends DeleteGraphqlApiResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes 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, DeleteGraphqlApiCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, DeleteGraphqlApiCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new DeleteGraphqlApiCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteGraphqlApiCommandInput} for command's `input` shape.
- * @see {@link DeleteGraphqlApiCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteGraphqlApiCommand extends $Command<DeleteGraphqlApiCommandInput, DeleteGraphqlApiCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: DeleteGraphqlApiCommandInput;
     constructor(input: DeleteGraphqlApiCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteGraphqlApiCommandInput, DeleteGraphqlApiCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteResolverCommandInput extends DeleteResolverRequest {
 }
 export interface DeleteResolverCommandOutput extends DeleteResolverResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes 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, DeleteResolverCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, DeleteResolverCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new DeleteResolverCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteResolverCommandInput} for command's `input` shape.
- * @see {@link DeleteResolverCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteResolverCommand extends $Command<DeleteResolverCommandInput, DeleteResolverCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: DeleteResolverCommandInput;
     constructor(input: DeleteResolverCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteResolverCommandInput, DeleteResolverCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface DeleteTypeCommandInput extends DeleteTypeRequest {
 }
 export interface DeleteTypeCommandOutput extends DeleteTypeResponse, __MetadataBearer {
 }
-/**
- * <p>Deletes 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, DeleteTypeCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, DeleteTypeCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new DeleteTypeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteTypeCommandInput} for command's `input` shape.
- * @see {@link DeleteTypeCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class DeleteTypeCommand extends $Command<DeleteTypeCommandInput, DeleteTypeCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: DeleteTypeCommandInput;
     constructor(input: DeleteTypeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteTypeCommandInput, DeleteTypeCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,29 +6,11 @@ export interface GetDataSourceCommandInput extends GetDataSourceRequest {
 }
 export interface GetDataSourceCommandOutput extends GetDataSourceResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves 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, GetDataSourceCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, GetDataSourceCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new GetDataSourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetDataSourceCommandInput} for command's `input` shape.
- * @see {@link GetDataSourceCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetDataSourceCommand extends $Command<GetDataSourceCommandInput, GetDataSourceCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: GetDataSourceCommandInput;
     constructor(input: GetDataSourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDataSourceCommandInput, GetDataSourceCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface GetGraphqlApiCommandInput extends GetGraphqlApiRequest {
 }
 export interface GetGraphqlApiCommandOutput extends GetGraphqlApiResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves 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, GetGraphqlApiCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, GetGraphqlApiCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new GetGraphqlApiCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetGraphqlApiCommandInput} for command's `input` shape.
- * @see {@link GetGraphqlApiCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetGraphqlApiCommand extends $Command<GetGraphqlApiCommandInput, GetGraphqlApiCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: GetGraphqlApiCommandInput;
     constructor(input: GetGraphqlApiCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetGraphqlApiCommandInput, GetGraphqlApiCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface GetResolverCommandInput extends GetResolverRequest {
 }
 export interface GetResolverCommandOutput extends GetResolverResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves 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, GetResolverCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, GetResolverCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new GetResolverCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetResolverCommandInput} for command's `input` shape.
- * @see {@link GetResolverCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetResolverCommand extends $Command<GetResolverCommandInput, GetResolverCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: GetResolverCommandInput;
     constructor(input: GetResolverCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetResolverCommandInput, GetResolverCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,29 +6,11 @@ export interface GetTypeCommandInput extends GetTypeRequest {
 }
 export interface GetTypeCommandOutput extends GetTypeResponse, __MetadataBearer {
 }
-/**
- * <p>Retrieves 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, GetTypeCommand } from "@aws-sdk/client-appsync"; // ES Modules import
- * // const { AppSyncClient, GetTypeCommand } = require("@aws-sdk/client-appsync"); // CommonJS import
- * const client = new AppSyncClient(config);
- * const command = new GetTypeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetTypeCommandInput} for command's `input` shape.
- * @see {@link GetTypeCommandOutput} for command's `response` shape.
- * @see {@link AppSyncClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetTypeCommand extends $Command<GetTypeCommandInput, GetTypeCommandOutput, AppSyncClientResolvedConfig> {
     readonly input: GetTypeCommandInput;
     constructor(input: GetTypeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: AppSyncClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetTypeCommandInput, GetTypeCommandOutput>;
     private serialize;
     private deserialize;