pulumiTypes.go

// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***

package mwaa

import (
	"context"
	"reflect"

	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

type EnvironmentLastUpdated struct {
	// The Created At date of the MWAA Environment
	// * `logging_configuration[0].<LOG_CONFIGURATION_TYPE>[0].cloud_watch_log_group_arn` - Provides the ARN for the CloudWatch group where the logs will be published
	CreatedAt *string                       `pulumi:"createdAt"`
	Errors    []EnvironmentLastUpdatedError `pulumi:"errors"`
	// The status of the Amazon MWAA Environment
	Status *string `pulumi:"status"`
}

// EnvironmentLastUpdatedInput is an input type that accepts EnvironmentLastUpdatedArgs and EnvironmentLastUpdatedOutput values.
// You can construct a concrete instance of `EnvironmentLastUpdatedInput` via:
//
//          EnvironmentLastUpdatedArgs{...}
type EnvironmentLastUpdatedInput interface {
	pulumi.Input

	ToEnvironmentLastUpdatedOutput() EnvironmentLastUpdatedOutput
	ToEnvironmentLastUpdatedOutputWithContext(context.Context) EnvironmentLastUpdatedOutput
}

type EnvironmentLastUpdatedArgs struct {
	// The Created At date of the MWAA Environment
	// * `logging_configuration[0].<LOG_CONFIGURATION_TYPE>[0].cloud_watch_log_group_arn` - Provides the ARN for the CloudWatch group where the logs will be published
	CreatedAt pulumi.StringPtrInput                 `pulumi:"createdAt"`
	Errors    EnvironmentLastUpdatedErrorArrayInput `pulumi:"errors"`
	// The status of the Amazon MWAA Environment
	Status pulumi.StringPtrInput `pulumi:"status"`
}

func (EnvironmentLastUpdatedArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*EnvironmentLastUpdated)(nil)).Elem()
}

func (i EnvironmentLastUpdatedArgs) ToEnvironmentLastUpdatedOutput() EnvironmentLastUpdatedOutput {
	return i.ToEnvironmentLastUpdatedOutputWithContext(context.Background())
}

func (i EnvironmentLastUpdatedArgs) ToEnvironmentLastUpdatedOutputWithContext(ctx context.Context) EnvironmentLastUpdatedOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLastUpdatedOutput)
}

// EnvironmentLastUpdatedArrayInput is an input type that accepts EnvironmentLastUpdatedArray and EnvironmentLastUpdatedArrayOutput values.
// You can construct a concrete instance of `EnvironmentLastUpdatedArrayInput` via:
//
//          EnvironmentLastUpdatedArray{ EnvironmentLastUpdatedArgs{...} }
type EnvironmentLastUpdatedArrayInput interface {
	pulumi.Input

	ToEnvironmentLastUpdatedArrayOutput() EnvironmentLastUpdatedArrayOutput
	ToEnvironmentLastUpdatedArrayOutputWithContext(context.Context) EnvironmentLastUpdatedArrayOutput
}

type EnvironmentLastUpdatedArray []EnvironmentLastUpdatedInput

func (EnvironmentLastUpdatedArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]EnvironmentLastUpdated)(nil)).Elem()
}

func (i EnvironmentLastUpdatedArray) ToEnvironmentLastUpdatedArrayOutput() EnvironmentLastUpdatedArrayOutput {
	return i.ToEnvironmentLastUpdatedArrayOutputWithContext(context.Background())
}

func (i EnvironmentLastUpdatedArray) ToEnvironmentLastUpdatedArrayOutputWithContext(ctx context.Context) EnvironmentLastUpdatedArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLastUpdatedArrayOutput)
}

type EnvironmentLastUpdatedOutput struct{ *pulumi.OutputState }

func (EnvironmentLastUpdatedOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*EnvironmentLastUpdated)(nil)).Elem()
}

func (o EnvironmentLastUpdatedOutput) ToEnvironmentLastUpdatedOutput() EnvironmentLastUpdatedOutput {
	return o
}

func (o EnvironmentLastUpdatedOutput) ToEnvironmentLastUpdatedOutputWithContext(ctx context.Context) EnvironmentLastUpdatedOutput {
	return o
}

// The Created At date of the MWAA Environment
// * `logging_configuration[0].<LOG_CONFIGURATION_TYPE>[0].cloud_watch_log_group_arn` - Provides the ARN for the CloudWatch group where the logs will be published
func (o EnvironmentLastUpdatedOutput) CreatedAt() pulumi.StringPtrOutput {
	return o.ApplyT(func(v EnvironmentLastUpdated) *string { return v.CreatedAt }).(pulumi.StringPtrOutput)
}

func (o EnvironmentLastUpdatedOutput) Errors() EnvironmentLastUpdatedErrorArrayOutput {
	return o.ApplyT(func(v EnvironmentLastUpdated) []EnvironmentLastUpdatedError { return v.Errors }).(EnvironmentLastUpdatedErrorArrayOutput)
}

// The status of the Amazon MWAA Environment
func (o EnvironmentLastUpdatedOutput) Status() pulumi.StringPtrOutput {
	return o.ApplyT(func(v EnvironmentLastUpdated) *string { return v.Status }).(pulumi.StringPtrOutput)
}

type EnvironmentLastUpdatedArrayOutput struct{ *pulumi.OutputState }

func (EnvironmentLastUpdatedArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]EnvironmentLastUpdated)(nil)).Elem()
}

func (o EnvironmentLastUpdatedArrayOutput) ToEnvironmentLastUpdatedArrayOutput() EnvironmentLastUpdatedArrayOutput {
	return o
}

func (o EnvironmentLastUpdatedArrayOutput) ToEnvironmentLastUpdatedArrayOutputWithContext(ctx context.Context) EnvironmentLastUpdatedArrayOutput {
	return o
}

func (o EnvironmentLastUpdatedArrayOutput) Index(i pulumi.IntInput) EnvironmentLastUpdatedOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) EnvironmentLastUpdated {
		return vs[0].([]EnvironmentLastUpdated)[vs[1].(int)]
	}).(EnvironmentLastUpdatedOutput)
}

type EnvironmentLastUpdatedError struct {
	ErrorCode    *string `pulumi:"errorCode"`
	ErrorMessage *string `pulumi:"errorMessage"`
}

// EnvironmentLastUpdatedErrorInput is an input type that accepts EnvironmentLastUpdatedErrorArgs and EnvironmentLastUpdatedErrorOutput values.
// You can construct a concrete instance of `EnvironmentLastUpdatedErrorInput` via:
//
//          EnvironmentLastUpdatedErrorArgs{...}
type EnvironmentLastUpdatedErrorInput interface {
	pulumi.Input

	ToEnvironmentLastUpdatedErrorOutput() EnvironmentLastUpdatedErrorOutput
	ToEnvironmentLastUpdatedErrorOutputWithContext(context.Context) EnvironmentLastUpdatedErrorOutput
}

type EnvironmentLastUpdatedErrorArgs struct {
	ErrorCode    pulumi.StringPtrInput `pulumi:"errorCode"`
	ErrorMessage pulumi.StringPtrInput `pulumi:"errorMessage"`
}

func (EnvironmentLastUpdatedErrorArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*EnvironmentLastUpdatedError)(nil)).Elem()
}

func (i EnvironmentLastUpdatedErrorArgs) ToEnvironmentLastUpdatedErrorOutput() EnvironmentLastUpdatedErrorOutput {
	return i.ToEnvironmentLastUpdatedErrorOutputWithContext(context.Background())
}

func (i EnvironmentLastUpdatedErrorArgs) ToEnvironmentLastUpdatedErrorOutputWithContext(ctx context.Context) EnvironmentLastUpdatedErrorOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLastUpdatedErrorOutput)
}

// EnvironmentLastUpdatedErrorArrayInput is an input type that accepts EnvironmentLastUpdatedErrorArray and EnvironmentLastUpdatedErrorArrayOutput values.
// You can construct a concrete instance of `EnvironmentLastUpdatedErrorArrayInput` via:
//
//          EnvironmentLastUpdatedErrorArray{ EnvironmentLastUpdatedErrorArgs{...} }
type EnvironmentLastUpdatedErrorArrayInput interface {
	pulumi.Input

	ToEnvironmentLastUpdatedErrorArrayOutput() EnvironmentLastUpdatedErrorArrayOutput
	ToEnvironmentLastUpdatedErrorArrayOutputWithContext(context.Context) EnvironmentLastUpdatedErrorArrayOutput
}

type EnvironmentLastUpdatedErrorArray []EnvironmentLastUpdatedErrorInput

func (EnvironmentLastUpdatedErrorArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]EnvironmentLastUpdatedError)(nil)).Elem()
}

func (i EnvironmentLastUpdatedErrorArray) ToEnvironmentLastUpdatedErrorArrayOutput() EnvironmentLastUpdatedErrorArrayOutput {
	return i.ToEnvironmentLastUpdatedErrorArrayOutputWithContext(context.Background())
}

func (i EnvironmentLastUpdatedErrorArray) ToEnvironmentLastUpdatedErrorArrayOutputWithContext(ctx context.Context) EnvironmentLastUpdatedErrorArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLastUpdatedErrorArrayOutput)
}

type EnvironmentLastUpdatedErrorOutput struct{ *pulumi.OutputState }

func (EnvironmentLastUpdatedErrorOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*EnvironmentLastUpdatedError)(nil)).Elem()
}

func (o EnvironmentLastUpdatedErrorOutput) ToEnvironmentLastUpdatedErrorOutput() EnvironmentLastUpdatedErrorOutput {
	return o
}

func (o EnvironmentLastUpdatedErrorOutput) ToEnvironmentLastUpdatedErrorOutputWithContext(ctx context.Context) EnvironmentLastUpdatedErrorOutput {
	return o
}

func (o EnvironmentLastUpdatedErrorOutput) ErrorCode() pulumi.StringPtrOutput {
	return o.ApplyT(func(v EnvironmentLastUpdatedError) *string { return v.ErrorCode }).(pulumi.StringPtrOutput)
}

func (o EnvironmentLastUpdatedErrorOutput) ErrorMessage() pulumi.StringPtrOutput {
	return o.ApplyT(func(v EnvironmentLastUpdatedError) *string { return v.ErrorMessage }).(pulumi.StringPtrOutput)
}

type EnvironmentLastUpdatedErrorArrayOutput struct{ *pulumi.OutputState }

func (EnvironmentLastUpdatedErrorArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]EnvironmentLastUpdatedError)(nil)).Elem()
}

func (o EnvironmentLastUpdatedErrorArrayOutput) ToEnvironmentLastUpdatedErrorArrayOutput() EnvironmentLastUpdatedErrorArrayOutput {
	return o
}

func (o EnvironmentLastUpdatedErrorArrayOutput) ToEnvironmentLastUpdatedErrorArrayOutputWithContext(ctx context.Context) EnvironmentLastUpdatedErrorArrayOutput {
	return o
}

func (o EnvironmentLastUpdatedErrorArrayOutput) Index(i pulumi.IntInput) EnvironmentLastUpdatedErrorOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) EnvironmentLastUpdatedError {
		return vs[0].([]EnvironmentLastUpdatedError)[vs[1].(int)]
	}).(EnvironmentLastUpdatedErrorOutput)
}

type EnvironmentLoggingConfiguration struct {
	// (Optional) Log configuration options for processing DAGs. See Module logging configuration for more information. Disabled by default.
	DagProcessingLogs *EnvironmentLoggingConfigurationDagProcessingLogs `pulumi:"dagProcessingLogs"`
	// Log configuration options for the schedulers. See Module logging configuration for more information. Disabled by default.
	SchedulerLogs *EnvironmentLoggingConfigurationSchedulerLogs `pulumi:"schedulerLogs"`
	// Log configuration options for DAG tasks. See Module logging configuration for more information. Enabled by default with `INFO` log level.
	TaskLogs *EnvironmentLoggingConfigurationTaskLogs `pulumi:"taskLogs"`
	// Log configuration options for the webservers. See Module logging configuration for more information. Disabled by default.
	WebserverLogs *EnvironmentLoggingConfigurationWebserverLogs `pulumi:"webserverLogs"`
	// Log configuration options for the workers. See Module logging configuration for more information. Disabled by default.
	WorkerLogs *EnvironmentLoggingConfigurationWorkerLogs `pulumi:"workerLogs"`
}

// EnvironmentLoggingConfigurationInput is an input type that accepts EnvironmentLoggingConfigurationArgs and EnvironmentLoggingConfigurationOutput values.
// You can construct a concrete instance of `EnvironmentLoggingConfigurationInput` via:
//
//          EnvironmentLoggingConfigurationArgs{...}
type EnvironmentLoggingConfigurationInput interface {
	pulumi.Input

	ToEnvironmentLoggingConfigurationOutput() EnvironmentLoggingConfigurationOutput
	ToEnvironmentLoggingConfigurationOutputWithContext(context.Context) EnvironmentLoggingConfigurationOutput
}

type EnvironmentLoggingConfigurationArgs struct {
	// (Optional) Log configuration options for processing DAGs. See Module logging configuration for more information. Disabled by default.
	DagProcessingLogs EnvironmentLoggingConfigurationDagProcessingLogsPtrInput `pulumi:"dagProcessingLogs"`
	// Log configuration options for the schedulers. See Module logging configuration for more information. Disabled by default.
	SchedulerLogs EnvironmentLoggingConfigurationSchedulerLogsPtrInput `pulumi:"schedulerLogs"`
	// Log configuration options for DAG tasks. See Module logging configuration for more information. Enabled by default with `INFO` log level.
	TaskLogs EnvironmentLoggingConfigurationTaskLogsPtrInput `pulumi:"taskLogs"`
	// Log configuration options for the webservers. See Module logging configuration for more information. Disabled by default.
	WebserverLogs EnvironmentLoggingConfigurationWebserverLogsPtrInput `pulumi:"webserverLogs"`
	// Log configuration options for the workers. See Module logging configuration for more information. Disabled by default.
	WorkerLogs EnvironmentLoggingConfigurationWorkerLogsPtrInput `pulumi:"workerLogs"`
}

func (EnvironmentLoggingConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*EnvironmentLoggingConfiguration)(nil)).Elem()
}

func (i EnvironmentLoggingConfigurationArgs) ToEnvironmentLoggingConfigurationOutput() EnvironmentLoggingConfigurationOutput {
	return i.ToEnvironmentLoggingConfigurationOutputWithContext(context.Background())
}

func (i EnvironmentLoggingConfigurationArgs) ToEnvironmentLoggingConfigurationOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLoggingConfigurationOutput)
}

func (i EnvironmentLoggingConfigurationArgs) ToEnvironmentLoggingConfigurationPtrOutput() EnvironmentLoggingConfigurationPtrOutput {
	return i.ToEnvironmentLoggingConfigurationPtrOutputWithContext(context.Background())
}

func (i EnvironmentLoggingConfigurationArgs) ToEnvironmentLoggingConfigurationPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLoggingConfigurationOutput).ToEnvironmentLoggingConfigurationPtrOutputWithContext(ctx)
}

// EnvironmentLoggingConfigurationPtrInput is an input type that accepts EnvironmentLoggingConfigurationArgs, EnvironmentLoggingConfigurationPtr and EnvironmentLoggingConfigurationPtrOutput values.
// You can construct a concrete instance of `EnvironmentLoggingConfigurationPtrInput` via:
//
//          EnvironmentLoggingConfigurationArgs{...}
//
//  or:
//
//          nil
type EnvironmentLoggingConfigurationPtrInput interface {
	pulumi.Input

	ToEnvironmentLoggingConfigurationPtrOutput() EnvironmentLoggingConfigurationPtrOutput
	ToEnvironmentLoggingConfigurationPtrOutputWithContext(context.Context) EnvironmentLoggingConfigurationPtrOutput
}

type environmentLoggingConfigurationPtrType EnvironmentLoggingConfigurationArgs

func EnvironmentLoggingConfigurationPtr(v *EnvironmentLoggingConfigurationArgs) EnvironmentLoggingConfigurationPtrInput {
	return (*environmentLoggingConfigurationPtrType)(v)
}

func (*environmentLoggingConfigurationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**EnvironmentLoggingConfiguration)(nil)).Elem()
}

func (i *environmentLoggingConfigurationPtrType) ToEnvironmentLoggingConfigurationPtrOutput() EnvironmentLoggingConfigurationPtrOutput {
	return i.ToEnvironmentLoggingConfigurationPtrOutputWithContext(context.Background())
}

func (i *environmentLoggingConfigurationPtrType) ToEnvironmentLoggingConfigurationPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLoggingConfigurationPtrOutput)
}

type EnvironmentLoggingConfigurationOutput struct{ *pulumi.OutputState }

func (EnvironmentLoggingConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*EnvironmentLoggingConfiguration)(nil)).Elem()
}

func (o EnvironmentLoggingConfigurationOutput) ToEnvironmentLoggingConfigurationOutput() EnvironmentLoggingConfigurationOutput {
	return o
}

func (o EnvironmentLoggingConfigurationOutput) ToEnvironmentLoggingConfigurationOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationOutput {
	return o
}

func (o EnvironmentLoggingConfigurationOutput) ToEnvironmentLoggingConfigurationPtrOutput() EnvironmentLoggingConfigurationPtrOutput {
	return o.ToEnvironmentLoggingConfigurationPtrOutputWithContext(context.Background())
}

func (o EnvironmentLoggingConfigurationOutput) ToEnvironmentLoggingConfigurationPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v EnvironmentLoggingConfiguration) *EnvironmentLoggingConfiguration {
		return &v
	}).(EnvironmentLoggingConfigurationPtrOutput)
}

// (Optional) Log configuration options for processing DAGs. See Module logging configuration for more information. Disabled by default.
func (o EnvironmentLoggingConfigurationOutput) DagProcessingLogs() EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput {
	return o.ApplyT(func(v EnvironmentLoggingConfiguration) *EnvironmentLoggingConfigurationDagProcessingLogs {
		return v.DagProcessingLogs
	}).(EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput)
}

// Log configuration options for the schedulers. See Module logging configuration for more information. Disabled by default.
func (o EnvironmentLoggingConfigurationOutput) SchedulerLogs() EnvironmentLoggingConfigurationSchedulerLogsPtrOutput {
	return o.ApplyT(func(v EnvironmentLoggingConfiguration) *EnvironmentLoggingConfigurationSchedulerLogs {
		return v.SchedulerLogs
	}).(EnvironmentLoggingConfigurationSchedulerLogsPtrOutput)
}

// Log configuration options for DAG tasks. See Module logging configuration for more information. Enabled by default with `INFO` log level.
func (o EnvironmentLoggingConfigurationOutput) TaskLogs() EnvironmentLoggingConfigurationTaskLogsPtrOutput {
	return o.ApplyT(func(v EnvironmentLoggingConfiguration) *EnvironmentLoggingConfigurationTaskLogs { return v.TaskLogs }).(EnvironmentLoggingConfigurationTaskLogsPtrOutput)
}

// Log configuration options for the webservers. See Module logging configuration for more information. Disabled by default.
func (o EnvironmentLoggingConfigurationOutput) WebserverLogs() EnvironmentLoggingConfigurationWebserverLogsPtrOutput {
	return o.ApplyT(func(v EnvironmentLoggingConfiguration) *EnvironmentLoggingConfigurationWebserverLogs {
		return v.WebserverLogs
	}).(EnvironmentLoggingConfigurationWebserverLogsPtrOutput)
}

// Log configuration options for the workers. See Module logging configuration for more information. Disabled by default.
func (o EnvironmentLoggingConfigurationOutput) WorkerLogs() EnvironmentLoggingConfigurationWorkerLogsPtrOutput {
	return o.ApplyT(func(v EnvironmentLoggingConfiguration) *EnvironmentLoggingConfigurationWorkerLogs {
		return v.WorkerLogs
	}).(EnvironmentLoggingConfigurationWorkerLogsPtrOutput)
}

type EnvironmentLoggingConfigurationPtrOutput struct{ *pulumi.OutputState }

func (EnvironmentLoggingConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**EnvironmentLoggingConfiguration)(nil)).Elem()
}

func (o EnvironmentLoggingConfigurationPtrOutput) ToEnvironmentLoggingConfigurationPtrOutput() EnvironmentLoggingConfigurationPtrOutput {
	return o
}

func (o EnvironmentLoggingConfigurationPtrOutput) ToEnvironmentLoggingConfigurationPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationPtrOutput {
	return o
}

func (o EnvironmentLoggingConfigurationPtrOutput) Elem() EnvironmentLoggingConfigurationOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfiguration) EnvironmentLoggingConfiguration {
		if v != nil {
			return *v
		}
		var ret EnvironmentLoggingConfiguration
		return ret
	}).(EnvironmentLoggingConfigurationOutput)
}

// (Optional) Log configuration options for processing DAGs. See Module logging configuration for more information. Disabled by default.
func (o EnvironmentLoggingConfigurationPtrOutput) DagProcessingLogs() EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfiguration) *EnvironmentLoggingConfigurationDagProcessingLogs {
		if v == nil {
			return nil
		}
		return v.DagProcessingLogs
	}).(EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput)
}

// Log configuration options for the schedulers. See Module logging configuration for more information. Disabled by default.
func (o EnvironmentLoggingConfigurationPtrOutput) SchedulerLogs() EnvironmentLoggingConfigurationSchedulerLogsPtrOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfiguration) *EnvironmentLoggingConfigurationSchedulerLogs {
		if v == nil {
			return nil
		}
		return v.SchedulerLogs
	}).(EnvironmentLoggingConfigurationSchedulerLogsPtrOutput)
}

// Log configuration options for DAG tasks. See Module logging configuration for more information. Enabled by default with `INFO` log level.
func (o EnvironmentLoggingConfigurationPtrOutput) TaskLogs() EnvironmentLoggingConfigurationTaskLogsPtrOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfiguration) *EnvironmentLoggingConfigurationTaskLogs {
		if v == nil {
			return nil
		}
		return v.TaskLogs
	}).(EnvironmentLoggingConfigurationTaskLogsPtrOutput)
}

// Log configuration options for the webservers. See Module logging configuration for more information. Disabled by default.
func (o EnvironmentLoggingConfigurationPtrOutput) WebserverLogs() EnvironmentLoggingConfigurationWebserverLogsPtrOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfiguration) *EnvironmentLoggingConfigurationWebserverLogs {
		if v == nil {
			return nil
		}
		return v.WebserverLogs
	}).(EnvironmentLoggingConfigurationWebserverLogsPtrOutput)
}

// Log configuration options for the workers. See Module logging configuration for more information. Disabled by default.
func (o EnvironmentLoggingConfigurationPtrOutput) WorkerLogs() EnvironmentLoggingConfigurationWorkerLogsPtrOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfiguration) *EnvironmentLoggingConfigurationWorkerLogs {
		if v == nil {
			return nil
		}
		return v.WorkerLogs
	}).(EnvironmentLoggingConfigurationWorkerLogsPtrOutput)
}

type EnvironmentLoggingConfigurationDagProcessingLogs struct {
	CloudWatchLogGroupArn *string `pulumi:"cloudWatchLogGroupArn"`
	// Enabling or disabling the collection of logs
	Enabled *bool `pulumi:"enabled"`
	// Logging level. Valid values: `CRITICAL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`. Will be `INFO` by default.
	LogLevel *string `pulumi:"logLevel"`
}

// EnvironmentLoggingConfigurationDagProcessingLogsInput is an input type that accepts EnvironmentLoggingConfigurationDagProcessingLogsArgs and EnvironmentLoggingConfigurationDagProcessingLogsOutput values.
// You can construct a concrete instance of `EnvironmentLoggingConfigurationDagProcessingLogsInput` via:
//
//          EnvironmentLoggingConfigurationDagProcessingLogsArgs{...}
type EnvironmentLoggingConfigurationDagProcessingLogsInput interface {
	pulumi.Input

	ToEnvironmentLoggingConfigurationDagProcessingLogsOutput() EnvironmentLoggingConfigurationDagProcessingLogsOutput
	ToEnvironmentLoggingConfigurationDagProcessingLogsOutputWithContext(context.Context) EnvironmentLoggingConfigurationDagProcessingLogsOutput
}

type EnvironmentLoggingConfigurationDagProcessingLogsArgs struct {
	CloudWatchLogGroupArn pulumi.StringPtrInput `pulumi:"cloudWatchLogGroupArn"`
	// Enabling or disabling the collection of logs
	Enabled pulumi.BoolPtrInput `pulumi:"enabled"`
	// Logging level. Valid values: `CRITICAL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`. Will be `INFO` by default.
	LogLevel pulumi.StringPtrInput `pulumi:"logLevel"`
}

func (EnvironmentLoggingConfigurationDagProcessingLogsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*EnvironmentLoggingConfigurationDagProcessingLogs)(nil)).Elem()
}

func (i EnvironmentLoggingConfigurationDagProcessingLogsArgs) ToEnvironmentLoggingConfigurationDagProcessingLogsOutput() EnvironmentLoggingConfigurationDagProcessingLogsOutput {
	return i.ToEnvironmentLoggingConfigurationDagProcessingLogsOutputWithContext(context.Background())
}

func (i EnvironmentLoggingConfigurationDagProcessingLogsArgs) ToEnvironmentLoggingConfigurationDagProcessingLogsOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationDagProcessingLogsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLoggingConfigurationDagProcessingLogsOutput)
}

func (i EnvironmentLoggingConfigurationDagProcessingLogsArgs) ToEnvironmentLoggingConfigurationDagProcessingLogsPtrOutput() EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput {
	return i.ToEnvironmentLoggingConfigurationDagProcessingLogsPtrOutputWithContext(context.Background())
}

func (i EnvironmentLoggingConfigurationDagProcessingLogsArgs) ToEnvironmentLoggingConfigurationDagProcessingLogsPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLoggingConfigurationDagProcessingLogsOutput).ToEnvironmentLoggingConfigurationDagProcessingLogsPtrOutputWithContext(ctx)
}

// EnvironmentLoggingConfigurationDagProcessingLogsPtrInput is an input type that accepts EnvironmentLoggingConfigurationDagProcessingLogsArgs, EnvironmentLoggingConfigurationDagProcessingLogsPtr and EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput values.
// You can construct a concrete instance of `EnvironmentLoggingConfigurationDagProcessingLogsPtrInput` via:
//
//          EnvironmentLoggingConfigurationDagProcessingLogsArgs{...}
//
//  or:
//
//          nil
type EnvironmentLoggingConfigurationDagProcessingLogsPtrInput interface {
	pulumi.Input

	ToEnvironmentLoggingConfigurationDagProcessingLogsPtrOutput() EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput
	ToEnvironmentLoggingConfigurationDagProcessingLogsPtrOutputWithContext(context.Context) EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput
}

type environmentLoggingConfigurationDagProcessingLogsPtrType EnvironmentLoggingConfigurationDagProcessingLogsArgs

func EnvironmentLoggingConfigurationDagProcessingLogsPtr(v *EnvironmentLoggingConfigurationDagProcessingLogsArgs) EnvironmentLoggingConfigurationDagProcessingLogsPtrInput {
	return (*environmentLoggingConfigurationDagProcessingLogsPtrType)(v)
}

func (*environmentLoggingConfigurationDagProcessingLogsPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**EnvironmentLoggingConfigurationDagProcessingLogs)(nil)).Elem()
}

func (i *environmentLoggingConfigurationDagProcessingLogsPtrType) ToEnvironmentLoggingConfigurationDagProcessingLogsPtrOutput() EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput {
	return i.ToEnvironmentLoggingConfigurationDagProcessingLogsPtrOutputWithContext(context.Background())
}

func (i *environmentLoggingConfigurationDagProcessingLogsPtrType) ToEnvironmentLoggingConfigurationDagProcessingLogsPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput)
}

type EnvironmentLoggingConfigurationDagProcessingLogsOutput struct{ *pulumi.OutputState }

func (EnvironmentLoggingConfigurationDagProcessingLogsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*EnvironmentLoggingConfigurationDagProcessingLogs)(nil)).Elem()
}

func (o EnvironmentLoggingConfigurationDagProcessingLogsOutput) ToEnvironmentLoggingConfigurationDagProcessingLogsOutput() EnvironmentLoggingConfigurationDagProcessingLogsOutput {
	return o
}

func (o EnvironmentLoggingConfigurationDagProcessingLogsOutput) ToEnvironmentLoggingConfigurationDagProcessingLogsOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationDagProcessingLogsOutput {
	return o
}

func (o EnvironmentLoggingConfigurationDagProcessingLogsOutput) ToEnvironmentLoggingConfigurationDagProcessingLogsPtrOutput() EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput {
	return o.ToEnvironmentLoggingConfigurationDagProcessingLogsPtrOutputWithContext(context.Background())
}

func (o EnvironmentLoggingConfigurationDagProcessingLogsOutput) ToEnvironmentLoggingConfigurationDagProcessingLogsPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v EnvironmentLoggingConfigurationDagProcessingLogs) *EnvironmentLoggingConfigurationDagProcessingLogs {
		return &v
	}).(EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput)
}

func (o EnvironmentLoggingConfigurationDagProcessingLogsOutput) CloudWatchLogGroupArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v EnvironmentLoggingConfigurationDagProcessingLogs) *string { return v.CloudWatchLogGroupArn }).(pulumi.StringPtrOutput)
}

// Enabling or disabling the collection of logs
func (o EnvironmentLoggingConfigurationDagProcessingLogsOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v EnvironmentLoggingConfigurationDagProcessingLogs) *bool { return v.Enabled }).(pulumi.BoolPtrOutput)
}

// Logging level. Valid values: `CRITICAL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`. Will be `INFO` by default.
func (o EnvironmentLoggingConfigurationDagProcessingLogsOutput) LogLevel() pulumi.StringPtrOutput {
	return o.ApplyT(func(v EnvironmentLoggingConfigurationDagProcessingLogs) *string { return v.LogLevel }).(pulumi.StringPtrOutput)
}

type EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput struct{ *pulumi.OutputState }

func (EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**EnvironmentLoggingConfigurationDagProcessingLogs)(nil)).Elem()
}

func (o EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput) ToEnvironmentLoggingConfigurationDagProcessingLogsPtrOutput() EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput {
	return o
}

func (o EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput) ToEnvironmentLoggingConfigurationDagProcessingLogsPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput {
	return o
}

func (o EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput) Elem() EnvironmentLoggingConfigurationDagProcessingLogsOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfigurationDagProcessingLogs) EnvironmentLoggingConfigurationDagProcessingLogs {
		if v != nil {
			return *v
		}
		var ret EnvironmentLoggingConfigurationDagProcessingLogs
		return ret
	}).(EnvironmentLoggingConfigurationDagProcessingLogsOutput)
}

func (o EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput) CloudWatchLogGroupArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfigurationDagProcessingLogs) *string {
		if v == nil {
			return nil
		}
		return v.CloudWatchLogGroupArn
	}).(pulumi.StringPtrOutput)
}

// Enabling or disabling the collection of logs
func (o EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfigurationDagProcessingLogs) *bool {
		if v == nil {
			return nil
		}
		return v.Enabled
	}).(pulumi.BoolPtrOutput)
}

// Logging level. Valid values: `CRITICAL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`. Will be `INFO` by default.
func (o EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput) LogLevel() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfigurationDagProcessingLogs) *string {
		if v == nil {
			return nil
		}
		return v.LogLevel
	}).(pulumi.StringPtrOutput)
}

type EnvironmentLoggingConfigurationSchedulerLogs struct {
	CloudWatchLogGroupArn *string `pulumi:"cloudWatchLogGroupArn"`
	// Enabling or disabling the collection of logs
	Enabled *bool `pulumi:"enabled"`
	// Logging level. Valid values: `CRITICAL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`. Will be `INFO` by default.
	LogLevel *string `pulumi:"logLevel"`
}

// EnvironmentLoggingConfigurationSchedulerLogsInput is an input type that accepts EnvironmentLoggingConfigurationSchedulerLogsArgs and EnvironmentLoggingConfigurationSchedulerLogsOutput values.
// You can construct a concrete instance of `EnvironmentLoggingConfigurationSchedulerLogsInput` via:
//
//          EnvironmentLoggingConfigurationSchedulerLogsArgs{...}
type EnvironmentLoggingConfigurationSchedulerLogsInput interface {
	pulumi.Input

	ToEnvironmentLoggingConfigurationSchedulerLogsOutput() EnvironmentLoggingConfigurationSchedulerLogsOutput
	ToEnvironmentLoggingConfigurationSchedulerLogsOutputWithContext(context.Context) EnvironmentLoggingConfigurationSchedulerLogsOutput
}

type EnvironmentLoggingConfigurationSchedulerLogsArgs struct {
	CloudWatchLogGroupArn pulumi.StringPtrInput `pulumi:"cloudWatchLogGroupArn"`
	// Enabling or disabling the collection of logs
	Enabled pulumi.BoolPtrInput `pulumi:"enabled"`
	// Logging level. Valid values: `CRITICAL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`. Will be `INFO` by default.
	LogLevel pulumi.StringPtrInput `pulumi:"logLevel"`
}

func (EnvironmentLoggingConfigurationSchedulerLogsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*EnvironmentLoggingConfigurationSchedulerLogs)(nil)).Elem()
}

func (i EnvironmentLoggingConfigurationSchedulerLogsArgs) ToEnvironmentLoggingConfigurationSchedulerLogsOutput() EnvironmentLoggingConfigurationSchedulerLogsOutput {
	return i.ToEnvironmentLoggingConfigurationSchedulerLogsOutputWithContext(context.Background())
}

func (i EnvironmentLoggingConfigurationSchedulerLogsArgs) ToEnvironmentLoggingConfigurationSchedulerLogsOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationSchedulerLogsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLoggingConfigurationSchedulerLogsOutput)
}

func (i EnvironmentLoggingConfigurationSchedulerLogsArgs) ToEnvironmentLoggingConfigurationSchedulerLogsPtrOutput() EnvironmentLoggingConfigurationSchedulerLogsPtrOutput {
	return i.ToEnvironmentLoggingConfigurationSchedulerLogsPtrOutputWithContext(context.Background())
}

func (i EnvironmentLoggingConfigurationSchedulerLogsArgs) ToEnvironmentLoggingConfigurationSchedulerLogsPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationSchedulerLogsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLoggingConfigurationSchedulerLogsOutput).ToEnvironmentLoggingConfigurationSchedulerLogsPtrOutputWithContext(ctx)
}

// EnvironmentLoggingConfigurationSchedulerLogsPtrInput is an input type that accepts EnvironmentLoggingConfigurationSchedulerLogsArgs, EnvironmentLoggingConfigurationSchedulerLogsPtr and EnvironmentLoggingConfigurationSchedulerLogsPtrOutput values.
// You can construct a concrete instance of `EnvironmentLoggingConfigurationSchedulerLogsPtrInput` via:
//
//          EnvironmentLoggingConfigurationSchedulerLogsArgs{...}
//
//  or:
//
//          nil
type EnvironmentLoggingConfigurationSchedulerLogsPtrInput interface {
	pulumi.Input

	ToEnvironmentLoggingConfigurationSchedulerLogsPtrOutput() EnvironmentLoggingConfigurationSchedulerLogsPtrOutput
	ToEnvironmentLoggingConfigurationSchedulerLogsPtrOutputWithContext(context.Context) EnvironmentLoggingConfigurationSchedulerLogsPtrOutput
}

type environmentLoggingConfigurationSchedulerLogsPtrType EnvironmentLoggingConfigurationSchedulerLogsArgs

func EnvironmentLoggingConfigurationSchedulerLogsPtr(v *EnvironmentLoggingConfigurationSchedulerLogsArgs) EnvironmentLoggingConfigurationSchedulerLogsPtrInput {
	return (*environmentLoggingConfigurationSchedulerLogsPtrType)(v)
}

func (*environmentLoggingConfigurationSchedulerLogsPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**EnvironmentLoggingConfigurationSchedulerLogs)(nil)).Elem()
}

func (i *environmentLoggingConfigurationSchedulerLogsPtrType) ToEnvironmentLoggingConfigurationSchedulerLogsPtrOutput() EnvironmentLoggingConfigurationSchedulerLogsPtrOutput {
	return i.ToEnvironmentLoggingConfigurationSchedulerLogsPtrOutputWithContext(context.Background())
}

func (i *environmentLoggingConfigurationSchedulerLogsPtrType) ToEnvironmentLoggingConfigurationSchedulerLogsPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationSchedulerLogsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLoggingConfigurationSchedulerLogsPtrOutput)
}

type EnvironmentLoggingConfigurationSchedulerLogsOutput struct{ *pulumi.OutputState }

func (EnvironmentLoggingConfigurationSchedulerLogsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*EnvironmentLoggingConfigurationSchedulerLogs)(nil)).Elem()
}

func (o EnvironmentLoggingConfigurationSchedulerLogsOutput) ToEnvironmentLoggingConfigurationSchedulerLogsOutput() EnvironmentLoggingConfigurationSchedulerLogsOutput {
	return o
}

func (o EnvironmentLoggingConfigurationSchedulerLogsOutput) ToEnvironmentLoggingConfigurationSchedulerLogsOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationSchedulerLogsOutput {
	return o
}

func (o EnvironmentLoggingConfigurationSchedulerLogsOutput) ToEnvironmentLoggingConfigurationSchedulerLogsPtrOutput() EnvironmentLoggingConfigurationSchedulerLogsPtrOutput {
	return o.ToEnvironmentLoggingConfigurationSchedulerLogsPtrOutputWithContext(context.Background())
}

func (o EnvironmentLoggingConfigurationSchedulerLogsOutput) ToEnvironmentLoggingConfigurationSchedulerLogsPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationSchedulerLogsPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v EnvironmentLoggingConfigurationSchedulerLogs) *EnvironmentLoggingConfigurationSchedulerLogs {
		return &v
	}).(EnvironmentLoggingConfigurationSchedulerLogsPtrOutput)
}

func (o EnvironmentLoggingConfigurationSchedulerLogsOutput) CloudWatchLogGroupArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v EnvironmentLoggingConfigurationSchedulerLogs) *string { return v.CloudWatchLogGroupArn }).(pulumi.StringPtrOutput)
}

// Enabling or disabling the collection of logs
func (o EnvironmentLoggingConfigurationSchedulerLogsOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v EnvironmentLoggingConfigurationSchedulerLogs) *bool { return v.Enabled }).(pulumi.BoolPtrOutput)
}

// Logging level. Valid values: `CRITICAL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`. Will be `INFO` by default.
func (o EnvironmentLoggingConfigurationSchedulerLogsOutput) LogLevel() pulumi.StringPtrOutput {
	return o.ApplyT(func(v EnvironmentLoggingConfigurationSchedulerLogs) *string { return v.LogLevel }).(pulumi.StringPtrOutput)
}

type EnvironmentLoggingConfigurationSchedulerLogsPtrOutput struct{ *pulumi.OutputState }

func (EnvironmentLoggingConfigurationSchedulerLogsPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**EnvironmentLoggingConfigurationSchedulerLogs)(nil)).Elem()
}

func (o EnvironmentLoggingConfigurationSchedulerLogsPtrOutput) ToEnvironmentLoggingConfigurationSchedulerLogsPtrOutput() EnvironmentLoggingConfigurationSchedulerLogsPtrOutput {
	return o
}

func (o EnvironmentLoggingConfigurationSchedulerLogsPtrOutput) ToEnvironmentLoggingConfigurationSchedulerLogsPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationSchedulerLogsPtrOutput {
	return o
}

func (o EnvironmentLoggingConfigurationSchedulerLogsPtrOutput) Elem() EnvironmentLoggingConfigurationSchedulerLogsOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfigurationSchedulerLogs) EnvironmentLoggingConfigurationSchedulerLogs {
		if v != nil {
			return *v
		}
		var ret EnvironmentLoggingConfigurationSchedulerLogs
		return ret
	}).(EnvironmentLoggingConfigurationSchedulerLogsOutput)
}

func (o EnvironmentLoggingConfigurationSchedulerLogsPtrOutput) CloudWatchLogGroupArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfigurationSchedulerLogs) *string {
		if v == nil {
			return nil
		}
		return v.CloudWatchLogGroupArn
	}).(pulumi.StringPtrOutput)
}

// Enabling or disabling the collection of logs
func (o EnvironmentLoggingConfigurationSchedulerLogsPtrOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfigurationSchedulerLogs) *bool {
		if v == nil {
			return nil
		}
		return v.Enabled
	}).(pulumi.BoolPtrOutput)
}

// Logging level. Valid values: `CRITICAL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`. Will be `INFO` by default.
func (o EnvironmentLoggingConfigurationSchedulerLogsPtrOutput) LogLevel() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfigurationSchedulerLogs) *string {
		if v == nil {
			return nil
		}
		return v.LogLevel
	}).(pulumi.StringPtrOutput)
}

type EnvironmentLoggingConfigurationTaskLogs struct {
	CloudWatchLogGroupArn *string `pulumi:"cloudWatchLogGroupArn"`
	// Enabling or disabling the collection of logs
	Enabled *bool `pulumi:"enabled"`
	// Logging level. Valid values: `CRITICAL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`. Will be `INFO` by default.
	LogLevel *string `pulumi:"logLevel"`
}

// EnvironmentLoggingConfigurationTaskLogsInput is an input type that accepts EnvironmentLoggingConfigurationTaskLogsArgs and EnvironmentLoggingConfigurationTaskLogsOutput values.
// You can construct a concrete instance of `EnvironmentLoggingConfigurationTaskLogsInput` via:
//
//          EnvironmentLoggingConfigurationTaskLogsArgs{...}
type EnvironmentLoggingConfigurationTaskLogsInput interface {
	pulumi.Input

	ToEnvironmentLoggingConfigurationTaskLogsOutput() EnvironmentLoggingConfigurationTaskLogsOutput
	ToEnvironmentLoggingConfigurationTaskLogsOutputWithContext(context.Context) EnvironmentLoggingConfigurationTaskLogsOutput
}

type EnvironmentLoggingConfigurationTaskLogsArgs struct {
	CloudWatchLogGroupArn pulumi.StringPtrInput `pulumi:"cloudWatchLogGroupArn"`
	// Enabling or disabling the collection of logs
	Enabled pulumi.BoolPtrInput `pulumi:"enabled"`
	// Logging level. Valid values: `CRITICAL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`. Will be `INFO` by default.
	LogLevel pulumi.StringPtrInput `pulumi:"logLevel"`
}

func (EnvironmentLoggingConfigurationTaskLogsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*EnvironmentLoggingConfigurationTaskLogs)(nil)).Elem()
}

func (i EnvironmentLoggingConfigurationTaskLogsArgs) ToEnvironmentLoggingConfigurationTaskLogsOutput() EnvironmentLoggingConfigurationTaskLogsOutput {
	return i.ToEnvironmentLoggingConfigurationTaskLogsOutputWithContext(context.Background())
}

func (i EnvironmentLoggingConfigurationTaskLogsArgs) ToEnvironmentLoggingConfigurationTaskLogsOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationTaskLogsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLoggingConfigurationTaskLogsOutput)
}

func (i EnvironmentLoggingConfigurationTaskLogsArgs) ToEnvironmentLoggingConfigurationTaskLogsPtrOutput() EnvironmentLoggingConfigurationTaskLogsPtrOutput {
	return i.ToEnvironmentLoggingConfigurationTaskLogsPtrOutputWithContext(context.Background())
}

func (i EnvironmentLoggingConfigurationTaskLogsArgs) ToEnvironmentLoggingConfigurationTaskLogsPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationTaskLogsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLoggingConfigurationTaskLogsOutput).ToEnvironmentLoggingConfigurationTaskLogsPtrOutputWithContext(ctx)
}

// EnvironmentLoggingConfigurationTaskLogsPtrInput is an input type that accepts EnvironmentLoggingConfigurationTaskLogsArgs, EnvironmentLoggingConfigurationTaskLogsPtr and EnvironmentLoggingConfigurationTaskLogsPtrOutput values.
// You can construct a concrete instance of `EnvironmentLoggingConfigurationTaskLogsPtrInput` via:
//
//          EnvironmentLoggingConfigurationTaskLogsArgs{...}
//
//  or:
//
//          nil
type EnvironmentLoggingConfigurationTaskLogsPtrInput interface {
	pulumi.Input

	ToEnvironmentLoggingConfigurationTaskLogsPtrOutput() EnvironmentLoggingConfigurationTaskLogsPtrOutput
	ToEnvironmentLoggingConfigurationTaskLogsPtrOutputWithContext(context.Context) EnvironmentLoggingConfigurationTaskLogsPtrOutput
}

type environmentLoggingConfigurationTaskLogsPtrType EnvironmentLoggingConfigurationTaskLogsArgs

func EnvironmentLoggingConfigurationTaskLogsPtr(v *EnvironmentLoggingConfigurationTaskLogsArgs) EnvironmentLoggingConfigurationTaskLogsPtrInput {
	return (*environmentLoggingConfigurationTaskLogsPtrType)(v)
}

func (*environmentLoggingConfigurationTaskLogsPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**EnvironmentLoggingConfigurationTaskLogs)(nil)).Elem()
}

func (i *environmentLoggingConfigurationTaskLogsPtrType) ToEnvironmentLoggingConfigurationTaskLogsPtrOutput() EnvironmentLoggingConfigurationTaskLogsPtrOutput {
	return i.ToEnvironmentLoggingConfigurationTaskLogsPtrOutputWithContext(context.Background())
}

func (i *environmentLoggingConfigurationTaskLogsPtrType) ToEnvironmentLoggingConfigurationTaskLogsPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationTaskLogsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLoggingConfigurationTaskLogsPtrOutput)
}

type EnvironmentLoggingConfigurationTaskLogsOutput struct{ *pulumi.OutputState }

func (EnvironmentLoggingConfigurationTaskLogsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*EnvironmentLoggingConfigurationTaskLogs)(nil)).Elem()
}

func (o EnvironmentLoggingConfigurationTaskLogsOutput) ToEnvironmentLoggingConfigurationTaskLogsOutput() EnvironmentLoggingConfigurationTaskLogsOutput {
	return o
}

func (o EnvironmentLoggingConfigurationTaskLogsOutput) ToEnvironmentLoggingConfigurationTaskLogsOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationTaskLogsOutput {
	return o
}

func (o EnvironmentLoggingConfigurationTaskLogsOutput) ToEnvironmentLoggingConfigurationTaskLogsPtrOutput() EnvironmentLoggingConfigurationTaskLogsPtrOutput {
	return o.ToEnvironmentLoggingConfigurationTaskLogsPtrOutputWithContext(context.Background())
}

func (o EnvironmentLoggingConfigurationTaskLogsOutput) ToEnvironmentLoggingConfigurationTaskLogsPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationTaskLogsPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v EnvironmentLoggingConfigurationTaskLogs) *EnvironmentLoggingConfigurationTaskLogs {
		return &v
	}).(EnvironmentLoggingConfigurationTaskLogsPtrOutput)
}

func (o EnvironmentLoggingConfigurationTaskLogsOutput) CloudWatchLogGroupArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v EnvironmentLoggingConfigurationTaskLogs) *string { return v.CloudWatchLogGroupArn }).(pulumi.StringPtrOutput)
}

// Enabling or disabling the collection of logs
func (o EnvironmentLoggingConfigurationTaskLogsOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v EnvironmentLoggingConfigurationTaskLogs) *bool { return v.Enabled }).(pulumi.BoolPtrOutput)
}

// Logging level. Valid values: `CRITICAL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`. Will be `INFO` by default.
func (o EnvironmentLoggingConfigurationTaskLogsOutput) LogLevel() pulumi.StringPtrOutput {
	return o.ApplyT(func(v EnvironmentLoggingConfigurationTaskLogs) *string { return v.LogLevel }).(pulumi.StringPtrOutput)
}

type EnvironmentLoggingConfigurationTaskLogsPtrOutput struct{ *pulumi.OutputState }

func (EnvironmentLoggingConfigurationTaskLogsPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**EnvironmentLoggingConfigurationTaskLogs)(nil)).Elem()
}

func (o EnvironmentLoggingConfigurationTaskLogsPtrOutput) ToEnvironmentLoggingConfigurationTaskLogsPtrOutput() EnvironmentLoggingConfigurationTaskLogsPtrOutput {
	return o
}

func (o EnvironmentLoggingConfigurationTaskLogsPtrOutput) ToEnvironmentLoggingConfigurationTaskLogsPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationTaskLogsPtrOutput {
	return o
}

func (o EnvironmentLoggingConfigurationTaskLogsPtrOutput) Elem() EnvironmentLoggingConfigurationTaskLogsOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfigurationTaskLogs) EnvironmentLoggingConfigurationTaskLogs {
		if v != nil {
			return *v
		}
		var ret EnvironmentLoggingConfigurationTaskLogs
		return ret
	}).(EnvironmentLoggingConfigurationTaskLogsOutput)
}

func (o EnvironmentLoggingConfigurationTaskLogsPtrOutput) CloudWatchLogGroupArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfigurationTaskLogs) *string {
		if v == nil {
			return nil
		}
		return v.CloudWatchLogGroupArn
	}).(pulumi.StringPtrOutput)
}

// Enabling or disabling the collection of logs
func (o EnvironmentLoggingConfigurationTaskLogsPtrOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfigurationTaskLogs) *bool {
		if v == nil {
			return nil
		}
		return v.Enabled
	}).(pulumi.BoolPtrOutput)
}

// Logging level. Valid values: `CRITICAL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`. Will be `INFO` by default.
func (o EnvironmentLoggingConfigurationTaskLogsPtrOutput) LogLevel() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfigurationTaskLogs) *string {
		if v == nil {
			return nil
		}
		return v.LogLevel
	}).(pulumi.StringPtrOutput)
}

type EnvironmentLoggingConfigurationWebserverLogs struct {
	CloudWatchLogGroupArn *string `pulumi:"cloudWatchLogGroupArn"`
	// Enabling or disabling the collection of logs
	Enabled *bool `pulumi:"enabled"`
	// Logging level. Valid values: `CRITICAL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`. Will be `INFO` by default.
	LogLevel *string `pulumi:"logLevel"`
}

// EnvironmentLoggingConfigurationWebserverLogsInput is an input type that accepts EnvironmentLoggingConfigurationWebserverLogsArgs and EnvironmentLoggingConfigurationWebserverLogsOutput values.
// You can construct a concrete instance of `EnvironmentLoggingConfigurationWebserverLogsInput` via:
//
//          EnvironmentLoggingConfigurationWebserverLogsArgs{...}
type EnvironmentLoggingConfigurationWebserverLogsInput interface {
	pulumi.Input

	ToEnvironmentLoggingConfigurationWebserverLogsOutput() EnvironmentLoggingConfigurationWebserverLogsOutput
	ToEnvironmentLoggingConfigurationWebserverLogsOutputWithContext(context.Context) EnvironmentLoggingConfigurationWebserverLogsOutput
}

type EnvironmentLoggingConfigurationWebserverLogsArgs struct {
	CloudWatchLogGroupArn pulumi.StringPtrInput `pulumi:"cloudWatchLogGroupArn"`
	// Enabling or disabling the collection of logs
	Enabled pulumi.BoolPtrInput `pulumi:"enabled"`
	// Logging level. Valid values: `CRITICAL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`. Will be `INFO` by default.
	LogLevel pulumi.StringPtrInput `pulumi:"logLevel"`
}

func (EnvironmentLoggingConfigurationWebserverLogsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*EnvironmentLoggingConfigurationWebserverLogs)(nil)).Elem()
}

func (i EnvironmentLoggingConfigurationWebserverLogsArgs) ToEnvironmentLoggingConfigurationWebserverLogsOutput() EnvironmentLoggingConfigurationWebserverLogsOutput {
	return i.ToEnvironmentLoggingConfigurationWebserverLogsOutputWithContext(context.Background())
}

func (i EnvironmentLoggingConfigurationWebserverLogsArgs) ToEnvironmentLoggingConfigurationWebserverLogsOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationWebserverLogsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLoggingConfigurationWebserverLogsOutput)
}

func (i EnvironmentLoggingConfigurationWebserverLogsArgs) ToEnvironmentLoggingConfigurationWebserverLogsPtrOutput() EnvironmentLoggingConfigurationWebserverLogsPtrOutput {
	return i.ToEnvironmentLoggingConfigurationWebserverLogsPtrOutputWithContext(context.Background())
}

func (i EnvironmentLoggingConfigurationWebserverLogsArgs) ToEnvironmentLoggingConfigurationWebserverLogsPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationWebserverLogsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLoggingConfigurationWebserverLogsOutput).ToEnvironmentLoggingConfigurationWebserverLogsPtrOutputWithContext(ctx)
}

// EnvironmentLoggingConfigurationWebserverLogsPtrInput is an input type that accepts EnvironmentLoggingConfigurationWebserverLogsArgs, EnvironmentLoggingConfigurationWebserverLogsPtr and EnvironmentLoggingConfigurationWebserverLogsPtrOutput values.
// You can construct a concrete instance of `EnvironmentLoggingConfigurationWebserverLogsPtrInput` via:
//
//          EnvironmentLoggingConfigurationWebserverLogsArgs{...}
//
//  or:
//
//          nil
type EnvironmentLoggingConfigurationWebserverLogsPtrInput interface {
	pulumi.Input

	ToEnvironmentLoggingConfigurationWebserverLogsPtrOutput() EnvironmentLoggingConfigurationWebserverLogsPtrOutput
	ToEnvironmentLoggingConfigurationWebserverLogsPtrOutputWithContext(context.Context) EnvironmentLoggingConfigurationWebserverLogsPtrOutput
}

type environmentLoggingConfigurationWebserverLogsPtrType EnvironmentLoggingConfigurationWebserverLogsArgs

func EnvironmentLoggingConfigurationWebserverLogsPtr(v *EnvironmentLoggingConfigurationWebserverLogsArgs) EnvironmentLoggingConfigurationWebserverLogsPtrInput {
	return (*environmentLoggingConfigurationWebserverLogsPtrType)(v)
}

func (*environmentLoggingConfigurationWebserverLogsPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**EnvironmentLoggingConfigurationWebserverLogs)(nil)).Elem()
}

func (i *environmentLoggingConfigurationWebserverLogsPtrType) ToEnvironmentLoggingConfigurationWebserverLogsPtrOutput() EnvironmentLoggingConfigurationWebserverLogsPtrOutput {
	return i.ToEnvironmentLoggingConfigurationWebserverLogsPtrOutputWithContext(context.Background())
}

func (i *environmentLoggingConfigurationWebserverLogsPtrType) ToEnvironmentLoggingConfigurationWebserverLogsPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationWebserverLogsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLoggingConfigurationWebserverLogsPtrOutput)
}

type EnvironmentLoggingConfigurationWebserverLogsOutput struct{ *pulumi.OutputState }

func (EnvironmentLoggingConfigurationWebserverLogsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*EnvironmentLoggingConfigurationWebserverLogs)(nil)).Elem()
}

func (o EnvironmentLoggingConfigurationWebserverLogsOutput) ToEnvironmentLoggingConfigurationWebserverLogsOutput() EnvironmentLoggingConfigurationWebserverLogsOutput {
	return o
}

func (o EnvironmentLoggingConfigurationWebserverLogsOutput) ToEnvironmentLoggingConfigurationWebserverLogsOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationWebserverLogsOutput {
	return o
}

func (o EnvironmentLoggingConfigurationWebserverLogsOutput) ToEnvironmentLoggingConfigurationWebserverLogsPtrOutput() EnvironmentLoggingConfigurationWebserverLogsPtrOutput {
	return o.ToEnvironmentLoggingConfigurationWebserverLogsPtrOutputWithContext(context.Background())
}

func (o EnvironmentLoggingConfigurationWebserverLogsOutput) ToEnvironmentLoggingConfigurationWebserverLogsPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationWebserverLogsPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v EnvironmentLoggingConfigurationWebserverLogs) *EnvironmentLoggingConfigurationWebserverLogs {
		return &v
	}).(EnvironmentLoggingConfigurationWebserverLogsPtrOutput)
}

func (o EnvironmentLoggingConfigurationWebserverLogsOutput) CloudWatchLogGroupArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v EnvironmentLoggingConfigurationWebserverLogs) *string { return v.CloudWatchLogGroupArn }).(pulumi.StringPtrOutput)
}

// Enabling or disabling the collection of logs
func (o EnvironmentLoggingConfigurationWebserverLogsOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v EnvironmentLoggingConfigurationWebserverLogs) *bool { return v.Enabled }).(pulumi.BoolPtrOutput)
}

// Logging level. Valid values: `CRITICAL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`. Will be `INFO` by default.
func (o EnvironmentLoggingConfigurationWebserverLogsOutput) LogLevel() pulumi.StringPtrOutput {
	return o.ApplyT(func(v EnvironmentLoggingConfigurationWebserverLogs) *string { return v.LogLevel }).(pulumi.StringPtrOutput)
}

type EnvironmentLoggingConfigurationWebserverLogsPtrOutput struct{ *pulumi.OutputState }

func (EnvironmentLoggingConfigurationWebserverLogsPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**EnvironmentLoggingConfigurationWebserverLogs)(nil)).Elem()
}

func (o EnvironmentLoggingConfigurationWebserverLogsPtrOutput) ToEnvironmentLoggingConfigurationWebserverLogsPtrOutput() EnvironmentLoggingConfigurationWebserverLogsPtrOutput {
	return o
}

func (o EnvironmentLoggingConfigurationWebserverLogsPtrOutput) ToEnvironmentLoggingConfigurationWebserverLogsPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationWebserverLogsPtrOutput {
	return o
}

func (o EnvironmentLoggingConfigurationWebserverLogsPtrOutput) Elem() EnvironmentLoggingConfigurationWebserverLogsOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfigurationWebserverLogs) EnvironmentLoggingConfigurationWebserverLogs {
		if v != nil {
			return *v
		}
		var ret EnvironmentLoggingConfigurationWebserverLogs
		return ret
	}).(EnvironmentLoggingConfigurationWebserverLogsOutput)
}

func (o EnvironmentLoggingConfigurationWebserverLogsPtrOutput) CloudWatchLogGroupArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfigurationWebserverLogs) *string {
		if v == nil {
			return nil
		}
		return v.CloudWatchLogGroupArn
	}).(pulumi.StringPtrOutput)
}

// Enabling or disabling the collection of logs
func (o EnvironmentLoggingConfigurationWebserverLogsPtrOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfigurationWebserverLogs) *bool {
		if v == nil {
			return nil
		}
		return v.Enabled
	}).(pulumi.BoolPtrOutput)
}

// Logging level. Valid values: `CRITICAL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`. Will be `INFO` by default.
func (o EnvironmentLoggingConfigurationWebserverLogsPtrOutput) LogLevel() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfigurationWebserverLogs) *string {
		if v == nil {
			return nil
		}
		return v.LogLevel
	}).(pulumi.StringPtrOutput)
}

type EnvironmentLoggingConfigurationWorkerLogs struct {
	CloudWatchLogGroupArn *string `pulumi:"cloudWatchLogGroupArn"`
	// Enabling or disabling the collection of logs
	Enabled *bool `pulumi:"enabled"`
	// Logging level. Valid values: `CRITICAL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`. Will be `INFO` by default.
	LogLevel *string `pulumi:"logLevel"`
}

// EnvironmentLoggingConfigurationWorkerLogsInput is an input type that accepts EnvironmentLoggingConfigurationWorkerLogsArgs and EnvironmentLoggingConfigurationWorkerLogsOutput values.
// You can construct a concrete instance of `EnvironmentLoggingConfigurationWorkerLogsInput` via:
//
//          EnvironmentLoggingConfigurationWorkerLogsArgs{...}
type EnvironmentLoggingConfigurationWorkerLogsInput interface {
	pulumi.Input

	ToEnvironmentLoggingConfigurationWorkerLogsOutput() EnvironmentLoggingConfigurationWorkerLogsOutput
	ToEnvironmentLoggingConfigurationWorkerLogsOutputWithContext(context.Context) EnvironmentLoggingConfigurationWorkerLogsOutput
}

type EnvironmentLoggingConfigurationWorkerLogsArgs struct {
	CloudWatchLogGroupArn pulumi.StringPtrInput `pulumi:"cloudWatchLogGroupArn"`
	// Enabling or disabling the collection of logs
	Enabled pulumi.BoolPtrInput `pulumi:"enabled"`
	// Logging level. Valid values: `CRITICAL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`. Will be `INFO` by default.
	LogLevel pulumi.StringPtrInput `pulumi:"logLevel"`
}

func (EnvironmentLoggingConfigurationWorkerLogsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*EnvironmentLoggingConfigurationWorkerLogs)(nil)).Elem()
}

func (i EnvironmentLoggingConfigurationWorkerLogsArgs) ToEnvironmentLoggingConfigurationWorkerLogsOutput() EnvironmentLoggingConfigurationWorkerLogsOutput {
	return i.ToEnvironmentLoggingConfigurationWorkerLogsOutputWithContext(context.Background())
}

func (i EnvironmentLoggingConfigurationWorkerLogsArgs) ToEnvironmentLoggingConfigurationWorkerLogsOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationWorkerLogsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLoggingConfigurationWorkerLogsOutput)
}

func (i EnvironmentLoggingConfigurationWorkerLogsArgs) ToEnvironmentLoggingConfigurationWorkerLogsPtrOutput() EnvironmentLoggingConfigurationWorkerLogsPtrOutput {
	return i.ToEnvironmentLoggingConfigurationWorkerLogsPtrOutputWithContext(context.Background())
}

func (i EnvironmentLoggingConfigurationWorkerLogsArgs) ToEnvironmentLoggingConfigurationWorkerLogsPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationWorkerLogsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLoggingConfigurationWorkerLogsOutput).ToEnvironmentLoggingConfigurationWorkerLogsPtrOutputWithContext(ctx)
}

// EnvironmentLoggingConfigurationWorkerLogsPtrInput is an input type that accepts EnvironmentLoggingConfigurationWorkerLogsArgs, EnvironmentLoggingConfigurationWorkerLogsPtr and EnvironmentLoggingConfigurationWorkerLogsPtrOutput values.
// You can construct a concrete instance of `EnvironmentLoggingConfigurationWorkerLogsPtrInput` via:
//
//          EnvironmentLoggingConfigurationWorkerLogsArgs{...}
//
//  or:
//
//          nil
type EnvironmentLoggingConfigurationWorkerLogsPtrInput interface {
	pulumi.Input

	ToEnvironmentLoggingConfigurationWorkerLogsPtrOutput() EnvironmentLoggingConfigurationWorkerLogsPtrOutput
	ToEnvironmentLoggingConfigurationWorkerLogsPtrOutputWithContext(context.Context) EnvironmentLoggingConfigurationWorkerLogsPtrOutput
}

type environmentLoggingConfigurationWorkerLogsPtrType EnvironmentLoggingConfigurationWorkerLogsArgs

func EnvironmentLoggingConfigurationWorkerLogsPtr(v *EnvironmentLoggingConfigurationWorkerLogsArgs) EnvironmentLoggingConfigurationWorkerLogsPtrInput {
	return (*environmentLoggingConfigurationWorkerLogsPtrType)(v)
}

func (*environmentLoggingConfigurationWorkerLogsPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**EnvironmentLoggingConfigurationWorkerLogs)(nil)).Elem()
}

func (i *environmentLoggingConfigurationWorkerLogsPtrType) ToEnvironmentLoggingConfigurationWorkerLogsPtrOutput() EnvironmentLoggingConfigurationWorkerLogsPtrOutput {
	return i.ToEnvironmentLoggingConfigurationWorkerLogsPtrOutputWithContext(context.Background())
}

func (i *environmentLoggingConfigurationWorkerLogsPtrType) ToEnvironmentLoggingConfigurationWorkerLogsPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationWorkerLogsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentLoggingConfigurationWorkerLogsPtrOutput)
}

type EnvironmentLoggingConfigurationWorkerLogsOutput struct{ *pulumi.OutputState }

func (EnvironmentLoggingConfigurationWorkerLogsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*EnvironmentLoggingConfigurationWorkerLogs)(nil)).Elem()
}

func (o EnvironmentLoggingConfigurationWorkerLogsOutput) ToEnvironmentLoggingConfigurationWorkerLogsOutput() EnvironmentLoggingConfigurationWorkerLogsOutput {
	return o
}

func (o EnvironmentLoggingConfigurationWorkerLogsOutput) ToEnvironmentLoggingConfigurationWorkerLogsOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationWorkerLogsOutput {
	return o
}

func (o EnvironmentLoggingConfigurationWorkerLogsOutput) ToEnvironmentLoggingConfigurationWorkerLogsPtrOutput() EnvironmentLoggingConfigurationWorkerLogsPtrOutput {
	return o.ToEnvironmentLoggingConfigurationWorkerLogsPtrOutputWithContext(context.Background())
}

func (o EnvironmentLoggingConfigurationWorkerLogsOutput) ToEnvironmentLoggingConfigurationWorkerLogsPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationWorkerLogsPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v EnvironmentLoggingConfigurationWorkerLogs) *EnvironmentLoggingConfigurationWorkerLogs {
		return &v
	}).(EnvironmentLoggingConfigurationWorkerLogsPtrOutput)
}

func (o EnvironmentLoggingConfigurationWorkerLogsOutput) CloudWatchLogGroupArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v EnvironmentLoggingConfigurationWorkerLogs) *string { return v.CloudWatchLogGroupArn }).(pulumi.StringPtrOutput)
}

// Enabling or disabling the collection of logs
func (o EnvironmentLoggingConfigurationWorkerLogsOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v EnvironmentLoggingConfigurationWorkerLogs) *bool { return v.Enabled }).(pulumi.BoolPtrOutput)
}

// Logging level. Valid values: `CRITICAL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`. Will be `INFO` by default.
func (o EnvironmentLoggingConfigurationWorkerLogsOutput) LogLevel() pulumi.StringPtrOutput {
	return o.ApplyT(func(v EnvironmentLoggingConfigurationWorkerLogs) *string { return v.LogLevel }).(pulumi.StringPtrOutput)
}

type EnvironmentLoggingConfigurationWorkerLogsPtrOutput struct{ *pulumi.OutputState }

func (EnvironmentLoggingConfigurationWorkerLogsPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**EnvironmentLoggingConfigurationWorkerLogs)(nil)).Elem()
}

func (o EnvironmentLoggingConfigurationWorkerLogsPtrOutput) ToEnvironmentLoggingConfigurationWorkerLogsPtrOutput() EnvironmentLoggingConfigurationWorkerLogsPtrOutput {
	return o
}

func (o EnvironmentLoggingConfigurationWorkerLogsPtrOutput) ToEnvironmentLoggingConfigurationWorkerLogsPtrOutputWithContext(ctx context.Context) EnvironmentLoggingConfigurationWorkerLogsPtrOutput {
	return o
}

func (o EnvironmentLoggingConfigurationWorkerLogsPtrOutput) Elem() EnvironmentLoggingConfigurationWorkerLogsOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfigurationWorkerLogs) EnvironmentLoggingConfigurationWorkerLogs {
		if v != nil {
			return *v
		}
		var ret EnvironmentLoggingConfigurationWorkerLogs
		return ret
	}).(EnvironmentLoggingConfigurationWorkerLogsOutput)
}

func (o EnvironmentLoggingConfigurationWorkerLogsPtrOutput) CloudWatchLogGroupArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfigurationWorkerLogs) *string {
		if v == nil {
			return nil
		}
		return v.CloudWatchLogGroupArn
	}).(pulumi.StringPtrOutput)
}

// Enabling or disabling the collection of logs
func (o EnvironmentLoggingConfigurationWorkerLogsPtrOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfigurationWorkerLogs) *bool {
		if v == nil {
			return nil
		}
		return v.Enabled
	}).(pulumi.BoolPtrOutput)
}

// Logging level. Valid values: `CRITICAL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`. Will be `INFO` by default.
func (o EnvironmentLoggingConfigurationWorkerLogsPtrOutput) LogLevel() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *EnvironmentLoggingConfigurationWorkerLogs) *string {
		if v == nil {
			return nil
		}
		return v.LogLevel
	}).(pulumi.StringPtrOutput)
}

type EnvironmentNetworkConfiguration struct {
	// Security groups IDs for the environment. At least one of the security group needs to allow MWAA resources to talk to each other, otherwise MWAA cannot be provisioned.
	SecurityGroupIds []string `pulumi:"securityGroupIds"`
	// The private subnet IDs in which the environment should be created. MWAA requires two subnets.
	SubnetIds []string `pulumi:"subnetIds"`
}

// EnvironmentNetworkConfigurationInput is an input type that accepts EnvironmentNetworkConfigurationArgs and EnvironmentNetworkConfigurationOutput values.
// You can construct a concrete instance of `EnvironmentNetworkConfigurationInput` via:
//
//          EnvironmentNetworkConfigurationArgs{...}
type EnvironmentNetworkConfigurationInput interface {
	pulumi.Input

	ToEnvironmentNetworkConfigurationOutput() EnvironmentNetworkConfigurationOutput
	ToEnvironmentNetworkConfigurationOutputWithContext(context.Context) EnvironmentNetworkConfigurationOutput
}

type EnvironmentNetworkConfigurationArgs struct {
	// Security groups IDs for the environment. At least one of the security group needs to allow MWAA resources to talk to each other, otherwise MWAA cannot be provisioned.
	SecurityGroupIds pulumi.StringArrayInput `pulumi:"securityGroupIds"`
	// The private subnet IDs in which the environment should be created. MWAA requires two subnets.
	SubnetIds pulumi.StringArrayInput `pulumi:"subnetIds"`
}

func (EnvironmentNetworkConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*EnvironmentNetworkConfiguration)(nil)).Elem()
}

func (i EnvironmentNetworkConfigurationArgs) ToEnvironmentNetworkConfigurationOutput() EnvironmentNetworkConfigurationOutput {
	return i.ToEnvironmentNetworkConfigurationOutputWithContext(context.Background())
}

func (i EnvironmentNetworkConfigurationArgs) ToEnvironmentNetworkConfigurationOutputWithContext(ctx context.Context) EnvironmentNetworkConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentNetworkConfigurationOutput)
}

func (i EnvironmentNetworkConfigurationArgs) ToEnvironmentNetworkConfigurationPtrOutput() EnvironmentNetworkConfigurationPtrOutput {
	return i.ToEnvironmentNetworkConfigurationPtrOutputWithContext(context.Background())
}

func (i EnvironmentNetworkConfigurationArgs) ToEnvironmentNetworkConfigurationPtrOutputWithContext(ctx context.Context) EnvironmentNetworkConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentNetworkConfigurationOutput).ToEnvironmentNetworkConfigurationPtrOutputWithContext(ctx)
}

// EnvironmentNetworkConfigurationPtrInput is an input type that accepts EnvironmentNetworkConfigurationArgs, EnvironmentNetworkConfigurationPtr and EnvironmentNetworkConfigurationPtrOutput values.
// You can construct a concrete instance of `EnvironmentNetworkConfigurationPtrInput` via:
//
//          EnvironmentNetworkConfigurationArgs{...}
//
//  or:
//
//          nil
type EnvironmentNetworkConfigurationPtrInput interface {
	pulumi.Input

	ToEnvironmentNetworkConfigurationPtrOutput() EnvironmentNetworkConfigurationPtrOutput
	ToEnvironmentNetworkConfigurationPtrOutputWithContext(context.Context) EnvironmentNetworkConfigurationPtrOutput
}

type environmentNetworkConfigurationPtrType EnvironmentNetworkConfigurationArgs

func EnvironmentNetworkConfigurationPtr(v *EnvironmentNetworkConfigurationArgs) EnvironmentNetworkConfigurationPtrInput {
	return (*environmentNetworkConfigurationPtrType)(v)
}

func (*environmentNetworkConfigurationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**EnvironmentNetworkConfiguration)(nil)).Elem()
}

func (i *environmentNetworkConfigurationPtrType) ToEnvironmentNetworkConfigurationPtrOutput() EnvironmentNetworkConfigurationPtrOutput {
	return i.ToEnvironmentNetworkConfigurationPtrOutputWithContext(context.Background())
}

func (i *environmentNetworkConfigurationPtrType) ToEnvironmentNetworkConfigurationPtrOutputWithContext(ctx context.Context) EnvironmentNetworkConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(EnvironmentNetworkConfigurationPtrOutput)
}

type EnvironmentNetworkConfigurationOutput struct{ *pulumi.OutputState }

func (EnvironmentNetworkConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*EnvironmentNetworkConfiguration)(nil)).Elem()
}

func (o EnvironmentNetworkConfigurationOutput) ToEnvironmentNetworkConfigurationOutput() EnvironmentNetworkConfigurationOutput {
	return o
}

func (o EnvironmentNetworkConfigurationOutput) ToEnvironmentNetworkConfigurationOutputWithContext(ctx context.Context) EnvironmentNetworkConfigurationOutput {
	return o
}

func (o EnvironmentNetworkConfigurationOutput) ToEnvironmentNetworkConfigurationPtrOutput() EnvironmentNetworkConfigurationPtrOutput {
	return o.ToEnvironmentNetworkConfigurationPtrOutputWithContext(context.Background())
}

func (o EnvironmentNetworkConfigurationOutput) ToEnvironmentNetworkConfigurationPtrOutputWithContext(ctx context.Context) EnvironmentNetworkConfigurationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v EnvironmentNetworkConfiguration) *EnvironmentNetworkConfiguration {
		return &v
	}).(EnvironmentNetworkConfigurationPtrOutput)
}

// Security groups IDs for the environment. At least one of the security group needs to allow MWAA resources to talk to each other, otherwise MWAA cannot be provisioned.
func (o EnvironmentNetworkConfigurationOutput) SecurityGroupIds() pulumi.StringArrayOutput {
	return o.ApplyT(func(v EnvironmentNetworkConfiguration) []string { return v.SecurityGroupIds }).(pulumi.StringArrayOutput)
}

// The private subnet IDs in which the environment should be created. MWAA requires two subnets.
func (o EnvironmentNetworkConfigurationOutput) SubnetIds() pulumi.StringArrayOutput {
	return o.ApplyT(func(v EnvironmentNetworkConfiguration) []string { return v.SubnetIds }).(pulumi.StringArrayOutput)
}

type EnvironmentNetworkConfigurationPtrOutput struct{ *pulumi.OutputState }

func (EnvironmentNetworkConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**EnvironmentNetworkConfiguration)(nil)).Elem()
}

func (o EnvironmentNetworkConfigurationPtrOutput) ToEnvironmentNetworkConfigurationPtrOutput() EnvironmentNetworkConfigurationPtrOutput {
	return o
}

func (o EnvironmentNetworkConfigurationPtrOutput) ToEnvironmentNetworkConfigurationPtrOutputWithContext(ctx context.Context) EnvironmentNetworkConfigurationPtrOutput {
	return o
}

func (o EnvironmentNetworkConfigurationPtrOutput) Elem() EnvironmentNetworkConfigurationOutput {
	return o.ApplyT(func(v *EnvironmentNetworkConfiguration) EnvironmentNetworkConfiguration {
		if v != nil {
			return *v
		}
		var ret EnvironmentNetworkConfiguration
		return ret
	}).(EnvironmentNetworkConfigurationOutput)
}

// Security groups IDs for the environment. At least one of the security group needs to allow MWAA resources to talk to each other, otherwise MWAA cannot be provisioned.
func (o EnvironmentNetworkConfigurationPtrOutput) SecurityGroupIds() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *EnvironmentNetworkConfiguration) []string {
		if v == nil {
			return nil
		}
		return v.SecurityGroupIds
	}).(pulumi.StringArrayOutput)
}

// The private subnet IDs in which the environment should be created. MWAA requires two subnets.
func (o EnvironmentNetworkConfigurationPtrOutput) SubnetIds() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *EnvironmentNetworkConfiguration) []string {
		if v == nil {
			return nil
		}
		return v.SubnetIds
	}).(pulumi.StringArrayOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*EnvironmentLastUpdatedInput)(nil)).Elem(), EnvironmentLastUpdatedArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*EnvironmentLastUpdatedArrayInput)(nil)).Elem(), EnvironmentLastUpdatedArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*EnvironmentLastUpdatedErrorInput)(nil)).Elem(), EnvironmentLastUpdatedErrorArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*EnvironmentLastUpdatedErrorArrayInput)(nil)).Elem(), EnvironmentLastUpdatedErrorArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*EnvironmentLoggingConfigurationInput)(nil)).Elem(), EnvironmentLoggingConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*EnvironmentLoggingConfigurationPtrInput)(nil)).Elem(), EnvironmentLoggingConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*EnvironmentLoggingConfigurationDagProcessingLogsInput)(nil)).Elem(), EnvironmentLoggingConfigurationDagProcessingLogsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*EnvironmentLoggingConfigurationDagProcessingLogsPtrInput)(nil)).Elem(), EnvironmentLoggingConfigurationDagProcessingLogsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*EnvironmentLoggingConfigurationSchedulerLogsInput)(nil)).Elem(), EnvironmentLoggingConfigurationSchedulerLogsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*EnvironmentLoggingConfigurationSchedulerLogsPtrInput)(nil)).Elem(), EnvironmentLoggingConfigurationSchedulerLogsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*EnvironmentLoggingConfigurationTaskLogsInput)(nil)).Elem(), EnvironmentLoggingConfigurationTaskLogsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*EnvironmentLoggingConfigurationTaskLogsPtrInput)(nil)).Elem(), EnvironmentLoggingConfigurationTaskLogsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*EnvironmentLoggingConfigurationWebserverLogsInput)(nil)).Elem(), EnvironmentLoggingConfigurationWebserverLogsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*EnvironmentLoggingConfigurationWebserverLogsPtrInput)(nil)).Elem(), EnvironmentLoggingConfigurationWebserverLogsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*EnvironmentLoggingConfigurationWorkerLogsInput)(nil)).Elem(), EnvironmentLoggingConfigurationWorkerLogsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*EnvironmentLoggingConfigurationWorkerLogsPtrInput)(nil)).Elem(), EnvironmentLoggingConfigurationWorkerLogsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*EnvironmentNetworkConfigurationInput)(nil)).Elem(), EnvironmentNetworkConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*EnvironmentNetworkConfigurationPtrInput)(nil)).Elem(), EnvironmentNetworkConfigurationArgs{})
	pulumi.RegisterOutputType(EnvironmentLastUpdatedOutput{})
	pulumi.RegisterOutputType(EnvironmentLastUpdatedArrayOutput{})
	pulumi.RegisterOutputType(EnvironmentLastUpdatedErrorOutput{})
	pulumi.RegisterOutputType(EnvironmentLastUpdatedErrorArrayOutput{})
	pulumi.RegisterOutputType(EnvironmentLoggingConfigurationOutput{})
	pulumi.RegisterOutputType(EnvironmentLoggingConfigurationPtrOutput{})
	pulumi.RegisterOutputType(EnvironmentLoggingConfigurationDagProcessingLogsOutput{})
	pulumi.RegisterOutputType(EnvironmentLoggingConfigurationDagProcessingLogsPtrOutput{})
	pulumi.RegisterOutputType(EnvironmentLoggingConfigurationSchedulerLogsOutput{})
	pulumi.RegisterOutputType(EnvironmentLoggingConfigurationSchedulerLogsPtrOutput{})
	pulumi.RegisterOutputType(EnvironmentLoggingConfigurationTaskLogsOutput{})
	pulumi.RegisterOutputType(EnvironmentLoggingConfigurationTaskLogsPtrOutput{})
	pulumi.RegisterOutputType(EnvironmentLoggingConfigurationWebserverLogsOutput{})
	pulumi.RegisterOutputType(EnvironmentLoggingConfigurationWebserverLogsPtrOutput{})
	pulumi.RegisterOutputType(EnvironmentLoggingConfigurationWorkerLogsOutput{})
	pulumi.RegisterOutputType(EnvironmentLoggingConfigurationWorkerLogsPtrOutput{})
	pulumi.RegisterOutputType(EnvironmentNetworkConfigurationOutput{})
	pulumi.RegisterOutputType(EnvironmentNetworkConfigurationPtrOutput{})
}