@aws-sdk/client-lambda 3.830.0 → 3.833.0

package/dist-cjs/index.js

@@ -109,6 +109,8 @@ __export(index_exports, {
   KMSDisabledException: () => KMSDisabledException,
   KMSInvalidStateException: () => KMSInvalidStateException,
   KMSNotFoundException: () => KMSNotFoundException,
+  KafkaSchemaRegistryAuthType: () => KafkaSchemaRegistryAuthType,
+  KafkaSchemaValidationAttribute: () => KafkaSchemaValidationAttribute,
   Lambda: () => Lambda,
   LambdaClient: () => LambdaClient,
   LambdaServiceException: () => LambdaServiceException,
@@ -158,6 +160,7 @@ __export(index_exports, {
   Runtime: () => Runtime,
   RuntimeVersionConfigFilterSensitiveLog: () => RuntimeVersionConfigFilterSensitiveLog,
   RuntimeVersionErrorFilterSensitiveLog: () => RuntimeVersionErrorFilterSensitiveLog,
+  SchemaRegistryEventRecordFormat: () => SchemaRegistryEventRecordFormat,
   ServiceException: () => ServiceException,
   SnapStartApplyOn: () => SnapStartApplyOn,
   SnapStartException: () => SnapStartException,
@@ -561,6 +564,19 @@ var FunctionUrlAuthType = {
   AWS_IAM: "AWS_IAM",
   NONE: "NONE"
 };
+var KafkaSchemaRegistryAuthType = {
+  BASIC_AUTH: "BASIC_AUTH",
+  CLIENT_CERTIFICATE_TLS_AUTH: "CLIENT_CERTIFICATE_TLS_AUTH",
+  SERVER_ROOT_CA_CERTIFICATE: "SERVER_ROOT_CA_CERTIFICATE"
+};
+var SchemaRegistryEventRecordFormat = {
+  JSON: "JSON",
+  SOURCE: "SOURCE"
+};
+var KafkaSchemaValidationAttribute = {
+  KEY: "KEY",
+  VALUE: "VALUE"
+};
 var ApplicationLogLevel = {
   Debug: "DEBUG",
   Error: "ERROR",
@@ -2506,6 +2522,7 @@ var se_UpdateEventSourceMappingCommand = /* @__PURE__ */ __name(async (input, co
   let body;
   body = JSON.stringify(
     (0, import_smithy_client.take)(input, {
+      AmazonManagedKafkaEventSourceConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "AmazonManagedKafkaEventSourceConfig"),
       BatchSize: [],
       BisectBatchOnFunctionError: [],
       DestinationConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "DestinationConfig"),
@@ -2522,6 +2539,7 @@ var se_UpdateEventSourceMappingCommand = /* @__PURE__ */ __name(async (input, co
       ParallelizationFactor: [],
       ProvisionedPollerConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "ProvisionedPollerConfig"),
       ScalingConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "ScalingConfig"),
+      SelfManagedKafkaEventSourceConfig: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "SelfManagedKafkaEventSourceConfig"),
       SourceAccessConfigurations: /* @__PURE__ */ __name((_) => (0, import_smithy_client._json)(_), "SourceAccessConfigurations"),
       TumblingWindowInSeconds: []
     })
@@ -6309,6 +6327,9 @@ var waitUntilPublishedVersionActive = /* @__PURE__ */ __name(async (params, inpu
   ThrottleReason,
   TooManyRequestsException,
   FunctionUrlAuthType,
+  KafkaSchemaRegistryAuthType,
+  SchemaRegistryEventRecordFormat,
+  KafkaSchemaValidationAttribute,
   ApplicationLogLevel,
   Architecture,
   CodeSigningPolicy,

package/dist-es/models/models_0.js

@@ -118,6 +118,19 @@ export const FunctionUrlAuthType = {
     AWS_IAM: "AWS_IAM",
     NONE: "NONE",
 };
+export const KafkaSchemaRegistryAuthType = {
+    BASIC_AUTH: "BASIC_AUTH",
+    CLIENT_CERTIFICATE_TLS_AUTH: "CLIENT_CERTIFICATE_TLS_AUTH",
+    SERVER_ROOT_CA_CERTIFICATE: "SERVER_ROOT_CA_CERTIFICATE",
+};
+export const SchemaRegistryEventRecordFormat = {
+    JSON: "JSON",
+    SOURCE: "SOURCE",
+};
+export const KafkaSchemaValidationAttribute = {
+    KEY: "KEY",
+    VALUE: "VALUE",
+};
 export const ApplicationLogLevel = {
     Debug: "DEBUG",
     Error: "ERROR",

package/dist-es/protocols/Aws_restJson1.js

@@ -898,6 +898,7 @@ export const se_UpdateEventSourceMappingCommand = async (input, context) => {
     b.p("UUID", () => input.UUID, "{UUID}", false);
     let body;
     body = JSON.stringify(take(input, {
+        AmazonManagedKafkaEventSourceConfig: (_) => _json(_),
         BatchSize: [],
         BisectBatchOnFunctionError: [],
         DestinationConfig: (_) => _json(_),
@@ -914,6 +915,7 @@ export const se_UpdateEventSourceMappingCommand = async (input, context) => {
         ParallelizationFactor: [],
         ProvisionedPollerConfig: (_) => _json(_),
         ScalingConfig: (_) => _json(_),
+        SelfManagedKafkaEventSourceConfig: (_) => _json(_),
         SourceAccessConfigurations: (_) => _json(_),
         TumblingWindowInSeconds: [],
     }));

package/dist-types/commands/CreateEventSourceMappingCommand.d.ts

@@ -96,8 +96,8 @@ declare const CreateEventSourceMappingCommand_base: {
  *          <ul>
  *             <li>
  *                <p>
- *                   <code>DestinationConfig</code> – Send discarded records to an Amazon SQS queue, Amazon SNS topic, or
- *             Amazon S3 bucket.</p>
+ *                   <code>OnFailure</code> – Send discarded records to an Amazon SQS queue, Amazon SNS topic, or
+ *             Amazon S3 bucket. For more information, see <a href="https://docs.aws.amazon.com/lambda/latest/dg/invocation-async-retain-records.html#invocation-async-destinations">Adding a destination</a>.</p>
  *             </li>
  *          </ul>
  *          <p>For information about which configuration parameters apply to each event source, see the following topics.</p>
@@ -206,9 +206,39 @@ declare const CreateEventSourceMappingCommand_base: {
  *   ],
  *   AmazonManagedKafkaEventSourceConfig: { // AmazonManagedKafkaEventSourceConfig
  *     ConsumerGroupId: "STRING_VALUE",
+ *     SchemaRegistryConfig: { // KafkaSchemaRegistryConfig
+ *       SchemaRegistryURI: "STRING_VALUE",
+ *       EventRecordFormat: "JSON" || "SOURCE",
+ *       AccessConfigs: [ // KafkaSchemaRegistryAccessConfigList
+ *         { // KafkaSchemaRegistryAccessConfig
+ *           Type: "BASIC_AUTH" || "CLIENT_CERTIFICATE_TLS_AUTH" || "SERVER_ROOT_CA_CERTIFICATE",
+ *           URI: "STRING_VALUE",
+ *         },
+ *       ],
+ *       SchemaValidationConfigs: [ // KafkaSchemaValidationConfigList
+ *         { // KafkaSchemaValidationConfig
+ *           Attribute: "KEY" || "VALUE",
+ *         },
+ *       ],
+ *     },
  *   },
  *   SelfManagedKafkaEventSourceConfig: { // SelfManagedKafkaEventSourceConfig
  *     ConsumerGroupId: "STRING_VALUE",
+ *     SchemaRegistryConfig: {
+ *       SchemaRegistryURI: "STRING_VALUE",
+ *       EventRecordFormat: "JSON" || "SOURCE",
+ *       AccessConfigs: [
+ *         {
+ *           Type: "BASIC_AUTH" || "CLIENT_CERTIFICATE_TLS_AUTH" || "SERVER_ROOT_CA_CERTIFICATE",
+ *           URI: "STRING_VALUE",
+ *         },
+ *       ],
+ *       SchemaValidationConfigs: [
+ *         {
+ *           Attribute: "KEY" || "VALUE",
+ *         },
+ *       ],
+ *     },
  *   },
  *   ScalingConfig: { // ScalingConfig
  *     MaximumConcurrency: Number("int"),
@@ -287,9 +317,39 @@ declare const CreateEventSourceMappingCommand_base: {
  * //   ],
  * //   AmazonManagedKafkaEventSourceConfig: { // AmazonManagedKafkaEventSourceConfig
  * //     ConsumerGroupId: "STRING_VALUE",
+ * //     SchemaRegistryConfig: { // KafkaSchemaRegistryConfig
+ * //       SchemaRegistryURI: "STRING_VALUE",
+ * //       EventRecordFormat: "JSON" || "SOURCE",
+ * //       AccessConfigs: [ // KafkaSchemaRegistryAccessConfigList
+ * //         { // KafkaSchemaRegistryAccessConfig
+ * //           Type: "BASIC_AUTH" || "CLIENT_CERTIFICATE_TLS_AUTH" || "SERVER_ROOT_CA_CERTIFICATE",
+ * //           URI: "STRING_VALUE",
+ * //         },
+ * //       ],
+ * //       SchemaValidationConfigs: [ // KafkaSchemaValidationConfigList
+ * //         { // KafkaSchemaValidationConfig
+ * //           Attribute: "KEY" || "VALUE",
+ * //         },
+ * //       ],
+ * //     },
  * //   },
  * //   SelfManagedKafkaEventSourceConfig: { // SelfManagedKafkaEventSourceConfig
  * //     ConsumerGroupId: "STRING_VALUE",
+ * //     SchemaRegistryConfig: {
+ * //       SchemaRegistryURI: "STRING_VALUE",
+ * //       EventRecordFormat: "JSON" || "SOURCE",
+ * //       AccessConfigs: [
+ * //         {
+ * //           Type: "BASIC_AUTH" || "CLIENT_CERTIFICATE_TLS_AUTH" || "SERVER_ROOT_CA_CERTIFICATE",
+ * //           URI: "STRING_VALUE",
+ * //         },
+ * //       ],
+ * //       SchemaValidationConfigs: [
+ * //         {
+ * //           Attribute: "KEY" || "VALUE",
+ * //         },
+ * //       ],
+ * //     },
  * //   },
  * //   ScalingConfig: { // ScalingConfig
  * //     MaximumConcurrency: Number("int"),

package/dist-types/commands/DeleteEventSourceMappingCommand.d.ts

@@ -98,9 +98,39 @@ declare const DeleteEventSourceMappingCommand_base: {
  * //   ],
  * //   AmazonManagedKafkaEventSourceConfig: { // AmazonManagedKafkaEventSourceConfig
  * //     ConsumerGroupId: "STRING_VALUE",
+ * //     SchemaRegistryConfig: { // KafkaSchemaRegistryConfig
+ * //       SchemaRegistryURI: "STRING_VALUE",
+ * //       EventRecordFormat: "JSON" || "SOURCE",
+ * //       AccessConfigs: [ // KafkaSchemaRegistryAccessConfigList
+ * //         { // KafkaSchemaRegistryAccessConfig
+ * //           Type: "BASIC_AUTH" || "CLIENT_CERTIFICATE_TLS_AUTH" || "SERVER_ROOT_CA_CERTIFICATE",
+ * //           URI: "STRING_VALUE",
+ * //         },
+ * //       ],
+ * //       SchemaValidationConfigs: [ // KafkaSchemaValidationConfigList
+ * //         { // KafkaSchemaValidationConfig
+ * //           Attribute: "KEY" || "VALUE",
+ * //         },
+ * //       ],
+ * //     },
  * //   },
  * //   SelfManagedKafkaEventSourceConfig: { // SelfManagedKafkaEventSourceConfig
  * //     ConsumerGroupId: "STRING_VALUE",
+ * //     SchemaRegistryConfig: {
+ * //       SchemaRegistryURI: "STRING_VALUE",
+ * //       EventRecordFormat: "JSON" || "SOURCE",
+ * //       AccessConfigs: [
+ * //         {
+ * //           Type: "BASIC_AUTH" || "CLIENT_CERTIFICATE_TLS_AUTH" || "SERVER_ROOT_CA_CERTIFICATE",
+ * //           URI: "STRING_VALUE",
+ * //         },
+ * //       ],
+ * //       SchemaValidationConfigs: [
+ * //         {
+ * //           Attribute: "KEY" || "VALUE",
+ * //         },
+ * //       ],
+ * //     },
  * //   },
  * //   ScalingConfig: { // ScalingConfig
  * //     MaximumConcurrency: Number("int"),
@@ -158,6 +188,27 @@ declare const DeleteEventSourceMappingCommand_base: {
  * <p>Base exception class for all service exceptions from Lambda service.</p>
  *
  *
+ * @example To delete a Lambda function event source mapping
+ * ```javascript
+ * // The following example deletes an event source mapping. To get a mapping's UUID, use ListEventSourceMappings.
+ * const input = {
+ *   UUID: "14e0db71-xmpl-4eb5-b481-8945cf9d10c2"
+ * };
+ * const command = new DeleteEventSourceMappingCommand(input);
+ * const response = await client.send(command);
+ * /* response is
+ * {
+ *   BatchSize: 5,
+ *   EventSourceArn: "arn:aws:sqs:us-west-2:123456789012:my-queue",
+ *   FunctionArn: "arn:aws:lambda:us-east-2:123456789012:function:my-function",
+ *   LastModified: "2016-11-21T19:49:20.006Z",
+ *   State: "Enabled",
+ *   StateTransitionReason: "USER_INITIATED",
+ *   UUID: "14e0db71-xmpl-4eb5-b481-8945cf9d10c2"
+ * }
+ * *\/
+ * ```
+ *
  * @public
  */
 export declare class DeleteEventSourceMappingCommand extends DeleteEventSourceMappingCommand_base {

package/dist-types/commands/GetEventSourceMappingCommand.d.ts

@@ -96,9 +96,39 @@ declare const GetEventSourceMappingCommand_base: {
  * //   ],
  * //   AmazonManagedKafkaEventSourceConfig: { // AmazonManagedKafkaEventSourceConfig
  * //     ConsumerGroupId: "STRING_VALUE",
+ * //     SchemaRegistryConfig: { // KafkaSchemaRegistryConfig
+ * //       SchemaRegistryURI: "STRING_VALUE",
+ * //       EventRecordFormat: "JSON" || "SOURCE",
+ * //       AccessConfigs: [ // KafkaSchemaRegistryAccessConfigList
+ * //         { // KafkaSchemaRegistryAccessConfig
+ * //           Type: "BASIC_AUTH" || "CLIENT_CERTIFICATE_TLS_AUTH" || "SERVER_ROOT_CA_CERTIFICATE",
+ * //           URI: "STRING_VALUE",
+ * //         },
+ * //       ],
+ * //       SchemaValidationConfigs: [ // KafkaSchemaValidationConfigList
+ * //         { // KafkaSchemaValidationConfig
+ * //           Attribute: "KEY" || "VALUE",
+ * //         },
+ * //       ],
+ * //     },
  * //   },
  * //   SelfManagedKafkaEventSourceConfig: { // SelfManagedKafkaEventSourceConfig
  * //     ConsumerGroupId: "STRING_VALUE",
+ * //     SchemaRegistryConfig: {
+ * //       SchemaRegistryURI: "STRING_VALUE",
+ * //       EventRecordFormat: "JSON" || "SOURCE",
+ * //       AccessConfigs: [
+ * //         {
+ * //           Type: "BASIC_AUTH" || "CLIENT_CERTIFICATE_TLS_AUTH" || "SERVER_ROOT_CA_CERTIFICATE",
+ * //           URI: "STRING_VALUE",
+ * //         },
+ * //       ],
+ * //       SchemaValidationConfigs: [
+ * //         {
+ * //           Attribute: "KEY" || "VALUE",
+ * //         },
+ * //       ],
+ * //     },
  * //   },
  * //   ScalingConfig: { // ScalingConfig
  * //     MaximumConcurrency: Number("int"),
@@ -149,6 +179,32 @@ declare const GetEventSourceMappingCommand_base: {
  * <p>Base exception class for all service exceptions from Lambda service.</p>
  *
  *
+ * @example To get a Lambda function's event source mapping
+ * ```javascript
+ * // The following example returns details about an event source mapping. To get a mapping's UUID, use ListEventSourceMappings.
+ * const input = {
+ *   UUID: "14e0db71-xmpl-4eb5-b481-8945cf9d10c2"
+ * };
+ * const command = new GetEventSourceMappingCommand(input);
+ * const response = await client.send(command);
+ * /* response is
+ * {
+ *   BatchSize: 500,
+ *   BisectBatchOnFunctionError: false,
+ *   DestinationConfig:   { /* empty *\/ },
+ *   EventSourceArn: "arn:aws:sqs:us-east-2:123456789012:mySQSqueue",
+ *   FunctionArn: "arn:aws:lambda:us-east-2:123456789012:function:myFunction",
+ *   LastModified: "2016-11-21T19:49:20.006Z",
+ *   LastProcessingResult: "No records processed",
+ *   MaximumRecordAgeInSeconds: 604800,
+ *   MaximumRetryAttempts: 10000,
+ *   State: "Creating",
+ *   StateTransitionReason: "User action",
+ *   UUID: "14e0db71-xmpl-4eb5-b481-8945cf9d10c2"
+ * }
+ * *\/
+ * ```
+ *
  * @public
  */
 export declare class GetEventSourceMappingCommand extends GetEventSourceMappingCommand_base {

package/dist-types/commands/GetFunctionEventInvokeConfigCommand.d.ts

@@ -80,6 +80,31 @@ declare const GetFunctionEventInvokeConfigCommand_base: {
  * <p>Base exception class for all service exceptions from Lambda service.</p>
  *
  *
+ * @example To get an asynchronous invocation configuration
+ * ```javascript
+ * // The following example returns the asynchronous invocation configuration for the BLUE alias of a function named my-function.
+ * const input = {
+ *   FunctionName: "my-function",
+ *   Qualifier: "BLUE"
+ * };
+ * const command = new GetFunctionEventInvokeConfigCommand(input);
+ * const response = await client.send(command);
+ * /* response is
+ * {
+ *   DestinationConfig: {
+ *     OnFailure: {
+ *       Destination: "arn:aws:sqs:us-east-2:123456789012:failed-invocations"
+ *     },
+ *     OnSuccess:     { /* empty *\/ }
+ *   },
+ *   FunctionArn: "arn:aws:lambda:us-east-2:123456789012:function:my-function:BLUE",
+ *   LastModified: "2016-11-21T19:49:20.006Z",
+ *   MaximumEventAgeInSeconds: 3600,
+ *   MaximumRetryAttempts: 0
+ * }
+ * *\/
+ * ```
+ *
  * @public
  */
 export declare class GetFunctionEventInvokeConfigCommand extends GetFunctionEventInvokeConfigCommand_base {

package/dist-types/commands/ListEventSourceMappingsCommand.d.ts

@@ -102,9 +102,39 @@ declare const ListEventSourceMappingsCommand_base: {
  * //       ],
  * //       AmazonManagedKafkaEventSourceConfig: { // AmazonManagedKafkaEventSourceConfig
  * //         ConsumerGroupId: "STRING_VALUE",
+ * //         SchemaRegistryConfig: { // KafkaSchemaRegistryConfig
+ * //           SchemaRegistryURI: "STRING_VALUE",
+ * //           EventRecordFormat: "JSON" || "SOURCE",
+ * //           AccessConfigs: [ // KafkaSchemaRegistryAccessConfigList
+ * //             { // KafkaSchemaRegistryAccessConfig
+ * //               Type: "BASIC_AUTH" || "CLIENT_CERTIFICATE_TLS_AUTH" || "SERVER_ROOT_CA_CERTIFICATE",
+ * //               URI: "STRING_VALUE",
+ * //             },
+ * //           ],
+ * //           SchemaValidationConfigs: [ // KafkaSchemaValidationConfigList
+ * //             { // KafkaSchemaValidationConfig
+ * //               Attribute: "KEY" || "VALUE",
+ * //             },
+ * //           ],
+ * //         },
  * //       },
  * //       SelfManagedKafkaEventSourceConfig: { // SelfManagedKafkaEventSourceConfig
  * //         ConsumerGroupId: "STRING_VALUE",
+ * //         SchemaRegistryConfig: {
+ * //           SchemaRegistryURI: "STRING_VALUE",
+ * //           EventRecordFormat: "JSON" || "SOURCE",
+ * //           AccessConfigs: [
+ * //             {
+ * //               Type: "BASIC_AUTH" || "CLIENT_CERTIFICATE_TLS_AUTH" || "SERVER_ROOT_CA_CERTIFICATE",
+ * //               URI: "STRING_VALUE",
+ * //             },
+ * //           ],
+ * //           SchemaValidationConfigs: [
+ * //             {
+ * //               Attribute: "KEY" || "VALUE",
+ * //             },
+ * //           ],
+ * //         },
  * //       },
  * //       ScalingConfig: { // ScalingConfig
  * //         MaximumConcurrency: Number("int"),

package/dist-types/commands/PutFunctionEventInvokeConfigCommand.d.ts

@@ -105,6 +105,30 @@ declare const PutFunctionEventInvokeConfigCommand_base: {
  * <p>Base exception class for all service exceptions from Lambda service.</p>
  *
  *
+ * @example To configure error handling for asynchronous invocation
+ * ```javascript
+ * // The following example sets a maximum event age of one hour and disables retries for the specified function.
+ * const input = {
+ *   FunctionName: "my-function",
+ *   MaximumEventAgeInSeconds: 3600,
+ *   MaximumRetryAttempts: 0
+ * };
+ * const command = new PutFunctionEventInvokeConfigCommand(input);
+ * const response = await client.send(command);
+ * /* response is
+ * {
+ *   DestinationConfig: {
+ *     OnFailure:     { /* empty *\/ },
+ *     OnSuccess:     { /* empty *\/ }
+ *   },
+ *   FunctionArn: "arn:aws:lambda:us-east-2:123456789012:function:my-function:$LATEST",
+ *   LastModified: "2016-11-21T19:49:20.006Z",
+ *   MaximumEventAgeInSeconds: 3600,
+ *   MaximumRetryAttempts: 0
+ * }
+ * *\/
+ * ```
+ *
  * @public
  */
 export declare class PutFunctionEventInvokeConfigCommand extends PutFunctionEventInvokeConfigCommand_base {

package/dist-types/commands/UpdateEventSourceMappingCommand.d.ts

@@ -97,8 +97,8 @@ declare const UpdateEventSourceMappingCommand_base: {
  *          <ul>
  *             <li>
  *                <p>
- *                   <code>DestinationConfig</code> – Send discarded records to an Amazon SQS queue, Amazon SNS topic, or
- *             Amazon S3 bucket.</p>
+ *                   <code>OnFailure</code> – Send discarded records to an Amazon SQS queue, Amazon SNS topic, or
+ *             Amazon S3 bucket. For more information, see <a href="https://docs.aws.amazon.com/lambda/latest/dg/invocation-async-retain-records.html#invocation-async-destinations">Adding a destination</a>.</p>
  *             </li>
  *          </ul>
  *          <p>For information about which configuration parameters apply to each event source, see the following topics.</p>
@@ -190,6 +190,42 @@ declare const UpdateEventSourceMappingCommand_base: {
  *   ScalingConfig: { // ScalingConfig
  *     MaximumConcurrency: Number("int"),
  *   },
+ *   AmazonManagedKafkaEventSourceConfig: { // AmazonManagedKafkaEventSourceConfig
+ *     ConsumerGroupId: "STRING_VALUE",
+ *     SchemaRegistryConfig: { // KafkaSchemaRegistryConfig
+ *       SchemaRegistryURI: "STRING_VALUE",
+ *       EventRecordFormat: "JSON" || "SOURCE",
+ *       AccessConfigs: [ // KafkaSchemaRegistryAccessConfigList
+ *         { // KafkaSchemaRegistryAccessConfig
+ *           Type: "BASIC_AUTH" || "CLIENT_CERTIFICATE_TLS_AUTH" || "SERVER_ROOT_CA_CERTIFICATE",
+ *           URI: "STRING_VALUE",
+ *         },
+ *       ],
+ *       SchemaValidationConfigs: [ // KafkaSchemaValidationConfigList
+ *         { // KafkaSchemaValidationConfig
+ *           Attribute: "KEY" || "VALUE",
+ *         },
+ *       ],
+ *     },
+ *   },
+ *   SelfManagedKafkaEventSourceConfig: { // SelfManagedKafkaEventSourceConfig
+ *     ConsumerGroupId: "STRING_VALUE",
+ *     SchemaRegistryConfig: {
+ *       SchemaRegistryURI: "STRING_VALUE",
+ *       EventRecordFormat: "JSON" || "SOURCE",
+ *       AccessConfigs: [
+ *         {
+ *           Type: "BASIC_AUTH" || "CLIENT_CERTIFICATE_TLS_AUTH" || "SERVER_ROOT_CA_CERTIFICATE",
+ *           URI: "STRING_VALUE",
+ *         },
+ *       ],
+ *       SchemaValidationConfigs: [
+ *         {
+ *           Attribute: "KEY" || "VALUE",
+ *         },
+ *       ],
+ *     },
+ *   },
  *   DocumentDBEventSourceConfig: { // DocumentDBEventSourceConfig
  *     DatabaseName: "STRING_VALUE",
  *     CollectionName: "STRING_VALUE",
@@ -264,9 +300,39 @@ declare const UpdateEventSourceMappingCommand_base: {
  * //   ],
  * //   AmazonManagedKafkaEventSourceConfig: { // AmazonManagedKafkaEventSourceConfig
  * //     ConsumerGroupId: "STRING_VALUE",
+ * //     SchemaRegistryConfig: { // KafkaSchemaRegistryConfig
+ * //       SchemaRegistryURI: "STRING_VALUE",
+ * //       EventRecordFormat: "JSON" || "SOURCE",
+ * //       AccessConfigs: [ // KafkaSchemaRegistryAccessConfigList
+ * //         { // KafkaSchemaRegistryAccessConfig
+ * //           Type: "BASIC_AUTH" || "CLIENT_CERTIFICATE_TLS_AUTH" || "SERVER_ROOT_CA_CERTIFICATE",
+ * //           URI: "STRING_VALUE",
+ * //         },
+ * //       ],
+ * //       SchemaValidationConfigs: [ // KafkaSchemaValidationConfigList
+ * //         { // KafkaSchemaValidationConfig
+ * //           Attribute: "KEY" || "VALUE",
+ * //         },
+ * //       ],
+ * //     },
  * //   },
  * //   SelfManagedKafkaEventSourceConfig: { // SelfManagedKafkaEventSourceConfig
  * //     ConsumerGroupId: "STRING_VALUE",
+ * //     SchemaRegistryConfig: {
+ * //       SchemaRegistryURI: "STRING_VALUE",
+ * //       EventRecordFormat: "JSON" || "SOURCE",
+ * //       AccessConfigs: [
+ * //         {
+ * //           Type: "BASIC_AUTH" || "CLIENT_CERTIFICATE_TLS_AUTH" || "SERVER_ROOT_CA_CERTIFICATE",
+ * //           URI: "STRING_VALUE",
+ * //         },
+ * //       ],
+ * //       SchemaValidationConfigs: [
+ * //         {
+ * //           Attribute: "KEY" || "VALUE",
+ * //         },
+ * //       ],
+ * //     },
  * //   },
  * //   ScalingConfig: { // ScalingConfig
  * //     MaximumConcurrency: Number("int"),
@@ -324,6 +390,31 @@ declare const UpdateEventSourceMappingCommand_base: {
  * <p>Base exception class for all service exceptions from Lambda service.</p>
  *
  *
+ * @example To update a Lambda function event source mapping
+ * ```javascript
+ * // This operation updates a Lambda function event source mapping
+ * const input = {
+ *   BatchSize: 123,
+ *   Enabled: true,
+ *   FunctionName: "myFunction",
+ *   UUID: "1234xCy789012"
+ * };
+ * const command = new UpdateEventSourceMappingCommand(input);
+ * const response = await client.send(command);
+ * /* response is
+ * {
+ *   BatchSize: 123,
+ *   EventSourceArn: "arn:aws:s3:::examplebucket/*",
+ *   FunctionArn: "arn:aws:lambda:us-west-2:123456789012:function:myFunction",
+ *   LastModified: "2016-11-21T19:49:20.006Z",
+ *   LastProcessingResult: "",
+ *   State: "",
+ *   StateTransitionReason: "",
+ *   UUID: "1234xCy789012"
+ * }
+ * *\/
+ * ```
+ *
  * @public
  */
 export declare class UpdateEventSourceMappingCommand extends UpdateEventSourceMappingCommand_base {

package/dist-types/models/models_0.d.ts

@@ -419,6 +419,126 @@ export interface AllowedPublishers {
      */
     SigningProfileVersionArns: string[] | undefined;
 }
+/**
+ * @public
+ * @enum
+ */
+export declare const KafkaSchemaRegistryAuthType: {
+    readonly BASIC_AUTH: "BASIC_AUTH";
+    readonly CLIENT_CERTIFICATE_TLS_AUTH: "CLIENT_CERTIFICATE_TLS_AUTH";
+    readonly SERVER_ROOT_CA_CERTIFICATE: "SERVER_ROOT_CA_CERTIFICATE";
+};
+/**
+ * @public
+ */
+export type KafkaSchemaRegistryAuthType = (typeof KafkaSchemaRegistryAuthType)[keyof typeof KafkaSchemaRegistryAuthType];
+/**
+ * <p>Specific access configuration settings that tell Lambda how to authenticate with your schema registry.</p>
+ *          <p>If you're working with an Glue schema registry, don't provide authentication details in this object.
+ *       Instead, ensure that your execution role has the required permissions for Lambda to access your cluster.</p>
+ *          <p>If you're working with a Confluent schema registry, choose the authentication method in the <code>Type</code> field,
+ *       and provide the Secrets Manager secret ARN in the <code>URI</code> field.</p>
+ * @public
+ */
+export interface KafkaSchemaRegistryAccessConfig {
+    /**
+     * <p>
+     *       The type of authentication Lambda uses to access your schema registry.
+     *     </p>
+     * @public
+     */
+    Type?: KafkaSchemaRegistryAuthType | undefined;
+    /**
+     * <p>
+     *       The URI of the secret (Secrets Manager secret ARN) to authenticate with your schema registry.
+     *     </p>
+     * @public
+     */
+    URI?: string | undefined;
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const SchemaRegistryEventRecordFormat: {
+    readonly JSON: "JSON";
+    readonly SOURCE: "SOURCE";
+};
+/**
+ * @public
+ */
+export type SchemaRegistryEventRecordFormat = (typeof SchemaRegistryEventRecordFormat)[keyof typeof SchemaRegistryEventRecordFormat];
+/**
+ * @public
+ * @enum
+ */
+export declare const KafkaSchemaValidationAttribute: {
+    readonly KEY: "KEY";
+    readonly VALUE: "VALUE";
+};
+/**
+ * @public
+ */
+export type KafkaSchemaValidationAttribute = (typeof KafkaSchemaValidationAttribute)[keyof typeof KafkaSchemaValidationAttribute];
+/**
+ * <p>Specific schema validation configuration settings that tell Lambda the message
+ *   attributes you want to validate and filter using your schema registry.</p>
+ * @public
+ */
+export interface KafkaSchemaValidationConfig {
+    /**
+     * <p>
+     *       The attributes you want your schema registry to validate and filter for. If you selected <code>JSON</code> as the
+     *         <code>EventRecordFormat</code>, Lambda also deserializes the selected message attributes.
+     *     </p>
+     * @public
+     */
+    Attribute?: KafkaSchemaValidationAttribute | undefined;
+}
+/**
+ * <p>Specific configuration settings for a Kafka schema registry.</p>
+ * @public
+ */
+export interface KafkaSchemaRegistryConfig {
+    /**
+     * <p>The URI for your schema registry. The correct URI format depends on the type of schema registry you're using.</p>
+     *          <ul>
+     *             <li>
+     *                <p>For Glue schema registries, use the ARN of the registry.</p>
+     *             </li>
+     *             <li>
+     *                <p>For Confluent schema registries, use the URL of the registry.</p>
+     *             </li>
+     *          </ul>
+     * @public
+     */
+    SchemaRegistryURI?: string | undefined;
+    /**
+     * <p>The record format that Lambda delivers to your function after schema validation.</p>
+     *          <ul>
+     *             <li>
+     *                <p>Choose <code>JSON</code> to have Lambda deliver the record to your function as a standard JSON object.</p>
+     *             </li>
+     *             <li>
+     *                <p>Choose <code>SOURCE</code> to have Lambda deliver the record to your function in its original source format.
+     *           Lambda removes all schema metadata, such as the schema ID, before sending the record to your function.</p>
+     *             </li>
+     *          </ul>
+     * @public
+     */
+    EventRecordFormat?: SchemaRegistryEventRecordFormat | undefined;
+    /**
+     * <p>An array of access configuration objects that tell Lambda how to authenticate with your schema registry.</p>
+     * @public
+     */
+    AccessConfigs?: KafkaSchemaRegistryAccessConfig[] | undefined;
+    /**
+     * <p>An array of schema validation configuration objects, which tell Lambda the message
+     *   attributes you want to validate and filter using your schema registry.</p>
+     * @public
+     */
+    SchemaValidationConfigs?: KafkaSchemaValidationConfig[] | undefined;
+}
 /**
  * <p>Specific configuration settings for an Amazon Managed Streaming for Apache Kafka (Amazon MSK) event source.</p>
  * @public
@@ -431,6 +551,11 @@ export interface AmazonManagedKafkaEventSourceConfig {
      * @public
      */
     ConsumerGroupId?: string | undefined;
+    /**
+     * <p>Specific configuration settings for a Kafka schema registry.</p>
+     * @public
+     */
+    SchemaRegistryConfig?: KafkaSchemaRegistryConfig | undefined;
 }
 /**
  * @public
@@ -610,7 +735,7 @@ export interface CreateCodeSigningConfigResponse {
     CodeSigningConfig: CodeSigningConfig | undefined;
 }
 /**
- * <p>A destination for events that failed processing.</p>
+ * <p>A destination for events that failed processing. For more information, see <a href="https://docs.aws.amazon.com/lambda/latest/dg/invocation-async-retain-records.html#invocation-async-destinations">Adding a destination</a>.</p>
  * @public
  */
 export interface OnFailure {
@@ -632,6 +757,10 @@ export interface OnFailure {
  *          <p>To retain records of successful <a href="https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html#invocation-async-destinations">asynchronous invocations</a>,
  *       you can configure an Amazon SNS topic, Amazon SQS queue, Lambda function,
  *       or Amazon EventBridge event bus as the destination.</p>
+ *          <note>
+ *             <p>
+ *                <code>OnSuccess</code> is not supported in <code>CreateEventSourceMapping</code> or <code>UpdateEventSourceMapping</code> requests.</p>
+ *          </note>
  * @public
  */
 export interface OnSuccess {
@@ -642,12 +771,12 @@ export interface OnSuccess {
     Destination?: string | undefined;
 }
 /**
- * <p>A configuration object that specifies the destination of an event after Lambda processes it.</p>
+ * <p>A configuration object that specifies the destination of an event after Lambda processes it. For more information, see <a href="https://docs.aws.amazon.com/lambda/latest/dg/invocation-async-retain-records.html#invocation-async-destinations">Adding a destination</a>.</p>
  * @public
  */
 export interface DestinationConfig {
     /**
-     * <p>The destination configuration for successful invocations.</p>
+     * <p>The destination configuration for successful invocations. Not supported in <code>CreateEventSourceMapping</code> or <code>UpdateEventSourceMapping</code>.</p>
      * @public
      */
     OnSuccess?: OnSuccess | undefined;
@@ -827,12 +956,17 @@ export interface SelfManagedEventSource {
  */
 export interface SelfManagedKafkaEventSourceConfig {
     /**
-     * <p>The identifier for the Kafka consumer group to join. The consumer group ID must be unique among all your Kafka event sources.
-     *   After creating a Kafka event source mapping with the consumer group ID specified, you cannot update this value. For more information, see
-     *   <a href="https://docs.aws.amazon.com/lambda/latest/dg/with-msk.html#services-msk-consumer-group-id">Customizable consumer group ID</a>.</p>
+     * <p> The identifier for the Kafka consumer group to join. The consumer group ID must be unique
+     *       among all your Kafka event sources. After creating a Kafka event source mapping with the
+     *       consumer group ID specified, you cannot update this value. For more information, see <a href="https://docs.aws.amazon.com/lambda/latest/dg/with-kafka-process.html#services-smaa-topic-add">Customizable consumer group ID</a>.</p>
      * @public
      */
     ConsumerGroupId?: string | undefined;
+    /**
+     * <p>Specific configuration settings for a Kafka schema registry.</p>
+     * @public
+     */
+    SchemaRegistryConfig?: KafkaSchemaRegistryConfig | undefined;
 }
 /**
  * @public
@@ -1245,7 +1379,7 @@ export interface EventSourceMappingConfiguration {
      */
     LastModified?: Date | undefined;
     /**
-     * <p>The result of the last Lambda invocation of your function.</p>
+     * <p>The result of the event source mapping's last processing attempt.</p>
      * @public
      */
     LastProcessingResult?: string | undefined;
@@ -1452,7 +1586,7 @@ export interface FunctionCode {
     SourceKMSKeyArn?: string | undefined;
 }
 /**
- * <p>The <a href="https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html#dlq">dead-letter queue</a> for
+ * <p>The <a href="https://docs.aws.amazon.com/lambda/latest/dg/invocation-async-retain-records.html#invocation-dlq">dead-letter queue</a> for
  *       failed asynchronous invocations.</p>
  * @public
  */
@@ -6214,6 +6348,16 @@ export interface UpdateEventSourceMappingRequest {
      * @public
      */
     ScalingConfig?: ScalingConfig | undefined;
+    /**
+     * <p>Specific configuration settings for an Amazon Managed Streaming for Apache Kafka (Amazon MSK) event source.</p>
+     * @public
+     */
+    AmazonManagedKafkaEventSourceConfig?: AmazonManagedKafkaEventSourceConfig | undefined;
+    /**
+     * <p>Specific configuration settings for a self-managed Apache Kafka event source.</p>
+     * @public
+     */
+    SelfManagedKafkaEventSourceConfig?: SelfManagedKafkaEventSourceConfig | undefined;
     /**
      * <p>Specific configuration settings for a DocumentDB event source.</p>
      * @public

package/dist-types/ts3.4/models/models_0.d.ts

@@ -129,8 +129,41 @@ export interface AliasConfiguration {
 export interface AllowedPublishers {
   SigningProfileVersionArns: string[] | undefined;
 }
+export declare const KafkaSchemaRegistryAuthType: {
+  readonly BASIC_AUTH: "BASIC_AUTH";
+  readonly CLIENT_CERTIFICATE_TLS_AUTH: "CLIENT_CERTIFICATE_TLS_AUTH";
+  readonly SERVER_ROOT_CA_CERTIFICATE: "SERVER_ROOT_CA_CERTIFICATE";
+};
+export type KafkaSchemaRegistryAuthType =
+  (typeof KafkaSchemaRegistryAuthType)[keyof typeof KafkaSchemaRegistryAuthType];
+export interface KafkaSchemaRegistryAccessConfig {
+  Type?: KafkaSchemaRegistryAuthType | undefined;
+  URI?: string | undefined;
+}
+export declare const SchemaRegistryEventRecordFormat: {
+  readonly JSON: "JSON";
+  readonly SOURCE: "SOURCE";
+};
+export type SchemaRegistryEventRecordFormat =
+  (typeof SchemaRegistryEventRecordFormat)[keyof typeof SchemaRegistryEventRecordFormat];
+export declare const KafkaSchemaValidationAttribute: {
+  readonly KEY: "KEY";
+  readonly VALUE: "VALUE";
+};
+export type KafkaSchemaValidationAttribute =
+  (typeof KafkaSchemaValidationAttribute)[keyof typeof KafkaSchemaValidationAttribute];
+export interface KafkaSchemaValidationConfig {
+  Attribute?: KafkaSchemaValidationAttribute | undefined;
+}
+export interface KafkaSchemaRegistryConfig {
+  SchemaRegistryURI?: string | undefined;
+  EventRecordFormat?: SchemaRegistryEventRecordFormat | undefined;
+  AccessConfigs?: KafkaSchemaRegistryAccessConfig[] | undefined;
+  SchemaValidationConfigs?: KafkaSchemaValidationConfig[] | undefined;
+}
 export interface AmazonManagedKafkaEventSourceConfig {
   ConsumerGroupId?: string | undefined;
+  SchemaRegistryConfig?: KafkaSchemaRegistryConfig | undefined;
 }
 export declare const ApplicationLogLevel: {
   readonly Debug: "DEBUG";
@@ -235,6 +268,7 @@ export interface SelfManagedEventSource {
 }
 export interface SelfManagedKafkaEventSourceConfig {
   ConsumerGroupId?: string | undefined;
+  SchemaRegistryConfig?: KafkaSchemaRegistryConfig | undefined;
 }
 export declare const SourceAccessType: {
   readonly BASIC_AUTH: "BASIC_AUTH";
@@ -1527,6 +1561,12 @@ export interface UpdateEventSourceMappingRequest {
   TumblingWindowInSeconds?: number | undefined;
   FunctionResponseTypes?: FunctionResponseType[] | undefined;
   ScalingConfig?: ScalingConfig | undefined;
+  AmazonManagedKafkaEventSourceConfig?:
+    | AmazonManagedKafkaEventSourceConfig
+    | undefined;
+  SelfManagedKafkaEventSourceConfig?:
+    | SelfManagedKafkaEventSourceConfig
+    | undefined;
   DocumentDBEventSourceConfig?: DocumentDBEventSourceConfig | undefined;
   KMSKeyArn?: string | undefined;
   MetricsConfig?: EventSourceMappingMetricsConfig | undefined;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aws-sdk/client-lambda",
   "description": "AWS SDK for JavaScript Lambda Client for Node.js, Browser and React Native",
-  "version": "3.830.0",
+  "version": "3.833.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "node ../../scripts/compilation/inline client-lambda",