> **Experimental**
>
> `@aws-cdk/aws-kinesisanalytics-flink-alpha` is an [**experimental**](https://docs.aws.amazon.com/cdk/api/stability.html) (alpha) package: its API may change in any release, without a major version bump.
# ApplicationCodeConfig

The return type of `ApplicationCode.bind`. This represents CloudFormation configuration and an s3 bucket holding the Flink application JAR file.

Returned by: [ApplicationCode.bind](https://docs.aws.amazon.com/cdk/api/v2/docs/@aws-cdk_aws-kinesisanalytics-flink-alpha.ApplicationCode.html#bind)

- Stability: [Experimental](https://docs.aws.amazon.com/cdk/api/stability.html)
- Source: [`lib/application-code.ts`](https://github.com/aws/aws-cdk/blob/v2.278.0/packages/@aws-cdk/aws-kinesisanalytics-flink-alpha/lib/application-code.ts#L11)

## Example

TypeScript:

```ts
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import * as kinesisanalytics_flink_alpha from '@aws-cdk/aws-kinesisanalytics-flink-alpha';
import { aws_s3 as s3 } from 'aws-cdk-lib';

declare const bucket: s3.Bucket;
const applicationCodeConfig: kinesisanalytics_flink_alpha.ApplicationCodeConfig = {
  applicationCodeConfigurationProperty: {
    applicationCodeConfiguration: {
      codeContent: {
        s3ContentLocation: {
          bucketArn: 'bucketArn',
          fileKey: 'fileKey',

          // the properties below are optional
          objectVersion: 'objectVersion',
        },
        textContent: 'textContent',
        zipFileContent: 'zipFileContent',
      },
      codeContentType: 'codeContentType',
    },
    applicationEncryptionConfiguration: {
      keyType: 'keyType',

      // the properties below are optional
      keyId: 'keyId',
    },
    applicationSnapshotConfiguration: {
      snapshotsEnabled: false,

      // the properties below are optional
      snapshotMode: 'snapshotMode',
    },
    applicationSystemRollbackConfiguration: {
      rollbackEnabled: false,
    },
    environmentProperties: {
      propertyGroups: [{
        propertyGroupId: 'propertyGroupId',
        propertyMap: {
          propertyMapKey: 'propertyMap',
        },
      }],
    },
    flinkApplicationConfiguration: {
      checkpointConfiguration: {
        configurationType: 'configurationType',

        // the properties below are optional
        checkpointingEnabled: false,
        checkpointInterval: 123,
        minPauseBetweenCheckpoints: 123,
      },
      monitoringConfiguration: {
        configurationType: 'configurationType',

        // the properties below are optional
        logLevel: 'logLevel',
        metricsLevel: 'metricsLevel',
      },
      parallelismConfiguration: {
        configurationType: 'configurationType',

        // the properties below are optional
        autoScalingEnabled: false,
        parallelism: 123,
        parallelismPerKpu: 123,
      },
    },
    sqlApplicationConfiguration: {
      inputs: [{
        inputSchema: {
          recordColumns: [{
            name: 'name',
            sqlType: 'sqlType',

            // the properties below are optional
            mapping: 'mapping',
          }],
          recordFormat: {
            recordFormatType: 'recordFormatType',

            // the properties below are optional
            mappingParameters: {
              csvMappingParameters: {
                recordColumnDelimiter: 'recordColumnDelimiter',
                recordRowDelimiter: 'recordRowDelimiter',
              },
              jsonMappingParameters: {
                recordRowPath: 'recordRowPath',
              },
            },
          },

          // the properties below are optional
          recordEncoding: 'recordEncoding',
        },
        namePrefix: 'namePrefix',

        // the properties below are optional
        inputParallelism: {
          count: 123,
        },
        inputProcessingConfiguration: {
          inputLambdaProcessor: {
            resourceArn: 'resourceArn',
          },
        },
        kinesisFirehoseInput: {
          resourceArn: 'resourceArn',
        },
        kinesisStreamsInput: {
          resourceArn: 'resourceArn',
        },
      }],
    },
    vpcConfigurations: [{
      securityGroupIds: ['securityGroupIds'],
      subnetIds: ['subnetIds'],
    }],
    zeppelinApplicationConfiguration: {
      catalogConfiguration: {
        glueDataCatalogConfiguration: {
          databaseArn: 'databaseArn',
        },
      },
      customArtifactsConfiguration: [{
        artifactType: 'artifactType',

        // the properties below are optional
        mavenReference: {
          artifactId: 'artifactId',
          groupId: 'groupId',
          version: 'version',
        },
        s3ContentLocation: {
          bucketArn: 'bucketArn',
          fileKey: 'fileKey',

          // the properties below are optional
          objectVersion: 'objectVersion',
        },
      }],
      deployAsApplicationConfiguration: {
        s3ContentLocation: {
          bucketArn: 'bucketArn',

          // the properties below are optional
          basePath: 'basePath',
        },
      },
      monitoringConfiguration: {
        logLevel: 'logLevel',
      },
    },
  },
  bucket: bucket,
};
```

Python:

```python
from aws_cdk.aws_kinesisanalytics.ApplicationConfigurationProperty import ApplicationConfigurationProperty
from aws_cdk.aws_kinesisanalytics.ApplicationCodeConfigurationProperty import ApplicationCodeConfigurationProperty
from aws_cdk.aws_kinesisanalytics.CodeContentProperty import CodeContentProperty
from aws_cdk.aws_kinesisanalytics.S3ContentLocationProperty import S3ContentLocationProperty, S3ContentLocationProperty
from aws_cdk.aws_kinesisanalytics.ApplicationEncryptionConfigurationProperty import ApplicationEncryptionConfigurationProperty
from aws_cdk.aws_kinesisanalytics.ApplicationSnapshotConfigurationProperty import ApplicationSnapshotConfigurationProperty
from aws_cdk.aws_kinesisanalytics.ApplicationSystemRollbackConfigurationProperty import ApplicationSystemRollbackConfigurationProperty
from aws_cdk.aws_kinesisanalytics.EnvironmentPropertiesProperty import EnvironmentPropertiesProperty
from aws_cdk.aws_kinesisanalytics.PropertyGroupProperty import PropertyGroupProperty
from aws_cdk.aws_kinesisanalytics.FlinkApplicationConfigurationProperty import FlinkApplicationConfigurationProperty
from aws_cdk.aws_kinesisanalytics.CheckpointConfigurationProperty import CheckpointConfigurationProperty
from aws_cdk.aws_kinesisanalytics.MonitoringConfigurationProperty import MonitoringConfigurationProperty
from aws_cdk.aws_kinesisanalytics.ParallelismConfigurationProperty import ParallelismConfigurationProperty
from aws_cdk.aws_kinesisanalytics.SqlApplicationConfigurationProperty import SqlApplicationConfigurationProperty
from aws_cdk.aws_kinesisanalytics.InputProperty import InputProperty
from aws_cdk.aws_kinesisanalytics.InputSchemaProperty import InputSchemaProperty
from aws_cdk.aws_kinesisanalytics.RecordColumnProperty import RecordColumnProperty
from aws_cdk.aws_kinesisanalytics.RecordFormatProperty import RecordFormatProperty
from aws_cdk.aws_kinesisanalytics.MappingParametersProperty import MappingParametersProperty
from aws_cdk.aws_kinesisanalytics.CSVMappingParametersProperty import CSVMappingParametersProperty
from aws_cdk.aws_kinesisanalytics.JSONMappingParametersProperty import JSONMappingParametersProperty
from aws_cdk.aws_kinesisanalytics.InputParallelismProperty import InputParallelismProperty
from aws_cdk.aws_kinesisanalytics.InputProcessingConfigurationProperty import InputProcessingConfigurationProperty
from aws_cdk.aws_kinesisanalytics.InputLambdaProcessorProperty import InputLambdaProcessorProperty
from aws_cdk.aws_kinesisanalytics.KinesisFirehoseInputProperty import KinesisFirehoseInputProperty
from aws_cdk.aws_kinesisanalytics.KinesisStreamsInputProperty import KinesisStreamsInputProperty
from aws_cdk.aws_kinesisanalytics.VpcConfigurationProperty import VpcConfigurationProperty
from aws_cdk.aws_kinesisanalytics.ZeppelinApplicationConfigurationProperty import ZeppelinApplicationConfigurationProperty
from aws_cdk.aws_kinesisanalytics.CatalogConfigurationProperty import CatalogConfigurationProperty
from aws_cdk.aws_kinesisanalytics.GlueDataCatalogConfigurationProperty import GlueDataCatalogConfigurationProperty
from aws_cdk.aws_kinesisanalytics.CustomArtifactConfigurationProperty import CustomArtifactConfigurationProperty
from aws_cdk.aws_kinesisanalytics.MavenReferenceProperty import MavenReferenceProperty
from aws_cdk.aws_kinesisanalytics.DeployAsApplicationConfigurationProperty import DeployAsApplicationConfigurationProperty
from aws_cdk.aws_kinesisanalytics.S3ContentBaseLocationProperty import S3ContentBaseLocationProperty
from aws_cdk.aws_kinesisanalytics.ZeppelinMonitoringConfigurationProperty import ZeppelinMonitoringConfigurationProperty
# The code below shows an example of how to instantiate this type.
# The values are placeholders you should change.
import aws_cdk.aws_kinesisanalytics_flink_alpha as kinesisanalytics_flink_alpha
from aws_cdk import aws_s3 as s3

# bucket: s3.Bucket

application_code_config = kinesisanalytics_flink_alpha.ApplicationCodeConfig(
    application_code_configuration_property=ApplicationConfigurationProperty(
        application_code_configuration=ApplicationCodeConfigurationProperty(
            code_content=CodeContentProperty(
                s3_content_location=S3ContentLocationProperty(
                    bucket_arn="bucketArn",
                    file_key="fileKey",

                    # the properties below are optional
                    object_version="objectVersion"
                ),
                text_content="textContent",
                zip_file_content="zipFileContent"
            ),
            code_content_type="codeContentType"
        ),
        application_encryption_configuration=ApplicationEncryptionConfigurationProperty(
            key_type="keyType",

            # the properties below are optional
            key_id="keyId"
        ),
        application_snapshot_configuration=ApplicationSnapshotConfigurationProperty(
            snapshots_enabled=False,

            # the properties below are optional
            snapshot_mode="snapshotMode"
        ),
        application_system_rollback_configuration=ApplicationSystemRollbackConfigurationProperty(
            rollback_enabled=False
        ),
        environment_properties=EnvironmentPropertiesProperty(
            property_groups=[PropertyGroupProperty(
                property_group_id="propertyGroupId",
                property_map={
                    "property_map_key": "propertyMap"
                }
            )]
        ),
        flink_application_configuration=FlinkApplicationConfigurationProperty(
            checkpoint_configuration=CheckpointConfigurationProperty(
                configuration_type="configurationType",

                # the properties below are optional
                checkpointing_enabled=False,
                checkpoint_interval=123,
                min_pause_between_checkpoints=123
            ),
            monitoring_configuration=MonitoringConfigurationProperty(
                configuration_type="configurationType",

                # the properties below are optional
                log_level="logLevel",
                metrics_level="metricsLevel"
            ),
            parallelism_configuration=ParallelismConfigurationProperty(
                configuration_type="configurationType",

                # the properties below are optional
                auto_scaling_enabled=False,
                parallelism=123,
                parallelism_per_kpu=123
            )
        ),
        sql_application_configuration=SqlApplicationConfigurationProperty(
            inputs=[InputProperty(
                input_schema=InputSchemaProperty(
                    record_columns=[RecordColumnProperty(
                        name="name",
                        sql_type="sqlType",

                        # the properties below are optional
                        mapping="mapping"
                    )],
                    record_format=RecordFormatProperty(
                        record_format_type="recordFormatType",

                        # the properties below are optional
                        mapping_parameters=MappingParametersProperty(
                            csv_mapping_parameters=CSVMappingParametersProperty(
                                record_column_delimiter="recordColumnDelimiter",
                                record_row_delimiter="recordRowDelimiter"
                            ),
                            json_mapping_parameters=JSONMappingParametersProperty(
                                record_row_path="recordRowPath"
                            )
                        )
                    ),

                    # the properties below are optional
                    record_encoding="recordEncoding"
                ),
                name_prefix="namePrefix",

                # the properties below are optional
                input_parallelism=InputParallelismProperty(
                    count=123
                ),
                input_processing_configuration=InputProcessingConfigurationProperty(
                    input_lambda_processor=InputLambdaProcessorProperty(
                        resource_arn="resourceArn"
                    )
                ),
                kinesis_firehose_input=KinesisFirehoseInputProperty(
                    resource_arn="resourceArn"
                ),
                kinesis_streams_input=KinesisStreamsInputProperty(
                    resource_arn="resourceArn"
                )
            )]
        ),
        vpc_configurations=[VpcConfigurationProperty(
            security_group_ids=["securityGroupIds"],
            subnet_ids=["subnetIds"]
        )],
        zeppelin_application_configuration=ZeppelinApplicationConfigurationProperty(
            catalog_configuration=CatalogConfigurationProperty(
                glue_data_catalog_configuration=GlueDataCatalogConfigurationProperty(
                    database_arn="databaseArn"
                )
            ),
            custom_artifacts_configuration=[CustomArtifactConfigurationProperty(
                artifact_type="artifactType",

                # the properties below are optional
                maven_reference=MavenReferenceProperty(
                    artifact_id="artifactId",
                    group_id="groupId",
                    version="version"
                ),
                s3_content_location=S3ContentLocationProperty(
                    bucket_arn="bucketArn",
                    file_key="fileKey",

                    # the properties below are optional
                    object_version="objectVersion"
                )
            )],
            deploy_as_application_configuration=DeployAsApplicationConfigurationProperty(
                s3_content_location=S3ContentBaseLocationProperty(
                    bucket_arn="bucketArn",

                    # the properties below are optional
                    base_path="basePath"
                )
            ),
            monitoring_configuration=ZeppelinMonitoringConfigurationProperty(
                log_level="logLevel"
            )
        )
    ),
    bucket=bucket
)
```

Java:

```java
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import software.amazon.awscdk.services.kinesisanalytics.flink.alpha.*;
import software.amazon.awscdk.services.s3.*;

Bucket bucket;

ApplicationCodeConfig applicationCodeConfig = ApplicationCodeConfig.builder()
        .applicationCodeConfigurationProperty(ApplicationConfigurationProperty.builder()
                .applicationCodeConfiguration(ApplicationCodeConfigurationProperty.builder()
                        .codeContent(CodeContentProperty.builder()
                                .s3ContentLocation(S3ContentLocationProperty.builder()
                                        .bucketArn("bucketArn")
                                        .fileKey("fileKey")

                                        // the properties below are optional
                                        .objectVersion("objectVersion")
                                        .build())
                                .textContent("textContent")
                                .zipFileContent("zipFileContent")
                                .build())
                        .codeContentType("codeContentType")
                        .build())
                .applicationEncryptionConfiguration(ApplicationEncryptionConfigurationProperty.builder()
                        .keyType("keyType")

                        // the properties below are optional
                        .keyId("keyId")
                        .build())
                .applicationSnapshotConfiguration(ApplicationSnapshotConfigurationProperty.builder()
                        .snapshotsEnabled(false)

                        // the properties below are optional
                        .snapshotMode("snapshotMode")
                        .build())
                .applicationSystemRollbackConfiguration(ApplicationSystemRollbackConfigurationProperty.builder()
                        .rollbackEnabled(false)
                        .build())
                .environmentProperties(EnvironmentPropertiesProperty.builder()
                        .propertyGroups(List.of(PropertyGroupProperty.builder()
                                .propertyGroupId("propertyGroupId")
                                .propertyMap(Map.of(
                                        "propertyMapKey", "propertyMap"))
                                .build()))
                        .build())
                .flinkApplicationConfiguration(FlinkApplicationConfigurationProperty.builder()
                        .checkpointConfiguration(CheckpointConfigurationProperty.builder()
                                .configurationType("configurationType")

                                // the properties below are optional
                                .checkpointingEnabled(false)
                                .checkpointInterval(123)
                                .minPauseBetweenCheckpoints(123)
                                .build())
                        .monitoringConfiguration(MonitoringConfigurationProperty.builder()
                                .configurationType("configurationType")

                                // the properties below are optional
                                .logLevel("logLevel")
                                .metricsLevel("metricsLevel")
                                .build())
                        .parallelismConfiguration(ParallelismConfigurationProperty.builder()
                                .configurationType("configurationType")

                                // the properties below are optional
                                .autoScalingEnabled(false)
                                .parallelism(123)
                                .parallelismPerKpu(123)
                                .build())
                        .build())
                .sqlApplicationConfiguration(SqlApplicationConfigurationProperty.builder()
                        .inputs(List.of(InputProperty.builder()
                                .inputSchema(InputSchemaProperty.builder()
                                        .recordColumns(List.of(RecordColumnProperty.builder()
                                                .name("name")
                                                .sqlType("sqlType")

                                                // the properties below are optional
                                                .mapping("mapping")
                                                .build()))
                                        .recordFormat(RecordFormatProperty.builder()
                                                .recordFormatType("recordFormatType")

                                                // the properties below are optional
                                                .mappingParameters(MappingParametersProperty.builder()
                                                        .csvMappingParameters(CSVMappingParametersProperty.builder()
                                                                .recordColumnDelimiter("recordColumnDelimiter")
                                                                .recordRowDelimiter("recordRowDelimiter")
                                                                .build())
                                                        .jsonMappingParameters(JSONMappingParametersProperty.builder()
                                                                .recordRowPath("recordRowPath")
                                                                .build())
                                                        .build())
                                                .build())

                                        // the properties below are optional
                                        .recordEncoding("recordEncoding")
                                        .build())
                                .namePrefix("namePrefix")

                                // the properties below are optional
                                .inputParallelism(InputParallelismProperty.builder()
                                        .count(123)
                                        .build())
                                .inputProcessingConfiguration(InputProcessingConfigurationProperty.builder()
                                        .inputLambdaProcessor(InputLambdaProcessorProperty.builder()
                                                .resourceArn("resourceArn")
                                                .build())
                                        .build())
                                .kinesisFirehoseInput(KinesisFirehoseInputProperty.builder()
                                        .resourceArn("resourceArn")
                                        .build())
                                .kinesisStreamsInput(KinesisStreamsInputProperty.builder()
                                        .resourceArn("resourceArn")
                                        .build())
                                .build()))
                        .build())
                .vpcConfigurations(List.of(VpcConfigurationProperty.builder()
                        .securityGroupIds(List.of("securityGroupIds"))
                        .subnetIds(List.of("subnetIds"))
                        .build()))
                .zeppelinApplicationConfiguration(ZeppelinApplicationConfigurationProperty.builder()
                        .catalogConfiguration(CatalogConfigurationProperty.builder()
                                .glueDataCatalogConfiguration(GlueDataCatalogConfigurationProperty.builder()
                                        .databaseArn("databaseArn")
                                        .build())
                                .build())
                        .customArtifactsConfiguration(List.of(CustomArtifactConfigurationProperty.builder()
                                .artifactType("artifactType")

                                // the properties below are optional
                                .mavenReference(MavenReferenceProperty.builder()
                                        .artifactId("artifactId")
                                        .groupId("groupId")
                                        .version("version")
                                        .build())
                                .s3ContentLocation(S3ContentLocationProperty.builder()
                                        .bucketArn("bucketArn")
                                        .fileKey("fileKey")

                                        // the properties below are optional
                                        .objectVersion("objectVersion")
                                        .build())
                                .build()))
                        .deployAsApplicationConfiguration(DeployAsApplicationConfigurationProperty.builder()
                                .s3ContentLocation(S3ContentBaseLocationProperty.builder()
                                        .bucketArn("bucketArn")

                                        // the properties below are optional
                                        .basePath("basePath")
                                        .build())
                                .build())
                        .monitoringConfiguration(ZeppelinMonitoringConfigurationProperty.builder()
                                .logLevel("logLevel")
                                .build())
                        .build())
                .build())
        .bucket(bucket)
        .build();
```

C# / .NET:

```csharp
// Install: dotnet add package Amazon.CDK.AWS.KinesisAnalyticsFlink.Alpha
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
using Amazon.CDK.AWS.Kinesisanalytics.Flink.Alpha;
using Amazon.CDK.AWS.S3;

Bucket bucket;

var applicationCodeConfig = new ApplicationCodeConfig {
    ApplicationCodeConfigurationProperty = new ApplicationConfigurationProperty {
        ApplicationCodeConfiguration = new ApplicationCodeConfigurationProperty {
            CodeContent = new CodeContentProperty {
                S3ContentLocation = new S3ContentLocationProperty {
                    BucketArn = "bucketArn",
                    FileKey = "fileKey",

                    // the properties below are optional
                    ObjectVersion = "objectVersion"
                },
                TextContent = "textContent",
                ZipFileContent = "zipFileContent"
            },
            CodeContentType = "codeContentType"
        },
        ApplicationEncryptionConfiguration = new ApplicationEncryptionConfigurationProperty {
            KeyType = "keyType",

            // the properties below are optional
            KeyId = "keyId"
        },
        ApplicationSnapshotConfiguration = new ApplicationSnapshotConfigurationProperty {
            SnapshotsEnabled = false,

            // the properties below are optional
            SnapshotMode = "snapshotMode"
        },
        ApplicationSystemRollbackConfiguration = new ApplicationSystemRollbackConfigurationProperty {
            RollbackEnabled = false
        },
        EnvironmentProperties = new EnvironmentPropertiesProperty {
            PropertyGroups = new [] { new PropertyGroupProperty {
                PropertyGroupId = "propertyGroupId",
                PropertyMap = new Dictionary<string, string> {
                    { "propertyMapKey", "propertyMap" }
                }
            } }
        },
        FlinkApplicationConfiguration = new FlinkApplicationConfigurationProperty {
            CheckpointConfiguration = new CheckpointConfigurationProperty {
                ConfigurationType = "configurationType",

                // the properties below are optional
                CheckpointingEnabled = false,
                CheckpointInterval = 123,
                MinPauseBetweenCheckpoints = 123
            },
            MonitoringConfiguration = new MonitoringConfigurationProperty {
                ConfigurationType = "configurationType",

                // the properties below are optional
                LogLevel = "logLevel",
                MetricsLevel = "metricsLevel"
            },
            ParallelismConfiguration = new ParallelismConfigurationProperty {
                ConfigurationType = "configurationType",

                // the properties below are optional
                AutoScalingEnabled = false,
                Parallelism = 123,
                ParallelismPerKpu = 123
            }
        },
        SqlApplicationConfiguration = new SqlApplicationConfigurationProperty {
            Inputs = new [] { new InputProperty {
                InputSchema = new InputSchemaProperty {
                    RecordColumns = new [] { new RecordColumnProperty {
                        Name = "name",
                        SqlType = "sqlType",

                        // the properties below are optional
                        Mapping = "mapping"
                    } },
                    RecordFormat = new RecordFormatProperty {
                        RecordFormatType = "recordFormatType",

                        // the properties below are optional
                        MappingParameters = new MappingParametersProperty {
                            CsvMappingParameters = new CSVMappingParametersProperty {
                                RecordColumnDelimiter = "recordColumnDelimiter",
                                RecordRowDelimiter = "recordRowDelimiter"
                            },
                            JsonMappingParameters = new JSONMappingParametersProperty {
                                RecordRowPath = "recordRowPath"
                            }
                        }
                    },

                    // the properties below are optional
                    RecordEncoding = "recordEncoding"
                },
                NamePrefix = "namePrefix",

                // the properties below are optional
                InputParallelism = new InputParallelismProperty {
                    Count = 123
                },
                InputProcessingConfiguration = new InputProcessingConfigurationProperty {
                    InputLambdaProcessor = new InputLambdaProcessorProperty {
                        ResourceArn = "resourceArn"
                    }
                },
                KinesisFirehoseInput = new KinesisFirehoseInputProperty {
                    ResourceArn = "resourceArn"
                },
                KinesisStreamsInput = new KinesisStreamsInputProperty {
                    ResourceArn = "resourceArn"
                }
            } }
        },
        VpcConfigurations = new [] { new VpcConfigurationProperty {
            SecurityGroupIds = new [] { "securityGroupIds" },
            SubnetIds = new [] { "subnetIds" }
        } },
        ZeppelinApplicationConfiguration = new ZeppelinApplicationConfigurationProperty {
            CatalogConfiguration = new CatalogConfigurationProperty {
                GlueDataCatalogConfiguration = new GlueDataCatalogConfigurationProperty {
                    DatabaseArn = "databaseArn"
                }
            },
            CustomArtifactsConfiguration = new [] { new CustomArtifactConfigurationProperty {
                ArtifactType = "artifactType",

                // the properties below are optional
                MavenReference = new MavenReferenceProperty {
                    ArtifactId = "artifactId",
                    GroupId = "groupId",
                    Version = "version"
                },
                S3ContentLocation = new S3ContentLocationProperty {
                    BucketArn = "bucketArn",
                    FileKey = "fileKey",

                    // the properties below are optional
                    ObjectVersion = "objectVersion"
                }
            } },
            DeployAsApplicationConfiguration = new DeployAsApplicationConfigurationProperty {
                S3ContentLocation = new S3ContentBaseLocationProperty {
                    BucketArn = "bucketArn",

                    // the properties below are optional
                    BasePath = "basePath"
                }
            },
            MonitoringConfiguration = new ZeppelinMonitoringConfigurationProperty {
                LogLevel = "logLevel"
            }
        }
    },
    Bucket = bucket
};
```

Golang:

```go
// Install: go get github.com/aws/aws-cdk-go/awscdkkinesisanalyticsflinkalpha/v2
// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import kinesisanalytics_flink_alpha "github.com/aws/aws-cdk-go/awscdkkinesisanalyticsflinkalpha"
import "github.com/aws/aws-cdk-go/awscdk"

var bucket Bucket

applicationCodeConfig := &ApplicationCodeConfig{
	ApplicationCodeConfigurationProperty: &ApplicationConfigurationProperty{
		ApplicationCodeConfiguration: &ApplicationCodeConfigurationProperty{
			CodeContent: &CodeContentProperty{
				S3ContentLocation: &S3ContentLocationProperty{
					BucketArn: jsii.String("bucketArn"),
					FileKey: jsii.String("fileKey"),

					// the properties below are optional
					ObjectVersion: jsii.String("objectVersion"),
				},
				TextContent: jsii.String("textContent"),
				ZipFileContent: jsii.String("zipFileContent"),
			},
			CodeContentType: jsii.String("codeContentType"),
		},
		ApplicationEncryptionConfiguration: &ApplicationEncryptionConfigurationProperty{
			KeyType: jsii.String("keyType"),

			// the properties below are optional
			KeyId: jsii.String("keyId"),
		},
		ApplicationSnapshotConfiguration: &ApplicationSnapshotConfigurationProperty{
			SnapshotsEnabled: jsii.Boolean(false),

			// the properties below are optional
			SnapshotMode: jsii.String("snapshotMode"),
		},
		ApplicationSystemRollbackConfiguration: &ApplicationSystemRollbackConfigurationProperty{
			RollbackEnabled: jsii.Boolean(false),
		},
		EnvironmentProperties: &EnvironmentPropertiesProperty{
			PropertyGroups: []interface{}{
				&PropertyGroupProperty{
					PropertyGroupId: jsii.String("propertyGroupId"),
					PropertyMap: map[string]*string{
						"propertyMapKey": jsii.String("propertyMap"),
					},
				},
			},
		},
		FlinkApplicationConfiguration: &FlinkApplicationConfigurationProperty{
			CheckpointConfiguration: &CheckpointConfigurationProperty{
				ConfigurationType: jsii.String("configurationType"),

				// the properties below are optional
				CheckpointingEnabled: jsii.Boolean(false),
				CheckpointInterval: jsii.Number(123),
				MinPauseBetweenCheckpoints: jsii.Number(123),
			},
			MonitoringConfiguration: &MonitoringConfigurationProperty{
				ConfigurationType: jsii.String("configurationType"),

				// the properties below are optional
				LogLevel: jsii.String("logLevel"),
				MetricsLevel: jsii.String("metricsLevel"),
			},
			ParallelismConfiguration: &ParallelismConfigurationProperty{
				ConfigurationType: jsii.String("configurationType"),

				// the properties below are optional
				AutoScalingEnabled: jsii.Boolean(false),
				Parallelism: jsii.Number(123),
				ParallelismPerKpu: jsii.Number(123),
			},
		},
		SqlApplicationConfiguration: &SqlApplicationConfigurationProperty{
			Inputs: []interface{}{
				&InputProperty{
					InputSchema: &InputSchemaProperty{
						RecordColumns: []interface{}{
							&RecordColumnProperty{
								Name: jsii.String("name"),
								SqlType: jsii.String("sqlType"),

								// the properties below are optional
								Mapping: jsii.String("mapping"),
							},
						},
						RecordFormat: &RecordFormatProperty{
							RecordFormatType: jsii.String("recordFormatType"),

							// the properties below are optional
							MappingParameters: &MappingParametersProperty{
								CsvMappingParameters: &CSVMappingParametersProperty{
									RecordColumnDelimiter: jsii.String("recordColumnDelimiter"),
									RecordRowDelimiter: jsii.String("recordRowDelimiter"),
								},
								JsonMappingParameters: &JSONMappingParametersProperty{
									RecordRowPath: jsii.String("recordRowPath"),
								},
							},
						},

						// the properties below are optional
						RecordEncoding: jsii.String("recordEncoding"),
					},
					NamePrefix: jsii.String("namePrefix"),

					// the properties below are optional
					InputParallelism: &InputParallelismProperty{
						Count: jsii.Number(123),
					},
					InputProcessingConfiguration: &InputProcessingConfigurationProperty{
						InputLambdaProcessor: &InputLambdaProcessorProperty{
							ResourceArn: jsii.String("resourceArn"),
						},
					},
					KinesisFirehoseInput: &KinesisFirehoseInputProperty{
						ResourceArn: jsii.String("resourceArn"),
					},
					KinesisStreamsInput: &KinesisStreamsInputProperty{
						ResourceArn: jsii.String("resourceArn"),
					},
				},
			},
		},
		VpcConfigurations: []interface{}{
			&VpcConfigurationProperty{
				SecurityGroupIds: []*string{
					jsii.String("securityGroupIds"),
				},
				SubnetIds: []*string{
					jsii.String("subnetIds"),
				},
			},
		},
		ZeppelinApplicationConfiguration: &ZeppelinApplicationConfigurationProperty{
			CatalogConfiguration: &CatalogConfigurationProperty{
				GlueDataCatalogConfiguration: &GlueDataCatalogConfigurationProperty{
					DatabaseArn: jsii.String("databaseArn"),
				},
			},
			CustomArtifactsConfiguration: []interface{}{
				&CustomArtifactConfigurationProperty{
					ArtifactType: jsii.String("artifactType"),

					// the properties below are optional
					MavenReference: &MavenReferenceProperty{
						ArtifactId: jsii.String("artifactId"),
						GroupId: jsii.String("groupId"),
						Version: jsii.String("version"),
					},
					S3ContentLocation: &S3ContentLocationProperty{
						BucketArn: jsii.String("bucketArn"),
						FileKey: jsii.String("fileKey"),

						// the properties below are optional
						ObjectVersion: jsii.String("objectVersion"),
					},
				},
			},
			DeployAsApplicationConfiguration: &DeployAsApplicationConfigurationProperty{
				S3ContentLocation: &S3ContentBaseLocationProperty{
					BucketArn: jsii.String("bucketArn"),

					// the properties below are optional
					BasePath: jsii.String("basePath"),
				},
			},
			MonitoringConfiguration: &ZeppelinMonitoringConfigurationProperty{
				LogLevel: jsii.String("logLevel"),
			},
		},
	},
	Bucket: bucket,
}
```

## Properties

- `applicationCodeConfigurationProperty`: [CfnApplicationV2.ApplicationConfigurationProperty](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_kinesisanalytics.CfnApplicationV2.ApplicationConfigurationProperty.html) (required) — Low-level Cloudformation ApplicationConfigurationProperty.

- `bucket`: [IBucket](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.IBucket.html) (required) — S3 Bucket that stores the Flink application code.
