ddcdkconstruct

type APMFeatureConfig struct {
	// Enables APM.
	IsEnabled *bool `field:"optional" json:"isEnabled" yaml:"isEnabled"`
	// Enables Profile collection.
	//
	// Requires Datadog APM SSI instrumentation on your application containers.
	IsProfilingEnabled *bool `field:"optional" json:"isProfilingEnabled" yaml:"isProfilingEnabled"`
	// Enables APM traces traffic over Unix Domain Socket.
	//
	// Falls back to TCP configuration for application containers when disabled.
	IsSocketEnabled *bool `field:"optional" json:"isSocketEnabled" yaml:"isSocketEnabled"`
	// Enables inferred spans for proxy services like AWS API Gateway.
	//
	// When enabled, the tracer will create spans for proxy services by using headers
	// passed from the proxy service to the application.
	TraceInferredProxyServices *bool `field:"optional" json:"traceInferredProxyServices" yaml:"traceInferredProxyServices"`
}

type CWSFeatureConfig struct {
	// Enables CWS.
	IsEnabled *bool `field:"optional" json:"isEnabled" yaml:"isEnabled"`
}

type Cardinality string

type DatadogECSBaseProps struct {
	// The Datadog API key string.
	//
	// Must define at least 1 source for the API key.
	ApiKey *string `field:"optional" json:"apiKey" yaml:"apiKey"`
	// The Datadog API key secret.
	//
	// Must define at least 1 source for the API key.
	ApiKeySecret awssecretsmanager.ISecret `field:"optional" json:"apiKeySecret" yaml:"apiKeySecret"`
	// The ARN of the Datadog API key secret.
	//
	// Must define at least 1 source for the API key.
	ApiKeySecretArn *string `field:"optional" json:"apiKeySecretArn" yaml:"apiKeySecretArn"`
	// APM feature configuration.
	Apm *APMFeatureConfig `field:"optional" json:"apm" yaml:"apm"`
	// The Datadog Agent checks tag cardinality.
	ChecksCardinality Cardinality `field:"optional" json:"checksCardinality" yaml:"checksCardinality"`
	// The cluster name to use for tagging.
	ClusterName *string `field:"optional" json:"clusterName" yaml:"clusterName"`
	// The minimum number of CPU units to reserve for the Datadog Agent container.
	Cpu *float64 `field:"optional" json:"cpu" yaml:"cpu"`
	// Configure health check for the Datadog Agent container.
	DatadogHealthCheck *awsecs.HealthCheck `field:"optional" json:"datadogHealthCheck" yaml:"datadogHealthCheck"`
	// DogStatsD feature configuration.
	Dogstatsd *DogstatsdFeatureConfig `field:"optional" json:"dogstatsd" yaml:"dogstatsd"`
	// The task environment name.
	//
	// Used for tagging (UST).
	Env *string `field:"optional" json:"env" yaml:"env"`
	// Datadog Agent environment variables.
	EnvironmentVariables *map[string]*string `field:"optional" json:"environmentVariables" yaml:"environmentVariables"`
	// Global tags to apply to all data sent by the Agent.
	//
	// Overrides any DD_TAGS values in environmentVariables.
	GlobalTags *string `field:"optional" json:"globalTags" yaml:"globalTags"`
	// The version of the Datadog Agent container image to use.
	ImageVersion *string `field:"optional" json:"imageVersion" yaml:"imageVersion"`
	// Configure added containers to have container dependency on the Datadog Agent container.
	IsDatadogDependencyEnabled *bool `field:"optional" json:"isDatadogDependencyEnabled" yaml:"isDatadogDependencyEnabled"`
	// Configure Datadog Agent container to be essential for the task.
	IsDatadogEssential *bool `field:"optional" json:"isDatadogEssential" yaml:"isDatadogEssential"`
	// The amount (in MiB) of memory to present to the Datadog Agent container.
	MemoryLimitMiB *float64 `field:"optional" json:"memoryLimitMiB" yaml:"memoryLimitMiB"`
	// The registry to pull the Datadog Agent container image from.
	Registry *string `field:"optional" json:"registry" yaml:"registry"`
	// The task service name.
	//
	// Used for tagging (UST).
	Service *string `field:"optional" json:"service" yaml:"service"`
	// The Datadog site to send data to.
	Site *string `field:"optional" json:"site" yaml:"site"`
	// The task version.
	//
	// Used for tagging (UST).
	Version *string `field:"optional" json:"version" yaml:"version"`
}

type DatadogECSFargate interface {
	// Creates a new Fargate Task Definition instrumented with Datadog.
	//
	// Merges the provided task's datadogProps with the class's datadogProps.
	FargateTaskDefinition(scope constructs.Construct, id *string, props *awsecs.FargateTaskDefinitionProps, datadogProps *DatadogECSFargateProps) DatadogECSFargateTaskDefinition
}

type DatadogECSFargateProps struct {
	// The Datadog API key string.
	//
	// Must define at least 1 source for the API key.
	ApiKey *string `field:"optional" json:"apiKey" yaml:"apiKey"`
	// The Datadog API key secret.
	//
	// Must define at least 1 source for the API key.
	ApiKeySecret awssecretsmanager.ISecret `field:"optional" json:"apiKeySecret" yaml:"apiKeySecret"`
	// The ARN of the Datadog API key secret.
	//
	// Must define at least 1 source for the API key.
	ApiKeySecretArn *string `field:"optional" json:"apiKeySecretArn" yaml:"apiKeySecretArn"`
	// APM feature configuration.
	Apm *APMFeatureConfig `field:"optional" json:"apm" yaml:"apm"`
	// The Datadog Agent checks tag cardinality.
	ChecksCardinality Cardinality `field:"optional" json:"checksCardinality" yaml:"checksCardinality"`
	// The cluster name to use for tagging.
	ClusterName *string `field:"optional" json:"clusterName" yaml:"clusterName"`
	// The minimum number of CPU units to reserve for the Datadog Agent container.
	Cpu *float64 `field:"optional" json:"cpu" yaml:"cpu"`
	// Configure health check for the Datadog Agent container.
	DatadogHealthCheck *awsecs.HealthCheck `field:"optional" json:"datadogHealthCheck" yaml:"datadogHealthCheck"`
	// DogStatsD feature configuration.
	Dogstatsd *DogstatsdFeatureConfig `field:"optional" json:"dogstatsd" yaml:"dogstatsd"`
	// The task environment name.
	//
	// Used for tagging (UST).
	Env *string `field:"optional" json:"env" yaml:"env"`
	// Datadog Agent environment variables.
	EnvironmentVariables *map[string]*string `field:"optional" json:"environmentVariables" yaml:"environmentVariables"`
	// Global tags to apply to all data sent by the Agent.
	//
	// Overrides any DD_TAGS values in environmentVariables.
	GlobalTags *string `field:"optional" json:"globalTags" yaml:"globalTags"`
	// The version of the Datadog Agent container image to use.
	ImageVersion *string `field:"optional" json:"imageVersion" yaml:"imageVersion"`
	// Configure added containers to have container dependency on the Datadog Agent container.
	IsDatadogDependencyEnabled *bool `field:"optional" json:"isDatadogDependencyEnabled" yaml:"isDatadogDependencyEnabled"`
	// Configure Datadog Agent container to be essential for the task.
	IsDatadogEssential *bool `field:"optional" json:"isDatadogEssential" yaml:"isDatadogEssential"`
	// The amount (in MiB) of memory to present to the Datadog Agent container.
	MemoryLimitMiB *float64 `field:"optional" json:"memoryLimitMiB" yaml:"memoryLimitMiB"`
	// The registry to pull the Datadog Agent container image from.
	Registry *string `field:"optional" json:"registry" yaml:"registry"`
	// The task service name.
	//
	// Used for tagging (UST).
	Service *string `field:"optional" json:"service" yaml:"service"`
	// The Datadog site to send data to.
	Site *string `field:"optional" json:"site" yaml:"site"`
	// The task version.
	//
	// Used for tagging (UST).
	Version       *string                            `field:"optional" json:"version" yaml:"version"`
	Cws           *FargateCWSFeatureConfig           `field:"optional" json:"cws" yaml:"cws"`
	LogCollection *FargateLogCollectionFeatureConfig `field:"optional" json:"logCollection" yaml:"logCollection"`
}

type DatadogECSFargateTaskDefinition interface {
	awsecs.FargateTaskDefinition
	// The task launch type compatibility requirement.
	Compatibility() awsecs.Compatibility
	// The container definitions.
	Containers() *[]awsecs.ContainerDefinition
	CwsContainer() awsecs.ContainerDefinition
	DatadogContainer() awsecs.ContainerDefinition
	// Default container for this task.
	//
	// Load balancers will send traffic to this container. The first
	// essential container that is added to this task will become the default
	// container.
	DefaultContainer() awsecs.ContainerDefinition
	SetDefaultContainer(val awsecs.ContainerDefinition)
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	Env() *awscdk.ResourceEnvironment
	// The amount (in GiB) of ephemeral storage to be allocated to the task.
	EphemeralStorageGiB() *float64
	// Execution role for this task definition.
	ExecutionRole() awsiam.IRole
	// The name of a family that this task definition is registered to.
	//
	// A family groups multiple versions of a task definition.
	Family() *string
	// Public getter method to access list of inference accelerators attached to the instance.
	InferenceAccelerators() *[]*awsecs.InferenceAccelerator
	// Return true if the task definition can be run on an EC2 cluster.
	IsEc2Compatible() *bool
	// Return true if the task definition can be run on a ECS anywhere cluster.
	IsExternalCompatible() *bool
	// Return true if the task definition can be run on a Fargate cluster.
	IsFargateCompatible() *bool
	LogContainer() awsecs.ContainerDefinition
	// The Docker networking mode to use for the containers in the task.
	//
	// Fargate tasks require the awsvpc network mode.
	NetworkMode() awsecs.NetworkMode
	// The tree node.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	PhysicalName() *string
	// The process namespace to use for the containers in the task.
	//
	// Only supported for tasks that are hosted on AWS Fargate if the tasks
	// are using platform version 1.4.0 or later (Linux). Not supported in
	// Windows containers. If pidMode is specified for a Fargate task,
	// then runtimePlatform.operatingSystemFamily must also be specified.  For more
	// information, see [Task Definition Parameters](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#task_definition_pidmode).
	PidMode() awsecs.PidMode
	// Whether this task definition has at least a container that references a specific JSON field of a secret stored in Secrets Manager.
	ReferencesSecretJsonField() *bool
	// The stack in which this resource is defined.
	Stack() awscdk.Stack
	// The full Amazon Resource Name (ARN) of the task definition.
	TaskDefinitionArn() *string
	// The name of the IAM role that grants containers in the task permission to call AWS APIs on your behalf.
	TaskRole() awsiam.IRole
	// Adds a new container to the task definition.
	//
	// Modifies properties of container to support specified agent configuration in task.
	AddContainer(id *string, containerProps *awsecs.ContainerDefinitionOptions) awsecs.ContainerDefinition
	// Adds the specified extension to the task definition.
	//
	// Extension can be used to apply a packaged modification to
	// a task definition.
	AddExtension(extension awsecs.ITaskDefinitionExtension)
	// Adds a firelens log router to the task definition.
	AddFirelensLogRouter(id *string, props *awsecs.FirelensLogRouterDefinitionOptions) awsecs.FirelensLogRouter
	// Adds an inference accelerator to the task definition.
	AddInferenceAccelerator(inferenceAccelerator *awsecs.InferenceAccelerator)
	// Adds the specified placement constraint to the task definition.
	AddPlacementConstraint(constraint awsecs.PlacementConstraint)
	// Adds a policy statement to the task execution IAM role.
	AddToExecutionRolePolicy(statement awsiam.PolicyStatement)
	// Adds a policy statement to the task IAM role.
	AddToTaskRolePolicy(statement awsiam.PolicyStatement)
	// Adds a volume to the task definition.
	AddVolume(volume *awsecs.Volume)
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Returns the container that match the provided containerName.
	FindContainer(containerName *string) awsecs.ContainerDefinition
	// Determine the existing port mapping for the provided name.
	//
	// Returns: PortMapping for the provided name, if it exists.
	FindPortMappingByName(name *string) *awsecs.PortMapping
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	GetResourceNameAttribute(nameAttr *string) *string
	// Grants permissions to run this task definition.
	//
	// This will grant the following permissions:
	//
	//   - ecs:RunTask
	// - iam:PassRole.
	GrantRun(grantee awsiam.IGrantable) awsiam.Grant
	// Creates the task execution IAM role if it doesn't already exist.
	ObtainExecutionRole() awsiam.IRole
	// Returns a string representation of this construct.
	ToString() *string
}

type DatadogECSLogDriverProps struct {
	Compress     *string `field:"optional" json:"compress" yaml:"compress"`
	HostEndpoint *string `field:"optional" json:"hostEndpoint" yaml:"hostEndpoint"`
	MessageKey   *string `field:"optional" json:"messageKey" yaml:"messageKey"`
	ServiceName  *string `field:"optional" json:"serviceName" yaml:"serviceName"`
	SourceName   *string `field:"optional" json:"sourceName" yaml:"sourceName"`
	Tls          *string `field:"optional" json:"tls" yaml:"tls"`
}

type DatadogFirelensOptions struct {
	// Custom configuration file, s3 or file.
	//
	// Both configFileType and configFileValue must be used together
	// to define a custom configuration source.
	// Default: - determined by checking configFileValue with S3 ARN.
	//
	ConfigFileType awsecs.FirelensConfigFileType `field:"optional" json:"configFileType" yaml:"configFileType"`
	// Custom configuration file, S3 ARN or a file path Both configFileType and configFileValue must be used together to define a custom configuration source.
	// Default: - no config file value.
	//
	ConfigFileValue *string `field:"optional" json:"configFileValue" yaml:"configFileValue"`
	// By default, Amazon ECS adds additional fields in your log entries that help identify the source of the logs.
	//
	// You can disable this action by setting enable-ecs-log-metadata to false.
	// Default: - true.
	//
	EnableECSLogMetadata *bool `field:"optional" json:"enableECSLogMetadata" yaml:"enableECSLogMetadata"`
	// Overrides the config file type and value to support JSON parsing.
	IsParseJson *bool `field:"optional" json:"isParseJson" yaml:"isParseJson"`
}

type DatadogLambda interface {
	constructs.Construct
	ContextGitShaOverrideKey() *string
	SetContextGitShaOverrideKey(val *string)
	GitCommitShaOverride() *string
	SetGitCommitShaOverride(val *string)
	GitRepoUrlOverride() *string
	SetGitRepoUrlOverride(val *string)
	Lambdas() *[]interface{}
	SetLambdas(val *[]interface{})
	// The tree node.
	Node() constructs.Node
	Props() *DatadogLambdaProps
	SetProps(val *DatadogLambdaProps)
	Scope() constructs.Construct
	SetScope(val constructs.Construct)
	Transport() Transport
	SetTransport(val Transport)
	AddForwarderToNonLambdaLogGroups(logGroups *[]awslogs.ILogGroup)
	AddGitCommitMetadata(lambdaFunctions *[]interface{}, gitCommitSha *string, gitRepoUrl *string)
	AddLambdaFunctions(lambdaFunctions *[]interface{}, construct constructs.Construct)
	OverrideGitMetadata(gitCommitSha *string, gitRepoUrl *string)
	// Returns a string representation of this construct.
	ToString() *string
}

type DatadogLambdaProps struct {
	AddLayers                  *bool                     `field:"optional" json:"addLayers" yaml:"addLayers"`
	ApiKey                     *string                   `field:"optional" json:"apiKey" yaml:"apiKey"`
	ApiKeySecret               awssecretsmanager.ISecret `field:"optional" json:"apiKeySecret" yaml:"apiKeySecret"`
	ApiKeySecretArn            *string                   `field:"optional" json:"apiKeySecretArn" yaml:"apiKeySecretArn"`
	ApiKmsKey                  *string                   `field:"optional" json:"apiKmsKey" yaml:"apiKmsKey"`
	ApmFlushDeadline           interface{}               `field:"optional" json:"apmFlushDeadline" yaml:"apmFlushDeadline"`
	CaptureCloudServicePayload *bool                     `field:"optional" json:"captureCloudServicePayload" yaml:"captureCloudServicePayload"`
	CaptureLambdaPayload       *bool                     `field:"optional" json:"captureLambdaPayload" yaml:"captureLambdaPayload"`
	ColdStartTraceSkipLibs     *string                   `field:"optional" json:"coldStartTraceSkipLibs" yaml:"coldStartTraceSkipLibs"`
	CreateForwarderPermissions *bool                     `field:"optional" json:"createForwarderPermissions" yaml:"createForwarderPermissions"`
	DecodeAuthorizerContext    *bool                     `field:"optional" json:"decodeAuthorizerContext" yaml:"decodeAuthorizerContext"`
	DotnetLayerArn             *string                   `field:"optional" json:"dotnetLayerArn" yaml:"dotnetLayerArn"`
	DotnetLayerVersion         *float64                  `field:"optional" json:"dotnetLayerVersion" yaml:"dotnetLayerVersion"`
	EnableColdStartTracing     *bool                     `field:"optional" json:"enableColdStartTracing" yaml:"enableColdStartTracing"`
	EnableDatadogASM           *bool                     `field:"optional" json:"enableDatadogASM" yaml:"enableDatadogASM"`
	EnableDatadogLogs          *bool                     `field:"optional" json:"enableDatadogLogs" yaml:"enableDatadogLogs"`
	EnableDatadogTracing       *bool                     `field:"optional" json:"enableDatadogTracing" yaml:"enableDatadogTracing"`
	EnableMergeXrayTraces      *bool                     `field:"optional" json:"enableMergeXrayTraces" yaml:"enableMergeXrayTraces"`
	EnableProfiling            *bool                     `field:"optional" json:"enableProfiling" yaml:"enableProfiling"`
	EncodeAuthorizerContext    *bool                     `field:"optional" json:"encodeAuthorizerContext" yaml:"encodeAuthorizerContext"`
	Env                        *string                   `field:"optional" json:"env" yaml:"env"`
	ExtensionLayerArn          *string                   `field:"optional" json:"extensionLayerArn" yaml:"extensionLayerArn"`
	ExtensionLayerVersion      *float64                  `field:"optional" json:"extensionLayerVersion" yaml:"extensionLayerVersion"`
	FlushMetricsToLogs         *bool                     `field:"optional" json:"flushMetricsToLogs" yaml:"flushMetricsToLogs"`
	ForwarderArn               *string                   `field:"optional" json:"forwarderArn" yaml:"forwarderArn"`
	GrantSecretReadAccess      *bool                     `field:"optional" json:"grantSecretReadAccess" yaml:"grantSecretReadAccess"`
	InjectLogContext           *bool                     `field:"optional" json:"injectLogContext" yaml:"injectLogContext"`
	JavaLayerArn               *string                   `field:"optional" json:"javaLayerArn" yaml:"javaLayerArn"`
	JavaLayerVersion           *float64                  `field:"optional" json:"javaLayerVersion" yaml:"javaLayerVersion"`
	LlmObsAgentlessEnabled     *bool                     `field:"optional" json:"llmObsAgentlessEnabled" yaml:"llmObsAgentlessEnabled"`
	LlmObsEnabled              *bool                     `field:"optional" json:"llmObsEnabled" yaml:"llmObsEnabled"`
	LlmObsMlApp                *string                   `field:"optional" json:"llmObsMlApp" yaml:"llmObsMlApp"`
	LogLevel                   *string                   `field:"optional" json:"logLevel" yaml:"logLevel"`
	MinColdStartTraceDuration  *float64                  `field:"optional" json:"minColdStartTraceDuration" yaml:"minColdStartTraceDuration"`
	NodeLayerArn               *string                   `field:"optional" json:"nodeLayerArn" yaml:"nodeLayerArn"`
	NodeLayerVersion           *float64                  `field:"optional" json:"nodeLayerVersion" yaml:"nodeLayerVersion"`
	PythonLayerArn             *string                   `field:"optional" json:"pythonLayerArn" yaml:"pythonLayerArn"`
	PythonLayerVersion         *float64                  `field:"optional" json:"pythonLayerVersion" yaml:"pythonLayerVersion"`
	RedirectHandler            *bool                     `field:"optional" json:"redirectHandler" yaml:"redirectHandler"`
	RubyLayerArn               *string                   `field:"optional" json:"rubyLayerArn" yaml:"rubyLayerArn"`
	RubyLayerVersion           *float64                  `field:"optional" json:"rubyLayerVersion" yaml:"rubyLayerVersion"`
	Service                    *string                   `field:"optional" json:"service" yaml:"service"`
	Site                       *string                   `field:"optional" json:"site" yaml:"site"`
	SourceCodeIntegration      *bool                     `field:"optional" json:"sourceCodeIntegration" yaml:"sourceCodeIntegration"`
	Tags                       *string                   `field:"optional" json:"tags" yaml:"tags"`
	UseLayersFromAccount       *string                   `field:"optional" json:"useLayersFromAccount" yaml:"useLayersFromAccount"`
	Version                    *string                   `field:"optional" json:"version" yaml:"version"`
}

type DatadogLambdaStrictProps struct {
	AddLayers                  *bool                     `field:"required" json:"addLayers" yaml:"addLayers"`
	CaptureCloudServicePayload *bool                     `field:"required" json:"captureCloudServicePayload" yaml:"captureCloudServicePayload"`
	CaptureLambdaPayload       *bool                     `field:"required" json:"captureLambdaPayload" yaml:"captureLambdaPayload"`
	EnableDatadogASM           *bool                     `field:"required" json:"enableDatadogASM" yaml:"enableDatadogASM"`
	EnableDatadogLogs          *bool                     `field:"required" json:"enableDatadogLogs" yaml:"enableDatadogLogs"`
	EnableDatadogTracing       *bool                     `field:"required" json:"enableDatadogTracing" yaml:"enableDatadogTracing"`
	EnableMergeXrayTraces      *bool                     `field:"required" json:"enableMergeXrayTraces" yaml:"enableMergeXrayTraces"`
	GrantSecretReadAccess      *bool                     `field:"required" json:"grantSecretReadAccess" yaml:"grantSecretReadAccess"`
	InjectLogContext           *bool                     `field:"required" json:"injectLogContext" yaml:"injectLogContext"`
	ApiKey                     *string                   `field:"optional" json:"apiKey" yaml:"apiKey"`
	ApiKeySecret               awssecretsmanager.ISecret `field:"optional" json:"apiKeySecret" yaml:"apiKeySecret"`
	ApiKeySecretArn            *string                   `field:"optional" json:"apiKeySecretArn" yaml:"apiKeySecretArn"`
	ApiKmsKey                  *string                   `field:"optional" json:"apiKmsKey" yaml:"apiKmsKey"`
	ExtensionLayerArn          *string                   `field:"optional" json:"extensionLayerArn" yaml:"extensionLayerArn"`
	ExtensionLayerVersion      *float64                  `field:"optional" json:"extensionLayerVersion" yaml:"extensionLayerVersion"`
	FlushMetricsToLogs         *bool                     `field:"optional" json:"flushMetricsToLogs" yaml:"flushMetricsToLogs"`
	ForwarderArn               *string                   `field:"optional" json:"forwarderArn" yaml:"forwarderArn"`
	JavaLayerArn               *string                   `field:"optional" json:"javaLayerArn" yaml:"javaLayerArn"`
	JavaLayerVersion           *float64                  `field:"optional" json:"javaLayerVersion" yaml:"javaLayerVersion"`
	LogLevel                   *string                   `field:"optional" json:"logLevel" yaml:"logLevel"`
	NodeLayerArn               *string                   `field:"optional" json:"nodeLayerArn" yaml:"nodeLayerArn"`
	NodeLayerVersion           *float64                  `field:"optional" json:"nodeLayerVersion" yaml:"nodeLayerVersion"`
	PythonLayerArn             *string                   `field:"optional" json:"pythonLayerArn" yaml:"pythonLayerArn"`
	PythonLayerVersion         *float64                  `field:"optional" json:"pythonLayerVersion" yaml:"pythonLayerVersion"`
	RedirectHandler            *bool                     `field:"optional" json:"redirectHandler" yaml:"redirectHandler"`
	Site                       *string                   `field:"optional" json:"site" yaml:"site"`
	SourceCodeIntegration      *bool                     `field:"optional" json:"sourceCodeIntegration" yaml:"sourceCodeIntegration"`
}

type DatadogStepFunctions interface {
	constructs.Construct
	// The tree node.
	Node() constructs.Node
	Props() *DatadogStepFunctionsProps
	SetProps(val *DatadogStepFunctionsProps)
	Scope() constructs.Construct
	SetScope(val constructs.Construct)
	Stack() awscdk.Stack
	SetStack(val awscdk.Stack)
	AddStateMachines(stateMachines *[]awsstepfunctions.StateMachine, construct constructs.Construct)
	// Returns a string representation of this construct.
	ToString() *string
}

type DatadogStepFunctionsProps struct {
	Env          *string `field:"optional" json:"env" yaml:"env"`
	ForwarderArn *string `field:"optional" json:"forwarderArn" yaml:"forwarderArn"`
	Service      *string `field:"optional" json:"service" yaml:"service"`
	Tags         *string `field:"optional" json:"tags" yaml:"tags"`
	Version      *string `field:"optional" json:"version" yaml:"version"`
}

type DogstatsdFeatureConfig struct {
	// Controls the cardinality of custom dogstatsd metrics.
	DogstatsdCardinality Cardinality `field:"optional" json:"dogstatsdCardinality" yaml:"dogstatsdCardinality"`
	// Enables Dogstatsd.
	IsEnabled *bool `field:"optional" json:"isEnabled" yaml:"isEnabled"`
	// Enables Dogstatsd origin detection.
	IsOriginDetectionEnabled *bool `field:"optional" json:"isOriginDetectionEnabled" yaml:"isOriginDetectionEnabled"`
	// Enables Dogstatsd traffic over Unix Domain Socket.
	//
	// Falls back to UDP configuration for application containers when disabled.
	IsSocketEnabled *bool `field:"optional" json:"isSocketEnabled" yaml:"isSocketEnabled"`
}

type FargateCWSFeatureConfig struct {
	// Enables CWS.
	IsEnabled *bool `field:"optional" json:"isEnabled" yaml:"isEnabled"`
	// The minimum number of CPU units to reserve for the Datadog CWS init container.
	Cpu *float64 `field:"optional" json:"cpu" yaml:"cpu"`
	// The amount (in MiB) of memory to present to the Datadog CWS init container.
	MemoryLimitMiB *float64 `field:"optional" json:"memoryLimitMiB" yaml:"memoryLimitMiB"`
}

type FargateLogCollectionFeatureConfig struct {
	// Enables log collection.
	IsEnabled *bool `field:"optional" json:"isEnabled" yaml:"isEnabled"`
	// Fluentbit log collection configuration.
	FluentbitConfig *FluentbitConfig `field:"optional" json:"fluentbitConfig" yaml:"fluentbitConfig"`
	// Type of log collection.
	LoggingType LoggingType `field:"optional" json:"loggingType" yaml:"loggingType"`
}

type FluentbitConfig struct {
	// The minimum number of CPU units to reserve for the Datadog fluent-bit container.
	Cpu *float64 `field:"optional" json:"cpu" yaml:"cpu"`
	// Firelens options for the Fluentbit container.
	FirelensOptions *DatadogFirelensOptions `field:"optional" json:"firelensOptions" yaml:"firelensOptions"`
	// The version of the Fluentbit container image to use.
	ImageVersion *string `field:"optional" json:"imageVersion" yaml:"imageVersion"`
	// Enables the log router health check.
	IsLogRouterDependencyEnabled *bool `field:"optional" json:"isLogRouterDependencyEnabled" yaml:"isLogRouterDependencyEnabled"`
	// Makes the log router essential.
	IsLogRouterEssential *bool `field:"optional" json:"isLogRouterEssential" yaml:"isLogRouterEssential"`
	// Configuration for the Datadog log driver.
	LogDriverConfig *DatadogECSLogDriverProps `field:"optional" json:"logDriverConfig" yaml:"logDriverConfig"`
	// Health check configuration for the log router.
	LogRouterHealthCheck *awsecs.HealthCheck `field:"optional" json:"logRouterHealthCheck" yaml:"logRouterHealthCheck"`
	// The amount (in MiB) of memory to present to the Datadog fluent-bit container.
	MemoryLimitMiB *float64 `field:"optional" json:"memoryLimitMiB" yaml:"memoryLimitMiB"`
	// The registry to pull the Fluentbit container image from.
	Registry *string `field:"optional" json:"registry" yaml:"registry"`
}

type LogCollectionFeatureConfig struct {
	// Enables log collection.
	IsEnabled *bool `field:"optional" json:"isEnabled" yaml:"isEnabled"`
}

type LoggingType string

type Node struct {
	DefaultChild interface{} `field:"required" json:"defaultChild" yaml:"defaultChild"`
}

type Runtime struct {
	Name *string `field:"required" json:"name" yaml:"name"`
}

type RuntimeType string

type TagKeys string

type Transport interface {
	ApiKey() *string
	SetApiKey(val *string)
	ApiKeySecretArn() *string
	SetApiKeySecretArn(val *string)
	ApiKmsKey() *string
	SetApiKmsKey(val *string)
	ExtensionLayerArn() *string
	SetExtensionLayerArn(val *string)
	ExtensionLayerVersion() *float64
	SetExtensionLayerVersion(val *float64)
	FlushMetricsToLogs() *bool
	SetFlushMetricsToLogs(val *bool)
	Site() *string
	SetSite(val *string)
	ApplyEnvVars(lam awslambda.Function)
}