cdk8s-aws-cdk 0.0.5

package/lib/imports/lambdaeventsourcemappings-lambda.services.k8s.aws.d.ts

@@ -0,0 +1,280 @@
+import { ApiObject, ApiObjectMetadata, GroupVersionKind } from 'cdk8s';
+import { Construct } from 'constructs';
+/**
+ * EventSourceMapping is the Schema for the EventSourceMappings API
+ *
+ * @schema EventSourceMapping
+ */
+export declare class EventSourceMapping extends ApiObject {
+    /**
+     * Returns the apiVersion and kind for "EventSourceMapping"
+     */
+    static readonly GVK: GroupVersionKind;
+    /**
+     * Renders a Kubernetes manifest for "EventSourceMapping".
+     *
+     * This can be used to inline resource manifests inside other objects (e.g. as templates).
+     *
+     * @param props initialization props
+     */
+    static manifest(props?: EventSourceMappingProps): any;
+    /**
+     * Defines a "EventSourceMapping" API object
+     * @param scope the scope in which to define this object
+     * @param id a scope-local name for the object
+     * @param props initialization props
+     */
+    constructor(scope: Construct, id: string, props?: EventSourceMappingProps);
+    /**
+     * Renders the object to Kubernetes JSON.
+     */
+    toJson(): any;
+}
+/**
+ * EventSourceMapping is the Schema for the EventSourceMappings API
+ *
+ * @schema EventSourceMapping
+ */
+export interface EventSourceMappingProps {
+    /**
+     * @schema EventSourceMapping#metadata
+     */
+    readonly metadata?: ApiObjectMetadata;
+    /**
+     * EventSourceMappingSpec defines the desired state of EventSourceMapping.
+     *
+     * @schema EventSourceMapping#spec
+     */
+    readonly spec?: EventSourceMappingSpec;
+}
+/**
+ * Converts an object of type 'EventSourceMappingProps' to JSON representation.
+ */
+export declare function toJson_EventSourceMappingProps(obj: EventSourceMappingProps | undefined): Record<string, any> | undefined;
+/**
+ * EventSourceMappingSpec defines the desired state of EventSourceMapping.
+ *
+ * @schema EventSourceMappingSpec
+ */
+export interface EventSourceMappingSpec {
+    /**
+     * The maximum number of records in each batch that Lambda pulls from your stream or queue and sends to your function. Lambda passes all of the records in the batch to the function in a single call, up to the payload limit for synchronous invocation (6 MB).
+     * * Amazon Kinesis - Default 100. Max 10,000.
+     * * Amazon DynamoDB Streams - Default 100. Max 1,000.
+     * * Amazon Simple Queue Service - Default 10. For standard queues the max    is 10,000. For FIFO queues the max is 10.
+     * * Amazon Managed Streaming for Apache Kafka - Default 100. Max 10,000.
+     * * Self-Managed Apache Kafka - Default 100. Max 10,000.
+     *
+     * @schema EventSourceMappingSpec#batchSize
+     */
+    readonly batchSize?: number;
+    /**
+     * (Streams only) If the function returns an error, split the batch in two and retry.
+     *
+     * @schema EventSourceMappingSpec#bisectBatchOnFunctionError
+     */
+    readonly bisectBatchOnFunctionError?: boolean;
+    /**
+     * (Streams only) An Amazon SQS queue or Amazon SNS topic destination for discarded records.
+     *
+     * @schema EventSourceMappingSpec#destinationConfig
+     */
+    readonly destinationConfig?: EventSourceMappingSpecDestinationConfig;
+    /**
+     * When true, the event source mapping is active. When false, Lambda pauses polling and invocation.
+     * Default: True
+     *
+     * @schema EventSourceMappingSpec#enabled
+     */
+    readonly enabled?: boolean;
+    /**
+     * The Amazon Resource Name (ARN) of the event source.
+     * * Amazon Kinesis - The ARN of the data stream or a stream consumer.
+     * * Amazon DynamoDB Streams - The ARN of the stream.
+     * * Amazon Simple Queue Service - The ARN of the queue.
+     * * Amazon Managed Streaming for Apache Kafka - The ARN of the cluster.
+     *
+     * @schema EventSourceMappingSpec#eventSourceARN
+     */
+    readonly eventSourceArn?: string;
+    /**
+     * The name of the Lambda function.
+     * Name formats
+     * * Function name - MyFunction.
+     * * Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.
+     * * Version or Alias ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction:PROD.
+     * * Partial ARN - 123456789012:function:MyFunction.
+     * The length constraint applies only to the full ARN. If you specify only the function name, it's limited to 64 characters in length.
+     *
+     * @schema EventSourceMappingSpec#functionName
+     */
+    readonly functionName: string;
+    /**
+     * (Streams only) A list of current response type enums applied to the event source mapping.
+     *
+     * @schema EventSourceMappingSpec#functionResponseTypes
+     */
+    readonly functionResponseTypes?: string[];
+    /**
+     * (Streams and Amazon SQS standard queues) The maximum amount of time, in seconds, that Lambda spends gathering records before invoking the function.
+     * Default: 0
+     * Related setting: When you set BatchSize to a value greater than 10, you must set MaximumBatchingWindowInSeconds to at least 1.
+     *
+     * @schema EventSourceMappingSpec#maximumBatchingWindowInSeconds
+     */
+    readonly maximumBatchingWindowInSeconds?: number;
+    /**
+     * (Streams only) Discard records older than the specified age. The default value is infinite (-1).
+     *
+     * @schema EventSourceMappingSpec#maximumRecordAgeInSeconds
+     */
+    readonly maximumRecordAgeInSeconds?: number;
+    /**
+     * (Streams only) Discard records after the specified number of retries. The default value is infinite (-1). When set to infinite (-1), failed records will be retried until the record expires.
+     *
+     * @schema EventSourceMappingSpec#maximumRetryAttempts
+     */
+    readonly maximumRetryAttempts?: number;
+    /**
+     * (Streams only) The number of batches to process from each shard concurrently.
+     *
+     * @schema EventSourceMappingSpec#parallelizationFactor
+     */
+    readonly parallelizationFactor?: number;
+    /**
+     * (MQ) The name of the Amazon MQ broker destination queue to consume.
+     *
+     * @schema EventSourceMappingSpec#queues
+     */
+    readonly queues?: string[];
+    /**
+     * The Self-Managed Apache Kafka cluster to send records.
+     *
+     * @schema EventSourceMappingSpec#selfManagedEventSource
+     */
+    readonly selfManagedEventSource?: EventSourceMappingSpecSelfManagedEventSource;
+    /**
+     * An array of authentication protocols or VPC components required to secure your event source.
+     *
+     * @schema EventSourceMappingSpec#sourceAccessConfigurations
+     */
+    readonly sourceAccessConfigurations?: EventSourceMappingSpecSourceAccessConfigurations[];
+    /**
+     * The position in a stream from which to start reading. Required for Amazon Kinesis, Amazon DynamoDB, and Amazon MSK Streams sources. AT_TIMESTAMP is only supported for Amazon Kinesis streams.
+     *
+     * @schema EventSourceMappingSpec#startingPosition
+     */
+    readonly startingPosition?: string;
+    /**
+     * With StartingPosition set to AT_TIMESTAMP, the time from which to start reading.
+     *
+     * @schema EventSourceMappingSpec#startingPositionTimestamp
+     */
+    readonly startingPositionTimestamp?: Date;
+    /**
+     * The name of the Kafka topic.
+     *
+     * @schema EventSourceMappingSpec#topics
+     */
+    readonly topics?: string[];
+    /**
+     * (Streams only) The duration in seconds of a processing window. The range is between 1 second up to 900 seconds.
+     *
+     * @schema EventSourceMappingSpec#tumblingWindowInSeconds
+     */
+    readonly tumblingWindowInSeconds?: number;
+}
+/**
+ * Converts an object of type 'EventSourceMappingSpec' to JSON representation.
+ */
+export declare function toJson_EventSourceMappingSpec(obj: EventSourceMappingSpec | undefined): Record<string, any> | undefined;
+/**
+ * (Streams only) An Amazon SQS queue or Amazon SNS topic destination for discarded records.
+ *
+ * @schema EventSourceMappingSpecDestinationConfig
+ */
+export interface EventSourceMappingSpecDestinationConfig {
+    /**
+     * A destination for events that failed processing.
+     *
+     * @schema EventSourceMappingSpecDestinationConfig#onFailure
+     */
+    readonly onFailure?: EventSourceMappingSpecDestinationConfigOnFailure;
+    /**
+     * A destination for events that were processed successfully.
+     *
+     * @schema EventSourceMappingSpecDestinationConfig#onSuccess
+     */
+    readonly onSuccess?: EventSourceMappingSpecDestinationConfigOnSuccess;
+}
+/**
+ * Converts an object of type 'EventSourceMappingSpecDestinationConfig' to JSON representation.
+ */
+export declare function toJson_EventSourceMappingSpecDestinationConfig(obj: EventSourceMappingSpecDestinationConfig | undefined): Record<string, any> | undefined;
+/**
+ * The Self-Managed Apache Kafka cluster to send records.
+ *
+ * @schema EventSourceMappingSpecSelfManagedEventSource
+ */
+export interface EventSourceMappingSpecSelfManagedEventSource {
+    /**
+     * @schema EventSourceMappingSpecSelfManagedEventSource#endpoints
+     */
+    readonly endpoints?: {
+        [key: string]: string[];
+    };
+}
+/**
+ * Converts an object of type 'EventSourceMappingSpecSelfManagedEventSource' to JSON representation.
+ */
+export declare function toJson_EventSourceMappingSpecSelfManagedEventSource(obj: EventSourceMappingSpecSelfManagedEventSource | undefined): Record<string, any> | undefined;
+/**
+ * To secure and define access to your event source, you can specify the authentication protocol, VPC components, or virtual host.
+ *
+ * @schema EventSourceMappingSpecSourceAccessConfigurations
+ */
+export interface EventSourceMappingSpecSourceAccessConfigurations {
+    /**
+     * @schema EventSourceMappingSpecSourceAccessConfigurations#type_
+     */
+    readonly type?: string;
+    /**
+     * @schema EventSourceMappingSpecSourceAccessConfigurations#uRI
+     */
+    readonly uRi?: string;
+}
+/**
+ * Converts an object of type 'EventSourceMappingSpecSourceAccessConfigurations' to JSON representation.
+ */
+export declare function toJson_EventSourceMappingSpecSourceAccessConfigurations(obj: EventSourceMappingSpecSourceAccessConfigurations | undefined): Record<string, any> | undefined;
+/**
+ * A destination for events that failed processing.
+ *
+ * @schema EventSourceMappingSpecDestinationConfigOnFailure
+ */
+export interface EventSourceMappingSpecDestinationConfigOnFailure {
+    /**
+     * @schema EventSourceMappingSpecDestinationConfigOnFailure#destination
+     */
+    readonly destination?: string;
+}
+/**
+ * Converts an object of type 'EventSourceMappingSpecDestinationConfigOnFailure' to JSON representation.
+ */
+export declare function toJson_EventSourceMappingSpecDestinationConfigOnFailure(obj: EventSourceMappingSpecDestinationConfigOnFailure | undefined): Record<string, any> | undefined;
+/**
+ * A destination for events that were processed successfully.
+ *
+ * @schema EventSourceMappingSpecDestinationConfigOnSuccess
+ */
+export interface EventSourceMappingSpecDestinationConfigOnSuccess {
+    /**
+     * @schema EventSourceMappingSpecDestinationConfigOnSuccess#destination
+     */
+    readonly destination?: string;
+}
+/**
+ * Converts an object of type 'EventSourceMappingSpecDestinationConfigOnSuccess' to JSON representation.
+ */
+export declare function toJson_EventSourceMappingSpecDestinationConfigOnSuccess(obj: EventSourceMappingSpecDestinationConfigOnSuccess | undefined): Record<string, any> | undefined;
+//# sourceMappingURL=lambdaeventsourcemappings-lambda.services.k8s.aws.d.ts.map

package/lib/imports/lambdaeventsourcemappings-lambda.services.k8s.aws.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lambdaeventsourcemappings-lambda.services.k8s.aws.d.ts","sourceRoot":"","sources":["../../src/imports/lambdaeventsourcemappings-lambda.services.k8s.aws.ts"],"names":[],"mappings":"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"}

package/lib/imports/lambdaeventsourcemappings-lambda.services.k8s.aws.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toJson_EventSourceMappingSpecDestinationConfigOnSuccess = exports.toJson_EventSourceMappingSpecDestinationConfigOnFailure = exports.toJson_EventSourceMappingSpecSourceAccessConfigurations = exports.toJson_EventSourceMappingSpecSelfManagedEventSource = exports.toJson_EventSourceMappingSpecDestinationConfig = exports.toJson_EventSourceMappingSpec = exports.toJson_EventSourceMappingProps = exports.EventSourceMapping = void 0;
+// generated by cdk8s
+const cdk8s_1 = require("cdk8s");
+/**
+ * EventSourceMapping is the Schema for the EventSourceMappings API
+ *
+ * @schema EventSourceMapping
+ */
+class EventSourceMapping extends cdk8s_1.ApiObject {
+    /**
+     * Defines a "EventSourceMapping" API object
+     * @param scope the scope in which to define this object
+     * @param id a scope-local name for the object
+     * @param props initialization props
+     */
+    constructor(scope, id, props = {}) {
+        super(scope, id, {
+            ...EventSourceMapping.GVK,
+            ...props,
+        });
+    }
+    /**
+     * Renders a Kubernetes manifest for "EventSourceMapping".
+     *
+     * This can be used to inline resource manifests inside other objects (e.g. as templates).
+     *
+     * @param props initialization props
+     */
+    static manifest(props = {}) {
+        return {
+            ...EventSourceMapping.GVK,
+            ...toJson_EventSourceMappingProps(props),
+        };
+    }
+    /**
+     * Renders the object to Kubernetes JSON.
+     */
+    toJson() {
+        const resolved = super.toJson();
+        return {
+            ...EventSourceMapping.GVK,
+            ...toJson_EventSourceMappingProps(resolved),
+        };
+    }
+}
+exports.EventSourceMapping = EventSourceMapping;
+/**
+ * Returns the apiVersion and kind for "EventSourceMapping"
+ */
+EventSourceMapping.GVK = {
+    apiVersion: 'lambda.services.k8s.aws/v1alpha1',
+    kind: 'EventSourceMapping',
+};
+/**
+ * Converts an object of type 'EventSourceMappingProps' to JSON representation.
+ */
+/* eslint-disable max-len, quote-props */
+function toJson_EventSourceMappingProps(obj) {
+    if (obj === undefined) {
+        return undefined;
+    }
+    const result = {
+        'metadata': obj.metadata,
+        'spec': toJson_EventSourceMappingSpec(obj.spec),
+    };
+    // filter undefined values
+    return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});
+}
+exports.toJson_EventSourceMappingProps = toJson_EventSourceMappingProps;
+/**
+ * Converts an object of type 'EventSourceMappingSpec' to JSON representation.
+ */
+/* eslint-disable max-len, quote-props */
+function toJson_EventSourceMappingSpec(obj) {
+    var _a, _b, _c, _d, _e;
+    if (obj === undefined) {
+        return undefined;
+    }
+    const result = {
+        'batchSize': obj.batchSize,
+        'bisectBatchOnFunctionError': obj.bisectBatchOnFunctionError,
+        'destinationConfig': toJson_EventSourceMappingSpecDestinationConfig(obj.destinationConfig),
+        'enabled': obj.enabled,
+        'eventSourceARN': obj.eventSourceArn,
+        'functionName': obj.functionName,
+        'functionResponseTypes': (_a = obj.functionResponseTypes) === null || _a === void 0 ? void 0 : _a.map(y => y),
+        'maximumBatchingWindowInSeconds': obj.maximumBatchingWindowInSeconds,
+        'maximumRecordAgeInSeconds': obj.maximumRecordAgeInSeconds,
+        'maximumRetryAttempts': obj.maximumRetryAttempts,
+        'parallelizationFactor': obj.parallelizationFactor,
+        'queues': (_b = obj.queues) === null || _b === void 0 ? void 0 : _b.map(y => y),
+        'selfManagedEventSource': toJson_EventSourceMappingSpecSelfManagedEventSource(obj.selfManagedEventSource),
+        'sourceAccessConfigurations': (_c = obj.sourceAccessConfigurations) === null || _c === void 0 ? void 0 : _c.map(y => toJson_EventSourceMappingSpecSourceAccessConfigurations(y)),
+        'startingPosition': obj.startingPosition,
+        'startingPositionTimestamp': (_d = obj.startingPositionTimestamp) === null || _d === void 0 ? void 0 : _d.toISOString(),
+        'topics': (_e = obj.topics) === null || _e === void 0 ? void 0 : _e.map(y => y),
+        'tumblingWindowInSeconds': obj.tumblingWindowInSeconds,
+    };
+    // filter undefined values
+    return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});
+}
+exports.toJson_EventSourceMappingSpec = toJson_EventSourceMappingSpec;
+/**
+ * Converts an object of type 'EventSourceMappingSpecDestinationConfig' to JSON representation.
+ */
+/* eslint-disable max-len, quote-props */
+function toJson_EventSourceMappingSpecDestinationConfig(obj) {
+    if (obj === undefined) {
+        return undefined;
+    }
+    const result = {
+        'onFailure': toJson_EventSourceMappingSpecDestinationConfigOnFailure(obj.onFailure),
+        'onSuccess': toJson_EventSourceMappingSpecDestinationConfigOnSuccess(obj.onSuccess),
+    };
+    // filter undefined values
+    return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});
+}
+exports.toJson_EventSourceMappingSpecDestinationConfig = toJson_EventSourceMappingSpecDestinationConfig;
+/**
+ * Converts an object of type 'EventSourceMappingSpecSelfManagedEventSource' to JSON representation.
+ */
+/* eslint-disable max-len, quote-props */
+function toJson_EventSourceMappingSpecSelfManagedEventSource(obj) {
+    if (obj === undefined) {
+        return undefined;
+    }
+    const result = {
+        'endpoints': ((obj.endpoints) === undefined) ? undefined : (Object.entries(obj.endpoints).reduce((r, i) => { var _a; return (i[1] === undefined) ? r : ({ ...r, [i[0]]: (_a = i[1]) === null || _a === void 0 ? void 0 : _a.map(y => y) }); }, {})),
+    };
+    // filter undefined values
+    return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});
+}
+exports.toJson_EventSourceMappingSpecSelfManagedEventSource = toJson_EventSourceMappingSpecSelfManagedEventSource;
+/**
+ * Converts an object of type 'EventSourceMappingSpecSourceAccessConfigurations' to JSON representation.
+ */
+/* eslint-disable max-len, quote-props */
+function toJson_EventSourceMappingSpecSourceAccessConfigurations(obj) {
+    if (obj === undefined) {
+        return undefined;
+    }
+    const result = {
+        'type_': obj.type,
+        'uRI': obj.uRi,
+    };
+    // filter undefined values
+    return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});
+}
+exports.toJson_EventSourceMappingSpecSourceAccessConfigurations = toJson_EventSourceMappingSpecSourceAccessConfigurations;
+/**
+ * Converts an object of type 'EventSourceMappingSpecDestinationConfigOnFailure' to JSON representation.
+ */
+/* eslint-disable max-len, quote-props */
+function toJson_EventSourceMappingSpecDestinationConfigOnFailure(obj) {
+    if (obj === undefined) {
+        return undefined;
+    }
+    const result = {
+        'destination': obj.destination,
+    };
+    // filter undefined values
+    return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});
+}
+exports.toJson_EventSourceMappingSpecDestinationConfigOnFailure = toJson_EventSourceMappingSpecDestinationConfigOnFailure;
+/**
+ * Converts an object of type 'EventSourceMappingSpecDestinationConfigOnSuccess' to JSON representation.
+ */
+/* eslint-disable max-len, quote-props */
+function toJson_EventSourceMappingSpecDestinationConfigOnSuccess(obj) {
+    if (obj === undefined) {
+        return undefined;
+    }
+    const result = {
+        'destination': obj.destination,
+    };
+    // filter undefined values
+    return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});
+}
+exports.toJson_EventSourceMappingSpecDestinationConfigOnSuccess = toJson_EventSourceMappingSpecDestinationConfigOnSuccess;
+/* eslint-enable max-len, quote-props */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lambdaeventsourcemappings-lambda.services.k8s.aws.js","sourceRoot":"","sources":["../../src/imports/lambdaeventsourcemappings-lambda.services.k8s.aws.ts"],"names":[],"mappings":"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","sourcesContent":["// generated by cdk8s\nimport { ApiObject, ApiObjectMetadata, GroupVersionKind } from 'cdk8s';\nimport { Construct } from 'constructs';\n\n\n/**\n * EventSourceMapping is the Schema for the EventSourceMappings API\n *\n * @schema EventSourceMapping\n */\nexport class EventSourceMapping extends ApiObject {\n  /**\n   * Returns the apiVersion and kind for \"EventSourceMapping\"\n   */\n  public static readonly GVK: GroupVersionKind = {\n    apiVersion: 'lambda.services.k8s.aws/v1alpha1',\n    kind: 'EventSourceMapping',\n  };\n\n  /**\n   * Renders a Kubernetes manifest for \"EventSourceMapping\".\n   *\n   * This can be used to inline resource manifests inside other objects (e.g. as templates).\n   *\n   * @param props initialization props\n   */\n  public static manifest(props: EventSourceMappingProps = {}): any {\n    return {\n      ...EventSourceMapping.GVK,\n      ...toJson_EventSourceMappingProps(props),\n    };\n  }\n\n  /**\n   * Defines a \"EventSourceMapping\" API object\n   * @param scope the scope in which to define this object\n   * @param id a scope-local name for the object\n   * @param props initialization props\n   */\n  public constructor(scope: Construct, id: string, props: EventSourceMappingProps = {}) {\n    super(scope, id, {\n      ...EventSourceMapping.GVK,\n      ...props,\n    });\n  }\n\n  /**\n   * Renders the object to Kubernetes JSON.\n   */\n  public toJson(): any {\n    const resolved = super.toJson();\n\n    return {\n      ...EventSourceMapping.GVK,\n      ...toJson_EventSourceMappingProps(resolved),\n    };\n  }\n}\n\n/**\n * EventSourceMapping is the Schema for the EventSourceMappings API\n *\n * @schema EventSourceMapping\n */\nexport interface EventSourceMappingProps {\n  /**\n   * @schema EventSourceMapping#metadata\n   */\n  readonly metadata?: ApiObjectMetadata;\n\n  /**\n   * EventSourceMappingSpec defines the desired state of EventSourceMapping.\n   *\n   * @schema EventSourceMapping#spec\n   */\n  readonly spec?: EventSourceMappingSpec;\n\n}\n\n/**\n * Converts an object of type 'EventSourceMappingProps' to JSON representation.\n */\n/* eslint-disable max-len, quote-props */\nexport function toJson_EventSourceMappingProps(obj: EventSourceMappingProps | undefined): Record<string, any> | undefined {\n  if (obj === undefined) { return undefined; }\n  const result = {\n    'metadata': obj.metadata,\n    'spec': toJson_EventSourceMappingSpec(obj.spec),\n  };\n  // filter undefined values\n  return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});\n}\n/* eslint-enable max-len, quote-props */\n\n/**\n * EventSourceMappingSpec defines the desired state of EventSourceMapping.\n *\n * @schema EventSourceMappingSpec\n */\nexport interface EventSourceMappingSpec {\n  /**\n   * The maximum number of records in each batch that Lambda pulls from your stream or queue and sends to your function. Lambda passes all of the records in the batch to the function in a single call, up to the payload limit for synchronous invocation (6 MB).\n   * * Amazon Kinesis - Default 100. Max 10,000.\n   * * Amazon DynamoDB Streams - Default 100. Max 1,000.\n   * * Amazon Simple Queue Service - Default 10. For standard queues the max    is 10,000. For FIFO queues the max is 10.\n   * * Amazon Managed Streaming for Apache Kafka - Default 100. Max 10,000.\n   * * Self-Managed Apache Kafka - Default 100. Max 10,000.\n   *\n   * @schema EventSourceMappingSpec#batchSize\n   */\n  readonly batchSize?: number;\n\n  /**\n   * (Streams only) If the function returns an error, split the batch in two and retry.\n   *\n   * @schema EventSourceMappingSpec#bisectBatchOnFunctionError\n   */\n  readonly bisectBatchOnFunctionError?: boolean;\n\n  /**\n   * (Streams only) An Amazon SQS queue or Amazon SNS topic destination for discarded records.\n   *\n   * @schema EventSourceMappingSpec#destinationConfig\n   */\n  readonly destinationConfig?: EventSourceMappingSpecDestinationConfig;\n\n  /**\n   * When true, the event source mapping is active. When false, Lambda pauses polling and invocation.\n   * Default: True\n   *\n   * @schema EventSourceMappingSpec#enabled\n   */\n  readonly enabled?: boolean;\n\n  /**\n   * The Amazon Resource Name (ARN) of the event source.\n   * * Amazon Kinesis - The ARN of the data stream or a stream consumer.\n   * * Amazon DynamoDB Streams - The ARN of the stream.\n   * * Amazon Simple Queue Service - The ARN of the queue.\n   * * Amazon Managed Streaming for Apache Kafka - The ARN of the cluster.\n   *\n   * @schema EventSourceMappingSpec#eventSourceARN\n   */\n  readonly eventSourceArn?: string;\n\n  /**\n   * The name of the Lambda function.\n   * Name formats\n   * * Function name - MyFunction.\n   * * Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.\n   * * Version or Alias ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction:PROD.\n   * * Partial ARN - 123456789012:function:MyFunction.\n   * The length constraint applies only to the full ARN. If you specify only the function name, it's limited to 64 characters in length.\n   *\n   * @schema EventSourceMappingSpec#functionName\n   */\n  readonly functionName: string;\n\n  /**\n   * (Streams only) A list of current response type enums applied to the event source mapping.\n   *\n   * @schema EventSourceMappingSpec#functionResponseTypes\n   */\n  readonly functionResponseTypes?: string[];\n\n  /**\n   * (Streams and Amazon SQS standard queues) The maximum amount of time, in seconds, that Lambda spends gathering records before invoking the function.\n   * Default: 0\n   * Related setting: When you set BatchSize to a value greater than 10, you must set MaximumBatchingWindowInSeconds to at least 1.\n   *\n   * @schema EventSourceMappingSpec#maximumBatchingWindowInSeconds\n   */\n  readonly maximumBatchingWindowInSeconds?: number;\n\n  /**\n   * (Streams only) Discard records older than the specified age. The default value is infinite (-1).\n   *\n   * @schema EventSourceMappingSpec#maximumRecordAgeInSeconds\n   */\n  readonly maximumRecordAgeInSeconds?: number;\n\n  /**\n   * (Streams only) Discard records after the specified number of retries. The default value is infinite (-1). When set to infinite (-1), failed records will be retried until the record expires.\n   *\n   * @schema EventSourceMappingSpec#maximumRetryAttempts\n   */\n  readonly maximumRetryAttempts?: number;\n\n  /**\n   * (Streams only) The number of batches to process from each shard concurrently.\n   *\n   * @schema EventSourceMappingSpec#parallelizationFactor\n   */\n  readonly parallelizationFactor?: number;\n\n  /**\n   * (MQ) The name of the Amazon MQ broker destination queue to consume.\n   *\n   * @schema EventSourceMappingSpec#queues\n   */\n  readonly queues?: string[];\n\n  /**\n   * The Self-Managed Apache Kafka cluster to send records.\n   *\n   * @schema EventSourceMappingSpec#selfManagedEventSource\n   */\n  readonly selfManagedEventSource?: EventSourceMappingSpecSelfManagedEventSource;\n\n  /**\n   * An array of authentication protocols or VPC components required to secure your event source.\n   *\n   * @schema EventSourceMappingSpec#sourceAccessConfigurations\n   */\n  readonly sourceAccessConfigurations?: EventSourceMappingSpecSourceAccessConfigurations[];\n\n  /**\n   * The position in a stream from which to start reading. Required for Amazon Kinesis, Amazon DynamoDB, and Amazon MSK Streams sources. AT_TIMESTAMP is only supported for Amazon Kinesis streams.\n   *\n   * @schema EventSourceMappingSpec#startingPosition\n   */\n  readonly startingPosition?: string;\n\n  /**\n   * With StartingPosition set to AT_TIMESTAMP, the time from which to start reading.\n   *\n   * @schema EventSourceMappingSpec#startingPositionTimestamp\n   */\n  readonly startingPositionTimestamp?: Date;\n\n  /**\n   * The name of the Kafka topic.\n   *\n   * @schema EventSourceMappingSpec#topics\n   */\n  readonly topics?: string[];\n\n  /**\n   * (Streams only) The duration in seconds of a processing window. The range is between 1 second up to 900 seconds.\n   *\n   * @schema EventSourceMappingSpec#tumblingWindowInSeconds\n   */\n  readonly tumblingWindowInSeconds?: number;\n\n}\n\n/**\n * Converts an object of type 'EventSourceMappingSpec' to JSON representation.\n */\n/* eslint-disable max-len, quote-props */\nexport function toJson_EventSourceMappingSpec(obj: EventSourceMappingSpec | undefined): Record<string, any> | undefined {\n  if (obj === undefined) { return undefined; }\n  const result = {\n    'batchSize': obj.batchSize,\n    'bisectBatchOnFunctionError': obj.bisectBatchOnFunctionError,\n    'destinationConfig': toJson_EventSourceMappingSpecDestinationConfig(obj.destinationConfig),\n    'enabled': obj.enabled,\n    'eventSourceARN': obj.eventSourceArn,\n    'functionName': obj.functionName,\n    'functionResponseTypes': obj.functionResponseTypes?.map(y => y),\n    'maximumBatchingWindowInSeconds': obj.maximumBatchingWindowInSeconds,\n    'maximumRecordAgeInSeconds': obj.maximumRecordAgeInSeconds,\n    'maximumRetryAttempts': obj.maximumRetryAttempts,\n    'parallelizationFactor': obj.parallelizationFactor,\n    'queues': obj.queues?.map(y => y),\n    'selfManagedEventSource': toJson_EventSourceMappingSpecSelfManagedEventSource(obj.selfManagedEventSource),\n    'sourceAccessConfigurations': obj.sourceAccessConfigurations?.map(y => toJson_EventSourceMappingSpecSourceAccessConfigurations(y)),\n    'startingPosition': obj.startingPosition,\n    'startingPositionTimestamp': obj.startingPositionTimestamp?.toISOString(),\n    'topics': obj.topics?.map(y => y),\n    'tumblingWindowInSeconds': obj.tumblingWindowInSeconds,\n  };\n  // filter undefined values\n  return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});\n}\n/* eslint-enable max-len, quote-props */\n\n/**\n * (Streams only) An Amazon SQS queue or Amazon SNS topic destination for discarded records.\n *\n * @schema EventSourceMappingSpecDestinationConfig\n */\nexport interface EventSourceMappingSpecDestinationConfig {\n  /**\n   * A destination for events that failed processing.\n   *\n   * @schema EventSourceMappingSpecDestinationConfig#onFailure\n   */\n  readonly onFailure?: EventSourceMappingSpecDestinationConfigOnFailure;\n\n  /**\n   * A destination for events that were processed successfully.\n   *\n   * @schema EventSourceMappingSpecDestinationConfig#onSuccess\n   */\n  readonly onSuccess?: EventSourceMappingSpecDestinationConfigOnSuccess;\n\n}\n\n/**\n * Converts an object of type 'EventSourceMappingSpecDestinationConfig' to JSON representation.\n */\n/* eslint-disable max-len, quote-props */\nexport function toJson_EventSourceMappingSpecDestinationConfig(obj: EventSourceMappingSpecDestinationConfig | undefined): Record<string, any> | undefined {\n  if (obj === undefined) { return undefined; }\n  const result = {\n    'onFailure': toJson_EventSourceMappingSpecDestinationConfigOnFailure(obj.onFailure),\n    'onSuccess': toJson_EventSourceMappingSpecDestinationConfigOnSuccess(obj.onSuccess),\n  };\n  // filter undefined values\n  return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});\n}\n/* eslint-enable max-len, quote-props */\n\n/**\n * The Self-Managed Apache Kafka cluster to send records.\n *\n * @schema EventSourceMappingSpecSelfManagedEventSource\n */\nexport interface EventSourceMappingSpecSelfManagedEventSource {\n  /**\n   * @schema EventSourceMappingSpecSelfManagedEventSource#endpoints\n   */\n  readonly endpoints?: { [key: string]: string[] };\n\n}\n\n/**\n * Converts an object of type 'EventSourceMappingSpecSelfManagedEventSource' to JSON representation.\n */\n/* eslint-disable max-len, quote-props */\nexport function toJson_EventSourceMappingSpecSelfManagedEventSource(obj: EventSourceMappingSpecSelfManagedEventSource | undefined): Record<string, any> | undefined {\n  if (obj === undefined) { return undefined; }\n  const result = {\n    'endpoints': ((obj.endpoints) === undefined) ? undefined : (Object.entries(obj.endpoints).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1]?.map(y => y) }), {})),\n  };\n  // filter undefined values\n  return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});\n}\n/* eslint-enable max-len, quote-props */\n\n/**\n * To secure and define access to your event source, you can specify the authentication protocol, VPC components, or virtual host.\n *\n * @schema EventSourceMappingSpecSourceAccessConfigurations\n */\nexport interface EventSourceMappingSpecSourceAccessConfigurations {\n  /**\n   * @schema EventSourceMappingSpecSourceAccessConfigurations#type_\n   */\n  readonly type?: string;\n\n  /**\n   * @schema EventSourceMappingSpecSourceAccessConfigurations#uRI\n   */\n  readonly uRi?: string;\n\n}\n\n/**\n * Converts an object of type 'EventSourceMappingSpecSourceAccessConfigurations' to JSON representation.\n */\n/* eslint-disable max-len, quote-props */\nexport function toJson_EventSourceMappingSpecSourceAccessConfigurations(obj: EventSourceMappingSpecSourceAccessConfigurations | undefined): Record<string, any> | undefined {\n  if (obj === undefined) { return undefined; }\n  const result = {\n    'type_': obj.type,\n    'uRI': obj.uRi,\n  };\n  // filter undefined values\n  return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});\n}\n/* eslint-enable max-len, quote-props */\n\n/**\n * A destination for events that failed processing.\n *\n * @schema EventSourceMappingSpecDestinationConfigOnFailure\n */\nexport interface EventSourceMappingSpecDestinationConfigOnFailure {\n  /**\n   * @schema EventSourceMappingSpecDestinationConfigOnFailure#destination\n   */\n  readonly destination?: string;\n\n}\n\n/**\n * Converts an object of type 'EventSourceMappingSpecDestinationConfigOnFailure' to JSON representation.\n */\n/* eslint-disable max-len, quote-props */\nexport function toJson_EventSourceMappingSpecDestinationConfigOnFailure(obj: EventSourceMappingSpecDestinationConfigOnFailure | undefined): Record<string, any> | undefined {\n  if (obj === undefined) { return undefined; }\n  const result = {\n    'destination': obj.destination,\n  };\n  // filter undefined values\n  return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});\n}\n/* eslint-enable max-len, quote-props */\n\n/**\n * A destination for events that were processed successfully.\n *\n * @schema EventSourceMappingSpecDestinationConfigOnSuccess\n */\nexport interface EventSourceMappingSpecDestinationConfigOnSuccess {\n  /**\n   * @schema EventSourceMappingSpecDestinationConfigOnSuccess#destination\n   */\n  readonly destination?: string;\n\n}\n\n/**\n * Converts an object of type 'EventSourceMappingSpecDestinationConfigOnSuccess' to JSON representation.\n */\n/* eslint-disable max-len, quote-props */\nexport function toJson_EventSourceMappingSpecDestinationConfigOnSuccess(obj: EventSourceMappingSpecDestinationConfigOnSuccess | undefined): Record<string, any> | undefined {\n  if (obj === undefined) { return undefined; }\n  const result = {\n    'destination': obj.destination,\n  };\n  // filter undefined values\n  return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});\n}\n/* eslint-enable max-len, quote-props */\n\n"]}