pulumiTypes.go

// Code generated by pulumi-language-go DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package apprunner

import (
	"context"
	"reflect"

	"github.com/pulumi/pulumi-aws-native/sdk/go/aws/internal"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

var _ = internal.GetEnvOrDefault

type AutoScalingConfigurationTag struct {
	Key   *string `pulumi:"key"`
	Value *string `pulumi:"value"`
}

type ObservabilityConfigurationTag struct {
	Key   *string `pulumi:"key"`
	Value *string `pulumi:"value"`
}

// Describes the configuration of the tracing feature within an AWS App Runner observability configuration.
type ObservabilityConfigurationTraceConfiguration struct {
	// The implementation provider chosen for tracing App Runner services.
	Vendor ObservabilityConfigurationTraceConfigurationVendor `pulumi:"vendor"`
}

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

	ToObservabilityConfigurationTraceConfigurationOutput() ObservabilityConfigurationTraceConfigurationOutput
	ToObservabilityConfigurationTraceConfigurationOutputWithContext(context.Context) ObservabilityConfigurationTraceConfigurationOutput
}

// Describes the configuration of the tracing feature within an AWS App Runner observability configuration.
type ObservabilityConfigurationTraceConfigurationArgs struct {
	// The implementation provider chosen for tracing App Runner services.
	Vendor ObservabilityConfigurationTraceConfigurationVendorInput `pulumi:"vendor"`
}

func (ObservabilityConfigurationTraceConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ObservabilityConfigurationTraceConfiguration)(nil)).Elem()
}

func (i ObservabilityConfigurationTraceConfigurationArgs) ToObservabilityConfigurationTraceConfigurationOutput() ObservabilityConfigurationTraceConfigurationOutput {
	return i.ToObservabilityConfigurationTraceConfigurationOutputWithContext(context.Background())
}

func (i ObservabilityConfigurationTraceConfigurationArgs) ToObservabilityConfigurationTraceConfigurationOutputWithContext(ctx context.Context) ObservabilityConfigurationTraceConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ObservabilityConfigurationTraceConfigurationOutput)
}

func (i ObservabilityConfigurationTraceConfigurationArgs) ToObservabilityConfigurationTraceConfigurationPtrOutput() ObservabilityConfigurationTraceConfigurationPtrOutput {
	return i.ToObservabilityConfigurationTraceConfigurationPtrOutputWithContext(context.Background())
}

func (i ObservabilityConfigurationTraceConfigurationArgs) ToObservabilityConfigurationTraceConfigurationPtrOutputWithContext(ctx context.Context) ObservabilityConfigurationTraceConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ObservabilityConfigurationTraceConfigurationOutput).ToObservabilityConfigurationTraceConfigurationPtrOutputWithContext(ctx)
}

// ObservabilityConfigurationTraceConfigurationPtrInput is an input type that accepts ObservabilityConfigurationTraceConfigurationArgs, ObservabilityConfigurationTraceConfigurationPtr and ObservabilityConfigurationTraceConfigurationPtrOutput values.
// You can construct a concrete instance of `ObservabilityConfigurationTraceConfigurationPtrInput` via:
//
//	        ObservabilityConfigurationTraceConfigurationArgs{...}
//
//	or:
//
//	        nil
type ObservabilityConfigurationTraceConfigurationPtrInput interface {
	pulumi.Input

	ToObservabilityConfigurationTraceConfigurationPtrOutput() ObservabilityConfigurationTraceConfigurationPtrOutput
	ToObservabilityConfigurationTraceConfigurationPtrOutputWithContext(context.Context) ObservabilityConfigurationTraceConfigurationPtrOutput
}

type observabilityConfigurationTraceConfigurationPtrType ObservabilityConfigurationTraceConfigurationArgs

func ObservabilityConfigurationTraceConfigurationPtr(v *ObservabilityConfigurationTraceConfigurationArgs) ObservabilityConfigurationTraceConfigurationPtrInput {
	return (*observabilityConfigurationTraceConfigurationPtrType)(v)
}

func (*observabilityConfigurationTraceConfigurationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ObservabilityConfigurationTraceConfiguration)(nil)).Elem()
}

func (i *observabilityConfigurationTraceConfigurationPtrType) ToObservabilityConfigurationTraceConfigurationPtrOutput() ObservabilityConfigurationTraceConfigurationPtrOutput {
	return i.ToObservabilityConfigurationTraceConfigurationPtrOutputWithContext(context.Background())
}

func (i *observabilityConfigurationTraceConfigurationPtrType) ToObservabilityConfigurationTraceConfigurationPtrOutputWithContext(ctx context.Context) ObservabilityConfigurationTraceConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ObservabilityConfigurationTraceConfigurationPtrOutput)
}

// Describes the configuration of the tracing feature within an AWS App Runner observability configuration.
type ObservabilityConfigurationTraceConfigurationOutput struct{ *pulumi.OutputState }

func (ObservabilityConfigurationTraceConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ObservabilityConfigurationTraceConfiguration)(nil)).Elem()
}

func (o ObservabilityConfigurationTraceConfigurationOutput) ToObservabilityConfigurationTraceConfigurationOutput() ObservabilityConfigurationTraceConfigurationOutput {
	return o
}

func (o ObservabilityConfigurationTraceConfigurationOutput) ToObservabilityConfigurationTraceConfigurationOutputWithContext(ctx context.Context) ObservabilityConfigurationTraceConfigurationOutput {
	return o
}

func (o ObservabilityConfigurationTraceConfigurationOutput) ToObservabilityConfigurationTraceConfigurationPtrOutput() ObservabilityConfigurationTraceConfigurationPtrOutput {
	return o.ToObservabilityConfigurationTraceConfigurationPtrOutputWithContext(context.Background())
}

func (o ObservabilityConfigurationTraceConfigurationOutput) ToObservabilityConfigurationTraceConfigurationPtrOutputWithContext(ctx context.Context) ObservabilityConfigurationTraceConfigurationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ObservabilityConfigurationTraceConfiguration) *ObservabilityConfigurationTraceConfiguration {
		return &v
	}).(ObservabilityConfigurationTraceConfigurationPtrOutput)
}

// The implementation provider chosen for tracing App Runner services.
func (o ObservabilityConfigurationTraceConfigurationOutput) Vendor() ObservabilityConfigurationTraceConfigurationVendorOutput {
	return o.ApplyT(func(v ObservabilityConfigurationTraceConfiguration) ObservabilityConfigurationTraceConfigurationVendor {
		return v.Vendor
	}).(ObservabilityConfigurationTraceConfigurationVendorOutput)
}

type ObservabilityConfigurationTraceConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ObservabilityConfigurationTraceConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ObservabilityConfigurationTraceConfiguration)(nil)).Elem()
}

func (o ObservabilityConfigurationTraceConfigurationPtrOutput) ToObservabilityConfigurationTraceConfigurationPtrOutput() ObservabilityConfigurationTraceConfigurationPtrOutput {
	return o
}

func (o ObservabilityConfigurationTraceConfigurationPtrOutput) ToObservabilityConfigurationTraceConfigurationPtrOutputWithContext(ctx context.Context) ObservabilityConfigurationTraceConfigurationPtrOutput {
	return o
}

func (o ObservabilityConfigurationTraceConfigurationPtrOutput) Elem() ObservabilityConfigurationTraceConfigurationOutput {
	return o.ApplyT(func(v *ObservabilityConfigurationTraceConfiguration) ObservabilityConfigurationTraceConfiguration {
		if v != nil {
			return *v
		}
		var ret ObservabilityConfigurationTraceConfiguration
		return ret
	}).(ObservabilityConfigurationTraceConfigurationOutput)
}

// The implementation provider chosen for tracing App Runner services.
func (o ObservabilityConfigurationTraceConfigurationPtrOutput) Vendor() ObservabilityConfigurationTraceConfigurationVendorPtrOutput {
	return o.ApplyT(func(v *ObservabilityConfigurationTraceConfiguration) *ObservabilityConfigurationTraceConfigurationVendor {
		if v == nil {
			return nil
		}
		return &v.Vendor
	}).(ObservabilityConfigurationTraceConfigurationVendorPtrOutput)
}

// Authentication Configuration
type ServiceAuthenticationConfiguration struct {
	// Access Role Arn
	AccessRoleArn *string `pulumi:"accessRoleArn"`
	// Connection Arn
	ConnectionArn *string `pulumi:"connectionArn"`
}

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

	ToServiceAuthenticationConfigurationOutput() ServiceAuthenticationConfigurationOutput
	ToServiceAuthenticationConfigurationOutputWithContext(context.Context) ServiceAuthenticationConfigurationOutput
}

// Authentication Configuration
type ServiceAuthenticationConfigurationArgs struct {
	// Access Role Arn
	AccessRoleArn pulumi.StringPtrInput `pulumi:"accessRoleArn"`
	// Connection Arn
	ConnectionArn pulumi.StringPtrInput `pulumi:"connectionArn"`
}

func (ServiceAuthenticationConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceAuthenticationConfiguration)(nil)).Elem()
}

func (i ServiceAuthenticationConfigurationArgs) ToServiceAuthenticationConfigurationOutput() ServiceAuthenticationConfigurationOutput {
	return i.ToServiceAuthenticationConfigurationOutputWithContext(context.Background())
}

func (i ServiceAuthenticationConfigurationArgs) ToServiceAuthenticationConfigurationOutputWithContext(ctx context.Context) ServiceAuthenticationConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceAuthenticationConfigurationOutput)
}

func (i ServiceAuthenticationConfigurationArgs) ToServiceAuthenticationConfigurationPtrOutput() ServiceAuthenticationConfigurationPtrOutput {
	return i.ToServiceAuthenticationConfigurationPtrOutputWithContext(context.Background())
}

func (i ServiceAuthenticationConfigurationArgs) ToServiceAuthenticationConfigurationPtrOutputWithContext(ctx context.Context) ServiceAuthenticationConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceAuthenticationConfigurationOutput).ToServiceAuthenticationConfigurationPtrOutputWithContext(ctx)
}

// ServiceAuthenticationConfigurationPtrInput is an input type that accepts ServiceAuthenticationConfigurationArgs, ServiceAuthenticationConfigurationPtr and ServiceAuthenticationConfigurationPtrOutput values.
// You can construct a concrete instance of `ServiceAuthenticationConfigurationPtrInput` via:
//
//	        ServiceAuthenticationConfigurationArgs{...}
//
//	or:
//
//	        nil
type ServiceAuthenticationConfigurationPtrInput interface {
	pulumi.Input

	ToServiceAuthenticationConfigurationPtrOutput() ServiceAuthenticationConfigurationPtrOutput
	ToServiceAuthenticationConfigurationPtrOutputWithContext(context.Context) ServiceAuthenticationConfigurationPtrOutput
}

type serviceAuthenticationConfigurationPtrType ServiceAuthenticationConfigurationArgs

func ServiceAuthenticationConfigurationPtr(v *ServiceAuthenticationConfigurationArgs) ServiceAuthenticationConfigurationPtrInput {
	return (*serviceAuthenticationConfigurationPtrType)(v)
}

func (*serviceAuthenticationConfigurationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceAuthenticationConfiguration)(nil)).Elem()
}

func (i *serviceAuthenticationConfigurationPtrType) ToServiceAuthenticationConfigurationPtrOutput() ServiceAuthenticationConfigurationPtrOutput {
	return i.ToServiceAuthenticationConfigurationPtrOutputWithContext(context.Background())
}

func (i *serviceAuthenticationConfigurationPtrType) ToServiceAuthenticationConfigurationPtrOutputWithContext(ctx context.Context) ServiceAuthenticationConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceAuthenticationConfigurationPtrOutput)
}

// Authentication Configuration
type ServiceAuthenticationConfigurationOutput struct{ *pulumi.OutputState }

func (ServiceAuthenticationConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceAuthenticationConfiguration)(nil)).Elem()
}

func (o ServiceAuthenticationConfigurationOutput) ToServiceAuthenticationConfigurationOutput() ServiceAuthenticationConfigurationOutput {
	return o
}

func (o ServiceAuthenticationConfigurationOutput) ToServiceAuthenticationConfigurationOutputWithContext(ctx context.Context) ServiceAuthenticationConfigurationOutput {
	return o
}

func (o ServiceAuthenticationConfigurationOutput) ToServiceAuthenticationConfigurationPtrOutput() ServiceAuthenticationConfigurationPtrOutput {
	return o.ToServiceAuthenticationConfigurationPtrOutputWithContext(context.Background())
}

func (o ServiceAuthenticationConfigurationOutput) ToServiceAuthenticationConfigurationPtrOutputWithContext(ctx context.Context) ServiceAuthenticationConfigurationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ServiceAuthenticationConfiguration) *ServiceAuthenticationConfiguration {
		return &v
	}).(ServiceAuthenticationConfigurationPtrOutput)
}

// Access Role Arn
func (o ServiceAuthenticationConfigurationOutput) AccessRoleArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceAuthenticationConfiguration) *string { return v.AccessRoleArn }).(pulumi.StringPtrOutput)
}

// Connection Arn
func (o ServiceAuthenticationConfigurationOutput) ConnectionArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceAuthenticationConfiguration) *string { return v.ConnectionArn }).(pulumi.StringPtrOutput)
}

type ServiceAuthenticationConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ServiceAuthenticationConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceAuthenticationConfiguration)(nil)).Elem()
}

func (o ServiceAuthenticationConfigurationPtrOutput) ToServiceAuthenticationConfigurationPtrOutput() ServiceAuthenticationConfigurationPtrOutput {
	return o
}

func (o ServiceAuthenticationConfigurationPtrOutput) ToServiceAuthenticationConfigurationPtrOutputWithContext(ctx context.Context) ServiceAuthenticationConfigurationPtrOutput {
	return o
}

func (o ServiceAuthenticationConfigurationPtrOutput) Elem() ServiceAuthenticationConfigurationOutput {
	return o.ApplyT(func(v *ServiceAuthenticationConfiguration) ServiceAuthenticationConfiguration {
		if v != nil {
			return *v
		}
		var ret ServiceAuthenticationConfiguration
		return ret
	}).(ServiceAuthenticationConfigurationOutput)
}

// Access Role Arn
func (o ServiceAuthenticationConfigurationPtrOutput) AccessRoleArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceAuthenticationConfiguration) *string {
		if v == nil {
			return nil
		}
		return v.AccessRoleArn
	}).(pulumi.StringPtrOutput)
}

// Connection Arn
func (o ServiceAuthenticationConfigurationPtrOutput) ConnectionArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceAuthenticationConfiguration) *string {
		if v == nil {
			return nil
		}
		return v.ConnectionArn
	}).(pulumi.StringPtrOutput)
}

// Code Configuration
type ServiceCodeConfiguration struct {
	CodeConfigurationValues *ServiceCodeConfigurationValues `pulumi:"codeConfigurationValues"`
	// Configuration Source
	ConfigurationSource ServiceCodeConfigurationConfigurationSource `pulumi:"configurationSource"`
}

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

	ToServiceCodeConfigurationOutput() ServiceCodeConfigurationOutput
	ToServiceCodeConfigurationOutputWithContext(context.Context) ServiceCodeConfigurationOutput
}

// Code Configuration
type ServiceCodeConfigurationArgs struct {
	CodeConfigurationValues ServiceCodeConfigurationValuesPtrInput `pulumi:"codeConfigurationValues"`
	// Configuration Source
	ConfigurationSource ServiceCodeConfigurationConfigurationSourceInput `pulumi:"configurationSource"`
}

func (ServiceCodeConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceCodeConfiguration)(nil)).Elem()
}

func (i ServiceCodeConfigurationArgs) ToServiceCodeConfigurationOutput() ServiceCodeConfigurationOutput {
	return i.ToServiceCodeConfigurationOutputWithContext(context.Background())
}

func (i ServiceCodeConfigurationArgs) ToServiceCodeConfigurationOutputWithContext(ctx context.Context) ServiceCodeConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceCodeConfigurationOutput)
}

func (i ServiceCodeConfigurationArgs) ToServiceCodeConfigurationPtrOutput() ServiceCodeConfigurationPtrOutput {
	return i.ToServiceCodeConfigurationPtrOutputWithContext(context.Background())
}

func (i ServiceCodeConfigurationArgs) ToServiceCodeConfigurationPtrOutputWithContext(ctx context.Context) ServiceCodeConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceCodeConfigurationOutput).ToServiceCodeConfigurationPtrOutputWithContext(ctx)
}

// ServiceCodeConfigurationPtrInput is an input type that accepts ServiceCodeConfigurationArgs, ServiceCodeConfigurationPtr and ServiceCodeConfigurationPtrOutput values.
// You can construct a concrete instance of `ServiceCodeConfigurationPtrInput` via:
//
//	        ServiceCodeConfigurationArgs{...}
//
//	or:
//
//	        nil
type ServiceCodeConfigurationPtrInput interface {
	pulumi.Input

	ToServiceCodeConfigurationPtrOutput() ServiceCodeConfigurationPtrOutput
	ToServiceCodeConfigurationPtrOutputWithContext(context.Context) ServiceCodeConfigurationPtrOutput
}

type serviceCodeConfigurationPtrType ServiceCodeConfigurationArgs

func ServiceCodeConfigurationPtr(v *ServiceCodeConfigurationArgs) ServiceCodeConfigurationPtrInput {
	return (*serviceCodeConfigurationPtrType)(v)
}

func (*serviceCodeConfigurationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceCodeConfiguration)(nil)).Elem()
}

func (i *serviceCodeConfigurationPtrType) ToServiceCodeConfigurationPtrOutput() ServiceCodeConfigurationPtrOutput {
	return i.ToServiceCodeConfigurationPtrOutputWithContext(context.Background())
}

func (i *serviceCodeConfigurationPtrType) ToServiceCodeConfigurationPtrOutputWithContext(ctx context.Context) ServiceCodeConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceCodeConfigurationPtrOutput)
}

// Code Configuration
type ServiceCodeConfigurationOutput struct{ *pulumi.OutputState }

func (ServiceCodeConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceCodeConfiguration)(nil)).Elem()
}

func (o ServiceCodeConfigurationOutput) ToServiceCodeConfigurationOutput() ServiceCodeConfigurationOutput {
	return o
}

func (o ServiceCodeConfigurationOutput) ToServiceCodeConfigurationOutputWithContext(ctx context.Context) ServiceCodeConfigurationOutput {
	return o
}

func (o ServiceCodeConfigurationOutput) ToServiceCodeConfigurationPtrOutput() ServiceCodeConfigurationPtrOutput {
	return o.ToServiceCodeConfigurationPtrOutputWithContext(context.Background())
}

func (o ServiceCodeConfigurationOutput) ToServiceCodeConfigurationPtrOutputWithContext(ctx context.Context) ServiceCodeConfigurationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ServiceCodeConfiguration) *ServiceCodeConfiguration {
		return &v
	}).(ServiceCodeConfigurationPtrOutput)
}

func (o ServiceCodeConfigurationOutput) CodeConfigurationValues() ServiceCodeConfigurationValuesPtrOutput {
	return o.ApplyT(func(v ServiceCodeConfiguration) *ServiceCodeConfigurationValues { return v.CodeConfigurationValues }).(ServiceCodeConfigurationValuesPtrOutput)
}

// Configuration Source
func (o ServiceCodeConfigurationOutput) ConfigurationSource() ServiceCodeConfigurationConfigurationSourceOutput {
	return o.ApplyT(func(v ServiceCodeConfiguration) ServiceCodeConfigurationConfigurationSource {
		return v.ConfigurationSource
	}).(ServiceCodeConfigurationConfigurationSourceOutput)
}

type ServiceCodeConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ServiceCodeConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceCodeConfiguration)(nil)).Elem()
}

func (o ServiceCodeConfigurationPtrOutput) ToServiceCodeConfigurationPtrOutput() ServiceCodeConfigurationPtrOutput {
	return o
}

func (o ServiceCodeConfigurationPtrOutput) ToServiceCodeConfigurationPtrOutputWithContext(ctx context.Context) ServiceCodeConfigurationPtrOutput {
	return o
}

func (o ServiceCodeConfigurationPtrOutput) Elem() ServiceCodeConfigurationOutput {
	return o.ApplyT(func(v *ServiceCodeConfiguration) ServiceCodeConfiguration {
		if v != nil {
			return *v
		}
		var ret ServiceCodeConfiguration
		return ret
	}).(ServiceCodeConfigurationOutput)
}

func (o ServiceCodeConfigurationPtrOutput) CodeConfigurationValues() ServiceCodeConfigurationValuesPtrOutput {
	return o.ApplyT(func(v *ServiceCodeConfiguration) *ServiceCodeConfigurationValues {
		if v == nil {
			return nil
		}
		return v.CodeConfigurationValues
	}).(ServiceCodeConfigurationValuesPtrOutput)
}

// Configuration Source
func (o ServiceCodeConfigurationPtrOutput) ConfigurationSource() ServiceCodeConfigurationConfigurationSourcePtrOutput {
	return o.ApplyT(func(v *ServiceCodeConfiguration) *ServiceCodeConfigurationConfigurationSource {
		if v == nil {
			return nil
		}
		return &v.ConfigurationSource
	}).(ServiceCodeConfigurationConfigurationSourcePtrOutput)
}

// Code Configuration Values
type ServiceCodeConfigurationValues struct {
	// Build Command
	BuildCommand *string `pulumi:"buildCommand"`
	// Port
	Port *string `pulumi:"port"`
	// Runtime
	Runtime ServiceCodeConfigurationValuesRuntime `pulumi:"runtime"`
	// The secrets and parameters that get referenced by your service as environment variables
	RuntimeEnvironmentSecrets   []ServiceKeyValuePair `pulumi:"runtimeEnvironmentSecrets"`
	RuntimeEnvironmentVariables []ServiceKeyValuePair `pulumi:"runtimeEnvironmentVariables"`
	// Start Command
	StartCommand *string `pulumi:"startCommand"`
}

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

	ToServiceCodeConfigurationValuesOutput() ServiceCodeConfigurationValuesOutput
	ToServiceCodeConfigurationValuesOutputWithContext(context.Context) ServiceCodeConfigurationValuesOutput
}

// Code Configuration Values
type ServiceCodeConfigurationValuesArgs struct {
	// Build Command
	BuildCommand pulumi.StringPtrInput `pulumi:"buildCommand"`
	// Port
	Port pulumi.StringPtrInput `pulumi:"port"`
	// Runtime
	Runtime ServiceCodeConfigurationValuesRuntimeInput `pulumi:"runtime"`
	// The secrets and parameters that get referenced by your service as environment variables
	RuntimeEnvironmentSecrets   ServiceKeyValuePairArrayInput `pulumi:"runtimeEnvironmentSecrets"`
	RuntimeEnvironmentVariables ServiceKeyValuePairArrayInput `pulumi:"runtimeEnvironmentVariables"`
	// Start Command
	StartCommand pulumi.StringPtrInput `pulumi:"startCommand"`
}

func (ServiceCodeConfigurationValuesArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceCodeConfigurationValues)(nil)).Elem()
}

func (i ServiceCodeConfigurationValuesArgs) ToServiceCodeConfigurationValuesOutput() ServiceCodeConfigurationValuesOutput {
	return i.ToServiceCodeConfigurationValuesOutputWithContext(context.Background())
}

func (i ServiceCodeConfigurationValuesArgs) ToServiceCodeConfigurationValuesOutputWithContext(ctx context.Context) ServiceCodeConfigurationValuesOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceCodeConfigurationValuesOutput)
}

func (i ServiceCodeConfigurationValuesArgs) ToServiceCodeConfigurationValuesPtrOutput() ServiceCodeConfigurationValuesPtrOutput {
	return i.ToServiceCodeConfigurationValuesPtrOutputWithContext(context.Background())
}

func (i ServiceCodeConfigurationValuesArgs) ToServiceCodeConfigurationValuesPtrOutputWithContext(ctx context.Context) ServiceCodeConfigurationValuesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceCodeConfigurationValuesOutput).ToServiceCodeConfigurationValuesPtrOutputWithContext(ctx)
}

// ServiceCodeConfigurationValuesPtrInput is an input type that accepts ServiceCodeConfigurationValuesArgs, ServiceCodeConfigurationValuesPtr and ServiceCodeConfigurationValuesPtrOutput values.
// You can construct a concrete instance of `ServiceCodeConfigurationValuesPtrInput` via:
//
//	        ServiceCodeConfigurationValuesArgs{...}
//
//	or:
//
//	        nil
type ServiceCodeConfigurationValuesPtrInput interface {
	pulumi.Input

	ToServiceCodeConfigurationValuesPtrOutput() ServiceCodeConfigurationValuesPtrOutput
	ToServiceCodeConfigurationValuesPtrOutputWithContext(context.Context) ServiceCodeConfigurationValuesPtrOutput
}

type serviceCodeConfigurationValuesPtrType ServiceCodeConfigurationValuesArgs

func ServiceCodeConfigurationValuesPtr(v *ServiceCodeConfigurationValuesArgs) ServiceCodeConfigurationValuesPtrInput {
	return (*serviceCodeConfigurationValuesPtrType)(v)
}

func (*serviceCodeConfigurationValuesPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceCodeConfigurationValues)(nil)).Elem()
}

func (i *serviceCodeConfigurationValuesPtrType) ToServiceCodeConfigurationValuesPtrOutput() ServiceCodeConfigurationValuesPtrOutput {
	return i.ToServiceCodeConfigurationValuesPtrOutputWithContext(context.Background())
}

func (i *serviceCodeConfigurationValuesPtrType) ToServiceCodeConfigurationValuesPtrOutputWithContext(ctx context.Context) ServiceCodeConfigurationValuesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceCodeConfigurationValuesPtrOutput)
}

// Code Configuration Values
type ServiceCodeConfigurationValuesOutput struct{ *pulumi.OutputState }

func (ServiceCodeConfigurationValuesOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceCodeConfigurationValues)(nil)).Elem()
}

func (o ServiceCodeConfigurationValuesOutput) ToServiceCodeConfigurationValuesOutput() ServiceCodeConfigurationValuesOutput {
	return o
}

func (o ServiceCodeConfigurationValuesOutput) ToServiceCodeConfigurationValuesOutputWithContext(ctx context.Context) ServiceCodeConfigurationValuesOutput {
	return o
}

func (o ServiceCodeConfigurationValuesOutput) ToServiceCodeConfigurationValuesPtrOutput() ServiceCodeConfigurationValuesPtrOutput {
	return o.ToServiceCodeConfigurationValuesPtrOutputWithContext(context.Background())
}

func (o ServiceCodeConfigurationValuesOutput) ToServiceCodeConfigurationValuesPtrOutputWithContext(ctx context.Context) ServiceCodeConfigurationValuesPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ServiceCodeConfigurationValues) *ServiceCodeConfigurationValues {
		return &v
	}).(ServiceCodeConfigurationValuesPtrOutput)
}

// Build Command
func (o ServiceCodeConfigurationValuesOutput) BuildCommand() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceCodeConfigurationValues) *string { return v.BuildCommand }).(pulumi.StringPtrOutput)
}

// Port
func (o ServiceCodeConfigurationValuesOutput) Port() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceCodeConfigurationValues) *string { return v.Port }).(pulumi.StringPtrOutput)
}

// Runtime
func (o ServiceCodeConfigurationValuesOutput) Runtime() ServiceCodeConfigurationValuesRuntimeOutput {
	return o.ApplyT(func(v ServiceCodeConfigurationValues) ServiceCodeConfigurationValuesRuntime { return v.Runtime }).(ServiceCodeConfigurationValuesRuntimeOutput)
}

// The secrets and parameters that get referenced by your service as environment variables
func (o ServiceCodeConfigurationValuesOutput) RuntimeEnvironmentSecrets() ServiceKeyValuePairArrayOutput {
	return o.ApplyT(func(v ServiceCodeConfigurationValues) []ServiceKeyValuePair { return v.RuntimeEnvironmentSecrets }).(ServiceKeyValuePairArrayOutput)
}

func (o ServiceCodeConfigurationValuesOutput) RuntimeEnvironmentVariables() ServiceKeyValuePairArrayOutput {
	return o.ApplyT(func(v ServiceCodeConfigurationValues) []ServiceKeyValuePair { return v.RuntimeEnvironmentVariables }).(ServiceKeyValuePairArrayOutput)
}

// Start Command
func (o ServiceCodeConfigurationValuesOutput) StartCommand() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceCodeConfigurationValues) *string { return v.StartCommand }).(pulumi.StringPtrOutput)
}

type ServiceCodeConfigurationValuesPtrOutput struct{ *pulumi.OutputState }

func (ServiceCodeConfigurationValuesPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceCodeConfigurationValues)(nil)).Elem()
}

func (o ServiceCodeConfigurationValuesPtrOutput) ToServiceCodeConfigurationValuesPtrOutput() ServiceCodeConfigurationValuesPtrOutput {
	return o
}

func (o ServiceCodeConfigurationValuesPtrOutput) ToServiceCodeConfigurationValuesPtrOutputWithContext(ctx context.Context) ServiceCodeConfigurationValuesPtrOutput {
	return o
}

func (o ServiceCodeConfigurationValuesPtrOutput) Elem() ServiceCodeConfigurationValuesOutput {
	return o.ApplyT(func(v *ServiceCodeConfigurationValues) ServiceCodeConfigurationValues {
		if v != nil {
			return *v
		}
		var ret ServiceCodeConfigurationValues
		return ret
	}).(ServiceCodeConfigurationValuesOutput)
}

// Build Command
func (o ServiceCodeConfigurationValuesPtrOutput) BuildCommand() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceCodeConfigurationValues) *string {
		if v == nil {
			return nil
		}
		return v.BuildCommand
	}).(pulumi.StringPtrOutput)
}

// Port
func (o ServiceCodeConfigurationValuesPtrOutput) Port() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceCodeConfigurationValues) *string {
		if v == nil {
			return nil
		}
		return v.Port
	}).(pulumi.StringPtrOutput)
}

// Runtime
func (o ServiceCodeConfigurationValuesPtrOutput) Runtime() ServiceCodeConfigurationValuesRuntimePtrOutput {
	return o.ApplyT(func(v *ServiceCodeConfigurationValues) *ServiceCodeConfigurationValuesRuntime {
		if v == nil {
			return nil
		}
		return &v.Runtime
	}).(ServiceCodeConfigurationValuesRuntimePtrOutput)
}

// The secrets and parameters that get referenced by your service as environment variables
func (o ServiceCodeConfigurationValuesPtrOutput) RuntimeEnvironmentSecrets() ServiceKeyValuePairArrayOutput {
	return o.ApplyT(func(v *ServiceCodeConfigurationValues) []ServiceKeyValuePair {
		if v == nil {
			return nil
		}
		return v.RuntimeEnvironmentSecrets
	}).(ServiceKeyValuePairArrayOutput)
}

func (o ServiceCodeConfigurationValuesPtrOutput) RuntimeEnvironmentVariables() ServiceKeyValuePairArrayOutput {
	return o.ApplyT(func(v *ServiceCodeConfigurationValues) []ServiceKeyValuePair {
		if v == nil {
			return nil
		}
		return v.RuntimeEnvironmentVariables
	}).(ServiceKeyValuePairArrayOutput)
}

// Start Command
func (o ServiceCodeConfigurationValuesPtrOutput) StartCommand() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceCodeConfigurationValues) *string {
		if v == nil {
			return nil
		}
		return v.StartCommand
	}).(pulumi.StringPtrOutput)
}

// Source Code Repository
type ServiceCodeRepository struct {
	CodeConfiguration *ServiceCodeConfiguration `pulumi:"codeConfiguration"`
	// Repository Url
	RepositoryUrl     string                   `pulumi:"repositoryUrl"`
	SourceCodeVersion ServiceSourceCodeVersion `pulumi:"sourceCodeVersion"`
	// Source Directory
	SourceDirectory *string `pulumi:"sourceDirectory"`
}

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

	ToServiceCodeRepositoryOutput() ServiceCodeRepositoryOutput
	ToServiceCodeRepositoryOutputWithContext(context.Context) ServiceCodeRepositoryOutput
}

// Source Code Repository
type ServiceCodeRepositoryArgs struct {
	CodeConfiguration ServiceCodeConfigurationPtrInput `pulumi:"codeConfiguration"`
	// Repository Url
	RepositoryUrl     pulumi.StringInput            `pulumi:"repositoryUrl"`
	SourceCodeVersion ServiceSourceCodeVersionInput `pulumi:"sourceCodeVersion"`
	// Source Directory
	SourceDirectory pulumi.StringPtrInput `pulumi:"sourceDirectory"`
}

func (ServiceCodeRepositoryArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceCodeRepository)(nil)).Elem()
}

func (i ServiceCodeRepositoryArgs) ToServiceCodeRepositoryOutput() ServiceCodeRepositoryOutput {
	return i.ToServiceCodeRepositoryOutputWithContext(context.Background())
}

func (i ServiceCodeRepositoryArgs) ToServiceCodeRepositoryOutputWithContext(ctx context.Context) ServiceCodeRepositoryOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceCodeRepositoryOutput)
}

func (i ServiceCodeRepositoryArgs) ToServiceCodeRepositoryPtrOutput() ServiceCodeRepositoryPtrOutput {
	return i.ToServiceCodeRepositoryPtrOutputWithContext(context.Background())
}

func (i ServiceCodeRepositoryArgs) ToServiceCodeRepositoryPtrOutputWithContext(ctx context.Context) ServiceCodeRepositoryPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceCodeRepositoryOutput).ToServiceCodeRepositoryPtrOutputWithContext(ctx)
}

// ServiceCodeRepositoryPtrInput is an input type that accepts ServiceCodeRepositoryArgs, ServiceCodeRepositoryPtr and ServiceCodeRepositoryPtrOutput values.
// You can construct a concrete instance of `ServiceCodeRepositoryPtrInput` via:
//
//	        ServiceCodeRepositoryArgs{...}
//
//	or:
//
//	        nil
type ServiceCodeRepositoryPtrInput interface {
	pulumi.Input

	ToServiceCodeRepositoryPtrOutput() ServiceCodeRepositoryPtrOutput
	ToServiceCodeRepositoryPtrOutputWithContext(context.Context) ServiceCodeRepositoryPtrOutput
}

type serviceCodeRepositoryPtrType ServiceCodeRepositoryArgs

func ServiceCodeRepositoryPtr(v *ServiceCodeRepositoryArgs) ServiceCodeRepositoryPtrInput {
	return (*serviceCodeRepositoryPtrType)(v)
}

func (*serviceCodeRepositoryPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceCodeRepository)(nil)).Elem()
}

func (i *serviceCodeRepositoryPtrType) ToServiceCodeRepositoryPtrOutput() ServiceCodeRepositoryPtrOutput {
	return i.ToServiceCodeRepositoryPtrOutputWithContext(context.Background())
}

func (i *serviceCodeRepositoryPtrType) ToServiceCodeRepositoryPtrOutputWithContext(ctx context.Context) ServiceCodeRepositoryPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceCodeRepositoryPtrOutput)
}

// Source Code Repository
type ServiceCodeRepositoryOutput struct{ *pulumi.OutputState }

func (ServiceCodeRepositoryOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceCodeRepository)(nil)).Elem()
}

func (o ServiceCodeRepositoryOutput) ToServiceCodeRepositoryOutput() ServiceCodeRepositoryOutput {
	return o
}

func (o ServiceCodeRepositoryOutput) ToServiceCodeRepositoryOutputWithContext(ctx context.Context) ServiceCodeRepositoryOutput {
	return o
}

func (o ServiceCodeRepositoryOutput) ToServiceCodeRepositoryPtrOutput() ServiceCodeRepositoryPtrOutput {
	return o.ToServiceCodeRepositoryPtrOutputWithContext(context.Background())
}

func (o ServiceCodeRepositoryOutput) ToServiceCodeRepositoryPtrOutputWithContext(ctx context.Context) ServiceCodeRepositoryPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ServiceCodeRepository) *ServiceCodeRepository {
		return &v
	}).(ServiceCodeRepositoryPtrOutput)
}

func (o ServiceCodeRepositoryOutput) CodeConfiguration() ServiceCodeConfigurationPtrOutput {
	return o.ApplyT(func(v ServiceCodeRepository) *ServiceCodeConfiguration { return v.CodeConfiguration }).(ServiceCodeConfigurationPtrOutput)
}

// Repository Url
func (o ServiceCodeRepositoryOutput) RepositoryUrl() pulumi.StringOutput {
	return o.ApplyT(func(v ServiceCodeRepository) string { return v.RepositoryUrl }).(pulumi.StringOutput)
}

func (o ServiceCodeRepositoryOutput) SourceCodeVersion() ServiceSourceCodeVersionOutput {
	return o.ApplyT(func(v ServiceCodeRepository) ServiceSourceCodeVersion { return v.SourceCodeVersion }).(ServiceSourceCodeVersionOutput)
}

// Source Directory
func (o ServiceCodeRepositoryOutput) SourceDirectory() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceCodeRepository) *string { return v.SourceDirectory }).(pulumi.StringPtrOutput)
}

type ServiceCodeRepositoryPtrOutput struct{ *pulumi.OutputState }

func (ServiceCodeRepositoryPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceCodeRepository)(nil)).Elem()
}

func (o ServiceCodeRepositoryPtrOutput) ToServiceCodeRepositoryPtrOutput() ServiceCodeRepositoryPtrOutput {
	return o
}

func (o ServiceCodeRepositoryPtrOutput) ToServiceCodeRepositoryPtrOutputWithContext(ctx context.Context) ServiceCodeRepositoryPtrOutput {
	return o
}

func (o ServiceCodeRepositoryPtrOutput) Elem() ServiceCodeRepositoryOutput {
	return o.ApplyT(func(v *ServiceCodeRepository) ServiceCodeRepository {
		if v != nil {
			return *v
		}
		var ret ServiceCodeRepository
		return ret
	}).(ServiceCodeRepositoryOutput)
}

func (o ServiceCodeRepositoryPtrOutput) CodeConfiguration() ServiceCodeConfigurationPtrOutput {
	return o.ApplyT(func(v *ServiceCodeRepository) *ServiceCodeConfiguration {
		if v == nil {
			return nil
		}
		return v.CodeConfiguration
	}).(ServiceCodeConfigurationPtrOutput)
}

// Repository Url
func (o ServiceCodeRepositoryPtrOutput) RepositoryUrl() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceCodeRepository) *string {
		if v == nil {
			return nil
		}
		return &v.RepositoryUrl
	}).(pulumi.StringPtrOutput)
}

func (o ServiceCodeRepositoryPtrOutput) SourceCodeVersion() ServiceSourceCodeVersionPtrOutput {
	return o.ApplyT(func(v *ServiceCodeRepository) *ServiceSourceCodeVersion {
		if v == nil {
			return nil
		}
		return &v.SourceCodeVersion
	}).(ServiceSourceCodeVersionPtrOutput)
}

// Source Directory
func (o ServiceCodeRepositoryPtrOutput) SourceDirectory() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceCodeRepository) *string {
		if v == nil {
			return nil
		}
		return v.SourceDirectory
	}).(pulumi.StringPtrOutput)
}

// Network egress configuration
type ServiceEgressConfiguration struct {
	// Network egress type.
	EgressType ServiceEgressConfigurationEgressType `pulumi:"egressType"`
	// The Amazon Resource Name (ARN) of the App Runner VpcConnector.
	VpcConnectorArn *string `pulumi:"vpcConnectorArn"`
}

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

	ToServiceEgressConfigurationOutput() ServiceEgressConfigurationOutput
	ToServiceEgressConfigurationOutputWithContext(context.Context) ServiceEgressConfigurationOutput
}

// Network egress configuration
type ServiceEgressConfigurationArgs struct {
	// Network egress type.
	EgressType ServiceEgressConfigurationEgressTypeInput `pulumi:"egressType"`
	// The Amazon Resource Name (ARN) of the App Runner VpcConnector.
	VpcConnectorArn pulumi.StringPtrInput `pulumi:"vpcConnectorArn"`
}

func (ServiceEgressConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceEgressConfiguration)(nil)).Elem()
}

func (i ServiceEgressConfigurationArgs) ToServiceEgressConfigurationOutput() ServiceEgressConfigurationOutput {
	return i.ToServiceEgressConfigurationOutputWithContext(context.Background())
}

func (i ServiceEgressConfigurationArgs) ToServiceEgressConfigurationOutputWithContext(ctx context.Context) ServiceEgressConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceEgressConfigurationOutput)
}

func (i ServiceEgressConfigurationArgs) ToServiceEgressConfigurationPtrOutput() ServiceEgressConfigurationPtrOutput {
	return i.ToServiceEgressConfigurationPtrOutputWithContext(context.Background())
}

func (i ServiceEgressConfigurationArgs) ToServiceEgressConfigurationPtrOutputWithContext(ctx context.Context) ServiceEgressConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceEgressConfigurationOutput).ToServiceEgressConfigurationPtrOutputWithContext(ctx)
}

// ServiceEgressConfigurationPtrInput is an input type that accepts ServiceEgressConfigurationArgs, ServiceEgressConfigurationPtr and ServiceEgressConfigurationPtrOutput values.
// You can construct a concrete instance of `ServiceEgressConfigurationPtrInput` via:
//
//	        ServiceEgressConfigurationArgs{...}
//
//	or:
//
//	        nil
type ServiceEgressConfigurationPtrInput interface {
	pulumi.Input

	ToServiceEgressConfigurationPtrOutput() ServiceEgressConfigurationPtrOutput
	ToServiceEgressConfigurationPtrOutputWithContext(context.Context) ServiceEgressConfigurationPtrOutput
}

type serviceEgressConfigurationPtrType ServiceEgressConfigurationArgs

func ServiceEgressConfigurationPtr(v *ServiceEgressConfigurationArgs) ServiceEgressConfigurationPtrInput {
	return (*serviceEgressConfigurationPtrType)(v)
}

func (*serviceEgressConfigurationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceEgressConfiguration)(nil)).Elem()
}

func (i *serviceEgressConfigurationPtrType) ToServiceEgressConfigurationPtrOutput() ServiceEgressConfigurationPtrOutput {
	return i.ToServiceEgressConfigurationPtrOutputWithContext(context.Background())
}

func (i *serviceEgressConfigurationPtrType) ToServiceEgressConfigurationPtrOutputWithContext(ctx context.Context) ServiceEgressConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceEgressConfigurationPtrOutput)
}

// Network egress configuration
type ServiceEgressConfigurationOutput struct{ *pulumi.OutputState }

func (ServiceEgressConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceEgressConfiguration)(nil)).Elem()
}

func (o ServiceEgressConfigurationOutput) ToServiceEgressConfigurationOutput() ServiceEgressConfigurationOutput {
	return o
}

func (o ServiceEgressConfigurationOutput) ToServiceEgressConfigurationOutputWithContext(ctx context.Context) ServiceEgressConfigurationOutput {
	return o
}

func (o ServiceEgressConfigurationOutput) ToServiceEgressConfigurationPtrOutput() ServiceEgressConfigurationPtrOutput {
	return o.ToServiceEgressConfigurationPtrOutputWithContext(context.Background())
}

func (o ServiceEgressConfigurationOutput) ToServiceEgressConfigurationPtrOutputWithContext(ctx context.Context) ServiceEgressConfigurationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ServiceEgressConfiguration) *ServiceEgressConfiguration {
		return &v
	}).(ServiceEgressConfigurationPtrOutput)
}

// Network egress type.
func (o ServiceEgressConfigurationOutput) EgressType() ServiceEgressConfigurationEgressTypeOutput {
	return o.ApplyT(func(v ServiceEgressConfiguration) ServiceEgressConfigurationEgressType { return v.EgressType }).(ServiceEgressConfigurationEgressTypeOutput)
}

// The Amazon Resource Name (ARN) of the App Runner VpcConnector.
func (o ServiceEgressConfigurationOutput) VpcConnectorArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceEgressConfiguration) *string { return v.VpcConnectorArn }).(pulumi.StringPtrOutput)
}

type ServiceEgressConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ServiceEgressConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceEgressConfiguration)(nil)).Elem()
}

func (o ServiceEgressConfigurationPtrOutput) ToServiceEgressConfigurationPtrOutput() ServiceEgressConfigurationPtrOutput {
	return o
}

func (o ServiceEgressConfigurationPtrOutput) ToServiceEgressConfigurationPtrOutputWithContext(ctx context.Context) ServiceEgressConfigurationPtrOutput {
	return o
}

func (o ServiceEgressConfigurationPtrOutput) Elem() ServiceEgressConfigurationOutput {
	return o.ApplyT(func(v *ServiceEgressConfiguration) ServiceEgressConfiguration {
		if v != nil {
			return *v
		}
		var ret ServiceEgressConfiguration
		return ret
	}).(ServiceEgressConfigurationOutput)
}

// Network egress type.
func (o ServiceEgressConfigurationPtrOutput) EgressType() ServiceEgressConfigurationEgressTypePtrOutput {
	return o.ApplyT(func(v *ServiceEgressConfiguration) *ServiceEgressConfigurationEgressType {
		if v == nil {
			return nil
		}
		return &v.EgressType
	}).(ServiceEgressConfigurationEgressTypePtrOutput)
}

// The Amazon Resource Name (ARN) of the App Runner VpcConnector.
func (o ServiceEgressConfigurationPtrOutput) VpcConnectorArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceEgressConfiguration) *string {
		if v == nil {
			return nil
		}
		return v.VpcConnectorArn
	}).(pulumi.StringPtrOutput)
}

// Encryption configuration (KMS key)
type ServiceEncryptionConfiguration struct {
	// The KMS Key
	KmsKey string `pulumi:"kmsKey"`
}

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

	ToServiceEncryptionConfigurationOutput() ServiceEncryptionConfigurationOutput
	ToServiceEncryptionConfigurationOutputWithContext(context.Context) ServiceEncryptionConfigurationOutput
}

// Encryption configuration (KMS key)
type ServiceEncryptionConfigurationArgs struct {
	// The KMS Key
	KmsKey pulumi.StringInput `pulumi:"kmsKey"`
}

func (ServiceEncryptionConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceEncryptionConfiguration)(nil)).Elem()
}

func (i ServiceEncryptionConfigurationArgs) ToServiceEncryptionConfigurationOutput() ServiceEncryptionConfigurationOutput {
	return i.ToServiceEncryptionConfigurationOutputWithContext(context.Background())
}

func (i ServiceEncryptionConfigurationArgs) ToServiceEncryptionConfigurationOutputWithContext(ctx context.Context) ServiceEncryptionConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceEncryptionConfigurationOutput)
}

func (i ServiceEncryptionConfigurationArgs) ToServiceEncryptionConfigurationPtrOutput() ServiceEncryptionConfigurationPtrOutput {
	return i.ToServiceEncryptionConfigurationPtrOutputWithContext(context.Background())
}

func (i ServiceEncryptionConfigurationArgs) ToServiceEncryptionConfigurationPtrOutputWithContext(ctx context.Context) ServiceEncryptionConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceEncryptionConfigurationOutput).ToServiceEncryptionConfigurationPtrOutputWithContext(ctx)
}

// ServiceEncryptionConfigurationPtrInput is an input type that accepts ServiceEncryptionConfigurationArgs, ServiceEncryptionConfigurationPtr and ServiceEncryptionConfigurationPtrOutput values.
// You can construct a concrete instance of `ServiceEncryptionConfigurationPtrInput` via:
//
//	        ServiceEncryptionConfigurationArgs{...}
//
//	or:
//
//	        nil
type ServiceEncryptionConfigurationPtrInput interface {
	pulumi.Input

	ToServiceEncryptionConfigurationPtrOutput() ServiceEncryptionConfigurationPtrOutput
	ToServiceEncryptionConfigurationPtrOutputWithContext(context.Context) ServiceEncryptionConfigurationPtrOutput
}

type serviceEncryptionConfigurationPtrType ServiceEncryptionConfigurationArgs

func ServiceEncryptionConfigurationPtr(v *ServiceEncryptionConfigurationArgs) ServiceEncryptionConfigurationPtrInput {
	return (*serviceEncryptionConfigurationPtrType)(v)
}

func (*serviceEncryptionConfigurationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceEncryptionConfiguration)(nil)).Elem()
}

func (i *serviceEncryptionConfigurationPtrType) ToServiceEncryptionConfigurationPtrOutput() ServiceEncryptionConfigurationPtrOutput {
	return i.ToServiceEncryptionConfigurationPtrOutputWithContext(context.Background())
}

func (i *serviceEncryptionConfigurationPtrType) ToServiceEncryptionConfigurationPtrOutputWithContext(ctx context.Context) ServiceEncryptionConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceEncryptionConfigurationPtrOutput)
}

// Encryption configuration (KMS key)
type ServiceEncryptionConfigurationOutput struct{ *pulumi.OutputState }

func (ServiceEncryptionConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceEncryptionConfiguration)(nil)).Elem()
}

func (o ServiceEncryptionConfigurationOutput) ToServiceEncryptionConfigurationOutput() ServiceEncryptionConfigurationOutput {
	return o
}

func (o ServiceEncryptionConfigurationOutput) ToServiceEncryptionConfigurationOutputWithContext(ctx context.Context) ServiceEncryptionConfigurationOutput {
	return o
}

func (o ServiceEncryptionConfigurationOutput) ToServiceEncryptionConfigurationPtrOutput() ServiceEncryptionConfigurationPtrOutput {
	return o.ToServiceEncryptionConfigurationPtrOutputWithContext(context.Background())
}

func (o ServiceEncryptionConfigurationOutput) ToServiceEncryptionConfigurationPtrOutputWithContext(ctx context.Context) ServiceEncryptionConfigurationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ServiceEncryptionConfiguration) *ServiceEncryptionConfiguration {
		return &v
	}).(ServiceEncryptionConfigurationPtrOutput)
}

// The KMS Key
func (o ServiceEncryptionConfigurationOutput) KmsKey() pulumi.StringOutput {
	return o.ApplyT(func(v ServiceEncryptionConfiguration) string { return v.KmsKey }).(pulumi.StringOutput)
}

type ServiceEncryptionConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ServiceEncryptionConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceEncryptionConfiguration)(nil)).Elem()
}

func (o ServiceEncryptionConfigurationPtrOutput) ToServiceEncryptionConfigurationPtrOutput() ServiceEncryptionConfigurationPtrOutput {
	return o
}

func (o ServiceEncryptionConfigurationPtrOutput) ToServiceEncryptionConfigurationPtrOutputWithContext(ctx context.Context) ServiceEncryptionConfigurationPtrOutput {
	return o
}

func (o ServiceEncryptionConfigurationPtrOutput) Elem() ServiceEncryptionConfigurationOutput {
	return o.ApplyT(func(v *ServiceEncryptionConfiguration) ServiceEncryptionConfiguration {
		if v != nil {
			return *v
		}
		var ret ServiceEncryptionConfiguration
		return ret
	}).(ServiceEncryptionConfigurationOutput)
}

// The KMS Key
func (o ServiceEncryptionConfigurationPtrOutput) KmsKey() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceEncryptionConfiguration) *string {
		if v == nil {
			return nil
		}
		return &v.KmsKey
	}).(pulumi.StringPtrOutput)
}

// Health check configuration
type ServiceHealthCheckConfiguration struct {
	// Health check Healthy Threshold
	HealthyThreshold *int `pulumi:"healthyThreshold"`
	// Health check Interval
	Interval *int `pulumi:"interval"`
	// Health check Path
	Path *string `pulumi:"path"`
	// Health Check Protocol
	Protocol *ServiceHealthCheckConfigurationProtocol `pulumi:"protocol"`
	// Health check Timeout
	Timeout *int `pulumi:"timeout"`
	// Health check Unhealthy Threshold
	UnhealthyThreshold *int `pulumi:"unhealthyThreshold"`
}

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

	ToServiceHealthCheckConfigurationOutput() ServiceHealthCheckConfigurationOutput
	ToServiceHealthCheckConfigurationOutputWithContext(context.Context) ServiceHealthCheckConfigurationOutput
}

// Health check configuration
type ServiceHealthCheckConfigurationArgs struct {
	// Health check Healthy Threshold
	HealthyThreshold pulumi.IntPtrInput `pulumi:"healthyThreshold"`
	// Health check Interval
	Interval pulumi.IntPtrInput `pulumi:"interval"`
	// Health check Path
	Path pulumi.StringPtrInput `pulumi:"path"`
	// Health Check Protocol
	Protocol ServiceHealthCheckConfigurationProtocolPtrInput `pulumi:"protocol"`
	// Health check Timeout
	Timeout pulumi.IntPtrInput `pulumi:"timeout"`
	// Health check Unhealthy Threshold
	UnhealthyThreshold pulumi.IntPtrInput `pulumi:"unhealthyThreshold"`
}

func (ServiceHealthCheckConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceHealthCheckConfiguration)(nil)).Elem()
}

func (i ServiceHealthCheckConfigurationArgs) ToServiceHealthCheckConfigurationOutput() ServiceHealthCheckConfigurationOutput {
	return i.ToServiceHealthCheckConfigurationOutputWithContext(context.Background())
}

func (i ServiceHealthCheckConfigurationArgs) ToServiceHealthCheckConfigurationOutputWithContext(ctx context.Context) ServiceHealthCheckConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceHealthCheckConfigurationOutput)
}

func (i ServiceHealthCheckConfigurationArgs) ToServiceHealthCheckConfigurationPtrOutput() ServiceHealthCheckConfigurationPtrOutput {
	return i.ToServiceHealthCheckConfigurationPtrOutputWithContext(context.Background())
}

func (i ServiceHealthCheckConfigurationArgs) ToServiceHealthCheckConfigurationPtrOutputWithContext(ctx context.Context) ServiceHealthCheckConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceHealthCheckConfigurationOutput).ToServiceHealthCheckConfigurationPtrOutputWithContext(ctx)
}

// ServiceHealthCheckConfigurationPtrInput is an input type that accepts ServiceHealthCheckConfigurationArgs, ServiceHealthCheckConfigurationPtr and ServiceHealthCheckConfigurationPtrOutput values.
// You can construct a concrete instance of `ServiceHealthCheckConfigurationPtrInput` via:
//
//	        ServiceHealthCheckConfigurationArgs{...}
//
//	or:
//
//	        nil
type ServiceHealthCheckConfigurationPtrInput interface {
	pulumi.Input

	ToServiceHealthCheckConfigurationPtrOutput() ServiceHealthCheckConfigurationPtrOutput
	ToServiceHealthCheckConfigurationPtrOutputWithContext(context.Context) ServiceHealthCheckConfigurationPtrOutput
}

type serviceHealthCheckConfigurationPtrType ServiceHealthCheckConfigurationArgs

func ServiceHealthCheckConfigurationPtr(v *ServiceHealthCheckConfigurationArgs) ServiceHealthCheckConfigurationPtrInput {
	return (*serviceHealthCheckConfigurationPtrType)(v)
}

func (*serviceHealthCheckConfigurationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceHealthCheckConfiguration)(nil)).Elem()
}

func (i *serviceHealthCheckConfigurationPtrType) ToServiceHealthCheckConfigurationPtrOutput() ServiceHealthCheckConfigurationPtrOutput {
	return i.ToServiceHealthCheckConfigurationPtrOutputWithContext(context.Background())
}

func (i *serviceHealthCheckConfigurationPtrType) ToServiceHealthCheckConfigurationPtrOutputWithContext(ctx context.Context) ServiceHealthCheckConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceHealthCheckConfigurationPtrOutput)
}

// Health check configuration
type ServiceHealthCheckConfigurationOutput struct{ *pulumi.OutputState }

func (ServiceHealthCheckConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceHealthCheckConfiguration)(nil)).Elem()
}

func (o ServiceHealthCheckConfigurationOutput) ToServiceHealthCheckConfigurationOutput() ServiceHealthCheckConfigurationOutput {
	return o
}

func (o ServiceHealthCheckConfigurationOutput) ToServiceHealthCheckConfigurationOutputWithContext(ctx context.Context) ServiceHealthCheckConfigurationOutput {
	return o
}

func (o ServiceHealthCheckConfigurationOutput) ToServiceHealthCheckConfigurationPtrOutput() ServiceHealthCheckConfigurationPtrOutput {
	return o.ToServiceHealthCheckConfigurationPtrOutputWithContext(context.Background())
}

func (o ServiceHealthCheckConfigurationOutput) ToServiceHealthCheckConfigurationPtrOutputWithContext(ctx context.Context) ServiceHealthCheckConfigurationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ServiceHealthCheckConfiguration) *ServiceHealthCheckConfiguration {
		return &v
	}).(ServiceHealthCheckConfigurationPtrOutput)
}

// Health check Healthy Threshold
func (o ServiceHealthCheckConfigurationOutput) HealthyThreshold() pulumi.IntPtrOutput {
	return o.ApplyT(func(v ServiceHealthCheckConfiguration) *int { return v.HealthyThreshold }).(pulumi.IntPtrOutput)
}

// Health check Interval
func (o ServiceHealthCheckConfigurationOutput) Interval() pulumi.IntPtrOutput {
	return o.ApplyT(func(v ServiceHealthCheckConfiguration) *int { return v.Interval }).(pulumi.IntPtrOutput)
}

// Health check Path
func (o ServiceHealthCheckConfigurationOutput) Path() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceHealthCheckConfiguration) *string { return v.Path }).(pulumi.StringPtrOutput)
}

// Health Check Protocol
func (o ServiceHealthCheckConfigurationOutput) Protocol() ServiceHealthCheckConfigurationProtocolPtrOutput {
	return o.ApplyT(func(v ServiceHealthCheckConfiguration) *ServiceHealthCheckConfigurationProtocol { return v.Protocol }).(ServiceHealthCheckConfigurationProtocolPtrOutput)
}

// Health check Timeout
func (o ServiceHealthCheckConfigurationOutput) Timeout() pulumi.IntPtrOutput {
	return o.ApplyT(func(v ServiceHealthCheckConfiguration) *int { return v.Timeout }).(pulumi.IntPtrOutput)
}

// Health check Unhealthy Threshold
func (o ServiceHealthCheckConfigurationOutput) UnhealthyThreshold() pulumi.IntPtrOutput {
	return o.ApplyT(func(v ServiceHealthCheckConfiguration) *int { return v.UnhealthyThreshold }).(pulumi.IntPtrOutput)
}

type ServiceHealthCheckConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ServiceHealthCheckConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceHealthCheckConfiguration)(nil)).Elem()
}

func (o ServiceHealthCheckConfigurationPtrOutput) ToServiceHealthCheckConfigurationPtrOutput() ServiceHealthCheckConfigurationPtrOutput {
	return o
}

func (o ServiceHealthCheckConfigurationPtrOutput) ToServiceHealthCheckConfigurationPtrOutputWithContext(ctx context.Context) ServiceHealthCheckConfigurationPtrOutput {
	return o
}

func (o ServiceHealthCheckConfigurationPtrOutput) Elem() ServiceHealthCheckConfigurationOutput {
	return o.ApplyT(func(v *ServiceHealthCheckConfiguration) ServiceHealthCheckConfiguration {
		if v != nil {
			return *v
		}
		var ret ServiceHealthCheckConfiguration
		return ret
	}).(ServiceHealthCheckConfigurationOutput)
}

// Health check Healthy Threshold
func (o ServiceHealthCheckConfigurationPtrOutput) HealthyThreshold() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *ServiceHealthCheckConfiguration) *int {
		if v == nil {
			return nil
		}
		return v.HealthyThreshold
	}).(pulumi.IntPtrOutput)
}

// Health check Interval
func (o ServiceHealthCheckConfigurationPtrOutput) Interval() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *ServiceHealthCheckConfiguration) *int {
		if v == nil {
			return nil
		}
		return v.Interval
	}).(pulumi.IntPtrOutput)
}

// Health check Path
func (o ServiceHealthCheckConfigurationPtrOutput) Path() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceHealthCheckConfiguration) *string {
		if v == nil {
			return nil
		}
		return v.Path
	}).(pulumi.StringPtrOutput)
}

// Health Check Protocol
func (o ServiceHealthCheckConfigurationPtrOutput) Protocol() ServiceHealthCheckConfigurationProtocolPtrOutput {
	return o.ApplyT(func(v *ServiceHealthCheckConfiguration) *ServiceHealthCheckConfigurationProtocol {
		if v == nil {
			return nil
		}
		return v.Protocol
	}).(ServiceHealthCheckConfigurationProtocolPtrOutput)
}

// Health check Timeout
func (o ServiceHealthCheckConfigurationPtrOutput) Timeout() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *ServiceHealthCheckConfiguration) *int {
		if v == nil {
			return nil
		}
		return v.Timeout
	}).(pulumi.IntPtrOutput)
}

// Health check Unhealthy Threshold
func (o ServiceHealthCheckConfigurationPtrOutput) UnhealthyThreshold() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *ServiceHealthCheckConfiguration) *int {
		if v == nil {
			return nil
		}
		return v.UnhealthyThreshold
	}).(pulumi.IntPtrOutput)
}

// Image Configuration
type ServiceImageConfiguration struct {
	// Port
	Port *string `pulumi:"port"`
	// The secrets and parameters that get referenced by your service as environment variables
	RuntimeEnvironmentSecrets   []ServiceKeyValuePair `pulumi:"runtimeEnvironmentSecrets"`
	RuntimeEnvironmentVariables []ServiceKeyValuePair `pulumi:"runtimeEnvironmentVariables"`
	// Start Command
	StartCommand *string `pulumi:"startCommand"`
}

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

	ToServiceImageConfigurationOutput() ServiceImageConfigurationOutput
	ToServiceImageConfigurationOutputWithContext(context.Context) ServiceImageConfigurationOutput
}

// Image Configuration
type ServiceImageConfigurationArgs struct {
	// Port
	Port pulumi.StringPtrInput `pulumi:"port"`
	// The secrets and parameters that get referenced by your service as environment variables
	RuntimeEnvironmentSecrets   ServiceKeyValuePairArrayInput `pulumi:"runtimeEnvironmentSecrets"`
	RuntimeEnvironmentVariables ServiceKeyValuePairArrayInput `pulumi:"runtimeEnvironmentVariables"`
	// Start Command
	StartCommand pulumi.StringPtrInput `pulumi:"startCommand"`
}

func (ServiceImageConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceImageConfiguration)(nil)).Elem()
}

func (i ServiceImageConfigurationArgs) ToServiceImageConfigurationOutput() ServiceImageConfigurationOutput {
	return i.ToServiceImageConfigurationOutputWithContext(context.Background())
}

func (i ServiceImageConfigurationArgs) ToServiceImageConfigurationOutputWithContext(ctx context.Context) ServiceImageConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceImageConfigurationOutput)
}

func (i ServiceImageConfigurationArgs) ToServiceImageConfigurationPtrOutput() ServiceImageConfigurationPtrOutput {
	return i.ToServiceImageConfigurationPtrOutputWithContext(context.Background())
}

func (i ServiceImageConfigurationArgs) ToServiceImageConfigurationPtrOutputWithContext(ctx context.Context) ServiceImageConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceImageConfigurationOutput).ToServiceImageConfigurationPtrOutputWithContext(ctx)
}

// ServiceImageConfigurationPtrInput is an input type that accepts ServiceImageConfigurationArgs, ServiceImageConfigurationPtr and ServiceImageConfigurationPtrOutput values.
// You can construct a concrete instance of `ServiceImageConfigurationPtrInput` via:
//
//	        ServiceImageConfigurationArgs{...}
//
//	or:
//
//	        nil
type ServiceImageConfigurationPtrInput interface {
	pulumi.Input

	ToServiceImageConfigurationPtrOutput() ServiceImageConfigurationPtrOutput
	ToServiceImageConfigurationPtrOutputWithContext(context.Context) ServiceImageConfigurationPtrOutput
}

type serviceImageConfigurationPtrType ServiceImageConfigurationArgs

func ServiceImageConfigurationPtr(v *ServiceImageConfigurationArgs) ServiceImageConfigurationPtrInput {
	return (*serviceImageConfigurationPtrType)(v)
}

func (*serviceImageConfigurationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceImageConfiguration)(nil)).Elem()
}

func (i *serviceImageConfigurationPtrType) ToServiceImageConfigurationPtrOutput() ServiceImageConfigurationPtrOutput {
	return i.ToServiceImageConfigurationPtrOutputWithContext(context.Background())
}

func (i *serviceImageConfigurationPtrType) ToServiceImageConfigurationPtrOutputWithContext(ctx context.Context) ServiceImageConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceImageConfigurationPtrOutput)
}

// Image Configuration
type ServiceImageConfigurationOutput struct{ *pulumi.OutputState }

func (ServiceImageConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceImageConfiguration)(nil)).Elem()
}

func (o ServiceImageConfigurationOutput) ToServiceImageConfigurationOutput() ServiceImageConfigurationOutput {
	return o
}

func (o ServiceImageConfigurationOutput) ToServiceImageConfigurationOutputWithContext(ctx context.Context) ServiceImageConfigurationOutput {
	return o
}

func (o ServiceImageConfigurationOutput) ToServiceImageConfigurationPtrOutput() ServiceImageConfigurationPtrOutput {
	return o.ToServiceImageConfigurationPtrOutputWithContext(context.Background())
}

func (o ServiceImageConfigurationOutput) ToServiceImageConfigurationPtrOutputWithContext(ctx context.Context) ServiceImageConfigurationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ServiceImageConfiguration) *ServiceImageConfiguration {
		return &v
	}).(ServiceImageConfigurationPtrOutput)
}

// Port
func (o ServiceImageConfigurationOutput) Port() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceImageConfiguration) *string { return v.Port }).(pulumi.StringPtrOutput)
}

// The secrets and parameters that get referenced by your service as environment variables
func (o ServiceImageConfigurationOutput) RuntimeEnvironmentSecrets() ServiceKeyValuePairArrayOutput {
	return o.ApplyT(func(v ServiceImageConfiguration) []ServiceKeyValuePair { return v.RuntimeEnvironmentSecrets }).(ServiceKeyValuePairArrayOutput)
}

func (o ServiceImageConfigurationOutput) RuntimeEnvironmentVariables() ServiceKeyValuePairArrayOutput {
	return o.ApplyT(func(v ServiceImageConfiguration) []ServiceKeyValuePair { return v.RuntimeEnvironmentVariables }).(ServiceKeyValuePairArrayOutput)
}

// Start Command
func (o ServiceImageConfigurationOutput) StartCommand() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceImageConfiguration) *string { return v.StartCommand }).(pulumi.StringPtrOutput)
}

type ServiceImageConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ServiceImageConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceImageConfiguration)(nil)).Elem()
}

func (o ServiceImageConfigurationPtrOutput) ToServiceImageConfigurationPtrOutput() ServiceImageConfigurationPtrOutput {
	return o
}

func (o ServiceImageConfigurationPtrOutput) ToServiceImageConfigurationPtrOutputWithContext(ctx context.Context) ServiceImageConfigurationPtrOutput {
	return o
}

func (o ServiceImageConfigurationPtrOutput) Elem() ServiceImageConfigurationOutput {
	return o.ApplyT(func(v *ServiceImageConfiguration) ServiceImageConfiguration {
		if v != nil {
			return *v
		}
		var ret ServiceImageConfiguration
		return ret
	}).(ServiceImageConfigurationOutput)
}

// Port
func (o ServiceImageConfigurationPtrOutput) Port() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceImageConfiguration) *string {
		if v == nil {
			return nil
		}
		return v.Port
	}).(pulumi.StringPtrOutput)
}

// The secrets and parameters that get referenced by your service as environment variables
func (o ServiceImageConfigurationPtrOutput) RuntimeEnvironmentSecrets() ServiceKeyValuePairArrayOutput {
	return o.ApplyT(func(v *ServiceImageConfiguration) []ServiceKeyValuePair {
		if v == nil {
			return nil
		}
		return v.RuntimeEnvironmentSecrets
	}).(ServiceKeyValuePairArrayOutput)
}

func (o ServiceImageConfigurationPtrOutput) RuntimeEnvironmentVariables() ServiceKeyValuePairArrayOutput {
	return o.ApplyT(func(v *ServiceImageConfiguration) []ServiceKeyValuePair {
		if v == nil {
			return nil
		}
		return v.RuntimeEnvironmentVariables
	}).(ServiceKeyValuePairArrayOutput)
}

// Start Command
func (o ServiceImageConfigurationPtrOutput) StartCommand() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceImageConfiguration) *string {
		if v == nil {
			return nil
		}
		return v.StartCommand
	}).(pulumi.StringPtrOutput)
}

// Image Repository
type ServiceImageRepository struct {
	ImageConfiguration *ServiceImageConfiguration `pulumi:"imageConfiguration"`
	// Image Identifier
	ImageIdentifier string `pulumi:"imageIdentifier"`
	// Image Repository Type
	ImageRepositoryType ServiceImageRepositoryImageRepositoryType `pulumi:"imageRepositoryType"`
}

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

	ToServiceImageRepositoryOutput() ServiceImageRepositoryOutput
	ToServiceImageRepositoryOutputWithContext(context.Context) ServiceImageRepositoryOutput
}

// Image Repository
type ServiceImageRepositoryArgs struct {
	ImageConfiguration ServiceImageConfigurationPtrInput `pulumi:"imageConfiguration"`
	// Image Identifier
	ImageIdentifier pulumi.StringInput `pulumi:"imageIdentifier"`
	// Image Repository Type
	ImageRepositoryType ServiceImageRepositoryImageRepositoryTypeInput `pulumi:"imageRepositoryType"`
}

func (ServiceImageRepositoryArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceImageRepository)(nil)).Elem()
}

func (i ServiceImageRepositoryArgs) ToServiceImageRepositoryOutput() ServiceImageRepositoryOutput {
	return i.ToServiceImageRepositoryOutputWithContext(context.Background())
}

func (i ServiceImageRepositoryArgs) ToServiceImageRepositoryOutputWithContext(ctx context.Context) ServiceImageRepositoryOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceImageRepositoryOutput)
}

func (i ServiceImageRepositoryArgs) ToServiceImageRepositoryPtrOutput() ServiceImageRepositoryPtrOutput {
	return i.ToServiceImageRepositoryPtrOutputWithContext(context.Background())
}

func (i ServiceImageRepositoryArgs) ToServiceImageRepositoryPtrOutputWithContext(ctx context.Context) ServiceImageRepositoryPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceImageRepositoryOutput).ToServiceImageRepositoryPtrOutputWithContext(ctx)
}

// ServiceImageRepositoryPtrInput is an input type that accepts ServiceImageRepositoryArgs, ServiceImageRepositoryPtr and ServiceImageRepositoryPtrOutput values.
// You can construct a concrete instance of `ServiceImageRepositoryPtrInput` via:
//
//	        ServiceImageRepositoryArgs{...}
//
//	or:
//
//	        nil
type ServiceImageRepositoryPtrInput interface {
	pulumi.Input

	ToServiceImageRepositoryPtrOutput() ServiceImageRepositoryPtrOutput
	ToServiceImageRepositoryPtrOutputWithContext(context.Context) ServiceImageRepositoryPtrOutput
}

type serviceImageRepositoryPtrType ServiceImageRepositoryArgs

func ServiceImageRepositoryPtr(v *ServiceImageRepositoryArgs) ServiceImageRepositoryPtrInput {
	return (*serviceImageRepositoryPtrType)(v)
}

func (*serviceImageRepositoryPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceImageRepository)(nil)).Elem()
}

func (i *serviceImageRepositoryPtrType) ToServiceImageRepositoryPtrOutput() ServiceImageRepositoryPtrOutput {
	return i.ToServiceImageRepositoryPtrOutputWithContext(context.Background())
}

func (i *serviceImageRepositoryPtrType) ToServiceImageRepositoryPtrOutputWithContext(ctx context.Context) ServiceImageRepositoryPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceImageRepositoryPtrOutput)
}

// Image Repository
type ServiceImageRepositoryOutput struct{ *pulumi.OutputState }

func (ServiceImageRepositoryOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceImageRepository)(nil)).Elem()
}

func (o ServiceImageRepositoryOutput) ToServiceImageRepositoryOutput() ServiceImageRepositoryOutput {
	return o
}

func (o ServiceImageRepositoryOutput) ToServiceImageRepositoryOutputWithContext(ctx context.Context) ServiceImageRepositoryOutput {
	return o
}

func (o ServiceImageRepositoryOutput) ToServiceImageRepositoryPtrOutput() ServiceImageRepositoryPtrOutput {
	return o.ToServiceImageRepositoryPtrOutputWithContext(context.Background())
}

func (o ServiceImageRepositoryOutput) ToServiceImageRepositoryPtrOutputWithContext(ctx context.Context) ServiceImageRepositoryPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ServiceImageRepository) *ServiceImageRepository {
		return &v
	}).(ServiceImageRepositoryPtrOutput)
}

func (o ServiceImageRepositoryOutput) ImageConfiguration() ServiceImageConfigurationPtrOutput {
	return o.ApplyT(func(v ServiceImageRepository) *ServiceImageConfiguration { return v.ImageConfiguration }).(ServiceImageConfigurationPtrOutput)
}

// Image Identifier
func (o ServiceImageRepositoryOutput) ImageIdentifier() pulumi.StringOutput {
	return o.ApplyT(func(v ServiceImageRepository) string { return v.ImageIdentifier }).(pulumi.StringOutput)
}

// Image Repository Type
func (o ServiceImageRepositoryOutput) ImageRepositoryType() ServiceImageRepositoryImageRepositoryTypeOutput {
	return o.ApplyT(func(v ServiceImageRepository) ServiceImageRepositoryImageRepositoryType { return v.ImageRepositoryType }).(ServiceImageRepositoryImageRepositoryTypeOutput)
}

type ServiceImageRepositoryPtrOutput struct{ *pulumi.OutputState }

func (ServiceImageRepositoryPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceImageRepository)(nil)).Elem()
}

func (o ServiceImageRepositoryPtrOutput) ToServiceImageRepositoryPtrOutput() ServiceImageRepositoryPtrOutput {
	return o
}

func (o ServiceImageRepositoryPtrOutput) ToServiceImageRepositoryPtrOutputWithContext(ctx context.Context) ServiceImageRepositoryPtrOutput {
	return o
}

func (o ServiceImageRepositoryPtrOutput) Elem() ServiceImageRepositoryOutput {
	return o.ApplyT(func(v *ServiceImageRepository) ServiceImageRepository {
		if v != nil {
			return *v
		}
		var ret ServiceImageRepository
		return ret
	}).(ServiceImageRepositoryOutput)
}

func (o ServiceImageRepositoryPtrOutput) ImageConfiguration() ServiceImageConfigurationPtrOutput {
	return o.ApplyT(func(v *ServiceImageRepository) *ServiceImageConfiguration {
		if v == nil {
			return nil
		}
		return v.ImageConfiguration
	}).(ServiceImageConfigurationPtrOutput)
}

// Image Identifier
func (o ServiceImageRepositoryPtrOutput) ImageIdentifier() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceImageRepository) *string {
		if v == nil {
			return nil
		}
		return &v.ImageIdentifier
	}).(pulumi.StringPtrOutput)
}

// Image Repository Type
func (o ServiceImageRepositoryPtrOutput) ImageRepositoryType() ServiceImageRepositoryImageRepositoryTypePtrOutput {
	return o.ApplyT(func(v *ServiceImageRepository) *ServiceImageRepositoryImageRepositoryType {
		if v == nil {
			return nil
		}
		return &v.ImageRepositoryType
	}).(ServiceImageRepositoryImageRepositoryTypePtrOutput)
}

// Network ingress configuration
type ServiceIngressConfiguration struct {
	// It's set to true if the Apprunner service is publicly accessible. It's set to false otherwise.
	IsPubliclyAccessible bool `pulumi:"isPubliclyAccessible"`
}

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

	ToServiceIngressConfigurationOutput() ServiceIngressConfigurationOutput
	ToServiceIngressConfigurationOutputWithContext(context.Context) ServiceIngressConfigurationOutput
}

// Network ingress configuration
type ServiceIngressConfigurationArgs struct {
	// It's set to true if the Apprunner service is publicly accessible. It's set to false otherwise.
	IsPubliclyAccessible pulumi.BoolInput `pulumi:"isPubliclyAccessible"`
}

func (ServiceIngressConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceIngressConfiguration)(nil)).Elem()
}

func (i ServiceIngressConfigurationArgs) ToServiceIngressConfigurationOutput() ServiceIngressConfigurationOutput {
	return i.ToServiceIngressConfigurationOutputWithContext(context.Background())
}

func (i ServiceIngressConfigurationArgs) ToServiceIngressConfigurationOutputWithContext(ctx context.Context) ServiceIngressConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceIngressConfigurationOutput)
}

func (i ServiceIngressConfigurationArgs) ToServiceIngressConfigurationPtrOutput() ServiceIngressConfigurationPtrOutput {
	return i.ToServiceIngressConfigurationPtrOutputWithContext(context.Background())
}

func (i ServiceIngressConfigurationArgs) ToServiceIngressConfigurationPtrOutputWithContext(ctx context.Context) ServiceIngressConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceIngressConfigurationOutput).ToServiceIngressConfigurationPtrOutputWithContext(ctx)
}

// ServiceIngressConfigurationPtrInput is an input type that accepts ServiceIngressConfigurationArgs, ServiceIngressConfigurationPtr and ServiceIngressConfigurationPtrOutput values.
// You can construct a concrete instance of `ServiceIngressConfigurationPtrInput` via:
//
//	        ServiceIngressConfigurationArgs{...}
//
//	or:
//
//	        nil
type ServiceIngressConfigurationPtrInput interface {
	pulumi.Input

	ToServiceIngressConfigurationPtrOutput() ServiceIngressConfigurationPtrOutput
	ToServiceIngressConfigurationPtrOutputWithContext(context.Context) ServiceIngressConfigurationPtrOutput
}

type serviceIngressConfigurationPtrType ServiceIngressConfigurationArgs

func ServiceIngressConfigurationPtr(v *ServiceIngressConfigurationArgs) ServiceIngressConfigurationPtrInput {
	return (*serviceIngressConfigurationPtrType)(v)
}

func (*serviceIngressConfigurationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceIngressConfiguration)(nil)).Elem()
}

func (i *serviceIngressConfigurationPtrType) ToServiceIngressConfigurationPtrOutput() ServiceIngressConfigurationPtrOutput {
	return i.ToServiceIngressConfigurationPtrOutputWithContext(context.Background())
}

func (i *serviceIngressConfigurationPtrType) ToServiceIngressConfigurationPtrOutputWithContext(ctx context.Context) ServiceIngressConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceIngressConfigurationPtrOutput)
}

// Network ingress configuration
type ServiceIngressConfigurationOutput struct{ *pulumi.OutputState }

func (ServiceIngressConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceIngressConfiguration)(nil)).Elem()
}

func (o ServiceIngressConfigurationOutput) ToServiceIngressConfigurationOutput() ServiceIngressConfigurationOutput {
	return o
}

func (o ServiceIngressConfigurationOutput) ToServiceIngressConfigurationOutputWithContext(ctx context.Context) ServiceIngressConfigurationOutput {
	return o
}

func (o ServiceIngressConfigurationOutput) ToServiceIngressConfigurationPtrOutput() ServiceIngressConfigurationPtrOutput {
	return o.ToServiceIngressConfigurationPtrOutputWithContext(context.Background())
}

func (o ServiceIngressConfigurationOutput) ToServiceIngressConfigurationPtrOutputWithContext(ctx context.Context) ServiceIngressConfigurationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ServiceIngressConfiguration) *ServiceIngressConfiguration {
		return &v
	}).(ServiceIngressConfigurationPtrOutput)
}

// It's set to true if the Apprunner service is publicly accessible. It's set to false otherwise.
func (o ServiceIngressConfigurationOutput) IsPubliclyAccessible() pulumi.BoolOutput {
	return o.ApplyT(func(v ServiceIngressConfiguration) bool { return v.IsPubliclyAccessible }).(pulumi.BoolOutput)
}

type ServiceIngressConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ServiceIngressConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceIngressConfiguration)(nil)).Elem()
}

func (o ServiceIngressConfigurationPtrOutput) ToServiceIngressConfigurationPtrOutput() ServiceIngressConfigurationPtrOutput {
	return o
}

func (o ServiceIngressConfigurationPtrOutput) ToServiceIngressConfigurationPtrOutputWithContext(ctx context.Context) ServiceIngressConfigurationPtrOutput {
	return o
}

func (o ServiceIngressConfigurationPtrOutput) Elem() ServiceIngressConfigurationOutput {
	return o.ApplyT(func(v *ServiceIngressConfiguration) ServiceIngressConfiguration {
		if v != nil {
			return *v
		}
		var ret ServiceIngressConfiguration
		return ret
	}).(ServiceIngressConfigurationOutput)
}

// It's set to true if the Apprunner service is publicly accessible. It's set to false otherwise.
func (o ServiceIngressConfigurationPtrOutput) IsPubliclyAccessible() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *ServiceIngressConfiguration) *bool {
		if v == nil {
			return nil
		}
		return &v.IsPubliclyAccessible
	}).(pulumi.BoolPtrOutput)
}

// Instance Configuration
type ServiceInstanceConfiguration struct {
	// CPU
	Cpu *string `pulumi:"cpu"`
	// Instance Role Arn
	InstanceRoleArn *string `pulumi:"instanceRoleArn"`
	// Memory
	Memory *string `pulumi:"memory"`
}

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

	ToServiceInstanceConfigurationOutput() ServiceInstanceConfigurationOutput
	ToServiceInstanceConfigurationOutputWithContext(context.Context) ServiceInstanceConfigurationOutput
}

// Instance Configuration
type ServiceInstanceConfigurationArgs struct {
	// CPU
	Cpu pulumi.StringPtrInput `pulumi:"cpu"`
	// Instance Role Arn
	InstanceRoleArn pulumi.StringPtrInput `pulumi:"instanceRoleArn"`
	// Memory
	Memory pulumi.StringPtrInput `pulumi:"memory"`
}

func (ServiceInstanceConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceInstanceConfiguration)(nil)).Elem()
}

func (i ServiceInstanceConfigurationArgs) ToServiceInstanceConfigurationOutput() ServiceInstanceConfigurationOutput {
	return i.ToServiceInstanceConfigurationOutputWithContext(context.Background())
}

func (i ServiceInstanceConfigurationArgs) ToServiceInstanceConfigurationOutputWithContext(ctx context.Context) ServiceInstanceConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceInstanceConfigurationOutput)
}

func (i ServiceInstanceConfigurationArgs) ToServiceInstanceConfigurationPtrOutput() ServiceInstanceConfigurationPtrOutput {
	return i.ToServiceInstanceConfigurationPtrOutputWithContext(context.Background())
}

func (i ServiceInstanceConfigurationArgs) ToServiceInstanceConfigurationPtrOutputWithContext(ctx context.Context) ServiceInstanceConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceInstanceConfigurationOutput).ToServiceInstanceConfigurationPtrOutputWithContext(ctx)
}

// ServiceInstanceConfigurationPtrInput is an input type that accepts ServiceInstanceConfigurationArgs, ServiceInstanceConfigurationPtr and ServiceInstanceConfigurationPtrOutput values.
// You can construct a concrete instance of `ServiceInstanceConfigurationPtrInput` via:
//
//	        ServiceInstanceConfigurationArgs{...}
//
//	or:
//
//	        nil
type ServiceInstanceConfigurationPtrInput interface {
	pulumi.Input

	ToServiceInstanceConfigurationPtrOutput() ServiceInstanceConfigurationPtrOutput
	ToServiceInstanceConfigurationPtrOutputWithContext(context.Context) ServiceInstanceConfigurationPtrOutput
}

type serviceInstanceConfigurationPtrType ServiceInstanceConfigurationArgs

func ServiceInstanceConfigurationPtr(v *ServiceInstanceConfigurationArgs) ServiceInstanceConfigurationPtrInput {
	return (*serviceInstanceConfigurationPtrType)(v)
}

func (*serviceInstanceConfigurationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceInstanceConfiguration)(nil)).Elem()
}

func (i *serviceInstanceConfigurationPtrType) ToServiceInstanceConfigurationPtrOutput() ServiceInstanceConfigurationPtrOutput {
	return i.ToServiceInstanceConfigurationPtrOutputWithContext(context.Background())
}

func (i *serviceInstanceConfigurationPtrType) ToServiceInstanceConfigurationPtrOutputWithContext(ctx context.Context) ServiceInstanceConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceInstanceConfigurationPtrOutput)
}

// Instance Configuration
type ServiceInstanceConfigurationOutput struct{ *pulumi.OutputState }

func (ServiceInstanceConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceInstanceConfiguration)(nil)).Elem()
}

func (o ServiceInstanceConfigurationOutput) ToServiceInstanceConfigurationOutput() ServiceInstanceConfigurationOutput {
	return o
}

func (o ServiceInstanceConfigurationOutput) ToServiceInstanceConfigurationOutputWithContext(ctx context.Context) ServiceInstanceConfigurationOutput {
	return o
}

func (o ServiceInstanceConfigurationOutput) ToServiceInstanceConfigurationPtrOutput() ServiceInstanceConfigurationPtrOutput {
	return o.ToServiceInstanceConfigurationPtrOutputWithContext(context.Background())
}

func (o ServiceInstanceConfigurationOutput) ToServiceInstanceConfigurationPtrOutputWithContext(ctx context.Context) ServiceInstanceConfigurationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ServiceInstanceConfiguration) *ServiceInstanceConfiguration {
		return &v
	}).(ServiceInstanceConfigurationPtrOutput)
}

// CPU
func (o ServiceInstanceConfigurationOutput) Cpu() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceInstanceConfiguration) *string { return v.Cpu }).(pulumi.StringPtrOutput)
}

// Instance Role Arn
func (o ServiceInstanceConfigurationOutput) InstanceRoleArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceInstanceConfiguration) *string { return v.InstanceRoleArn }).(pulumi.StringPtrOutput)
}

// Memory
func (o ServiceInstanceConfigurationOutput) Memory() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceInstanceConfiguration) *string { return v.Memory }).(pulumi.StringPtrOutput)
}

type ServiceInstanceConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ServiceInstanceConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceInstanceConfiguration)(nil)).Elem()
}

func (o ServiceInstanceConfigurationPtrOutput) ToServiceInstanceConfigurationPtrOutput() ServiceInstanceConfigurationPtrOutput {
	return o
}

func (o ServiceInstanceConfigurationPtrOutput) ToServiceInstanceConfigurationPtrOutputWithContext(ctx context.Context) ServiceInstanceConfigurationPtrOutput {
	return o
}

func (o ServiceInstanceConfigurationPtrOutput) Elem() ServiceInstanceConfigurationOutput {
	return o.ApplyT(func(v *ServiceInstanceConfiguration) ServiceInstanceConfiguration {
		if v != nil {
			return *v
		}
		var ret ServiceInstanceConfiguration
		return ret
	}).(ServiceInstanceConfigurationOutput)
}

// CPU
func (o ServiceInstanceConfigurationPtrOutput) Cpu() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceInstanceConfiguration) *string {
		if v == nil {
			return nil
		}
		return v.Cpu
	}).(pulumi.StringPtrOutput)
}

// Instance Role Arn
func (o ServiceInstanceConfigurationPtrOutput) InstanceRoleArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceInstanceConfiguration) *string {
		if v == nil {
			return nil
		}
		return v.InstanceRoleArn
	}).(pulumi.StringPtrOutput)
}

// Memory
func (o ServiceInstanceConfigurationPtrOutput) Memory() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceInstanceConfiguration) *string {
		if v == nil {
			return nil
		}
		return v.Memory
	}).(pulumi.StringPtrOutput)
}

type ServiceKeyValuePair struct {
	Name  *string `pulumi:"name"`
	Value *string `pulumi:"value"`
}

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

	ToServiceKeyValuePairOutput() ServiceKeyValuePairOutput
	ToServiceKeyValuePairOutputWithContext(context.Context) ServiceKeyValuePairOutput
}

type ServiceKeyValuePairArgs struct {
	Name  pulumi.StringPtrInput `pulumi:"name"`
	Value pulumi.StringPtrInput `pulumi:"value"`
}

func (ServiceKeyValuePairArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceKeyValuePair)(nil)).Elem()
}

func (i ServiceKeyValuePairArgs) ToServiceKeyValuePairOutput() ServiceKeyValuePairOutput {
	return i.ToServiceKeyValuePairOutputWithContext(context.Background())
}

func (i ServiceKeyValuePairArgs) ToServiceKeyValuePairOutputWithContext(ctx context.Context) ServiceKeyValuePairOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceKeyValuePairOutput)
}

// ServiceKeyValuePairArrayInput is an input type that accepts ServiceKeyValuePairArray and ServiceKeyValuePairArrayOutput values.
// You can construct a concrete instance of `ServiceKeyValuePairArrayInput` via:
//
//	ServiceKeyValuePairArray{ ServiceKeyValuePairArgs{...} }
type ServiceKeyValuePairArrayInput interface {
	pulumi.Input

	ToServiceKeyValuePairArrayOutput() ServiceKeyValuePairArrayOutput
	ToServiceKeyValuePairArrayOutputWithContext(context.Context) ServiceKeyValuePairArrayOutput
}

type ServiceKeyValuePairArray []ServiceKeyValuePairInput

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

func (i ServiceKeyValuePairArray) ToServiceKeyValuePairArrayOutput() ServiceKeyValuePairArrayOutput {
	return i.ToServiceKeyValuePairArrayOutputWithContext(context.Background())
}

func (i ServiceKeyValuePairArray) ToServiceKeyValuePairArrayOutputWithContext(ctx context.Context) ServiceKeyValuePairArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceKeyValuePairArrayOutput)
}

type ServiceKeyValuePairOutput struct{ *pulumi.OutputState }

func (ServiceKeyValuePairOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceKeyValuePair)(nil)).Elem()
}

func (o ServiceKeyValuePairOutput) ToServiceKeyValuePairOutput() ServiceKeyValuePairOutput {
	return o
}

func (o ServiceKeyValuePairOutput) ToServiceKeyValuePairOutputWithContext(ctx context.Context) ServiceKeyValuePairOutput {
	return o
}

func (o ServiceKeyValuePairOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceKeyValuePair) *string { return v.Name }).(pulumi.StringPtrOutput)
}

func (o ServiceKeyValuePairOutput) Value() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceKeyValuePair) *string { return v.Value }).(pulumi.StringPtrOutput)
}

type ServiceKeyValuePairArrayOutput struct{ *pulumi.OutputState }

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

func (o ServiceKeyValuePairArrayOutput) ToServiceKeyValuePairArrayOutput() ServiceKeyValuePairArrayOutput {
	return o
}

func (o ServiceKeyValuePairArrayOutput) ToServiceKeyValuePairArrayOutputWithContext(ctx context.Context) ServiceKeyValuePairArrayOutput {
	return o
}

func (o ServiceKeyValuePairArrayOutput) Index(i pulumi.IntInput) ServiceKeyValuePairOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ServiceKeyValuePair {
		return vs[0].([]ServiceKeyValuePair)[vs[1].(int)]
	}).(ServiceKeyValuePairOutput)
}

// Network configuration
type ServiceNetworkConfiguration struct {
	EgressConfiguration  *ServiceEgressConfiguration  `pulumi:"egressConfiguration"`
	IngressConfiguration *ServiceIngressConfiguration `pulumi:"ingressConfiguration"`
	// App Runner service endpoint IP address type
	IpAddressType *ServiceNetworkConfigurationIpAddressType `pulumi:"ipAddressType"`
}

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

	ToServiceNetworkConfigurationOutput() ServiceNetworkConfigurationOutput
	ToServiceNetworkConfigurationOutputWithContext(context.Context) ServiceNetworkConfigurationOutput
}

// Network configuration
type ServiceNetworkConfigurationArgs struct {
	EgressConfiguration  ServiceEgressConfigurationPtrInput  `pulumi:"egressConfiguration"`
	IngressConfiguration ServiceIngressConfigurationPtrInput `pulumi:"ingressConfiguration"`
	// App Runner service endpoint IP address type
	IpAddressType ServiceNetworkConfigurationIpAddressTypePtrInput `pulumi:"ipAddressType"`
}

func (ServiceNetworkConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceNetworkConfiguration)(nil)).Elem()
}

func (i ServiceNetworkConfigurationArgs) ToServiceNetworkConfigurationOutput() ServiceNetworkConfigurationOutput {
	return i.ToServiceNetworkConfigurationOutputWithContext(context.Background())
}

func (i ServiceNetworkConfigurationArgs) ToServiceNetworkConfigurationOutputWithContext(ctx context.Context) ServiceNetworkConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceNetworkConfigurationOutput)
}

func (i ServiceNetworkConfigurationArgs) ToServiceNetworkConfigurationPtrOutput() ServiceNetworkConfigurationPtrOutput {
	return i.ToServiceNetworkConfigurationPtrOutputWithContext(context.Background())
}

func (i ServiceNetworkConfigurationArgs) ToServiceNetworkConfigurationPtrOutputWithContext(ctx context.Context) ServiceNetworkConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceNetworkConfigurationOutput).ToServiceNetworkConfigurationPtrOutputWithContext(ctx)
}

// ServiceNetworkConfigurationPtrInput is an input type that accepts ServiceNetworkConfigurationArgs, ServiceNetworkConfigurationPtr and ServiceNetworkConfigurationPtrOutput values.
// You can construct a concrete instance of `ServiceNetworkConfigurationPtrInput` via:
//
//	        ServiceNetworkConfigurationArgs{...}
//
//	or:
//
//	        nil
type ServiceNetworkConfigurationPtrInput interface {
	pulumi.Input

	ToServiceNetworkConfigurationPtrOutput() ServiceNetworkConfigurationPtrOutput
	ToServiceNetworkConfigurationPtrOutputWithContext(context.Context) ServiceNetworkConfigurationPtrOutput
}

type serviceNetworkConfigurationPtrType ServiceNetworkConfigurationArgs

func ServiceNetworkConfigurationPtr(v *ServiceNetworkConfigurationArgs) ServiceNetworkConfigurationPtrInput {
	return (*serviceNetworkConfigurationPtrType)(v)
}

func (*serviceNetworkConfigurationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceNetworkConfiguration)(nil)).Elem()
}

func (i *serviceNetworkConfigurationPtrType) ToServiceNetworkConfigurationPtrOutput() ServiceNetworkConfigurationPtrOutput {
	return i.ToServiceNetworkConfigurationPtrOutputWithContext(context.Background())
}

func (i *serviceNetworkConfigurationPtrType) ToServiceNetworkConfigurationPtrOutputWithContext(ctx context.Context) ServiceNetworkConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceNetworkConfigurationPtrOutput)
}

// Network configuration
type ServiceNetworkConfigurationOutput struct{ *pulumi.OutputState }

func (ServiceNetworkConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceNetworkConfiguration)(nil)).Elem()
}

func (o ServiceNetworkConfigurationOutput) ToServiceNetworkConfigurationOutput() ServiceNetworkConfigurationOutput {
	return o
}

func (o ServiceNetworkConfigurationOutput) ToServiceNetworkConfigurationOutputWithContext(ctx context.Context) ServiceNetworkConfigurationOutput {
	return o
}

func (o ServiceNetworkConfigurationOutput) ToServiceNetworkConfigurationPtrOutput() ServiceNetworkConfigurationPtrOutput {
	return o.ToServiceNetworkConfigurationPtrOutputWithContext(context.Background())
}

func (o ServiceNetworkConfigurationOutput) ToServiceNetworkConfigurationPtrOutputWithContext(ctx context.Context) ServiceNetworkConfigurationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ServiceNetworkConfiguration) *ServiceNetworkConfiguration {
		return &v
	}).(ServiceNetworkConfigurationPtrOutput)
}

func (o ServiceNetworkConfigurationOutput) EgressConfiguration() ServiceEgressConfigurationPtrOutput {
	return o.ApplyT(func(v ServiceNetworkConfiguration) *ServiceEgressConfiguration { return v.EgressConfiguration }).(ServiceEgressConfigurationPtrOutput)
}

func (o ServiceNetworkConfigurationOutput) IngressConfiguration() ServiceIngressConfigurationPtrOutput {
	return o.ApplyT(func(v ServiceNetworkConfiguration) *ServiceIngressConfiguration { return v.IngressConfiguration }).(ServiceIngressConfigurationPtrOutput)
}

// App Runner service endpoint IP address type
func (o ServiceNetworkConfigurationOutput) IpAddressType() ServiceNetworkConfigurationIpAddressTypePtrOutput {
	return o.ApplyT(func(v ServiceNetworkConfiguration) *ServiceNetworkConfigurationIpAddressType { return v.IpAddressType }).(ServiceNetworkConfigurationIpAddressTypePtrOutput)
}

type ServiceNetworkConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ServiceNetworkConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceNetworkConfiguration)(nil)).Elem()
}

func (o ServiceNetworkConfigurationPtrOutput) ToServiceNetworkConfigurationPtrOutput() ServiceNetworkConfigurationPtrOutput {
	return o
}

func (o ServiceNetworkConfigurationPtrOutput) ToServiceNetworkConfigurationPtrOutputWithContext(ctx context.Context) ServiceNetworkConfigurationPtrOutput {
	return o
}

func (o ServiceNetworkConfigurationPtrOutput) Elem() ServiceNetworkConfigurationOutput {
	return o.ApplyT(func(v *ServiceNetworkConfiguration) ServiceNetworkConfiguration {
		if v != nil {
			return *v
		}
		var ret ServiceNetworkConfiguration
		return ret
	}).(ServiceNetworkConfigurationOutput)
}

func (o ServiceNetworkConfigurationPtrOutput) EgressConfiguration() ServiceEgressConfigurationPtrOutput {
	return o.ApplyT(func(v *ServiceNetworkConfiguration) *ServiceEgressConfiguration {
		if v == nil {
			return nil
		}
		return v.EgressConfiguration
	}).(ServiceEgressConfigurationPtrOutput)
}

func (o ServiceNetworkConfigurationPtrOutput) IngressConfiguration() ServiceIngressConfigurationPtrOutput {
	return o.ApplyT(func(v *ServiceNetworkConfiguration) *ServiceIngressConfiguration {
		if v == nil {
			return nil
		}
		return v.IngressConfiguration
	}).(ServiceIngressConfigurationPtrOutput)
}

// App Runner service endpoint IP address type
func (o ServiceNetworkConfigurationPtrOutput) IpAddressType() ServiceNetworkConfigurationIpAddressTypePtrOutput {
	return o.ApplyT(func(v *ServiceNetworkConfiguration) *ServiceNetworkConfigurationIpAddressType {
		if v == nil {
			return nil
		}
		return v.IpAddressType
	}).(ServiceNetworkConfigurationIpAddressTypePtrOutput)
}

// Service observability configuration
type ServiceObservabilityConfiguration struct {
	// The Amazon Resource Name (ARN) of the App Runner ObservabilityConfiguration.
	ObservabilityConfigurationArn *string `pulumi:"observabilityConfigurationArn"`
	// Observability enabled
	ObservabilityEnabled bool `pulumi:"observabilityEnabled"`
}

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

	ToServiceObservabilityConfigurationOutput() ServiceObservabilityConfigurationOutput
	ToServiceObservabilityConfigurationOutputWithContext(context.Context) ServiceObservabilityConfigurationOutput
}

// Service observability configuration
type ServiceObservabilityConfigurationArgs struct {
	// The Amazon Resource Name (ARN) of the App Runner ObservabilityConfiguration.
	ObservabilityConfigurationArn pulumi.StringPtrInput `pulumi:"observabilityConfigurationArn"`
	// Observability enabled
	ObservabilityEnabled pulumi.BoolInput `pulumi:"observabilityEnabled"`
}

func (ServiceObservabilityConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceObservabilityConfiguration)(nil)).Elem()
}

func (i ServiceObservabilityConfigurationArgs) ToServiceObservabilityConfigurationOutput() ServiceObservabilityConfigurationOutput {
	return i.ToServiceObservabilityConfigurationOutputWithContext(context.Background())
}

func (i ServiceObservabilityConfigurationArgs) ToServiceObservabilityConfigurationOutputWithContext(ctx context.Context) ServiceObservabilityConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceObservabilityConfigurationOutput)
}

func (i ServiceObservabilityConfigurationArgs) ToServiceObservabilityConfigurationPtrOutput() ServiceObservabilityConfigurationPtrOutput {
	return i.ToServiceObservabilityConfigurationPtrOutputWithContext(context.Background())
}

func (i ServiceObservabilityConfigurationArgs) ToServiceObservabilityConfigurationPtrOutputWithContext(ctx context.Context) ServiceObservabilityConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceObservabilityConfigurationOutput).ToServiceObservabilityConfigurationPtrOutputWithContext(ctx)
}

// ServiceObservabilityConfigurationPtrInput is an input type that accepts ServiceObservabilityConfigurationArgs, ServiceObservabilityConfigurationPtr and ServiceObservabilityConfigurationPtrOutput values.
// You can construct a concrete instance of `ServiceObservabilityConfigurationPtrInput` via:
//
//	        ServiceObservabilityConfigurationArgs{...}
//
//	or:
//
//	        nil
type ServiceObservabilityConfigurationPtrInput interface {
	pulumi.Input

	ToServiceObservabilityConfigurationPtrOutput() ServiceObservabilityConfigurationPtrOutput
	ToServiceObservabilityConfigurationPtrOutputWithContext(context.Context) ServiceObservabilityConfigurationPtrOutput
}

type serviceObservabilityConfigurationPtrType ServiceObservabilityConfigurationArgs

func ServiceObservabilityConfigurationPtr(v *ServiceObservabilityConfigurationArgs) ServiceObservabilityConfigurationPtrInput {
	return (*serviceObservabilityConfigurationPtrType)(v)
}

func (*serviceObservabilityConfigurationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceObservabilityConfiguration)(nil)).Elem()
}

func (i *serviceObservabilityConfigurationPtrType) ToServiceObservabilityConfigurationPtrOutput() ServiceObservabilityConfigurationPtrOutput {
	return i.ToServiceObservabilityConfigurationPtrOutputWithContext(context.Background())
}

func (i *serviceObservabilityConfigurationPtrType) ToServiceObservabilityConfigurationPtrOutputWithContext(ctx context.Context) ServiceObservabilityConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceObservabilityConfigurationPtrOutput)
}

// Service observability configuration
type ServiceObservabilityConfigurationOutput struct{ *pulumi.OutputState }

func (ServiceObservabilityConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceObservabilityConfiguration)(nil)).Elem()
}

func (o ServiceObservabilityConfigurationOutput) ToServiceObservabilityConfigurationOutput() ServiceObservabilityConfigurationOutput {
	return o
}

func (o ServiceObservabilityConfigurationOutput) ToServiceObservabilityConfigurationOutputWithContext(ctx context.Context) ServiceObservabilityConfigurationOutput {
	return o
}

func (o ServiceObservabilityConfigurationOutput) ToServiceObservabilityConfigurationPtrOutput() ServiceObservabilityConfigurationPtrOutput {
	return o.ToServiceObservabilityConfigurationPtrOutputWithContext(context.Background())
}

func (o ServiceObservabilityConfigurationOutput) ToServiceObservabilityConfigurationPtrOutputWithContext(ctx context.Context) ServiceObservabilityConfigurationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ServiceObservabilityConfiguration) *ServiceObservabilityConfiguration {
		return &v
	}).(ServiceObservabilityConfigurationPtrOutput)
}

// The Amazon Resource Name (ARN) of the App Runner ObservabilityConfiguration.
func (o ServiceObservabilityConfigurationOutput) ObservabilityConfigurationArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ServiceObservabilityConfiguration) *string { return v.ObservabilityConfigurationArn }).(pulumi.StringPtrOutput)
}

// Observability enabled
func (o ServiceObservabilityConfigurationOutput) ObservabilityEnabled() pulumi.BoolOutput {
	return o.ApplyT(func(v ServiceObservabilityConfiguration) bool { return v.ObservabilityEnabled }).(pulumi.BoolOutput)
}

type ServiceObservabilityConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ServiceObservabilityConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceObservabilityConfiguration)(nil)).Elem()
}

func (o ServiceObservabilityConfigurationPtrOutput) ToServiceObservabilityConfigurationPtrOutput() ServiceObservabilityConfigurationPtrOutput {
	return o
}

func (o ServiceObservabilityConfigurationPtrOutput) ToServiceObservabilityConfigurationPtrOutputWithContext(ctx context.Context) ServiceObservabilityConfigurationPtrOutput {
	return o
}

func (o ServiceObservabilityConfigurationPtrOutput) Elem() ServiceObservabilityConfigurationOutput {
	return o.ApplyT(func(v *ServiceObservabilityConfiguration) ServiceObservabilityConfiguration {
		if v != nil {
			return *v
		}
		var ret ServiceObservabilityConfiguration
		return ret
	}).(ServiceObservabilityConfigurationOutput)
}

// The Amazon Resource Name (ARN) of the App Runner ObservabilityConfiguration.
func (o ServiceObservabilityConfigurationPtrOutput) ObservabilityConfigurationArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceObservabilityConfiguration) *string {
		if v == nil {
			return nil
		}
		return v.ObservabilityConfigurationArn
	}).(pulumi.StringPtrOutput)
}

// Observability enabled
func (o ServiceObservabilityConfigurationPtrOutput) ObservabilityEnabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *ServiceObservabilityConfiguration) *bool {
		if v == nil {
			return nil
		}
		return &v.ObservabilityEnabled
	}).(pulumi.BoolPtrOutput)
}

// Source Code Version
type ServiceSourceCodeVersion struct {
	// Source Code Version Type
	Type ServiceSourceCodeVersionType `pulumi:"type"`
	// Source Code Version Value
	Value string `pulumi:"value"`
}

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

	ToServiceSourceCodeVersionOutput() ServiceSourceCodeVersionOutput
	ToServiceSourceCodeVersionOutputWithContext(context.Context) ServiceSourceCodeVersionOutput
}

// Source Code Version
type ServiceSourceCodeVersionArgs struct {
	// Source Code Version Type
	Type ServiceSourceCodeVersionTypeInput `pulumi:"type"`
	// Source Code Version Value
	Value pulumi.StringInput `pulumi:"value"`
}

func (ServiceSourceCodeVersionArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceSourceCodeVersion)(nil)).Elem()
}

func (i ServiceSourceCodeVersionArgs) ToServiceSourceCodeVersionOutput() ServiceSourceCodeVersionOutput {
	return i.ToServiceSourceCodeVersionOutputWithContext(context.Background())
}

func (i ServiceSourceCodeVersionArgs) ToServiceSourceCodeVersionOutputWithContext(ctx context.Context) ServiceSourceCodeVersionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceSourceCodeVersionOutput)
}

func (i ServiceSourceCodeVersionArgs) ToServiceSourceCodeVersionPtrOutput() ServiceSourceCodeVersionPtrOutput {
	return i.ToServiceSourceCodeVersionPtrOutputWithContext(context.Background())
}

func (i ServiceSourceCodeVersionArgs) ToServiceSourceCodeVersionPtrOutputWithContext(ctx context.Context) ServiceSourceCodeVersionPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceSourceCodeVersionOutput).ToServiceSourceCodeVersionPtrOutputWithContext(ctx)
}

// ServiceSourceCodeVersionPtrInput is an input type that accepts ServiceSourceCodeVersionArgs, ServiceSourceCodeVersionPtr and ServiceSourceCodeVersionPtrOutput values.
// You can construct a concrete instance of `ServiceSourceCodeVersionPtrInput` via:
//
//	        ServiceSourceCodeVersionArgs{...}
//
//	or:
//
//	        nil
type ServiceSourceCodeVersionPtrInput interface {
	pulumi.Input

	ToServiceSourceCodeVersionPtrOutput() ServiceSourceCodeVersionPtrOutput
	ToServiceSourceCodeVersionPtrOutputWithContext(context.Context) ServiceSourceCodeVersionPtrOutput
}

type serviceSourceCodeVersionPtrType ServiceSourceCodeVersionArgs

func ServiceSourceCodeVersionPtr(v *ServiceSourceCodeVersionArgs) ServiceSourceCodeVersionPtrInput {
	return (*serviceSourceCodeVersionPtrType)(v)
}

func (*serviceSourceCodeVersionPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceSourceCodeVersion)(nil)).Elem()
}

func (i *serviceSourceCodeVersionPtrType) ToServiceSourceCodeVersionPtrOutput() ServiceSourceCodeVersionPtrOutput {
	return i.ToServiceSourceCodeVersionPtrOutputWithContext(context.Background())
}

func (i *serviceSourceCodeVersionPtrType) ToServiceSourceCodeVersionPtrOutputWithContext(ctx context.Context) ServiceSourceCodeVersionPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceSourceCodeVersionPtrOutput)
}

// Source Code Version
type ServiceSourceCodeVersionOutput struct{ *pulumi.OutputState }

func (ServiceSourceCodeVersionOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceSourceCodeVersion)(nil)).Elem()
}

func (o ServiceSourceCodeVersionOutput) ToServiceSourceCodeVersionOutput() ServiceSourceCodeVersionOutput {
	return o
}

func (o ServiceSourceCodeVersionOutput) ToServiceSourceCodeVersionOutputWithContext(ctx context.Context) ServiceSourceCodeVersionOutput {
	return o
}

func (o ServiceSourceCodeVersionOutput) ToServiceSourceCodeVersionPtrOutput() ServiceSourceCodeVersionPtrOutput {
	return o.ToServiceSourceCodeVersionPtrOutputWithContext(context.Background())
}

func (o ServiceSourceCodeVersionOutput) ToServiceSourceCodeVersionPtrOutputWithContext(ctx context.Context) ServiceSourceCodeVersionPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ServiceSourceCodeVersion) *ServiceSourceCodeVersion {
		return &v
	}).(ServiceSourceCodeVersionPtrOutput)
}

// Source Code Version Type
func (o ServiceSourceCodeVersionOutput) Type() ServiceSourceCodeVersionTypeOutput {
	return o.ApplyT(func(v ServiceSourceCodeVersion) ServiceSourceCodeVersionType { return v.Type }).(ServiceSourceCodeVersionTypeOutput)
}

// Source Code Version Value
func (o ServiceSourceCodeVersionOutput) Value() pulumi.StringOutput {
	return o.ApplyT(func(v ServiceSourceCodeVersion) string { return v.Value }).(pulumi.StringOutput)
}

type ServiceSourceCodeVersionPtrOutput struct{ *pulumi.OutputState }

func (ServiceSourceCodeVersionPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceSourceCodeVersion)(nil)).Elem()
}

func (o ServiceSourceCodeVersionPtrOutput) ToServiceSourceCodeVersionPtrOutput() ServiceSourceCodeVersionPtrOutput {
	return o
}

func (o ServiceSourceCodeVersionPtrOutput) ToServiceSourceCodeVersionPtrOutputWithContext(ctx context.Context) ServiceSourceCodeVersionPtrOutput {
	return o
}

func (o ServiceSourceCodeVersionPtrOutput) Elem() ServiceSourceCodeVersionOutput {
	return o.ApplyT(func(v *ServiceSourceCodeVersion) ServiceSourceCodeVersion {
		if v != nil {
			return *v
		}
		var ret ServiceSourceCodeVersion
		return ret
	}).(ServiceSourceCodeVersionOutput)
}

// Source Code Version Type
func (o ServiceSourceCodeVersionPtrOutput) Type() ServiceSourceCodeVersionTypePtrOutput {
	return o.ApplyT(func(v *ServiceSourceCodeVersion) *ServiceSourceCodeVersionType {
		if v == nil {
			return nil
		}
		return &v.Type
	}).(ServiceSourceCodeVersionTypePtrOutput)
}

// Source Code Version Value
func (o ServiceSourceCodeVersionPtrOutput) Value() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ServiceSourceCodeVersion) *string {
		if v == nil {
			return nil
		}
		return &v.Value
	}).(pulumi.StringPtrOutput)
}

// Source Code configuration
type ServiceSourceConfiguration struct {
	AuthenticationConfiguration *ServiceAuthenticationConfiguration `pulumi:"authenticationConfiguration"`
	// Auto Deployment enabled
	AutoDeploymentsEnabled *bool                   `pulumi:"autoDeploymentsEnabled"`
	CodeRepository         *ServiceCodeRepository  `pulumi:"codeRepository"`
	ImageRepository        *ServiceImageRepository `pulumi:"imageRepository"`
}

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

	ToServiceSourceConfigurationOutput() ServiceSourceConfigurationOutput
	ToServiceSourceConfigurationOutputWithContext(context.Context) ServiceSourceConfigurationOutput
}

// Source Code configuration
type ServiceSourceConfigurationArgs struct {
	AuthenticationConfiguration ServiceAuthenticationConfigurationPtrInput `pulumi:"authenticationConfiguration"`
	// Auto Deployment enabled
	AutoDeploymentsEnabled pulumi.BoolPtrInput            `pulumi:"autoDeploymentsEnabled"`
	CodeRepository         ServiceCodeRepositoryPtrInput  `pulumi:"codeRepository"`
	ImageRepository        ServiceImageRepositoryPtrInput `pulumi:"imageRepository"`
}

func (ServiceSourceConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceSourceConfiguration)(nil)).Elem()
}

func (i ServiceSourceConfigurationArgs) ToServiceSourceConfigurationOutput() ServiceSourceConfigurationOutput {
	return i.ToServiceSourceConfigurationOutputWithContext(context.Background())
}

func (i ServiceSourceConfigurationArgs) ToServiceSourceConfigurationOutputWithContext(ctx context.Context) ServiceSourceConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ServiceSourceConfigurationOutput)
}

// Source Code configuration
type ServiceSourceConfigurationOutput struct{ *pulumi.OutputState }

func (ServiceSourceConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ServiceSourceConfiguration)(nil)).Elem()
}

func (o ServiceSourceConfigurationOutput) ToServiceSourceConfigurationOutput() ServiceSourceConfigurationOutput {
	return o
}

func (o ServiceSourceConfigurationOutput) ToServiceSourceConfigurationOutputWithContext(ctx context.Context) ServiceSourceConfigurationOutput {
	return o
}

func (o ServiceSourceConfigurationOutput) AuthenticationConfiguration() ServiceAuthenticationConfigurationPtrOutput {
	return o.ApplyT(func(v ServiceSourceConfiguration) *ServiceAuthenticationConfiguration {
		return v.AuthenticationConfiguration
	}).(ServiceAuthenticationConfigurationPtrOutput)
}

// Auto Deployment enabled
func (o ServiceSourceConfigurationOutput) AutoDeploymentsEnabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v ServiceSourceConfiguration) *bool { return v.AutoDeploymentsEnabled }).(pulumi.BoolPtrOutput)
}

func (o ServiceSourceConfigurationOutput) CodeRepository() ServiceCodeRepositoryPtrOutput {
	return o.ApplyT(func(v ServiceSourceConfiguration) *ServiceCodeRepository { return v.CodeRepository }).(ServiceCodeRepositoryPtrOutput)
}

func (o ServiceSourceConfigurationOutput) ImageRepository() ServiceImageRepositoryPtrOutput {
	return o.ApplyT(func(v ServiceSourceConfiguration) *ServiceImageRepository { return v.ImageRepository }).(ServiceImageRepositoryPtrOutput)
}

type ServiceSourceConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ServiceSourceConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ServiceSourceConfiguration)(nil)).Elem()
}

func (o ServiceSourceConfigurationPtrOutput) ToServiceSourceConfigurationPtrOutput() ServiceSourceConfigurationPtrOutput {
	return o
}

func (o ServiceSourceConfigurationPtrOutput) ToServiceSourceConfigurationPtrOutputWithContext(ctx context.Context) ServiceSourceConfigurationPtrOutput {
	return o
}

func (o ServiceSourceConfigurationPtrOutput) Elem() ServiceSourceConfigurationOutput {
	return o.ApplyT(func(v *ServiceSourceConfiguration) ServiceSourceConfiguration {
		if v != nil {
			return *v
		}
		var ret ServiceSourceConfiguration
		return ret
	}).(ServiceSourceConfigurationOutput)
}

func (o ServiceSourceConfigurationPtrOutput) AuthenticationConfiguration() ServiceAuthenticationConfigurationPtrOutput {
	return o.ApplyT(func(v *ServiceSourceConfiguration) *ServiceAuthenticationConfiguration {
		if v == nil {
			return nil
		}
		return v.AuthenticationConfiguration
	}).(ServiceAuthenticationConfigurationPtrOutput)
}

// Auto Deployment enabled
func (o ServiceSourceConfigurationPtrOutput) AutoDeploymentsEnabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *ServiceSourceConfiguration) *bool {
		if v == nil {
			return nil
		}
		return v.AutoDeploymentsEnabled
	}).(pulumi.BoolPtrOutput)
}

func (o ServiceSourceConfigurationPtrOutput) CodeRepository() ServiceCodeRepositoryPtrOutput {
	return o.ApplyT(func(v *ServiceSourceConfiguration) *ServiceCodeRepository {
		if v == nil {
			return nil
		}
		return v.CodeRepository
	}).(ServiceCodeRepositoryPtrOutput)
}

func (o ServiceSourceConfigurationPtrOutput) ImageRepository() ServiceImageRepositoryPtrOutput {
	return o.ApplyT(func(v *ServiceSourceConfiguration) *ServiceImageRepository {
		if v == nil {
			return nil
		}
		return v.ImageRepository
	}).(ServiceImageRepositoryPtrOutput)
}

type ServiceTag struct {
	Key   *string `pulumi:"key"`
	Value *string `pulumi:"value"`
}

type VpcConnectorTag struct {
	Key   *string `pulumi:"key"`
	Value *string `pulumi:"value"`
}

// The configuration of customer’s VPC and related VPC endpoint
type VpcIngressConnectionIngressVpcConfiguration struct {
	// The ID of the VPC endpoint that your App Runner service connects to.
	VpcEndpointId string `pulumi:"vpcEndpointId"`
	// The ID of the VPC that the VPC endpoint is used in.
	VpcId string `pulumi:"vpcId"`
}

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

	ToVpcIngressConnectionIngressVpcConfigurationOutput() VpcIngressConnectionIngressVpcConfigurationOutput
	ToVpcIngressConnectionIngressVpcConfigurationOutputWithContext(context.Context) VpcIngressConnectionIngressVpcConfigurationOutput
}

// The configuration of customer’s VPC and related VPC endpoint
type VpcIngressConnectionIngressVpcConfigurationArgs struct {
	// The ID of the VPC endpoint that your App Runner service connects to.
	VpcEndpointId pulumi.StringInput `pulumi:"vpcEndpointId"`
	// The ID of the VPC that the VPC endpoint is used in.
	VpcId pulumi.StringInput `pulumi:"vpcId"`
}

func (VpcIngressConnectionIngressVpcConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*VpcIngressConnectionIngressVpcConfiguration)(nil)).Elem()
}

func (i VpcIngressConnectionIngressVpcConfigurationArgs) ToVpcIngressConnectionIngressVpcConfigurationOutput() VpcIngressConnectionIngressVpcConfigurationOutput {
	return i.ToVpcIngressConnectionIngressVpcConfigurationOutputWithContext(context.Background())
}

func (i VpcIngressConnectionIngressVpcConfigurationArgs) ToVpcIngressConnectionIngressVpcConfigurationOutputWithContext(ctx context.Context) VpcIngressConnectionIngressVpcConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(VpcIngressConnectionIngressVpcConfigurationOutput)
}

// The configuration of customer’s VPC and related VPC endpoint
type VpcIngressConnectionIngressVpcConfigurationOutput struct{ *pulumi.OutputState }

func (VpcIngressConnectionIngressVpcConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*VpcIngressConnectionIngressVpcConfiguration)(nil)).Elem()
}

func (o VpcIngressConnectionIngressVpcConfigurationOutput) ToVpcIngressConnectionIngressVpcConfigurationOutput() VpcIngressConnectionIngressVpcConfigurationOutput {
	return o
}

func (o VpcIngressConnectionIngressVpcConfigurationOutput) ToVpcIngressConnectionIngressVpcConfigurationOutputWithContext(ctx context.Context) VpcIngressConnectionIngressVpcConfigurationOutput {
	return o
}

// The ID of the VPC endpoint that your App Runner service connects to.
func (o VpcIngressConnectionIngressVpcConfigurationOutput) VpcEndpointId() pulumi.StringOutput {
	return o.ApplyT(func(v VpcIngressConnectionIngressVpcConfiguration) string { return v.VpcEndpointId }).(pulumi.StringOutput)
}

// The ID of the VPC that the VPC endpoint is used in.
func (o VpcIngressConnectionIngressVpcConfigurationOutput) VpcId() pulumi.StringOutput {
	return o.ApplyT(func(v VpcIngressConnectionIngressVpcConfiguration) string { return v.VpcId }).(pulumi.StringOutput)
}

type VpcIngressConnectionIngressVpcConfigurationPtrOutput struct{ *pulumi.OutputState }

func (VpcIngressConnectionIngressVpcConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**VpcIngressConnectionIngressVpcConfiguration)(nil)).Elem()
}

func (o VpcIngressConnectionIngressVpcConfigurationPtrOutput) ToVpcIngressConnectionIngressVpcConfigurationPtrOutput() VpcIngressConnectionIngressVpcConfigurationPtrOutput {
	return o
}

func (o VpcIngressConnectionIngressVpcConfigurationPtrOutput) ToVpcIngressConnectionIngressVpcConfigurationPtrOutputWithContext(ctx context.Context) VpcIngressConnectionIngressVpcConfigurationPtrOutput {
	return o
}

func (o VpcIngressConnectionIngressVpcConfigurationPtrOutput) Elem() VpcIngressConnectionIngressVpcConfigurationOutput {
	return o.ApplyT(func(v *VpcIngressConnectionIngressVpcConfiguration) VpcIngressConnectionIngressVpcConfiguration {
		if v != nil {
			return *v
		}
		var ret VpcIngressConnectionIngressVpcConfiguration
		return ret
	}).(VpcIngressConnectionIngressVpcConfigurationOutput)
}

// The ID of the VPC endpoint that your App Runner service connects to.
func (o VpcIngressConnectionIngressVpcConfigurationPtrOutput) VpcEndpointId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *VpcIngressConnectionIngressVpcConfiguration) *string {
		if v == nil {
			return nil
		}
		return &v.VpcEndpointId
	}).(pulumi.StringPtrOutput)
}

// The ID of the VPC that the VPC endpoint is used in.
func (o VpcIngressConnectionIngressVpcConfigurationPtrOutput) VpcId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *VpcIngressConnectionIngressVpcConfiguration) *string {
		if v == nil {
			return nil
		}
		return &v.VpcId
	}).(pulumi.StringPtrOutput)
}

type VpcIngressConnectionTag struct {
	Key   *string `pulumi:"key"`
	Value *string `pulumi:"value"`
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityConfigurationTraceConfigurationInput)(nil)).Elem(), ObservabilityConfigurationTraceConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ObservabilityConfigurationTraceConfigurationPtrInput)(nil)).Elem(), ObservabilityConfigurationTraceConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceAuthenticationConfigurationInput)(nil)).Elem(), ServiceAuthenticationConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceAuthenticationConfigurationPtrInput)(nil)).Elem(), ServiceAuthenticationConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceCodeConfigurationInput)(nil)).Elem(), ServiceCodeConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceCodeConfigurationPtrInput)(nil)).Elem(), ServiceCodeConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceCodeConfigurationValuesInput)(nil)).Elem(), ServiceCodeConfigurationValuesArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceCodeConfigurationValuesPtrInput)(nil)).Elem(), ServiceCodeConfigurationValuesArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceCodeRepositoryInput)(nil)).Elem(), ServiceCodeRepositoryArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceCodeRepositoryPtrInput)(nil)).Elem(), ServiceCodeRepositoryArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceEgressConfigurationInput)(nil)).Elem(), ServiceEgressConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceEgressConfigurationPtrInput)(nil)).Elem(), ServiceEgressConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceEncryptionConfigurationInput)(nil)).Elem(), ServiceEncryptionConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceEncryptionConfigurationPtrInput)(nil)).Elem(), ServiceEncryptionConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceHealthCheckConfigurationInput)(nil)).Elem(), ServiceHealthCheckConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceHealthCheckConfigurationPtrInput)(nil)).Elem(), ServiceHealthCheckConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceImageConfigurationInput)(nil)).Elem(), ServiceImageConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceImageConfigurationPtrInput)(nil)).Elem(), ServiceImageConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceImageRepositoryInput)(nil)).Elem(), ServiceImageRepositoryArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceImageRepositoryPtrInput)(nil)).Elem(), ServiceImageRepositoryArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceIngressConfigurationInput)(nil)).Elem(), ServiceIngressConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceIngressConfigurationPtrInput)(nil)).Elem(), ServiceIngressConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceInstanceConfigurationInput)(nil)).Elem(), ServiceInstanceConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceInstanceConfigurationPtrInput)(nil)).Elem(), ServiceInstanceConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceKeyValuePairInput)(nil)).Elem(), ServiceKeyValuePairArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceKeyValuePairArrayInput)(nil)).Elem(), ServiceKeyValuePairArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceNetworkConfigurationInput)(nil)).Elem(), ServiceNetworkConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceNetworkConfigurationPtrInput)(nil)).Elem(), ServiceNetworkConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceObservabilityConfigurationInput)(nil)).Elem(), ServiceObservabilityConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceObservabilityConfigurationPtrInput)(nil)).Elem(), ServiceObservabilityConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceSourceCodeVersionInput)(nil)).Elem(), ServiceSourceCodeVersionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceSourceCodeVersionPtrInput)(nil)).Elem(), ServiceSourceCodeVersionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ServiceSourceConfigurationInput)(nil)).Elem(), ServiceSourceConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*VpcIngressConnectionIngressVpcConfigurationInput)(nil)).Elem(), VpcIngressConnectionIngressVpcConfigurationArgs{})
	pulumi.RegisterOutputType(ObservabilityConfigurationTraceConfigurationOutput{})
	pulumi.RegisterOutputType(ObservabilityConfigurationTraceConfigurationPtrOutput{})
	pulumi.RegisterOutputType(ServiceAuthenticationConfigurationOutput{})
	pulumi.RegisterOutputType(ServiceAuthenticationConfigurationPtrOutput{})
	pulumi.RegisterOutputType(ServiceCodeConfigurationOutput{})
	pulumi.RegisterOutputType(ServiceCodeConfigurationPtrOutput{})
	pulumi.RegisterOutputType(ServiceCodeConfigurationValuesOutput{})
	pulumi.RegisterOutputType(ServiceCodeConfigurationValuesPtrOutput{})
	pulumi.RegisterOutputType(ServiceCodeRepositoryOutput{})
	pulumi.RegisterOutputType(ServiceCodeRepositoryPtrOutput{})
	pulumi.RegisterOutputType(ServiceEgressConfigurationOutput{})
	pulumi.RegisterOutputType(ServiceEgressConfigurationPtrOutput{})
	pulumi.RegisterOutputType(ServiceEncryptionConfigurationOutput{})
	pulumi.RegisterOutputType(ServiceEncryptionConfigurationPtrOutput{})
	pulumi.RegisterOutputType(ServiceHealthCheckConfigurationOutput{})
	pulumi.RegisterOutputType(ServiceHealthCheckConfigurationPtrOutput{})
	pulumi.RegisterOutputType(ServiceImageConfigurationOutput{})
	pulumi.RegisterOutputType(ServiceImageConfigurationPtrOutput{})
	pulumi.RegisterOutputType(ServiceImageRepositoryOutput{})
	pulumi.RegisterOutputType(ServiceImageRepositoryPtrOutput{})
	pulumi.RegisterOutputType(ServiceIngressConfigurationOutput{})
	pulumi.RegisterOutputType(ServiceIngressConfigurationPtrOutput{})
	pulumi.RegisterOutputType(ServiceInstanceConfigurationOutput{})
	pulumi.RegisterOutputType(ServiceInstanceConfigurationPtrOutput{})
	pulumi.RegisterOutputType(ServiceKeyValuePairOutput{})
	pulumi.RegisterOutputType(ServiceKeyValuePairArrayOutput{})
	pulumi.RegisterOutputType(ServiceNetworkConfigurationOutput{})
	pulumi.RegisterOutputType(ServiceNetworkConfigurationPtrOutput{})
	pulumi.RegisterOutputType(ServiceObservabilityConfigurationOutput{})
	pulumi.RegisterOutputType(ServiceObservabilityConfigurationPtrOutput{})
	pulumi.RegisterOutputType(ServiceSourceCodeVersionOutput{})
	pulumi.RegisterOutputType(ServiceSourceCodeVersionPtrOutput{})
	pulumi.RegisterOutputType(ServiceSourceConfigurationOutput{})
	pulumi.RegisterOutputType(ServiceSourceConfigurationPtrOutput{})
	pulumi.RegisterOutputType(VpcIngressConnectionIngressVpcConfigurationOutput{})
	pulumi.RegisterOutputType(VpcIngressConnectionIngressVpcConfigurationPtrOutput{})
}