cdk8s-aws-cdk 0.0.5

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

@@ -0,0 +1,343 @@
+import { ApiObject, ApiObjectMetadata, GroupVersionKind } from 'cdk8s';
+import { Construct } from 'constructs';
+/**
+ * Function is the Schema for the Functions API
+ *
+ * @schema Function
+ */
+export declare class Function extends ApiObject {
+    /**
+     * Returns the apiVersion and kind for "Function"
+     */
+    static readonly GVK: GroupVersionKind;
+    /**
+     * Renders a Kubernetes manifest for "Function".
+     *
+     * This can be used to inline resource manifests inside other objects (e.g. as templates).
+     *
+     * @param props initialization props
+     */
+    static manifest(props?: FunctionProps): any;
+    /**
+     * Defines a "Function" 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?: FunctionProps);
+    /**
+     * Renders the object to Kubernetes JSON.
+     */
+    toJson(): any;
+}
+/**
+ * Function is the Schema for the Functions API
+ *
+ * @schema Function
+ */
+export interface FunctionProps {
+    /**
+     * @schema Function#metadata
+     */
+    readonly metadata?: ApiObjectMetadata;
+    /**
+     * FunctionSpec defines the desired state of Function.
+     *
+     * @schema Function#spec
+     */
+    readonly spec?: FunctionSpec;
+}
+/**
+ * Converts an object of type 'FunctionProps' to JSON representation.
+ */
+export declare function toJson_FunctionProps(obj: FunctionProps | undefined): Record<string, any> | undefined;
+/**
+ * FunctionSpec defines the desired state of Function.
+ *
+ * @schema FunctionSpec
+ */
+export interface FunctionSpec {
+    /**
+     * The instruction set architecture that the function supports. Enter a string array with one of the valid values. The default value is x86_64.
+     *
+     * @schema FunctionSpec#architectures
+     */
+    readonly architectures?: string[];
+    /**
+     * The code for the function.
+     *
+     * @schema FunctionSpec#code
+     */
+    readonly code: FunctionSpecCode;
+    /**
+     * To enable code signing for this function, specify the ARN of a code-signing configuration. A code-signing configuration includes a set of signing profiles, which define the trusted publishers for this function.
+     *
+     * @schema FunctionSpec#codeSigningConfigARN
+     */
+    readonly codeSigningConfigArn?: string;
+    /**
+     * A dead letter queue configuration that specifies the queue or topic where Lambda sends asynchronous events when they fail processing. For more information, see Dead Letter Queues (https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html#dlq).
+     *
+     * @schema FunctionSpec#deadLetterConfig
+     */
+    readonly deadLetterConfig?: FunctionSpecDeadLetterConfig;
+    /**
+     * A description of the function.
+     *
+     * @schema FunctionSpec#description
+     */
+    readonly description?: string;
+    /**
+     * Environment variables that are accessible from function code during execution.
+     *
+     * @schema FunctionSpec#environment
+     */
+    readonly environment?: FunctionSpecEnvironment;
+    /**
+     * Connection settings for an Amazon EFS file system.
+     *
+     * @schema FunctionSpec#fileSystemConfigs
+     */
+    readonly fileSystemConfigs?: FunctionSpecFileSystemConfigs[];
+    /**
+     * The name of the method within your code that Lambda calls to execute your function. The format includes the file name. It can also include namespaces and other qualifiers, depending on the runtime. For more information, see Programming Model (https://docs.aws.amazon.com/lambda/latest/dg/programming-model-v2.html).
+     *
+     * @schema FunctionSpec#handler
+     */
+    readonly handler?: string;
+    /**
+     * Container image configuration values (https://docs.aws.amazon.com/lambda/latest/dg/configuration-images.html#configuration-images-settings) that override the values in the container image Dockerfile.
+     *
+     * @schema FunctionSpec#imageConfig
+     */
+    readonly imageConfig?: FunctionSpecImageConfig;
+    /**
+     * The ARN of the Amazon Web Services Key Management Service (KMS) key that's used to encrypt your function's environment variables. If it's not provided, Lambda uses a default service key.
+     *
+     * @schema FunctionSpec#kmsKeyARN
+     */
+    readonly kmsKeyArn?: string;
+    /**
+     * A list of function layers (https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) to add to the function's execution environment. Specify each layer by its ARN, including the version.
+     *
+     * @schema FunctionSpec#layers
+     */
+    readonly layers?: string[];
+    /**
+     * The amount of memory available to the function (https://docs.aws.amazon.com/lambda/latest/dg/configuration-memory.html) at runtime. Increasing the function memory also increases its CPU allocation. The default value is 128 MB. The value can be any multiple of 1 MB.
+     *
+     * @schema FunctionSpec#memorySize
+     */
+    readonly memorySize?: number;
+    /**
+     * The name of the Lambda function.
+     * Name formats
+     * * Function name - my-function.
+     * * Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
+     * * Partial ARN - 123456789012:function:my-function.
+     * The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.
+     *
+     * @schema FunctionSpec#name
+     */
+    readonly name: string;
+    /**
+     * The type of deployment package. Set to Image for container image and set Zip for ZIP archive.
+     *
+     * @schema FunctionSpec#packageType
+     */
+    readonly packageType?: string;
+    /**
+     * Set to true to publish the first version of the function during creation.
+     *
+     * @schema FunctionSpec#publish
+     */
+    readonly publish?: boolean;
+    /**
+     * The number of simultaneous executions to reserve for the function.
+     *
+     * @schema FunctionSpec#reservedConcurrentExecutions
+     */
+    readonly reservedConcurrentExecutions?: number;
+    /**
+     * The Amazon Resource Name (ARN) of the function's execution role.
+     *
+     * @schema FunctionSpec#role
+     */
+    readonly role: string;
+    /**
+     * The identifier of the function's runtime (https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html).
+     *
+     * @schema FunctionSpec#runtime
+     */
+    readonly runtime?: string;
+    /**
+     * A list of tags (https://docs.aws.amazon.com/lambda/latest/dg/tagging.html) to apply to the function.
+     *
+     * @schema FunctionSpec#tags
+     */
+    readonly tags?: {
+        [key: string]: string;
+    };
+    /**
+     * The amount of time that Lambda allows a function to run before stopping it. The default is 3 seconds. The maximum allowed value is 900 seconds. For additional information, see Lambda execution environment (https://docs.aws.amazon.com/lambda/latest/dg/runtimes-context.html).
+     *
+     * @schema FunctionSpec#timeout
+     */
+    readonly timeout?: number;
+    /**
+     * Set Mode to Active to sample and trace a subset of incoming requests with X-Ray (https://docs.aws.amazon.com/lambda/latest/dg/services-xray.html).
+     *
+     * @schema FunctionSpec#tracingConfig
+     */
+    readonly tracingConfig?: FunctionSpecTracingConfig;
+    /**
+     * For network connectivity to Amazon Web Services resources in a VPC, specify a list of security groups and subnets in the VPC. When you connect a function to a VPC, it can only access resources and the internet through that VPC. For more information, see VPC Settings (https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html).
+     *
+     * @schema FunctionSpec#vpcConfig
+     */
+    readonly vpcConfig?: FunctionSpecVpcConfig;
+}
+/**
+ * Converts an object of type 'FunctionSpec' to JSON representation.
+ */
+export declare function toJson_FunctionSpec(obj: FunctionSpec | undefined): Record<string, any> | undefined;
+/**
+ * The code for the function.
+ *
+ * @schema FunctionSpecCode
+ */
+export interface FunctionSpecCode {
+    /**
+     * @schema FunctionSpecCode#imageURI
+     */
+    readonly imageUri?: string;
+    /**
+     * @schema FunctionSpecCode#s3Bucket
+     */
+    readonly s3Bucket?: string;
+    /**
+     * @schema FunctionSpecCode#s3Key
+     */
+    readonly s3Key?: string;
+    /**
+     * @schema FunctionSpecCode#s3ObjectVersion
+     */
+    readonly s3ObjectVersion?: string;
+    /**
+     * @schema FunctionSpecCode#zipFile
+     */
+    readonly zipFile?: string;
+}
+/**
+ * Converts an object of type 'FunctionSpecCode' to JSON representation.
+ */
+export declare function toJson_FunctionSpecCode(obj: FunctionSpecCode | undefined): Record<string, any> | undefined;
+/**
+ * A dead letter queue configuration that specifies the queue or topic where Lambda sends asynchronous events when they fail processing. For more information, see Dead Letter Queues (https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html#dlq).
+ *
+ * @schema FunctionSpecDeadLetterConfig
+ */
+export interface FunctionSpecDeadLetterConfig {
+    /**
+     * @schema FunctionSpecDeadLetterConfig#targetARN
+     */
+    readonly targetArn?: string;
+}
+/**
+ * Converts an object of type 'FunctionSpecDeadLetterConfig' to JSON representation.
+ */
+export declare function toJson_FunctionSpecDeadLetterConfig(obj: FunctionSpecDeadLetterConfig | undefined): Record<string, any> | undefined;
+/**
+ * Environment variables that are accessible from function code during execution.
+ *
+ * @schema FunctionSpecEnvironment
+ */
+export interface FunctionSpecEnvironment {
+    /**
+     * @schema FunctionSpecEnvironment#variables
+     */
+    readonly variables?: {
+        [key: string]: string;
+    };
+}
+/**
+ * Converts an object of type 'FunctionSpecEnvironment' to JSON representation.
+ */
+export declare function toJson_FunctionSpecEnvironment(obj: FunctionSpecEnvironment | undefined): Record<string, any> | undefined;
+/**
+ * Details about the connection between a Lambda function and an Amazon EFS file system (https://docs.aws.amazon.com/lambda/latest/dg/configuration-filesystem.html).
+ *
+ * @schema FunctionSpecFileSystemConfigs
+ */
+export interface FunctionSpecFileSystemConfigs {
+    /**
+     * @schema FunctionSpecFileSystemConfigs#arn
+     */
+    readonly arn?: string;
+    /**
+     * @schema FunctionSpecFileSystemConfigs#localMountPath
+     */
+    readonly localMountPath?: string;
+}
+/**
+ * Converts an object of type 'FunctionSpecFileSystemConfigs' to JSON representation.
+ */
+export declare function toJson_FunctionSpecFileSystemConfigs(obj: FunctionSpecFileSystemConfigs | undefined): Record<string, any> | undefined;
+/**
+ * Container image configuration values (https://docs.aws.amazon.com/lambda/latest/dg/configuration-images.html#configuration-images-settings) that override the values in the container image Dockerfile.
+ *
+ * @schema FunctionSpecImageConfig
+ */
+export interface FunctionSpecImageConfig {
+    /**
+     * @schema FunctionSpecImageConfig#command
+     */
+    readonly command?: string[];
+    /**
+     * @schema FunctionSpecImageConfig#entryPoint
+     */
+    readonly entryPoint?: string[];
+    /**
+     * @schema FunctionSpecImageConfig#workingDirectory
+     */
+    readonly workingDirectory?: string;
+}
+/**
+ * Converts an object of type 'FunctionSpecImageConfig' to JSON representation.
+ */
+export declare function toJson_FunctionSpecImageConfig(obj: FunctionSpecImageConfig | undefined): Record<string, any> | undefined;
+/**
+ * Set Mode to Active to sample and trace a subset of incoming requests with X-Ray (https://docs.aws.amazon.com/lambda/latest/dg/services-xray.html).
+ *
+ * @schema FunctionSpecTracingConfig
+ */
+export interface FunctionSpecTracingConfig {
+    /**
+     * @schema FunctionSpecTracingConfig#mode
+     */
+    readonly mode?: string;
+}
+/**
+ * Converts an object of type 'FunctionSpecTracingConfig' to JSON representation.
+ */
+export declare function toJson_FunctionSpecTracingConfig(obj: FunctionSpecTracingConfig | undefined): Record<string, any> | undefined;
+/**
+ * For network connectivity to Amazon Web Services resources in a VPC, specify a list of security groups and subnets in the VPC. When you connect a function to a VPC, it can only access resources and the internet through that VPC. For more information, see VPC Settings (https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html).
+ *
+ * @schema FunctionSpecVpcConfig
+ */
+export interface FunctionSpecVpcConfig {
+    /**
+     * @schema FunctionSpecVpcConfig#securityGroupIDs
+     */
+    readonly securityGroupIDs?: string[];
+    /**
+     * @schema FunctionSpecVpcConfig#subnetIDs
+     */
+    readonly subnetIDs?: string[];
+}
+/**
+ * Converts an object of type 'FunctionSpecVpcConfig' to JSON representation.
+ */
+export declare function toJson_FunctionSpecVpcConfig(obj: FunctionSpecVpcConfig | undefined): Record<string, any> | undefined;
+//# sourceMappingURL=lambdafunctions-lambda.services.k8s.aws.d.ts.map

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

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

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

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toJson_FunctionSpecVpcConfig = exports.toJson_FunctionSpecTracingConfig = exports.toJson_FunctionSpecImageConfig = exports.toJson_FunctionSpecFileSystemConfigs = exports.toJson_FunctionSpecEnvironment = exports.toJson_FunctionSpecDeadLetterConfig = exports.toJson_FunctionSpecCode = exports.toJson_FunctionSpec = exports.toJson_FunctionProps = exports.Function = void 0;
+// generated by cdk8s
+const cdk8s_1 = require("cdk8s");
+/**
+ * Function is the Schema for the Functions API
+ *
+ * @schema Function
+ */
+class Function extends cdk8s_1.ApiObject {
+    /**
+     * Defines a "Function" 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, {
+            ...Function.GVK,
+            ...props,
+        });
+    }
+    /**
+     * Renders a Kubernetes manifest for "Function".
+     *
+     * This can be used to inline resource manifests inside other objects (e.g. as templates).
+     *
+     * @param props initialization props
+     */
+    static manifest(props = {}) {
+        return {
+            ...Function.GVK,
+            ...toJson_FunctionProps(props),
+        };
+    }
+    /**
+     * Renders the object to Kubernetes JSON.
+     */
+    toJson() {
+        const resolved = super.toJson();
+        return {
+            ...Function.GVK,
+            ...toJson_FunctionProps(resolved),
+        };
+    }
+}
+exports.Function = Function;
+/**
+ * Returns the apiVersion and kind for "Function"
+ */
+Function.GVK = {
+    apiVersion: 'lambda.services.k8s.aws/v1alpha1',
+    kind: 'Function',
+};
+/**
+ * Converts an object of type 'FunctionProps' to JSON representation.
+ */
+/* eslint-disable max-len, quote-props */
+function toJson_FunctionProps(obj) {
+    if (obj === undefined) {
+        return undefined;
+    }
+    const result = {
+        'metadata': obj.metadata,
+        'spec': toJson_FunctionSpec(obj.spec),
+    };
+    // filter undefined values
+    return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});
+}
+exports.toJson_FunctionProps = toJson_FunctionProps;
+/**
+ * Converts an object of type 'FunctionSpec' to JSON representation.
+ */
+/* eslint-disable max-len, quote-props */
+function toJson_FunctionSpec(obj) {
+    var _a, _b, _c;
+    if (obj === undefined) {
+        return undefined;
+    }
+    const result = {
+        'architectures': (_a = obj.architectures) === null || _a === void 0 ? void 0 : _a.map(y => y),
+        'code': toJson_FunctionSpecCode(obj.code),
+        'codeSigningConfigARN': obj.codeSigningConfigArn,
+        'deadLetterConfig': toJson_FunctionSpecDeadLetterConfig(obj.deadLetterConfig),
+        'description': obj.description,
+        'environment': toJson_FunctionSpecEnvironment(obj.environment),
+        'fileSystemConfigs': (_b = obj.fileSystemConfigs) === null || _b === void 0 ? void 0 : _b.map(y => toJson_FunctionSpecFileSystemConfigs(y)),
+        'handler': obj.handler,
+        'imageConfig': toJson_FunctionSpecImageConfig(obj.imageConfig),
+        'kmsKeyARN': obj.kmsKeyArn,
+        'layers': (_c = obj.layers) === null || _c === void 0 ? void 0 : _c.map(y => y),
+        'memorySize': obj.memorySize,
+        'name': obj.name,
+        'packageType': obj.packageType,
+        'publish': obj.publish,
+        'reservedConcurrentExecutions': obj.reservedConcurrentExecutions,
+        'role': obj.role,
+        'runtime': obj.runtime,
+        'tags': ((obj.tags) === undefined) ? undefined : (Object.entries(obj.tags).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {})),
+        'timeout': obj.timeout,
+        'tracingConfig': toJson_FunctionSpecTracingConfig(obj.tracingConfig),
+        'vpcConfig': toJson_FunctionSpecVpcConfig(obj.vpcConfig),
+    };
+    // filter undefined values
+    return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});
+}
+exports.toJson_FunctionSpec = toJson_FunctionSpec;
+/**
+ * Converts an object of type 'FunctionSpecCode' to JSON representation.
+ */
+/* eslint-disable max-len, quote-props */
+function toJson_FunctionSpecCode(obj) {
+    if (obj === undefined) {
+        return undefined;
+    }
+    const result = {
+        'imageURI': obj.imageUri,
+        's3Bucket': obj.s3Bucket,
+        's3Key': obj.s3Key,
+        's3ObjectVersion': obj.s3ObjectVersion,
+        'zipFile': obj.zipFile,
+    };
+    // filter undefined values
+    return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});
+}
+exports.toJson_FunctionSpecCode = toJson_FunctionSpecCode;
+/**
+ * Converts an object of type 'FunctionSpecDeadLetterConfig' to JSON representation.
+ */
+/* eslint-disable max-len, quote-props */
+function toJson_FunctionSpecDeadLetterConfig(obj) {
+    if (obj === undefined) {
+        return undefined;
+    }
+    const result = {
+        'targetARN': obj.targetArn,
+    };
+    // filter undefined values
+    return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});
+}
+exports.toJson_FunctionSpecDeadLetterConfig = toJson_FunctionSpecDeadLetterConfig;
+/**
+ * Converts an object of type 'FunctionSpecEnvironment' to JSON representation.
+ */
+/* eslint-disable max-len, quote-props */
+function toJson_FunctionSpecEnvironment(obj) {
+    if (obj === undefined) {
+        return undefined;
+    }
+    const result = {
+        'variables': ((obj.variables) === undefined) ? undefined : (Object.entries(obj.variables).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {})),
+    };
+    // filter undefined values
+    return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});
+}
+exports.toJson_FunctionSpecEnvironment = toJson_FunctionSpecEnvironment;
+/**
+ * Converts an object of type 'FunctionSpecFileSystemConfigs' to JSON representation.
+ */
+/* eslint-disable max-len, quote-props */
+function toJson_FunctionSpecFileSystemConfigs(obj) {
+    if (obj === undefined) {
+        return undefined;
+    }
+    const result = {
+        'arn': obj.arn,
+        'localMountPath': obj.localMountPath,
+    };
+    // filter undefined values
+    return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});
+}
+exports.toJson_FunctionSpecFileSystemConfigs = toJson_FunctionSpecFileSystemConfigs;
+/**
+ * Converts an object of type 'FunctionSpecImageConfig' to JSON representation.
+ */
+/* eslint-disable max-len, quote-props */
+function toJson_FunctionSpecImageConfig(obj) {
+    var _a, _b;
+    if (obj === undefined) {
+        return undefined;
+    }
+    const result = {
+        'command': (_a = obj.command) === null || _a === void 0 ? void 0 : _a.map(y => y),
+        'entryPoint': (_b = obj.entryPoint) === null || _b === void 0 ? void 0 : _b.map(y => y),
+        'workingDirectory': obj.workingDirectory,
+    };
+    // filter undefined values
+    return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});
+}
+exports.toJson_FunctionSpecImageConfig = toJson_FunctionSpecImageConfig;
+/**
+ * Converts an object of type 'FunctionSpecTracingConfig' to JSON representation.
+ */
+/* eslint-disable max-len, quote-props */
+function toJson_FunctionSpecTracingConfig(obj) {
+    if (obj === undefined) {
+        return undefined;
+    }
+    const result = {
+        'mode': obj.mode,
+    };
+    // filter undefined values
+    return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});
+}
+exports.toJson_FunctionSpecTracingConfig = toJson_FunctionSpecTracingConfig;
+/**
+ * Converts an object of type 'FunctionSpecVpcConfig' to JSON representation.
+ */
+/* eslint-disable max-len, quote-props */
+function toJson_FunctionSpecVpcConfig(obj) {
+    var _a, _b;
+    if (obj === undefined) {
+        return undefined;
+    }
+    const result = {
+        'securityGroupIDs': (_a = obj.securityGroupIDs) === null || _a === void 0 ? void 0 : _a.map(y => y),
+        'subnetIDs': (_b = obj.subnetIDs) === null || _b === void 0 ? void 0 : _b.map(y => y),
+    };
+    // filter undefined values
+    return Object.entries(result).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {});
+}
+exports.toJson_FunctionSpecVpcConfig = toJson_FunctionSpecVpcConfig;
+/* eslint-enable max-len, quote-props */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lambdafunctions-lambda.services.k8s.aws.js","sourceRoot":"","sources":["../../src/imports/lambdafunctions-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 * Function is the Schema for the Functions API\n *\n * @schema Function\n */\nexport class Function extends ApiObject {\n  /**\n   * Returns the apiVersion and kind for \"Function\"\n   */\n  public static readonly GVK: GroupVersionKind = {\n    apiVersion: 'lambda.services.k8s.aws/v1alpha1',\n    kind: 'Function',\n  };\n\n  /**\n   * Renders a Kubernetes manifest for \"Function\".\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: FunctionProps = {}): any {\n    return {\n      ...Function.GVK,\n      ...toJson_FunctionProps(props),\n    };\n  }\n\n  /**\n   * Defines a \"Function\" 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: FunctionProps = {}) {\n    super(scope, id, {\n      ...Function.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      ...Function.GVK,\n      ...toJson_FunctionProps(resolved),\n    };\n  }\n}\n\n/**\n * Function is the Schema for the Functions API\n *\n * @schema Function\n */\nexport interface FunctionProps {\n  /**\n   * @schema Function#metadata\n   */\n  readonly metadata?: ApiObjectMetadata;\n\n  /**\n   * FunctionSpec defines the desired state of Function.\n   *\n   * @schema Function#spec\n   */\n  readonly spec?: FunctionSpec;\n\n}\n\n/**\n * Converts an object of type 'FunctionProps' to JSON representation.\n */\n/* eslint-disable max-len, quote-props */\nexport function toJson_FunctionProps(obj: FunctionProps | undefined): Record<string, any> | undefined {\n  if (obj === undefined) { return undefined; }\n  const result = {\n    'metadata': obj.metadata,\n    'spec': toJson_FunctionSpec(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 * FunctionSpec defines the desired state of Function.\n *\n * @schema FunctionSpec\n */\nexport interface FunctionSpec {\n  /**\n   * The instruction set architecture that the function supports. Enter a string array with one of the valid values. The default value is x86_64.\n   *\n   * @schema FunctionSpec#architectures\n   */\n  readonly architectures?: string[];\n\n  /**\n   * The code for the function.\n   *\n   * @schema FunctionSpec#code\n   */\n  readonly code: FunctionSpecCode;\n\n  /**\n   * To enable code signing for this function, specify the ARN of a code-signing configuration. A code-signing configuration includes a set of signing profiles, which define the trusted publishers for this function.\n   *\n   * @schema FunctionSpec#codeSigningConfigARN\n   */\n  readonly codeSigningConfigArn?: string;\n\n  /**\n   * A dead letter queue configuration that specifies the queue or topic where Lambda sends asynchronous events when they fail processing. For more information, see Dead Letter Queues (https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html#dlq).\n   *\n   * @schema FunctionSpec#deadLetterConfig\n   */\n  readonly deadLetterConfig?: FunctionSpecDeadLetterConfig;\n\n  /**\n   * A description of the function.\n   *\n   * @schema FunctionSpec#description\n   */\n  readonly description?: string;\n\n  /**\n   * Environment variables that are accessible from function code during execution.\n   *\n   * @schema FunctionSpec#environment\n   */\n  readonly environment?: FunctionSpecEnvironment;\n\n  /**\n   * Connection settings for an Amazon EFS file system.\n   *\n   * @schema FunctionSpec#fileSystemConfigs\n   */\n  readonly fileSystemConfigs?: FunctionSpecFileSystemConfigs[];\n\n  /**\n   * The name of the method within your code that Lambda calls to execute your function. The format includes the file name. It can also include namespaces and other qualifiers, depending on the runtime. For more information, see Programming Model (https://docs.aws.amazon.com/lambda/latest/dg/programming-model-v2.html).\n   *\n   * @schema FunctionSpec#handler\n   */\n  readonly handler?: string;\n\n  /**\n   * Container image configuration values (https://docs.aws.amazon.com/lambda/latest/dg/configuration-images.html#configuration-images-settings) that override the values in the container image Dockerfile.\n   *\n   * @schema FunctionSpec#imageConfig\n   */\n  readonly imageConfig?: FunctionSpecImageConfig;\n\n  /**\n   * The ARN of the Amazon Web Services Key Management Service (KMS) key that's used to encrypt your function's environment variables. If it's not provided, Lambda uses a default service key.\n   *\n   * @schema FunctionSpec#kmsKeyARN\n   */\n  readonly kmsKeyArn?: string;\n\n  /**\n   * A list of function layers (https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) to add to the function's execution environment. Specify each layer by its ARN, including the version.\n   *\n   * @schema FunctionSpec#layers\n   */\n  readonly layers?: string[];\n\n  /**\n   * The amount of memory available to the function (https://docs.aws.amazon.com/lambda/latest/dg/configuration-memory.html) at runtime. Increasing the function memory also increases its CPU allocation. The default value is 128 MB. The value can be any multiple of 1 MB.\n   *\n   * @schema FunctionSpec#memorySize\n   */\n  readonly memorySize?: number;\n\n  /**\n   * The name of the Lambda function.\n   * Name formats\n   * * Function name - my-function.\n   * * Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.\n   * * Partial ARN - 123456789012:function:my-function.\n   * The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.\n   *\n   * @schema FunctionSpec#name\n   */\n  readonly name: string;\n\n  /**\n   * The type of deployment package. Set to Image for container image and set Zip for ZIP archive.\n   *\n   * @schema FunctionSpec#packageType\n   */\n  readonly packageType?: string;\n\n  /**\n   * Set to true to publish the first version of the function during creation.\n   *\n   * @schema FunctionSpec#publish\n   */\n  readonly publish?: boolean;\n\n  /**\n   * The number of simultaneous executions to reserve for the function.\n   *\n   * @schema FunctionSpec#reservedConcurrentExecutions\n   */\n  readonly reservedConcurrentExecutions?: number;\n\n  /**\n   * The Amazon Resource Name (ARN) of the function's execution role.\n   *\n   * @schema FunctionSpec#role\n   */\n  readonly role: string;\n\n  /**\n   * The identifier of the function's runtime (https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html).\n   *\n   * @schema FunctionSpec#runtime\n   */\n  readonly runtime?: string;\n\n  /**\n   * A list of tags (https://docs.aws.amazon.com/lambda/latest/dg/tagging.html) to apply to the function.\n   *\n   * @schema FunctionSpec#tags\n   */\n  readonly tags?: { [key: string]: string };\n\n  /**\n   * The amount of time that Lambda allows a function to run before stopping it. The default is 3 seconds. The maximum allowed value is 900 seconds. For additional information, see Lambda execution environment (https://docs.aws.amazon.com/lambda/latest/dg/runtimes-context.html).\n   *\n   * @schema FunctionSpec#timeout\n   */\n  readonly timeout?: number;\n\n  /**\n   * Set Mode to Active to sample and trace a subset of incoming requests with X-Ray (https://docs.aws.amazon.com/lambda/latest/dg/services-xray.html).\n   *\n   * @schema FunctionSpec#tracingConfig\n   */\n  readonly tracingConfig?: FunctionSpecTracingConfig;\n\n  /**\n   * For network connectivity to Amazon Web Services resources in a VPC, specify a list of security groups and subnets in the VPC. When you connect a function to a VPC, it can only access resources and the internet through that VPC. For more information, see VPC Settings (https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html).\n   *\n   * @schema FunctionSpec#vpcConfig\n   */\n  readonly vpcConfig?: FunctionSpecVpcConfig;\n\n}\n\n/**\n * Converts an object of type 'FunctionSpec' to JSON representation.\n */\n/* eslint-disable max-len, quote-props */\nexport function toJson_FunctionSpec(obj: FunctionSpec | undefined): Record<string, any> | undefined {\n  if (obj === undefined) { return undefined; }\n  const result = {\n    'architectures': obj.architectures?.map(y => y),\n    'code': toJson_FunctionSpecCode(obj.code),\n    'codeSigningConfigARN': obj.codeSigningConfigArn,\n    'deadLetterConfig': toJson_FunctionSpecDeadLetterConfig(obj.deadLetterConfig),\n    'description': obj.description,\n    'environment': toJson_FunctionSpecEnvironment(obj.environment),\n    'fileSystemConfigs': obj.fileSystemConfigs?.map(y => toJson_FunctionSpecFileSystemConfigs(y)),\n    'handler': obj.handler,\n    'imageConfig': toJson_FunctionSpecImageConfig(obj.imageConfig),\n    'kmsKeyARN': obj.kmsKeyArn,\n    'layers': obj.layers?.map(y => y),\n    'memorySize': obj.memorySize,\n    'name': obj.name,\n    'packageType': obj.packageType,\n    'publish': obj.publish,\n    'reservedConcurrentExecutions': obj.reservedConcurrentExecutions,\n    'role': obj.role,\n    'runtime': obj.runtime,\n    'tags': ((obj.tags) === undefined) ? undefined : (Object.entries(obj.tags).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {})),\n    'timeout': obj.timeout,\n    'tracingConfig': toJson_FunctionSpecTracingConfig(obj.tracingConfig),\n    'vpcConfig': toJson_FunctionSpecVpcConfig(obj.vpcConfig),\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 code for the function.\n *\n * @schema FunctionSpecCode\n */\nexport interface FunctionSpecCode {\n  /**\n   * @schema FunctionSpecCode#imageURI\n   */\n  readonly imageUri?: string;\n\n  /**\n   * @schema FunctionSpecCode#s3Bucket\n   */\n  readonly s3Bucket?: string;\n\n  /**\n   * @schema FunctionSpecCode#s3Key\n   */\n  readonly s3Key?: string;\n\n  /**\n   * @schema FunctionSpecCode#s3ObjectVersion\n   */\n  readonly s3ObjectVersion?: string;\n\n  /**\n   * @schema FunctionSpecCode#zipFile\n   */\n  readonly zipFile?: string;\n\n}\n\n/**\n * Converts an object of type 'FunctionSpecCode' to JSON representation.\n */\n/* eslint-disable max-len, quote-props */\nexport function toJson_FunctionSpecCode(obj: FunctionSpecCode | undefined): Record<string, any> | undefined {\n  if (obj === undefined) { return undefined; }\n  const result = {\n    'imageURI': obj.imageUri,\n    's3Bucket': obj.s3Bucket,\n    's3Key': obj.s3Key,\n    's3ObjectVersion': obj.s3ObjectVersion,\n    'zipFile': obj.zipFile,\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 dead letter queue configuration that specifies the queue or topic where Lambda sends asynchronous events when they fail processing. For more information, see Dead Letter Queues (https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html#dlq).\n *\n * @schema FunctionSpecDeadLetterConfig\n */\nexport interface FunctionSpecDeadLetterConfig {\n  /**\n   * @schema FunctionSpecDeadLetterConfig#targetARN\n   */\n  readonly targetArn?: string;\n\n}\n\n/**\n * Converts an object of type 'FunctionSpecDeadLetterConfig' to JSON representation.\n */\n/* eslint-disable max-len, quote-props */\nexport function toJson_FunctionSpecDeadLetterConfig(obj: FunctionSpecDeadLetterConfig | undefined): Record<string, any> | undefined {\n  if (obj === undefined) { return undefined; }\n  const result = {\n    'targetARN': obj.targetArn,\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 * Environment variables that are accessible from function code during execution.\n *\n * @schema FunctionSpecEnvironment\n */\nexport interface FunctionSpecEnvironment {\n  /**\n   * @schema FunctionSpecEnvironment#variables\n   */\n  readonly variables?: { [key: string]: string };\n\n}\n\n/**\n * Converts an object of type 'FunctionSpecEnvironment' to JSON representation.\n */\n/* eslint-disable max-len, quote-props */\nexport function toJson_FunctionSpecEnvironment(obj: FunctionSpecEnvironment | undefined): Record<string, any> | undefined {\n  if (obj === undefined) { return undefined; }\n  const result = {\n    'variables': ((obj.variables) === undefined) ? undefined : (Object.entries(obj.variables).reduce((r, i) => (i[1] === undefined) ? r : ({ ...r, [i[0]]: i[1] }), {})),\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 * Details about the connection between a Lambda function and an Amazon EFS file system (https://docs.aws.amazon.com/lambda/latest/dg/configuration-filesystem.html).\n *\n * @schema FunctionSpecFileSystemConfigs\n */\nexport interface FunctionSpecFileSystemConfigs {\n  /**\n   * @schema FunctionSpecFileSystemConfigs#arn\n   */\n  readonly arn?: string;\n\n  /**\n   * @schema FunctionSpecFileSystemConfigs#localMountPath\n   */\n  readonly localMountPath?: string;\n\n}\n\n/**\n * Converts an object of type 'FunctionSpecFileSystemConfigs' to JSON representation.\n */\n/* eslint-disable max-len, quote-props */\nexport function toJson_FunctionSpecFileSystemConfigs(obj: FunctionSpecFileSystemConfigs | undefined): Record<string, any> | undefined {\n  if (obj === undefined) { return undefined; }\n  const result = {\n    'arn': obj.arn,\n    'localMountPath': obj.localMountPath,\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 * Container image configuration values (https://docs.aws.amazon.com/lambda/latest/dg/configuration-images.html#configuration-images-settings) that override the values in the container image Dockerfile.\n *\n * @schema FunctionSpecImageConfig\n */\nexport interface FunctionSpecImageConfig {\n  /**\n   * @schema FunctionSpecImageConfig#command\n   */\n  readonly command?: string[];\n\n  /**\n   * @schema FunctionSpecImageConfig#entryPoint\n   */\n  readonly entryPoint?: string[];\n\n  /**\n   * @schema FunctionSpecImageConfig#workingDirectory\n   */\n  readonly workingDirectory?: string;\n\n}\n\n/**\n * Converts an object of type 'FunctionSpecImageConfig' to JSON representation.\n */\n/* eslint-disable max-len, quote-props */\nexport function toJson_FunctionSpecImageConfig(obj: FunctionSpecImageConfig | undefined): Record<string, any> | undefined {\n  if (obj === undefined) { return undefined; }\n  const result = {\n    'command': obj.command?.map(y => y),\n    'entryPoint': obj.entryPoint?.map(y => y),\n    'workingDirectory': obj.workingDirectory,\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 * Set Mode to Active to sample and trace a subset of incoming requests with X-Ray (https://docs.aws.amazon.com/lambda/latest/dg/services-xray.html).\n *\n * @schema FunctionSpecTracingConfig\n */\nexport interface FunctionSpecTracingConfig {\n  /**\n   * @schema FunctionSpecTracingConfig#mode\n   */\n  readonly mode?: string;\n\n}\n\n/**\n * Converts an object of type 'FunctionSpecTracingConfig' to JSON representation.\n */\n/* eslint-disable max-len, quote-props */\nexport function toJson_FunctionSpecTracingConfig(obj: FunctionSpecTracingConfig | undefined): Record<string, any> | undefined {\n  if (obj === undefined) { return undefined; }\n  const result = {\n    'mode': obj.mode,\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 * For network connectivity to Amazon Web Services resources in a VPC, specify a list of security groups and subnets in the VPC. When you connect a function to a VPC, it can only access resources and the internet through that VPC. For more information, see VPC Settings (https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html).\n *\n * @schema FunctionSpecVpcConfig\n */\nexport interface FunctionSpecVpcConfig {\n  /**\n   * @schema FunctionSpecVpcConfig#securityGroupIDs\n   */\n  readonly securityGroupIDs?: string[];\n\n  /**\n   * @schema FunctionSpecVpcConfig#subnetIDs\n   */\n  readonly subnetIDs?: string[];\n\n}\n\n/**\n * Converts an object of type 'FunctionSpecVpcConfig' to JSON representation.\n */\n/* eslint-disable max-len, quote-props */\nexport function toJson_FunctionSpecVpcConfig(obj: FunctionSpecVpcConfig | undefined): Record<string, any> | undefined {\n  if (obj === undefined) { return undefined; }\n  const result = {\n    'securityGroupIDs': obj.securityGroupIDs?.map(y => y),\n    'subnetIDs': obj.subnetIDs?.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"]}