pulumiTypes.go

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

package ct

import (
	"context"
	"reflect"

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

type ContainerClone struct {
	DatastoreId *string `pulumi:"datastoreId"`
	NodeName    *string `pulumi:"nodeName"`
	VmId        int     `pulumi:"vmId"`
}

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

	ToContainerCloneOutput() ContainerCloneOutput
	ToContainerCloneOutputWithContext(context.Context) ContainerCloneOutput
}

type ContainerCloneArgs struct {
	DatastoreId pulumi.StringPtrInput `pulumi:"datastoreId"`
	NodeName    pulumi.StringPtrInput `pulumi:"nodeName"`
	VmId        pulumi.IntInput       `pulumi:"vmId"`
}

func (ContainerCloneArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerClone)(nil)).Elem()
}

func (i ContainerCloneArgs) ToContainerCloneOutput() ContainerCloneOutput {
	return i.ToContainerCloneOutputWithContext(context.Background())
}

func (i ContainerCloneArgs) ToContainerCloneOutputWithContext(ctx context.Context) ContainerCloneOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerCloneOutput)
}

func (i ContainerCloneArgs) ToContainerClonePtrOutput() ContainerClonePtrOutput {
	return i.ToContainerClonePtrOutputWithContext(context.Background())
}

func (i ContainerCloneArgs) ToContainerClonePtrOutputWithContext(ctx context.Context) ContainerClonePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerCloneOutput).ToContainerClonePtrOutputWithContext(ctx)
}

// ContainerClonePtrInput is an input type that accepts ContainerCloneArgs, ContainerClonePtr and ContainerClonePtrOutput values.
// You can construct a concrete instance of `ContainerClonePtrInput` via:
//
//	        ContainerCloneArgs{...}
//
//	or:
//
//	        nil
type ContainerClonePtrInput interface {
	pulumi.Input

	ToContainerClonePtrOutput() ContainerClonePtrOutput
	ToContainerClonePtrOutputWithContext(context.Context) ContainerClonePtrOutput
}

type containerClonePtrType ContainerCloneArgs

func ContainerClonePtr(v *ContainerCloneArgs) ContainerClonePtrInput {
	return (*containerClonePtrType)(v)
}

func (*containerClonePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerClone)(nil)).Elem()
}

func (i *containerClonePtrType) ToContainerClonePtrOutput() ContainerClonePtrOutput {
	return i.ToContainerClonePtrOutputWithContext(context.Background())
}

func (i *containerClonePtrType) ToContainerClonePtrOutputWithContext(ctx context.Context) ContainerClonePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerClonePtrOutput)
}

type ContainerCloneOutput struct{ *pulumi.OutputState }

func (ContainerCloneOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerClone)(nil)).Elem()
}

func (o ContainerCloneOutput) ToContainerCloneOutput() ContainerCloneOutput {
	return o
}

func (o ContainerCloneOutput) ToContainerCloneOutputWithContext(ctx context.Context) ContainerCloneOutput {
	return o
}

func (o ContainerCloneOutput) ToContainerClonePtrOutput() ContainerClonePtrOutput {
	return o.ToContainerClonePtrOutputWithContext(context.Background())
}

func (o ContainerCloneOutput) ToContainerClonePtrOutputWithContext(ctx context.Context) ContainerClonePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ContainerClone) *ContainerClone {
		return &v
	}).(ContainerClonePtrOutput)
}

func (o ContainerCloneOutput) DatastoreId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ContainerClone) *string { return v.DatastoreId }).(pulumi.StringPtrOutput)
}

func (o ContainerCloneOutput) NodeName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ContainerClone) *string { return v.NodeName }).(pulumi.StringPtrOutput)
}

func (o ContainerCloneOutput) VmId() pulumi.IntOutput {
	return o.ApplyT(func(v ContainerClone) int { return v.VmId }).(pulumi.IntOutput)
}

type ContainerClonePtrOutput struct{ *pulumi.OutputState }

func (ContainerClonePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerClone)(nil)).Elem()
}

func (o ContainerClonePtrOutput) ToContainerClonePtrOutput() ContainerClonePtrOutput {
	return o
}

func (o ContainerClonePtrOutput) ToContainerClonePtrOutputWithContext(ctx context.Context) ContainerClonePtrOutput {
	return o
}

func (o ContainerClonePtrOutput) Elem() ContainerCloneOutput {
	return o.ApplyT(func(v *ContainerClone) ContainerClone {
		if v != nil {
			return *v
		}
		var ret ContainerClone
		return ret
	}).(ContainerCloneOutput)
}

func (o ContainerClonePtrOutput) DatastoreId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ContainerClone) *string {
		if v == nil {
			return nil
		}
		return v.DatastoreId
	}).(pulumi.StringPtrOutput)
}

func (o ContainerClonePtrOutput) NodeName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ContainerClone) *string {
		if v == nil {
			return nil
		}
		return v.NodeName
	}).(pulumi.StringPtrOutput)
}

func (o ContainerClonePtrOutput) VmId() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *ContainerClone) *int {
		if v == nil {
			return nil
		}
		return &v.VmId
	}).(pulumi.IntPtrOutput)
}

type ContainerConsole struct {
	Enabled  *bool   `pulumi:"enabled"`
	TtyCount *int    `pulumi:"ttyCount"`
	Type     *string `pulumi:"type"`
}

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

	ToContainerConsoleOutput() ContainerConsoleOutput
	ToContainerConsoleOutputWithContext(context.Context) ContainerConsoleOutput
}

type ContainerConsoleArgs struct {
	Enabled  pulumi.BoolPtrInput   `pulumi:"enabled"`
	TtyCount pulumi.IntPtrInput    `pulumi:"ttyCount"`
	Type     pulumi.StringPtrInput `pulumi:"type"`
}

func (ContainerConsoleArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerConsole)(nil)).Elem()
}

func (i ContainerConsoleArgs) ToContainerConsoleOutput() ContainerConsoleOutput {
	return i.ToContainerConsoleOutputWithContext(context.Background())
}

func (i ContainerConsoleArgs) ToContainerConsoleOutputWithContext(ctx context.Context) ContainerConsoleOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerConsoleOutput)
}

func (i ContainerConsoleArgs) ToContainerConsolePtrOutput() ContainerConsolePtrOutput {
	return i.ToContainerConsolePtrOutputWithContext(context.Background())
}

func (i ContainerConsoleArgs) ToContainerConsolePtrOutputWithContext(ctx context.Context) ContainerConsolePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerConsoleOutput).ToContainerConsolePtrOutputWithContext(ctx)
}

// ContainerConsolePtrInput is an input type that accepts ContainerConsoleArgs, ContainerConsolePtr and ContainerConsolePtrOutput values.
// You can construct a concrete instance of `ContainerConsolePtrInput` via:
//
//	        ContainerConsoleArgs{...}
//
//	or:
//
//	        nil
type ContainerConsolePtrInput interface {
	pulumi.Input

	ToContainerConsolePtrOutput() ContainerConsolePtrOutput
	ToContainerConsolePtrOutputWithContext(context.Context) ContainerConsolePtrOutput
}

type containerConsolePtrType ContainerConsoleArgs

func ContainerConsolePtr(v *ContainerConsoleArgs) ContainerConsolePtrInput {
	return (*containerConsolePtrType)(v)
}

func (*containerConsolePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerConsole)(nil)).Elem()
}

func (i *containerConsolePtrType) ToContainerConsolePtrOutput() ContainerConsolePtrOutput {
	return i.ToContainerConsolePtrOutputWithContext(context.Background())
}

func (i *containerConsolePtrType) ToContainerConsolePtrOutputWithContext(ctx context.Context) ContainerConsolePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerConsolePtrOutput)
}

type ContainerConsoleOutput struct{ *pulumi.OutputState }

func (ContainerConsoleOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerConsole)(nil)).Elem()
}

func (o ContainerConsoleOutput) ToContainerConsoleOutput() ContainerConsoleOutput {
	return o
}

func (o ContainerConsoleOutput) ToContainerConsoleOutputWithContext(ctx context.Context) ContainerConsoleOutput {
	return o
}

func (o ContainerConsoleOutput) ToContainerConsolePtrOutput() ContainerConsolePtrOutput {
	return o.ToContainerConsolePtrOutputWithContext(context.Background())
}

func (o ContainerConsoleOutput) ToContainerConsolePtrOutputWithContext(ctx context.Context) ContainerConsolePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ContainerConsole) *ContainerConsole {
		return &v
	}).(ContainerConsolePtrOutput)
}

func (o ContainerConsoleOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v ContainerConsole) *bool { return v.Enabled }).(pulumi.BoolPtrOutput)
}

func (o ContainerConsoleOutput) TtyCount() pulumi.IntPtrOutput {
	return o.ApplyT(func(v ContainerConsole) *int { return v.TtyCount }).(pulumi.IntPtrOutput)
}

func (o ContainerConsoleOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ContainerConsole) *string { return v.Type }).(pulumi.StringPtrOutput)
}

type ContainerConsolePtrOutput struct{ *pulumi.OutputState }

func (ContainerConsolePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerConsole)(nil)).Elem()
}

func (o ContainerConsolePtrOutput) ToContainerConsolePtrOutput() ContainerConsolePtrOutput {
	return o
}

func (o ContainerConsolePtrOutput) ToContainerConsolePtrOutputWithContext(ctx context.Context) ContainerConsolePtrOutput {
	return o
}

func (o ContainerConsolePtrOutput) Elem() ContainerConsoleOutput {
	return o.ApplyT(func(v *ContainerConsole) ContainerConsole {
		if v != nil {
			return *v
		}
		var ret ContainerConsole
		return ret
	}).(ContainerConsoleOutput)
}

func (o ContainerConsolePtrOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *ContainerConsole) *bool {
		if v == nil {
			return nil
		}
		return v.Enabled
	}).(pulumi.BoolPtrOutput)
}

func (o ContainerConsolePtrOutput) TtyCount() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *ContainerConsole) *int {
		if v == nil {
			return nil
		}
		return v.TtyCount
	}).(pulumi.IntPtrOutput)
}

func (o ContainerConsolePtrOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ContainerConsole) *string {
		if v == nil {
			return nil
		}
		return v.Type
	}).(pulumi.StringPtrOutput)
}

type ContainerCpu struct {
	Architecture *string `pulumi:"architecture"`
	Cores        *int    `pulumi:"cores"`
	Units        *int    `pulumi:"units"`
}

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

	ToContainerCpuOutput() ContainerCpuOutput
	ToContainerCpuOutputWithContext(context.Context) ContainerCpuOutput
}

type ContainerCpuArgs struct {
	Architecture pulumi.StringPtrInput `pulumi:"architecture"`
	Cores        pulumi.IntPtrInput    `pulumi:"cores"`
	Units        pulumi.IntPtrInput    `pulumi:"units"`
}

func (ContainerCpuArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerCpu)(nil)).Elem()
}

func (i ContainerCpuArgs) ToContainerCpuOutput() ContainerCpuOutput {
	return i.ToContainerCpuOutputWithContext(context.Background())
}

func (i ContainerCpuArgs) ToContainerCpuOutputWithContext(ctx context.Context) ContainerCpuOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerCpuOutput)
}

func (i ContainerCpuArgs) ToContainerCpuPtrOutput() ContainerCpuPtrOutput {
	return i.ToContainerCpuPtrOutputWithContext(context.Background())
}

func (i ContainerCpuArgs) ToContainerCpuPtrOutputWithContext(ctx context.Context) ContainerCpuPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerCpuOutput).ToContainerCpuPtrOutputWithContext(ctx)
}

// ContainerCpuPtrInput is an input type that accepts ContainerCpuArgs, ContainerCpuPtr and ContainerCpuPtrOutput values.
// You can construct a concrete instance of `ContainerCpuPtrInput` via:
//
//	        ContainerCpuArgs{...}
//
//	or:
//
//	        nil
type ContainerCpuPtrInput interface {
	pulumi.Input

	ToContainerCpuPtrOutput() ContainerCpuPtrOutput
	ToContainerCpuPtrOutputWithContext(context.Context) ContainerCpuPtrOutput
}

type containerCpuPtrType ContainerCpuArgs

func ContainerCpuPtr(v *ContainerCpuArgs) ContainerCpuPtrInput {
	return (*containerCpuPtrType)(v)
}

func (*containerCpuPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerCpu)(nil)).Elem()
}

func (i *containerCpuPtrType) ToContainerCpuPtrOutput() ContainerCpuPtrOutput {
	return i.ToContainerCpuPtrOutputWithContext(context.Background())
}

func (i *containerCpuPtrType) ToContainerCpuPtrOutputWithContext(ctx context.Context) ContainerCpuPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerCpuPtrOutput)
}

type ContainerCpuOutput struct{ *pulumi.OutputState }

func (ContainerCpuOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerCpu)(nil)).Elem()
}

func (o ContainerCpuOutput) ToContainerCpuOutput() ContainerCpuOutput {
	return o
}

func (o ContainerCpuOutput) ToContainerCpuOutputWithContext(ctx context.Context) ContainerCpuOutput {
	return o
}

func (o ContainerCpuOutput) ToContainerCpuPtrOutput() ContainerCpuPtrOutput {
	return o.ToContainerCpuPtrOutputWithContext(context.Background())
}

func (o ContainerCpuOutput) ToContainerCpuPtrOutputWithContext(ctx context.Context) ContainerCpuPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ContainerCpu) *ContainerCpu {
		return &v
	}).(ContainerCpuPtrOutput)
}

func (o ContainerCpuOutput) Architecture() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ContainerCpu) *string { return v.Architecture }).(pulumi.StringPtrOutput)
}

func (o ContainerCpuOutput) Cores() pulumi.IntPtrOutput {
	return o.ApplyT(func(v ContainerCpu) *int { return v.Cores }).(pulumi.IntPtrOutput)
}

func (o ContainerCpuOutput) Units() pulumi.IntPtrOutput {
	return o.ApplyT(func(v ContainerCpu) *int { return v.Units }).(pulumi.IntPtrOutput)
}

type ContainerCpuPtrOutput struct{ *pulumi.OutputState }

func (ContainerCpuPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerCpu)(nil)).Elem()
}

func (o ContainerCpuPtrOutput) ToContainerCpuPtrOutput() ContainerCpuPtrOutput {
	return o
}

func (o ContainerCpuPtrOutput) ToContainerCpuPtrOutputWithContext(ctx context.Context) ContainerCpuPtrOutput {
	return o
}

func (o ContainerCpuPtrOutput) Elem() ContainerCpuOutput {
	return o.ApplyT(func(v *ContainerCpu) ContainerCpu {
		if v != nil {
			return *v
		}
		var ret ContainerCpu
		return ret
	}).(ContainerCpuOutput)
}

func (o ContainerCpuPtrOutput) Architecture() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ContainerCpu) *string {
		if v == nil {
			return nil
		}
		return v.Architecture
	}).(pulumi.StringPtrOutput)
}

func (o ContainerCpuPtrOutput) Cores() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *ContainerCpu) *int {
		if v == nil {
			return nil
		}
		return v.Cores
	}).(pulumi.IntPtrOutput)
}

func (o ContainerCpuPtrOutput) Units() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *ContainerCpu) *int {
		if v == nil {
			return nil
		}
		return v.Units
	}).(pulumi.IntPtrOutput)
}

type ContainerDisk struct {
	DatastoreId *string `pulumi:"datastoreId"`
	Size        *int    `pulumi:"size"`
}

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

	ToContainerDiskOutput() ContainerDiskOutput
	ToContainerDiskOutputWithContext(context.Context) ContainerDiskOutput
}

type ContainerDiskArgs struct {
	DatastoreId pulumi.StringPtrInput `pulumi:"datastoreId"`
	Size        pulumi.IntPtrInput    `pulumi:"size"`
}

func (ContainerDiskArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerDisk)(nil)).Elem()
}

func (i ContainerDiskArgs) ToContainerDiskOutput() ContainerDiskOutput {
	return i.ToContainerDiskOutputWithContext(context.Background())
}

func (i ContainerDiskArgs) ToContainerDiskOutputWithContext(ctx context.Context) ContainerDiskOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerDiskOutput)
}

func (i ContainerDiskArgs) ToContainerDiskPtrOutput() ContainerDiskPtrOutput {
	return i.ToContainerDiskPtrOutputWithContext(context.Background())
}

func (i ContainerDiskArgs) ToContainerDiskPtrOutputWithContext(ctx context.Context) ContainerDiskPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerDiskOutput).ToContainerDiskPtrOutputWithContext(ctx)
}

// ContainerDiskPtrInput is an input type that accepts ContainerDiskArgs, ContainerDiskPtr and ContainerDiskPtrOutput values.
// You can construct a concrete instance of `ContainerDiskPtrInput` via:
//
//	        ContainerDiskArgs{...}
//
//	or:
//
//	        nil
type ContainerDiskPtrInput interface {
	pulumi.Input

	ToContainerDiskPtrOutput() ContainerDiskPtrOutput
	ToContainerDiskPtrOutputWithContext(context.Context) ContainerDiskPtrOutput
}

type containerDiskPtrType ContainerDiskArgs

func ContainerDiskPtr(v *ContainerDiskArgs) ContainerDiskPtrInput {
	return (*containerDiskPtrType)(v)
}

func (*containerDiskPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerDisk)(nil)).Elem()
}

func (i *containerDiskPtrType) ToContainerDiskPtrOutput() ContainerDiskPtrOutput {
	return i.ToContainerDiskPtrOutputWithContext(context.Background())
}

func (i *containerDiskPtrType) ToContainerDiskPtrOutputWithContext(ctx context.Context) ContainerDiskPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerDiskPtrOutput)
}

type ContainerDiskOutput struct{ *pulumi.OutputState }

func (ContainerDiskOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerDisk)(nil)).Elem()
}

func (o ContainerDiskOutput) ToContainerDiskOutput() ContainerDiskOutput {
	return o
}

func (o ContainerDiskOutput) ToContainerDiskOutputWithContext(ctx context.Context) ContainerDiskOutput {
	return o
}

func (o ContainerDiskOutput) ToContainerDiskPtrOutput() ContainerDiskPtrOutput {
	return o.ToContainerDiskPtrOutputWithContext(context.Background())
}

func (o ContainerDiskOutput) ToContainerDiskPtrOutputWithContext(ctx context.Context) ContainerDiskPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ContainerDisk) *ContainerDisk {
		return &v
	}).(ContainerDiskPtrOutput)
}

func (o ContainerDiskOutput) DatastoreId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ContainerDisk) *string { return v.DatastoreId }).(pulumi.StringPtrOutput)
}

func (o ContainerDiskOutput) Size() pulumi.IntPtrOutput {
	return o.ApplyT(func(v ContainerDisk) *int { return v.Size }).(pulumi.IntPtrOutput)
}

type ContainerDiskPtrOutput struct{ *pulumi.OutputState }

func (ContainerDiskPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerDisk)(nil)).Elem()
}

func (o ContainerDiskPtrOutput) ToContainerDiskPtrOutput() ContainerDiskPtrOutput {
	return o
}

func (o ContainerDiskPtrOutput) ToContainerDiskPtrOutputWithContext(ctx context.Context) ContainerDiskPtrOutput {
	return o
}

func (o ContainerDiskPtrOutput) Elem() ContainerDiskOutput {
	return o.ApplyT(func(v *ContainerDisk) ContainerDisk {
		if v != nil {
			return *v
		}
		var ret ContainerDisk
		return ret
	}).(ContainerDiskOutput)
}

func (o ContainerDiskPtrOutput) DatastoreId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ContainerDisk) *string {
		if v == nil {
			return nil
		}
		return v.DatastoreId
	}).(pulumi.StringPtrOutput)
}

func (o ContainerDiskPtrOutput) Size() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *ContainerDisk) *int {
		if v == nil {
			return nil
		}
		return v.Size
	}).(pulumi.IntPtrOutput)
}

type ContainerFeatures struct {
	Nesting *bool `pulumi:"nesting"`
}

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

	ToContainerFeaturesOutput() ContainerFeaturesOutput
	ToContainerFeaturesOutputWithContext(context.Context) ContainerFeaturesOutput
}

type ContainerFeaturesArgs struct {
	Nesting pulumi.BoolPtrInput `pulumi:"nesting"`
}

func (ContainerFeaturesArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerFeatures)(nil)).Elem()
}

func (i ContainerFeaturesArgs) ToContainerFeaturesOutput() ContainerFeaturesOutput {
	return i.ToContainerFeaturesOutputWithContext(context.Background())
}

func (i ContainerFeaturesArgs) ToContainerFeaturesOutputWithContext(ctx context.Context) ContainerFeaturesOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerFeaturesOutput)
}

func (i ContainerFeaturesArgs) ToContainerFeaturesPtrOutput() ContainerFeaturesPtrOutput {
	return i.ToContainerFeaturesPtrOutputWithContext(context.Background())
}

func (i ContainerFeaturesArgs) ToContainerFeaturesPtrOutputWithContext(ctx context.Context) ContainerFeaturesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerFeaturesOutput).ToContainerFeaturesPtrOutputWithContext(ctx)
}

// ContainerFeaturesPtrInput is an input type that accepts ContainerFeaturesArgs, ContainerFeaturesPtr and ContainerFeaturesPtrOutput values.
// You can construct a concrete instance of `ContainerFeaturesPtrInput` via:
//
//	        ContainerFeaturesArgs{...}
//
//	or:
//
//	        nil
type ContainerFeaturesPtrInput interface {
	pulumi.Input

	ToContainerFeaturesPtrOutput() ContainerFeaturesPtrOutput
	ToContainerFeaturesPtrOutputWithContext(context.Context) ContainerFeaturesPtrOutput
}

type containerFeaturesPtrType ContainerFeaturesArgs

func ContainerFeaturesPtr(v *ContainerFeaturesArgs) ContainerFeaturesPtrInput {
	return (*containerFeaturesPtrType)(v)
}

func (*containerFeaturesPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerFeatures)(nil)).Elem()
}

func (i *containerFeaturesPtrType) ToContainerFeaturesPtrOutput() ContainerFeaturesPtrOutput {
	return i.ToContainerFeaturesPtrOutputWithContext(context.Background())
}

func (i *containerFeaturesPtrType) ToContainerFeaturesPtrOutputWithContext(ctx context.Context) ContainerFeaturesPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerFeaturesPtrOutput)
}

type ContainerFeaturesOutput struct{ *pulumi.OutputState }

func (ContainerFeaturesOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerFeatures)(nil)).Elem()
}

func (o ContainerFeaturesOutput) ToContainerFeaturesOutput() ContainerFeaturesOutput {
	return o
}

func (o ContainerFeaturesOutput) ToContainerFeaturesOutputWithContext(ctx context.Context) ContainerFeaturesOutput {
	return o
}

func (o ContainerFeaturesOutput) ToContainerFeaturesPtrOutput() ContainerFeaturesPtrOutput {
	return o.ToContainerFeaturesPtrOutputWithContext(context.Background())
}

func (o ContainerFeaturesOutput) ToContainerFeaturesPtrOutputWithContext(ctx context.Context) ContainerFeaturesPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ContainerFeatures) *ContainerFeatures {
		return &v
	}).(ContainerFeaturesPtrOutput)
}

func (o ContainerFeaturesOutput) Nesting() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v ContainerFeatures) *bool { return v.Nesting }).(pulumi.BoolPtrOutput)
}

type ContainerFeaturesPtrOutput struct{ *pulumi.OutputState }

func (ContainerFeaturesPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerFeatures)(nil)).Elem()
}

func (o ContainerFeaturesPtrOutput) ToContainerFeaturesPtrOutput() ContainerFeaturesPtrOutput {
	return o
}

func (o ContainerFeaturesPtrOutput) ToContainerFeaturesPtrOutputWithContext(ctx context.Context) ContainerFeaturesPtrOutput {
	return o
}

func (o ContainerFeaturesPtrOutput) Elem() ContainerFeaturesOutput {
	return o.ApplyT(func(v *ContainerFeatures) ContainerFeatures {
		if v != nil {
			return *v
		}
		var ret ContainerFeatures
		return ret
	}).(ContainerFeaturesOutput)
}

func (o ContainerFeaturesPtrOutput) Nesting() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *ContainerFeatures) *bool {
		if v == nil {
			return nil
		}
		return v.Nesting
	}).(pulumi.BoolPtrOutput)
}

type ContainerInitialization struct {
	Dns         *ContainerInitializationDns         `pulumi:"dns"`
	Hostname    *string                             `pulumi:"hostname"`
	IpConfigs   []ContainerInitializationIpConfig   `pulumi:"ipConfigs"`
	UserAccount *ContainerInitializationUserAccount `pulumi:"userAccount"`
}

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

	ToContainerInitializationOutput() ContainerInitializationOutput
	ToContainerInitializationOutputWithContext(context.Context) ContainerInitializationOutput
}

type ContainerInitializationArgs struct {
	Dns         ContainerInitializationDnsPtrInput         `pulumi:"dns"`
	Hostname    pulumi.StringPtrInput                      `pulumi:"hostname"`
	IpConfigs   ContainerInitializationIpConfigArrayInput  `pulumi:"ipConfigs"`
	UserAccount ContainerInitializationUserAccountPtrInput `pulumi:"userAccount"`
}

func (ContainerInitializationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerInitialization)(nil)).Elem()
}

func (i ContainerInitializationArgs) ToContainerInitializationOutput() ContainerInitializationOutput {
	return i.ToContainerInitializationOutputWithContext(context.Background())
}

func (i ContainerInitializationArgs) ToContainerInitializationOutputWithContext(ctx context.Context) ContainerInitializationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerInitializationOutput)
}

func (i ContainerInitializationArgs) ToContainerInitializationPtrOutput() ContainerInitializationPtrOutput {
	return i.ToContainerInitializationPtrOutputWithContext(context.Background())
}

func (i ContainerInitializationArgs) ToContainerInitializationPtrOutputWithContext(ctx context.Context) ContainerInitializationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerInitializationOutput).ToContainerInitializationPtrOutputWithContext(ctx)
}

// ContainerInitializationPtrInput is an input type that accepts ContainerInitializationArgs, ContainerInitializationPtr and ContainerInitializationPtrOutput values.
// You can construct a concrete instance of `ContainerInitializationPtrInput` via:
//
//	        ContainerInitializationArgs{...}
//
//	or:
//
//	        nil
type ContainerInitializationPtrInput interface {
	pulumi.Input

	ToContainerInitializationPtrOutput() ContainerInitializationPtrOutput
	ToContainerInitializationPtrOutputWithContext(context.Context) ContainerInitializationPtrOutput
}

type containerInitializationPtrType ContainerInitializationArgs

func ContainerInitializationPtr(v *ContainerInitializationArgs) ContainerInitializationPtrInput {
	return (*containerInitializationPtrType)(v)
}

func (*containerInitializationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerInitialization)(nil)).Elem()
}

func (i *containerInitializationPtrType) ToContainerInitializationPtrOutput() ContainerInitializationPtrOutput {
	return i.ToContainerInitializationPtrOutputWithContext(context.Background())
}

func (i *containerInitializationPtrType) ToContainerInitializationPtrOutputWithContext(ctx context.Context) ContainerInitializationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerInitializationPtrOutput)
}

type ContainerInitializationOutput struct{ *pulumi.OutputState }

func (ContainerInitializationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerInitialization)(nil)).Elem()
}

func (o ContainerInitializationOutput) ToContainerInitializationOutput() ContainerInitializationOutput {
	return o
}

func (o ContainerInitializationOutput) ToContainerInitializationOutputWithContext(ctx context.Context) ContainerInitializationOutput {
	return o
}

func (o ContainerInitializationOutput) ToContainerInitializationPtrOutput() ContainerInitializationPtrOutput {
	return o.ToContainerInitializationPtrOutputWithContext(context.Background())
}

func (o ContainerInitializationOutput) ToContainerInitializationPtrOutputWithContext(ctx context.Context) ContainerInitializationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ContainerInitialization) *ContainerInitialization {
		return &v
	}).(ContainerInitializationPtrOutput)
}

func (o ContainerInitializationOutput) Dns() ContainerInitializationDnsPtrOutput {
	return o.ApplyT(func(v ContainerInitialization) *ContainerInitializationDns { return v.Dns }).(ContainerInitializationDnsPtrOutput)
}

func (o ContainerInitializationOutput) Hostname() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ContainerInitialization) *string { return v.Hostname }).(pulumi.StringPtrOutput)
}

func (o ContainerInitializationOutput) IpConfigs() ContainerInitializationIpConfigArrayOutput {
	return o.ApplyT(func(v ContainerInitialization) []ContainerInitializationIpConfig { return v.IpConfigs }).(ContainerInitializationIpConfigArrayOutput)
}

func (o ContainerInitializationOutput) UserAccount() ContainerInitializationUserAccountPtrOutput {
	return o.ApplyT(func(v ContainerInitialization) *ContainerInitializationUserAccount { return v.UserAccount }).(ContainerInitializationUserAccountPtrOutput)
}

type ContainerInitializationPtrOutput struct{ *pulumi.OutputState }

func (ContainerInitializationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerInitialization)(nil)).Elem()
}

func (o ContainerInitializationPtrOutput) ToContainerInitializationPtrOutput() ContainerInitializationPtrOutput {
	return o
}

func (o ContainerInitializationPtrOutput) ToContainerInitializationPtrOutputWithContext(ctx context.Context) ContainerInitializationPtrOutput {
	return o
}

func (o ContainerInitializationPtrOutput) Elem() ContainerInitializationOutput {
	return o.ApplyT(func(v *ContainerInitialization) ContainerInitialization {
		if v != nil {
			return *v
		}
		var ret ContainerInitialization
		return ret
	}).(ContainerInitializationOutput)
}

func (o ContainerInitializationPtrOutput) Dns() ContainerInitializationDnsPtrOutput {
	return o.ApplyT(func(v *ContainerInitialization) *ContainerInitializationDns {
		if v == nil {
			return nil
		}
		return v.Dns
	}).(ContainerInitializationDnsPtrOutput)
}

func (o ContainerInitializationPtrOutput) Hostname() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ContainerInitialization) *string {
		if v == nil {
			return nil
		}
		return v.Hostname
	}).(pulumi.StringPtrOutput)
}

func (o ContainerInitializationPtrOutput) IpConfigs() ContainerInitializationIpConfigArrayOutput {
	return o.ApplyT(func(v *ContainerInitialization) []ContainerInitializationIpConfig {
		if v == nil {
			return nil
		}
		return v.IpConfigs
	}).(ContainerInitializationIpConfigArrayOutput)
}

func (o ContainerInitializationPtrOutput) UserAccount() ContainerInitializationUserAccountPtrOutput {
	return o.ApplyT(func(v *ContainerInitialization) *ContainerInitializationUserAccount {
		if v == nil {
			return nil
		}
		return v.UserAccount
	}).(ContainerInitializationUserAccountPtrOutput)
}

type ContainerInitializationDns struct {
	Domain *string `pulumi:"domain"`
	Server *string `pulumi:"server"`
}

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

	ToContainerInitializationDnsOutput() ContainerInitializationDnsOutput
	ToContainerInitializationDnsOutputWithContext(context.Context) ContainerInitializationDnsOutput
}

type ContainerInitializationDnsArgs struct {
	Domain pulumi.StringPtrInput `pulumi:"domain"`
	Server pulumi.StringPtrInput `pulumi:"server"`
}

func (ContainerInitializationDnsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerInitializationDns)(nil)).Elem()
}

func (i ContainerInitializationDnsArgs) ToContainerInitializationDnsOutput() ContainerInitializationDnsOutput {
	return i.ToContainerInitializationDnsOutputWithContext(context.Background())
}

func (i ContainerInitializationDnsArgs) ToContainerInitializationDnsOutputWithContext(ctx context.Context) ContainerInitializationDnsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerInitializationDnsOutput)
}

func (i ContainerInitializationDnsArgs) ToContainerInitializationDnsPtrOutput() ContainerInitializationDnsPtrOutput {
	return i.ToContainerInitializationDnsPtrOutputWithContext(context.Background())
}

func (i ContainerInitializationDnsArgs) ToContainerInitializationDnsPtrOutputWithContext(ctx context.Context) ContainerInitializationDnsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerInitializationDnsOutput).ToContainerInitializationDnsPtrOutputWithContext(ctx)
}

// ContainerInitializationDnsPtrInput is an input type that accepts ContainerInitializationDnsArgs, ContainerInitializationDnsPtr and ContainerInitializationDnsPtrOutput values.
// You can construct a concrete instance of `ContainerInitializationDnsPtrInput` via:
//
//	        ContainerInitializationDnsArgs{...}
//
//	or:
//
//	        nil
type ContainerInitializationDnsPtrInput interface {
	pulumi.Input

	ToContainerInitializationDnsPtrOutput() ContainerInitializationDnsPtrOutput
	ToContainerInitializationDnsPtrOutputWithContext(context.Context) ContainerInitializationDnsPtrOutput
}

type containerInitializationDnsPtrType ContainerInitializationDnsArgs

func ContainerInitializationDnsPtr(v *ContainerInitializationDnsArgs) ContainerInitializationDnsPtrInput {
	return (*containerInitializationDnsPtrType)(v)
}

func (*containerInitializationDnsPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerInitializationDns)(nil)).Elem()
}

func (i *containerInitializationDnsPtrType) ToContainerInitializationDnsPtrOutput() ContainerInitializationDnsPtrOutput {
	return i.ToContainerInitializationDnsPtrOutputWithContext(context.Background())
}

func (i *containerInitializationDnsPtrType) ToContainerInitializationDnsPtrOutputWithContext(ctx context.Context) ContainerInitializationDnsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerInitializationDnsPtrOutput)
}

type ContainerInitializationDnsOutput struct{ *pulumi.OutputState }

func (ContainerInitializationDnsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerInitializationDns)(nil)).Elem()
}

func (o ContainerInitializationDnsOutput) ToContainerInitializationDnsOutput() ContainerInitializationDnsOutput {
	return o
}

func (o ContainerInitializationDnsOutput) ToContainerInitializationDnsOutputWithContext(ctx context.Context) ContainerInitializationDnsOutput {
	return o
}

func (o ContainerInitializationDnsOutput) ToContainerInitializationDnsPtrOutput() ContainerInitializationDnsPtrOutput {
	return o.ToContainerInitializationDnsPtrOutputWithContext(context.Background())
}

func (o ContainerInitializationDnsOutput) ToContainerInitializationDnsPtrOutputWithContext(ctx context.Context) ContainerInitializationDnsPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ContainerInitializationDns) *ContainerInitializationDns {
		return &v
	}).(ContainerInitializationDnsPtrOutput)
}

func (o ContainerInitializationDnsOutput) Domain() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ContainerInitializationDns) *string { return v.Domain }).(pulumi.StringPtrOutput)
}

func (o ContainerInitializationDnsOutput) Server() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ContainerInitializationDns) *string { return v.Server }).(pulumi.StringPtrOutput)
}

type ContainerInitializationDnsPtrOutput struct{ *pulumi.OutputState }

func (ContainerInitializationDnsPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerInitializationDns)(nil)).Elem()
}

func (o ContainerInitializationDnsPtrOutput) ToContainerInitializationDnsPtrOutput() ContainerInitializationDnsPtrOutput {
	return o
}

func (o ContainerInitializationDnsPtrOutput) ToContainerInitializationDnsPtrOutputWithContext(ctx context.Context) ContainerInitializationDnsPtrOutput {
	return o
}

func (o ContainerInitializationDnsPtrOutput) Elem() ContainerInitializationDnsOutput {
	return o.ApplyT(func(v *ContainerInitializationDns) ContainerInitializationDns {
		if v != nil {
			return *v
		}
		var ret ContainerInitializationDns
		return ret
	}).(ContainerInitializationDnsOutput)
}

func (o ContainerInitializationDnsPtrOutput) Domain() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ContainerInitializationDns) *string {
		if v == nil {
			return nil
		}
		return v.Domain
	}).(pulumi.StringPtrOutput)
}

func (o ContainerInitializationDnsPtrOutput) Server() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ContainerInitializationDns) *string {
		if v == nil {
			return nil
		}
		return v.Server
	}).(pulumi.StringPtrOutput)
}

type ContainerInitializationIpConfig struct {
	Ipv4 *ContainerInitializationIpConfigIpv4 `pulumi:"ipv4"`
	Ipv6 *ContainerInitializationIpConfigIpv6 `pulumi:"ipv6"`
}

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

	ToContainerInitializationIpConfigOutput() ContainerInitializationIpConfigOutput
	ToContainerInitializationIpConfigOutputWithContext(context.Context) ContainerInitializationIpConfigOutput
}

type ContainerInitializationIpConfigArgs struct {
	Ipv4 ContainerInitializationIpConfigIpv4PtrInput `pulumi:"ipv4"`
	Ipv6 ContainerInitializationIpConfigIpv6PtrInput `pulumi:"ipv6"`
}

func (ContainerInitializationIpConfigArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerInitializationIpConfig)(nil)).Elem()
}

func (i ContainerInitializationIpConfigArgs) ToContainerInitializationIpConfigOutput() ContainerInitializationIpConfigOutput {
	return i.ToContainerInitializationIpConfigOutputWithContext(context.Background())
}

func (i ContainerInitializationIpConfigArgs) ToContainerInitializationIpConfigOutputWithContext(ctx context.Context) ContainerInitializationIpConfigOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerInitializationIpConfigOutput)
}

// ContainerInitializationIpConfigArrayInput is an input type that accepts ContainerInitializationIpConfigArray and ContainerInitializationIpConfigArrayOutput values.
// You can construct a concrete instance of `ContainerInitializationIpConfigArrayInput` via:
//
//	ContainerInitializationIpConfigArray{ ContainerInitializationIpConfigArgs{...} }
type ContainerInitializationIpConfigArrayInput interface {
	pulumi.Input

	ToContainerInitializationIpConfigArrayOutput() ContainerInitializationIpConfigArrayOutput
	ToContainerInitializationIpConfigArrayOutputWithContext(context.Context) ContainerInitializationIpConfigArrayOutput
}

type ContainerInitializationIpConfigArray []ContainerInitializationIpConfigInput

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

func (i ContainerInitializationIpConfigArray) ToContainerInitializationIpConfigArrayOutput() ContainerInitializationIpConfigArrayOutput {
	return i.ToContainerInitializationIpConfigArrayOutputWithContext(context.Background())
}

func (i ContainerInitializationIpConfigArray) ToContainerInitializationIpConfigArrayOutputWithContext(ctx context.Context) ContainerInitializationIpConfigArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerInitializationIpConfigArrayOutput)
}

type ContainerInitializationIpConfigOutput struct{ *pulumi.OutputState }

func (ContainerInitializationIpConfigOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerInitializationIpConfig)(nil)).Elem()
}

func (o ContainerInitializationIpConfigOutput) ToContainerInitializationIpConfigOutput() ContainerInitializationIpConfigOutput {
	return o
}

func (o ContainerInitializationIpConfigOutput) ToContainerInitializationIpConfigOutputWithContext(ctx context.Context) ContainerInitializationIpConfigOutput {
	return o
}

func (o ContainerInitializationIpConfigOutput) Ipv4() ContainerInitializationIpConfigIpv4PtrOutput {
	return o.ApplyT(func(v ContainerInitializationIpConfig) *ContainerInitializationIpConfigIpv4 { return v.Ipv4 }).(ContainerInitializationIpConfigIpv4PtrOutput)
}

func (o ContainerInitializationIpConfigOutput) Ipv6() ContainerInitializationIpConfigIpv6PtrOutput {
	return o.ApplyT(func(v ContainerInitializationIpConfig) *ContainerInitializationIpConfigIpv6 { return v.Ipv6 }).(ContainerInitializationIpConfigIpv6PtrOutput)
}

type ContainerInitializationIpConfigArrayOutput struct{ *pulumi.OutputState }

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

func (o ContainerInitializationIpConfigArrayOutput) ToContainerInitializationIpConfigArrayOutput() ContainerInitializationIpConfigArrayOutput {
	return o
}

func (o ContainerInitializationIpConfigArrayOutput) ToContainerInitializationIpConfigArrayOutputWithContext(ctx context.Context) ContainerInitializationIpConfigArrayOutput {
	return o
}

func (o ContainerInitializationIpConfigArrayOutput) Index(i pulumi.IntInput) ContainerInitializationIpConfigOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ContainerInitializationIpConfig {
		return vs[0].([]ContainerInitializationIpConfig)[vs[1].(int)]
	}).(ContainerInitializationIpConfigOutput)
}

type ContainerInitializationIpConfigIpv4 struct {
	Address *string `pulumi:"address"`
	Gateway *string `pulumi:"gateway"`
}

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

	ToContainerInitializationIpConfigIpv4Output() ContainerInitializationIpConfigIpv4Output
	ToContainerInitializationIpConfigIpv4OutputWithContext(context.Context) ContainerInitializationIpConfigIpv4Output
}

type ContainerInitializationIpConfigIpv4Args struct {
	Address pulumi.StringPtrInput `pulumi:"address"`
	Gateway pulumi.StringPtrInput `pulumi:"gateway"`
}

func (ContainerInitializationIpConfigIpv4Args) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerInitializationIpConfigIpv4)(nil)).Elem()
}

func (i ContainerInitializationIpConfigIpv4Args) ToContainerInitializationIpConfigIpv4Output() ContainerInitializationIpConfigIpv4Output {
	return i.ToContainerInitializationIpConfigIpv4OutputWithContext(context.Background())
}

func (i ContainerInitializationIpConfigIpv4Args) ToContainerInitializationIpConfigIpv4OutputWithContext(ctx context.Context) ContainerInitializationIpConfigIpv4Output {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerInitializationIpConfigIpv4Output)
}

func (i ContainerInitializationIpConfigIpv4Args) ToContainerInitializationIpConfigIpv4PtrOutput() ContainerInitializationIpConfigIpv4PtrOutput {
	return i.ToContainerInitializationIpConfigIpv4PtrOutputWithContext(context.Background())
}

func (i ContainerInitializationIpConfigIpv4Args) ToContainerInitializationIpConfigIpv4PtrOutputWithContext(ctx context.Context) ContainerInitializationIpConfigIpv4PtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerInitializationIpConfigIpv4Output).ToContainerInitializationIpConfigIpv4PtrOutputWithContext(ctx)
}

// ContainerInitializationIpConfigIpv4PtrInput is an input type that accepts ContainerInitializationIpConfigIpv4Args, ContainerInitializationIpConfigIpv4Ptr and ContainerInitializationIpConfigIpv4PtrOutput values.
// You can construct a concrete instance of `ContainerInitializationIpConfigIpv4PtrInput` via:
//
//	        ContainerInitializationIpConfigIpv4Args{...}
//
//	or:
//
//	        nil
type ContainerInitializationIpConfigIpv4PtrInput interface {
	pulumi.Input

	ToContainerInitializationIpConfigIpv4PtrOutput() ContainerInitializationIpConfigIpv4PtrOutput
	ToContainerInitializationIpConfigIpv4PtrOutputWithContext(context.Context) ContainerInitializationIpConfigIpv4PtrOutput
}

type containerInitializationIpConfigIpv4PtrType ContainerInitializationIpConfigIpv4Args

func ContainerInitializationIpConfigIpv4Ptr(v *ContainerInitializationIpConfigIpv4Args) ContainerInitializationIpConfigIpv4PtrInput {
	return (*containerInitializationIpConfigIpv4PtrType)(v)
}

func (*containerInitializationIpConfigIpv4PtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerInitializationIpConfigIpv4)(nil)).Elem()
}

func (i *containerInitializationIpConfigIpv4PtrType) ToContainerInitializationIpConfigIpv4PtrOutput() ContainerInitializationIpConfigIpv4PtrOutput {
	return i.ToContainerInitializationIpConfigIpv4PtrOutputWithContext(context.Background())
}

func (i *containerInitializationIpConfigIpv4PtrType) ToContainerInitializationIpConfigIpv4PtrOutputWithContext(ctx context.Context) ContainerInitializationIpConfigIpv4PtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerInitializationIpConfigIpv4PtrOutput)
}

type ContainerInitializationIpConfigIpv4Output struct{ *pulumi.OutputState }

func (ContainerInitializationIpConfigIpv4Output) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerInitializationIpConfigIpv4)(nil)).Elem()
}

func (o ContainerInitializationIpConfigIpv4Output) ToContainerInitializationIpConfigIpv4Output() ContainerInitializationIpConfigIpv4Output {
	return o
}

func (o ContainerInitializationIpConfigIpv4Output) ToContainerInitializationIpConfigIpv4OutputWithContext(ctx context.Context) ContainerInitializationIpConfigIpv4Output {
	return o
}

func (o ContainerInitializationIpConfigIpv4Output) ToContainerInitializationIpConfigIpv4PtrOutput() ContainerInitializationIpConfigIpv4PtrOutput {
	return o.ToContainerInitializationIpConfigIpv4PtrOutputWithContext(context.Background())
}

func (o ContainerInitializationIpConfigIpv4Output) ToContainerInitializationIpConfigIpv4PtrOutputWithContext(ctx context.Context) ContainerInitializationIpConfigIpv4PtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ContainerInitializationIpConfigIpv4) *ContainerInitializationIpConfigIpv4 {
		return &v
	}).(ContainerInitializationIpConfigIpv4PtrOutput)
}

func (o ContainerInitializationIpConfigIpv4Output) Address() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ContainerInitializationIpConfigIpv4) *string { return v.Address }).(pulumi.StringPtrOutput)
}

func (o ContainerInitializationIpConfigIpv4Output) Gateway() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ContainerInitializationIpConfigIpv4) *string { return v.Gateway }).(pulumi.StringPtrOutput)
}

type ContainerInitializationIpConfigIpv4PtrOutput struct{ *pulumi.OutputState }

func (ContainerInitializationIpConfigIpv4PtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerInitializationIpConfigIpv4)(nil)).Elem()
}

func (o ContainerInitializationIpConfigIpv4PtrOutput) ToContainerInitializationIpConfigIpv4PtrOutput() ContainerInitializationIpConfigIpv4PtrOutput {
	return o
}

func (o ContainerInitializationIpConfigIpv4PtrOutput) ToContainerInitializationIpConfigIpv4PtrOutputWithContext(ctx context.Context) ContainerInitializationIpConfigIpv4PtrOutput {
	return o
}

func (o ContainerInitializationIpConfigIpv4PtrOutput) Elem() ContainerInitializationIpConfigIpv4Output {
	return o.ApplyT(func(v *ContainerInitializationIpConfigIpv4) ContainerInitializationIpConfigIpv4 {
		if v != nil {
			return *v
		}
		var ret ContainerInitializationIpConfigIpv4
		return ret
	}).(ContainerInitializationIpConfigIpv4Output)
}

func (o ContainerInitializationIpConfigIpv4PtrOutput) Address() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ContainerInitializationIpConfigIpv4) *string {
		if v == nil {
			return nil
		}
		return v.Address
	}).(pulumi.StringPtrOutput)
}

func (o ContainerInitializationIpConfigIpv4PtrOutput) Gateway() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ContainerInitializationIpConfigIpv4) *string {
		if v == nil {
			return nil
		}
		return v.Gateway
	}).(pulumi.StringPtrOutput)
}

type ContainerInitializationIpConfigIpv6 struct {
	Address *string `pulumi:"address"`
	Gateway *string `pulumi:"gateway"`
}

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

	ToContainerInitializationIpConfigIpv6Output() ContainerInitializationIpConfigIpv6Output
	ToContainerInitializationIpConfigIpv6OutputWithContext(context.Context) ContainerInitializationIpConfigIpv6Output
}

type ContainerInitializationIpConfigIpv6Args struct {
	Address pulumi.StringPtrInput `pulumi:"address"`
	Gateway pulumi.StringPtrInput `pulumi:"gateway"`
}

func (ContainerInitializationIpConfigIpv6Args) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerInitializationIpConfigIpv6)(nil)).Elem()
}

func (i ContainerInitializationIpConfigIpv6Args) ToContainerInitializationIpConfigIpv6Output() ContainerInitializationIpConfigIpv6Output {
	return i.ToContainerInitializationIpConfigIpv6OutputWithContext(context.Background())
}

func (i ContainerInitializationIpConfigIpv6Args) ToContainerInitializationIpConfigIpv6OutputWithContext(ctx context.Context) ContainerInitializationIpConfigIpv6Output {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerInitializationIpConfigIpv6Output)
}

func (i ContainerInitializationIpConfigIpv6Args) ToContainerInitializationIpConfigIpv6PtrOutput() ContainerInitializationIpConfigIpv6PtrOutput {
	return i.ToContainerInitializationIpConfigIpv6PtrOutputWithContext(context.Background())
}

func (i ContainerInitializationIpConfigIpv6Args) ToContainerInitializationIpConfigIpv6PtrOutputWithContext(ctx context.Context) ContainerInitializationIpConfigIpv6PtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerInitializationIpConfigIpv6Output).ToContainerInitializationIpConfigIpv6PtrOutputWithContext(ctx)
}

// ContainerInitializationIpConfigIpv6PtrInput is an input type that accepts ContainerInitializationIpConfigIpv6Args, ContainerInitializationIpConfigIpv6Ptr and ContainerInitializationIpConfigIpv6PtrOutput values.
// You can construct a concrete instance of `ContainerInitializationIpConfigIpv6PtrInput` via:
//
//	        ContainerInitializationIpConfigIpv6Args{...}
//
//	or:
//
//	        nil
type ContainerInitializationIpConfigIpv6PtrInput interface {
	pulumi.Input

	ToContainerInitializationIpConfigIpv6PtrOutput() ContainerInitializationIpConfigIpv6PtrOutput
	ToContainerInitializationIpConfigIpv6PtrOutputWithContext(context.Context) ContainerInitializationIpConfigIpv6PtrOutput
}

type containerInitializationIpConfigIpv6PtrType ContainerInitializationIpConfigIpv6Args

func ContainerInitializationIpConfigIpv6Ptr(v *ContainerInitializationIpConfigIpv6Args) ContainerInitializationIpConfigIpv6PtrInput {
	return (*containerInitializationIpConfigIpv6PtrType)(v)
}

func (*containerInitializationIpConfigIpv6PtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerInitializationIpConfigIpv6)(nil)).Elem()
}

func (i *containerInitializationIpConfigIpv6PtrType) ToContainerInitializationIpConfigIpv6PtrOutput() ContainerInitializationIpConfigIpv6PtrOutput {
	return i.ToContainerInitializationIpConfigIpv6PtrOutputWithContext(context.Background())
}

func (i *containerInitializationIpConfigIpv6PtrType) ToContainerInitializationIpConfigIpv6PtrOutputWithContext(ctx context.Context) ContainerInitializationIpConfigIpv6PtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerInitializationIpConfigIpv6PtrOutput)
}

type ContainerInitializationIpConfigIpv6Output struct{ *pulumi.OutputState }

func (ContainerInitializationIpConfigIpv6Output) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerInitializationIpConfigIpv6)(nil)).Elem()
}

func (o ContainerInitializationIpConfigIpv6Output) ToContainerInitializationIpConfigIpv6Output() ContainerInitializationIpConfigIpv6Output {
	return o
}

func (o ContainerInitializationIpConfigIpv6Output) ToContainerInitializationIpConfigIpv6OutputWithContext(ctx context.Context) ContainerInitializationIpConfigIpv6Output {
	return o
}

func (o ContainerInitializationIpConfigIpv6Output) ToContainerInitializationIpConfigIpv6PtrOutput() ContainerInitializationIpConfigIpv6PtrOutput {
	return o.ToContainerInitializationIpConfigIpv6PtrOutputWithContext(context.Background())
}

func (o ContainerInitializationIpConfigIpv6Output) ToContainerInitializationIpConfigIpv6PtrOutputWithContext(ctx context.Context) ContainerInitializationIpConfigIpv6PtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ContainerInitializationIpConfigIpv6) *ContainerInitializationIpConfigIpv6 {
		return &v
	}).(ContainerInitializationIpConfigIpv6PtrOutput)
}

func (o ContainerInitializationIpConfigIpv6Output) Address() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ContainerInitializationIpConfigIpv6) *string { return v.Address }).(pulumi.StringPtrOutput)
}

func (o ContainerInitializationIpConfigIpv6Output) Gateway() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ContainerInitializationIpConfigIpv6) *string { return v.Gateway }).(pulumi.StringPtrOutput)
}

type ContainerInitializationIpConfigIpv6PtrOutput struct{ *pulumi.OutputState }

func (ContainerInitializationIpConfigIpv6PtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerInitializationIpConfigIpv6)(nil)).Elem()
}

func (o ContainerInitializationIpConfigIpv6PtrOutput) ToContainerInitializationIpConfigIpv6PtrOutput() ContainerInitializationIpConfigIpv6PtrOutput {
	return o
}

func (o ContainerInitializationIpConfigIpv6PtrOutput) ToContainerInitializationIpConfigIpv6PtrOutputWithContext(ctx context.Context) ContainerInitializationIpConfigIpv6PtrOutput {
	return o
}

func (o ContainerInitializationIpConfigIpv6PtrOutput) Elem() ContainerInitializationIpConfigIpv6Output {
	return o.ApplyT(func(v *ContainerInitializationIpConfigIpv6) ContainerInitializationIpConfigIpv6 {
		if v != nil {
			return *v
		}
		var ret ContainerInitializationIpConfigIpv6
		return ret
	}).(ContainerInitializationIpConfigIpv6Output)
}

func (o ContainerInitializationIpConfigIpv6PtrOutput) Address() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ContainerInitializationIpConfigIpv6) *string {
		if v == nil {
			return nil
		}
		return v.Address
	}).(pulumi.StringPtrOutput)
}

func (o ContainerInitializationIpConfigIpv6PtrOutput) Gateway() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ContainerInitializationIpConfigIpv6) *string {
		if v == nil {
			return nil
		}
		return v.Gateway
	}).(pulumi.StringPtrOutput)
}

type ContainerInitializationUserAccount struct {
	Keys     []string `pulumi:"keys"`
	Password *string  `pulumi:"password"`
}

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

	ToContainerInitializationUserAccountOutput() ContainerInitializationUserAccountOutput
	ToContainerInitializationUserAccountOutputWithContext(context.Context) ContainerInitializationUserAccountOutput
}

type ContainerInitializationUserAccountArgs struct {
	Keys     pulumi.StringArrayInput `pulumi:"keys"`
	Password pulumi.StringPtrInput   `pulumi:"password"`
}

func (ContainerInitializationUserAccountArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerInitializationUserAccount)(nil)).Elem()
}

func (i ContainerInitializationUserAccountArgs) ToContainerInitializationUserAccountOutput() ContainerInitializationUserAccountOutput {
	return i.ToContainerInitializationUserAccountOutputWithContext(context.Background())
}

func (i ContainerInitializationUserAccountArgs) ToContainerInitializationUserAccountOutputWithContext(ctx context.Context) ContainerInitializationUserAccountOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerInitializationUserAccountOutput)
}

func (i ContainerInitializationUserAccountArgs) ToContainerInitializationUserAccountPtrOutput() ContainerInitializationUserAccountPtrOutput {
	return i.ToContainerInitializationUserAccountPtrOutputWithContext(context.Background())
}

func (i ContainerInitializationUserAccountArgs) ToContainerInitializationUserAccountPtrOutputWithContext(ctx context.Context) ContainerInitializationUserAccountPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerInitializationUserAccountOutput).ToContainerInitializationUserAccountPtrOutputWithContext(ctx)
}

// ContainerInitializationUserAccountPtrInput is an input type that accepts ContainerInitializationUserAccountArgs, ContainerInitializationUserAccountPtr and ContainerInitializationUserAccountPtrOutput values.
// You can construct a concrete instance of `ContainerInitializationUserAccountPtrInput` via:
//
//	        ContainerInitializationUserAccountArgs{...}
//
//	or:
//
//	        nil
type ContainerInitializationUserAccountPtrInput interface {
	pulumi.Input

	ToContainerInitializationUserAccountPtrOutput() ContainerInitializationUserAccountPtrOutput
	ToContainerInitializationUserAccountPtrOutputWithContext(context.Context) ContainerInitializationUserAccountPtrOutput
}

type containerInitializationUserAccountPtrType ContainerInitializationUserAccountArgs

func ContainerInitializationUserAccountPtr(v *ContainerInitializationUserAccountArgs) ContainerInitializationUserAccountPtrInput {
	return (*containerInitializationUserAccountPtrType)(v)
}

func (*containerInitializationUserAccountPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerInitializationUserAccount)(nil)).Elem()
}

func (i *containerInitializationUserAccountPtrType) ToContainerInitializationUserAccountPtrOutput() ContainerInitializationUserAccountPtrOutput {
	return i.ToContainerInitializationUserAccountPtrOutputWithContext(context.Background())
}

func (i *containerInitializationUserAccountPtrType) ToContainerInitializationUserAccountPtrOutputWithContext(ctx context.Context) ContainerInitializationUserAccountPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerInitializationUserAccountPtrOutput)
}

type ContainerInitializationUserAccountOutput struct{ *pulumi.OutputState }

func (ContainerInitializationUserAccountOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerInitializationUserAccount)(nil)).Elem()
}

func (o ContainerInitializationUserAccountOutput) ToContainerInitializationUserAccountOutput() ContainerInitializationUserAccountOutput {
	return o
}

func (o ContainerInitializationUserAccountOutput) ToContainerInitializationUserAccountOutputWithContext(ctx context.Context) ContainerInitializationUserAccountOutput {
	return o
}

func (o ContainerInitializationUserAccountOutput) ToContainerInitializationUserAccountPtrOutput() ContainerInitializationUserAccountPtrOutput {
	return o.ToContainerInitializationUserAccountPtrOutputWithContext(context.Background())
}

func (o ContainerInitializationUserAccountOutput) ToContainerInitializationUserAccountPtrOutputWithContext(ctx context.Context) ContainerInitializationUserAccountPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ContainerInitializationUserAccount) *ContainerInitializationUserAccount {
		return &v
	}).(ContainerInitializationUserAccountPtrOutput)
}

func (o ContainerInitializationUserAccountOutput) Keys() pulumi.StringArrayOutput {
	return o.ApplyT(func(v ContainerInitializationUserAccount) []string { return v.Keys }).(pulumi.StringArrayOutput)
}

func (o ContainerInitializationUserAccountOutput) Password() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ContainerInitializationUserAccount) *string { return v.Password }).(pulumi.StringPtrOutput)
}

type ContainerInitializationUserAccountPtrOutput struct{ *pulumi.OutputState }

func (ContainerInitializationUserAccountPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerInitializationUserAccount)(nil)).Elem()
}

func (o ContainerInitializationUserAccountPtrOutput) ToContainerInitializationUserAccountPtrOutput() ContainerInitializationUserAccountPtrOutput {
	return o
}

func (o ContainerInitializationUserAccountPtrOutput) ToContainerInitializationUserAccountPtrOutputWithContext(ctx context.Context) ContainerInitializationUserAccountPtrOutput {
	return o
}

func (o ContainerInitializationUserAccountPtrOutput) Elem() ContainerInitializationUserAccountOutput {
	return o.ApplyT(func(v *ContainerInitializationUserAccount) ContainerInitializationUserAccount {
		if v != nil {
			return *v
		}
		var ret ContainerInitializationUserAccount
		return ret
	}).(ContainerInitializationUserAccountOutput)
}

func (o ContainerInitializationUserAccountPtrOutput) Keys() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *ContainerInitializationUserAccount) []string {
		if v == nil {
			return nil
		}
		return v.Keys
	}).(pulumi.StringArrayOutput)
}

func (o ContainerInitializationUserAccountPtrOutput) Password() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ContainerInitializationUserAccount) *string {
		if v == nil {
			return nil
		}
		return v.Password
	}).(pulumi.StringPtrOutput)
}

type ContainerMemory struct {
	Dedicated *int `pulumi:"dedicated"`
	Swap      *int `pulumi:"swap"`
}

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

	ToContainerMemoryOutput() ContainerMemoryOutput
	ToContainerMemoryOutputWithContext(context.Context) ContainerMemoryOutput
}

type ContainerMemoryArgs struct {
	Dedicated pulumi.IntPtrInput `pulumi:"dedicated"`
	Swap      pulumi.IntPtrInput `pulumi:"swap"`
}

func (ContainerMemoryArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerMemory)(nil)).Elem()
}

func (i ContainerMemoryArgs) ToContainerMemoryOutput() ContainerMemoryOutput {
	return i.ToContainerMemoryOutputWithContext(context.Background())
}

func (i ContainerMemoryArgs) ToContainerMemoryOutputWithContext(ctx context.Context) ContainerMemoryOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerMemoryOutput)
}

func (i ContainerMemoryArgs) ToContainerMemoryPtrOutput() ContainerMemoryPtrOutput {
	return i.ToContainerMemoryPtrOutputWithContext(context.Background())
}

func (i ContainerMemoryArgs) ToContainerMemoryPtrOutputWithContext(ctx context.Context) ContainerMemoryPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerMemoryOutput).ToContainerMemoryPtrOutputWithContext(ctx)
}

// ContainerMemoryPtrInput is an input type that accepts ContainerMemoryArgs, ContainerMemoryPtr and ContainerMemoryPtrOutput values.
// You can construct a concrete instance of `ContainerMemoryPtrInput` via:
//
//	        ContainerMemoryArgs{...}
//
//	or:
//
//	        nil
type ContainerMemoryPtrInput interface {
	pulumi.Input

	ToContainerMemoryPtrOutput() ContainerMemoryPtrOutput
	ToContainerMemoryPtrOutputWithContext(context.Context) ContainerMemoryPtrOutput
}

type containerMemoryPtrType ContainerMemoryArgs

func ContainerMemoryPtr(v *ContainerMemoryArgs) ContainerMemoryPtrInput {
	return (*containerMemoryPtrType)(v)
}

func (*containerMemoryPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerMemory)(nil)).Elem()
}

func (i *containerMemoryPtrType) ToContainerMemoryPtrOutput() ContainerMemoryPtrOutput {
	return i.ToContainerMemoryPtrOutputWithContext(context.Background())
}

func (i *containerMemoryPtrType) ToContainerMemoryPtrOutputWithContext(ctx context.Context) ContainerMemoryPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerMemoryPtrOutput)
}

type ContainerMemoryOutput struct{ *pulumi.OutputState }

func (ContainerMemoryOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerMemory)(nil)).Elem()
}

func (o ContainerMemoryOutput) ToContainerMemoryOutput() ContainerMemoryOutput {
	return o
}

func (o ContainerMemoryOutput) ToContainerMemoryOutputWithContext(ctx context.Context) ContainerMemoryOutput {
	return o
}

func (o ContainerMemoryOutput) ToContainerMemoryPtrOutput() ContainerMemoryPtrOutput {
	return o.ToContainerMemoryPtrOutputWithContext(context.Background())
}

func (o ContainerMemoryOutput) ToContainerMemoryPtrOutputWithContext(ctx context.Context) ContainerMemoryPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ContainerMemory) *ContainerMemory {
		return &v
	}).(ContainerMemoryPtrOutput)
}

func (o ContainerMemoryOutput) Dedicated() pulumi.IntPtrOutput {
	return o.ApplyT(func(v ContainerMemory) *int { return v.Dedicated }).(pulumi.IntPtrOutput)
}

func (o ContainerMemoryOutput) Swap() pulumi.IntPtrOutput {
	return o.ApplyT(func(v ContainerMemory) *int { return v.Swap }).(pulumi.IntPtrOutput)
}

type ContainerMemoryPtrOutput struct{ *pulumi.OutputState }

func (ContainerMemoryPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerMemory)(nil)).Elem()
}

func (o ContainerMemoryPtrOutput) ToContainerMemoryPtrOutput() ContainerMemoryPtrOutput {
	return o
}

func (o ContainerMemoryPtrOutput) ToContainerMemoryPtrOutputWithContext(ctx context.Context) ContainerMemoryPtrOutput {
	return o
}

func (o ContainerMemoryPtrOutput) Elem() ContainerMemoryOutput {
	return o.ApplyT(func(v *ContainerMemory) ContainerMemory {
		if v != nil {
			return *v
		}
		var ret ContainerMemory
		return ret
	}).(ContainerMemoryOutput)
}

func (o ContainerMemoryPtrOutput) Dedicated() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *ContainerMemory) *int {
		if v == nil {
			return nil
		}
		return v.Dedicated
	}).(pulumi.IntPtrOutput)
}

func (o ContainerMemoryPtrOutput) Swap() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *ContainerMemory) *int {
		if v == nil {
			return nil
		}
		return v.Swap
	}).(pulumi.IntPtrOutput)
}

type ContainerNetworkInterface struct {
	Bridge     *string  `pulumi:"bridge"`
	Enabled    *bool    `pulumi:"enabled"`
	MacAddress *string  `pulumi:"macAddress"`
	Mtu        *int     `pulumi:"mtu"`
	Name       string   `pulumi:"name"`
	RateLimit  *float64 `pulumi:"rateLimit"`
	VlanId     *int     `pulumi:"vlanId"`
}

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

	ToContainerNetworkInterfaceOutput() ContainerNetworkInterfaceOutput
	ToContainerNetworkInterfaceOutputWithContext(context.Context) ContainerNetworkInterfaceOutput
}

type ContainerNetworkInterfaceArgs struct {
	Bridge     pulumi.StringPtrInput  `pulumi:"bridge"`
	Enabled    pulumi.BoolPtrInput    `pulumi:"enabled"`
	MacAddress pulumi.StringPtrInput  `pulumi:"macAddress"`
	Mtu        pulumi.IntPtrInput     `pulumi:"mtu"`
	Name       pulumi.StringInput     `pulumi:"name"`
	RateLimit  pulumi.Float64PtrInput `pulumi:"rateLimit"`
	VlanId     pulumi.IntPtrInput     `pulumi:"vlanId"`
}

func (ContainerNetworkInterfaceArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerNetworkInterface)(nil)).Elem()
}

func (i ContainerNetworkInterfaceArgs) ToContainerNetworkInterfaceOutput() ContainerNetworkInterfaceOutput {
	return i.ToContainerNetworkInterfaceOutputWithContext(context.Background())
}

func (i ContainerNetworkInterfaceArgs) ToContainerNetworkInterfaceOutputWithContext(ctx context.Context) ContainerNetworkInterfaceOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerNetworkInterfaceOutput)
}

// ContainerNetworkInterfaceArrayInput is an input type that accepts ContainerNetworkInterfaceArray and ContainerNetworkInterfaceArrayOutput values.
// You can construct a concrete instance of `ContainerNetworkInterfaceArrayInput` via:
//
//	ContainerNetworkInterfaceArray{ ContainerNetworkInterfaceArgs{...} }
type ContainerNetworkInterfaceArrayInput interface {
	pulumi.Input

	ToContainerNetworkInterfaceArrayOutput() ContainerNetworkInterfaceArrayOutput
	ToContainerNetworkInterfaceArrayOutputWithContext(context.Context) ContainerNetworkInterfaceArrayOutput
}

type ContainerNetworkInterfaceArray []ContainerNetworkInterfaceInput

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

func (i ContainerNetworkInterfaceArray) ToContainerNetworkInterfaceArrayOutput() ContainerNetworkInterfaceArrayOutput {
	return i.ToContainerNetworkInterfaceArrayOutputWithContext(context.Background())
}

func (i ContainerNetworkInterfaceArray) ToContainerNetworkInterfaceArrayOutputWithContext(ctx context.Context) ContainerNetworkInterfaceArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerNetworkInterfaceArrayOutput)
}

type ContainerNetworkInterfaceOutput struct{ *pulumi.OutputState }

func (ContainerNetworkInterfaceOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerNetworkInterface)(nil)).Elem()
}

func (o ContainerNetworkInterfaceOutput) ToContainerNetworkInterfaceOutput() ContainerNetworkInterfaceOutput {
	return o
}

func (o ContainerNetworkInterfaceOutput) ToContainerNetworkInterfaceOutputWithContext(ctx context.Context) ContainerNetworkInterfaceOutput {
	return o
}

func (o ContainerNetworkInterfaceOutput) Bridge() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ContainerNetworkInterface) *string { return v.Bridge }).(pulumi.StringPtrOutput)
}

func (o ContainerNetworkInterfaceOutput) Enabled() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v ContainerNetworkInterface) *bool { return v.Enabled }).(pulumi.BoolPtrOutput)
}

func (o ContainerNetworkInterfaceOutput) MacAddress() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ContainerNetworkInterface) *string { return v.MacAddress }).(pulumi.StringPtrOutput)
}

func (o ContainerNetworkInterfaceOutput) Mtu() pulumi.IntPtrOutput {
	return o.ApplyT(func(v ContainerNetworkInterface) *int { return v.Mtu }).(pulumi.IntPtrOutput)
}

func (o ContainerNetworkInterfaceOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v ContainerNetworkInterface) string { return v.Name }).(pulumi.StringOutput)
}

func (o ContainerNetworkInterfaceOutput) RateLimit() pulumi.Float64PtrOutput {
	return o.ApplyT(func(v ContainerNetworkInterface) *float64 { return v.RateLimit }).(pulumi.Float64PtrOutput)
}

func (o ContainerNetworkInterfaceOutput) VlanId() pulumi.IntPtrOutput {
	return o.ApplyT(func(v ContainerNetworkInterface) *int { return v.VlanId }).(pulumi.IntPtrOutput)
}

type ContainerNetworkInterfaceArrayOutput struct{ *pulumi.OutputState }

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

func (o ContainerNetworkInterfaceArrayOutput) ToContainerNetworkInterfaceArrayOutput() ContainerNetworkInterfaceArrayOutput {
	return o
}

func (o ContainerNetworkInterfaceArrayOutput) ToContainerNetworkInterfaceArrayOutputWithContext(ctx context.Context) ContainerNetworkInterfaceArrayOutput {
	return o
}

func (o ContainerNetworkInterfaceArrayOutput) Index(i pulumi.IntInput) ContainerNetworkInterfaceOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ContainerNetworkInterface {
		return vs[0].([]ContainerNetworkInterface)[vs[1].(int)]
	}).(ContainerNetworkInterfaceOutput)
}

type ContainerOperatingSystem struct {
	TemplateFileId string  `pulumi:"templateFileId"`
	Type           *string `pulumi:"type"`
}

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

	ToContainerOperatingSystemOutput() ContainerOperatingSystemOutput
	ToContainerOperatingSystemOutputWithContext(context.Context) ContainerOperatingSystemOutput
}

type ContainerOperatingSystemArgs struct {
	TemplateFileId pulumi.StringInput    `pulumi:"templateFileId"`
	Type           pulumi.StringPtrInput `pulumi:"type"`
}

func (ContainerOperatingSystemArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerOperatingSystem)(nil)).Elem()
}

func (i ContainerOperatingSystemArgs) ToContainerOperatingSystemOutput() ContainerOperatingSystemOutput {
	return i.ToContainerOperatingSystemOutputWithContext(context.Background())
}

func (i ContainerOperatingSystemArgs) ToContainerOperatingSystemOutputWithContext(ctx context.Context) ContainerOperatingSystemOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerOperatingSystemOutput)
}

func (i ContainerOperatingSystemArgs) ToContainerOperatingSystemPtrOutput() ContainerOperatingSystemPtrOutput {
	return i.ToContainerOperatingSystemPtrOutputWithContext(context.Background())
}

func (i ContainerOperatingSystemArgs) ToContainerOperatingSystemPtrOutputWithContext(ctx context.Context) ContainerOperatingSystemPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerOperatingSystemOutput).ToContainerOperatingSystemPtrOutputWithContext(ctx)
}

// ContainerOperatingSystemPtrInput is an input type that accepts ContainerOperatingSystemArgs, ContainerOperatingSystemPtr and ContainerOperatingSystemPtrOutput values.
// You can construct a concrete instance of `ContainerOperatingSystemPtrInput` via:
//
//	        ContainerOperatingSystemArgs{...}
//
//	or:
//
//	        nil
type ContainerOperatingSystemPtrInput interface {
	pulumi.Input

	ToContainerOperatingSystemPtrOutput() ContainerOperatingSystemPtrOutput
	ToContainerOperatingSystemPtrOutputWithContext(context.Context) ContainerOperatingSystemPtrOutput
}

type containerOperatingSystemPtrType ContainerOperatingSystemArgs

func ContainerOperatingSystemPtr(v *ContainerOperatingSystemArgs) ContainerOperatingSystemPtrInput {
	return (*containerOperatingSystemPtrType)(v)
}

func (*containerOperatingSystemPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerOperatingSystem)(nil)).Elem()
}

func (i *containerOperatingSystemPtrType) ToContainerOperatingSystemPtrOutput() ContainerOperatingSystemPtrOutput {
	return i.ToContainerOperatingSystemPtrOutputWithContext(context.Background())
}

func (i *containerOperatingSystemPtrType) ToContainerOperatingSystemPtrOutputWithContext(ctx context.Context) ContainerOperatingSystemPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ContainerOperatingSystemPtrOutput)
}

type ContainerOperatingSystemOutput struct{ *pulumi.OutputState }

func (ContainerOperatingSystemOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ContainerOperatingSystem)(nil)).Elem()
}

func (o ContainerOperatingSystemOutput) ToContainerOperatingSystemOutput() ContainerOperatingSystemOutput {
	return o
}

func (o ContainerOperatingSystemOutput) ToContainerOperatingSystemOutputWithContext(ctx context.Context) ContainerOperatingSystemOutput {
	return o
}

func (o ContainerOperatingSystemOutput) ToContainerOperatingSystemPtrOutput() ContainerOperatingSystemPtrOutput {
	return o.ToContainerOperatingSystemPtrOutputWithContext(context.Background())
}

func (o ContainerOperatingSystemOutput) ToContainerOperatingSystemPtrOutputWithContext(ctx context.Context) ContainerOperatingSystemPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ContainerOperatingSystem) *ContainerOperatingSystem {
		return &v
	}).(ContainerOperatingSystemPtrOutput)
}

func (o ContainerOperatingSystemOutput) TemplateFileId() pulumi.StringOutput {
	return o.ApplyT(func(v ContainerOperatingSystem) string { return v.TemplateFileId }).(pulumi.StringOutput)
}

func (o ContainerOperatingSystemOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ContainerOperatingSystem) *string { return v.Type }).(pulumi.StringPtrOutput)
}

type ContainerOperatingSystemPtrOutput struct{ *pulumi.OutputState }

func (ContainerOperatingSystemPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ContainerOperatingSystem)(nil)).Elem()
}

func (o ContainerOperatingSystemPtrOutput) ToContainerOperatingSystemPtrOutput() ContainerOperatingSystemPtrOutput {
	return o
}

func (o ContainerOperatingSystemPtrOutput) ToContainerOperatingSystemPtrOutputWithContext(ctx context.Context) ContainerOperatingSystemPtrOutput {
	return o
}

func (o ContainerOperatingSystemPtrOutput) Elem() ContainerOperatingSystemOutput {
	return o.ApplyT(func(v *ContainerOperatingSystem) ContainerOperatingSystem {
		if v != nil {
			return *v
		}
		var ret ContainerOperatingSystem
		return ret
	}).(ContainerOperatingSystemOutput)
}

func (o ContainerOperatingSystemPtrOutput) TemplateFileId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ContainerOperatingSystem) *string {
		if v == nil {
			return nil
		}
		return &v.TemplateFileId
	}).(pulumi.StringPtrOutput)
}

func (o ContainerOperatingSystemPtrOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ContainerOperatingSystem) *string {
		if v == nil {
			return nil
		}
		return v.Type
	}).(pulumi.StringPtrOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerCloneInput)(nil)).Elem(), ContainerCloneArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerClonePtrInput)(nil)).Elem(), ContainerCloneArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerConsoleInput)(nil)).Elem(), ContainerConsoleArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerConsolePtrInput)(nil)).Elem(), ContainerConsoleArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerCpuInput)(nil)).Elem(), ContainerCpuArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerCpuPtrInput)(nil)).Elem(), ContainerCpuArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerDiskInput)(nil)).Elem(), ContainerDiskArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerDiskPtrInput)(nil)).Elem(), ContainerDiskArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerFeaturesInput)(nil)).Elem(), ContainerFeaturesArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerFeaturesPtrInput)(nil)).Elem(), ContainerFeaturesArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerInitializationInput)(nil)).Elem(), ContainerInitializationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerInitializationPtrInput)(nil)).Elem(), ContainerInitializationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerInitializationDnsInput)(nil)).Elem(), ContainerInitializationDnsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerInitializationDnsPtrInput)(nil)).Elem(), ContainerInitializationDnsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerInitializationIpConfigInput)(nil)).Elem(), ContainerInitializationIpConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerInitializationIpConfigArrayInput)(nil)).Elem(), ContainerInitializationIpConfigArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerInitializationIpConfigIpv4Input)(nil)).Elem(), ContainerInitializationIpConfigIpv4Args{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerInitializationIpConfigIpv4PtrInput)(nil)).Elem(), ContainerInitializationIpConfigIpv4Args{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerInitializationIpConfigIpv6Input)(nil)).Elem(), ContainerInitializationIpConfigIpv6Args{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerInitializationIpConfigIpv6PtrInput)(nil)).Elem(), ContainerInitializationIpConfigIpv6Args{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerInitializationUserAccountInput)(nil)).Elem(), ContainerInitializationUserAccountArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerInitializationUserAccountPtrInput)(nil)).Elem(), ContainerInitializationUserAccountArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerMemoryInput)(nil)).Elem(), ContainerMemoryArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerMemoryPtrInput)(nil)).Elem(), ContainerMemoryArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerNetworkInterfaceInput)(nil)).Elem(), ContainerNetworkInterfaceArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerNetworkInterfaceArrayInput)(nil)).Elem(), ContainerNetworkInterfaceArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerOperatingSystemInput)(nil)).Elem(), ContainerOperatingSystemArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ContainerOperatingSystemPtrInput)(nil)).Elem(), ContainerOperatingSystemArgs{})
	pulumi.RegisterOutputType(ContainerCloneOutput{})
	pulumi.RegisterOutputType(ContainerClonePtrOutput{})
	pulumi.RegisterOutputType(ContainerConsoleOutput{})
	pulumi.RegisterOutputType(ContainerConsolePtrOutput{})
	pulumi.RegisterOutputType(ContainerCpuOutput{})
	pulumi.RegisterOutputType(ContainerCpuPtrOutput{})
	pulumi.RegisterOutputType(ContainerDiskOutput{})
	pulumi.RegisterOutputType(ContainerDiskPtrOutput{})
	pulumi.RegisterOutputType(ContainerFeaturesOutput{})
	pulumi.RegisterOutputType(ContainerFeaturesPtrOutput{})
	pulumi.RegisterOutputType(ContainerInitializationOutput{})
	pulumi.RegisterOutputType(ContainerInitializationPtrOutput{})
	pulumi.RegisterOutputType(ContainerInitializationDnsOutput{})
	pulumi.RegisterOutputType(ContainerInitializationDnsPtrOutput{})
	pulumi.RegisterOutputType(ContainerInitializationIpConfigOutput{})
	pulumi.RegisterOutputType(ContainerInitializationIpConfigArrayOutput{})
	pulumi.RegisterOutputType(ContainerInitializationIpConfigIpv4Output{})
	pulumi.RegisterOutputType(ContainerInitializationIpConfigIpv4PtrOutput{})
	pulumi.RegisterOutputType(ContainerInitializationIpConfigIpv6Output{})
	pulumi.RegisterOutputType(ContainerInitializationIpConfigIpv6PtrOutput{})
	pulumi.RegisterOutputType(ContainerInitializationUserAccountOutput{})
	pulumi.RegisterOutputType(ContainerInitializationUserAccountPtrOutput{})
	pulumi.RegisterOutputType(ContainerMemoryOutput{})
	pulumi.RegisterOutputType(ContainerMemoryPtrOutput{})
	pulumi.RegisterOutputType(ContainerNetworkInterfaceOutput{})
	pulumi.RegisterOutputType(ContainerNetworkInterfaceArrayOutput{})
	pulumi.RegisterOutputType(ContainerOperatingSystemOutput{})
	pulumi.RegisterOutputType(ContainerOperatingSystemPtrOutput{})
}