pulumiTypes.go

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

package batch

import (
	"context"
	"reflect"

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

type AccountKeyVaultReference struct {
	// The Azure identifier of the Azure KeyVault to use.
	Id string `pulumi:"id"`
	// The HTTPS URL of the Azure KeyVault to use.
	Url string `pulumi:"url"`
}

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

	ToAccountKeyVaultReferenceOutput() AccountKeyVaultReferenceOutput
	ToAccountKeyVaultReferenceOutputWithContext(context.Context) AccountKeyVaultReferenceOutput
}

type AccountKeyVaultReferenceArgs struct {
	// The Azure identifier of the Azure KeyVault to use.
	Id pulumi.StringInput `pulumi:"id"`
	// The HTTPS URL of the Azure KeyVault to use.
	Url pulumi.StringInput `pulumi:"url"`
}

func (AccountKeyVaultReferenceArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AccountKeyVaultReference)(nil)).Elem()
}

func (i AccountKeyVaultReferenceArgs) ToAccountKeyVaultReferenceOutput() AccountKeyVaultReferenceOutput {
	return i.ToAccountKeyVaultReferenceOutputWithContext(context.Background())
}

func (i AccountKeyVaultReferenceArgs) ToAccountKeyVaultReferenceOutputWithContext(ctx context.Context) AccountKeyVaultReferenceOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccountKeyVaultReferenceOutput)
}

func (i AccountKeyVaultReferenceArgs) ToAccountKeyVaultReferencePtrOutput() AccountKeyVaultReferencePtrOutput {
	return i.ToAccountKeyVaultReferencePtrOutputWithContext(context.Background())
}

func (i AccountKeyVaultReferenceArgs) ToAccountKeyVaultReferencePtrOutputWithContext(ctx context.Context) AccountKeyVaultReferencePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccountKeyVaultReferenceOutput).ToAccountKeyVaultReferencePtrOutputWithContext(ctx)
}

// AccountKeyVaultReferencePtrInput is an input type that accepts AccountKeyVaultReferenceArgs, AccountKeyVaultReferencePtr and AccountKeyVaultReferencePtrOutput values.
// You can construct a concrete instance of `AccountKeyVaultReferencePtrInput` via:
//
//          AccountKeyVaultReferenceArgs{...}
//
//  or:
//
//          nil
type AccountKeyVaultReferencePtrInput interface {
	pulumi.Input

	ToAccountKeyVaultReferencePtrOutput() AccountKeyVaultReferencePtrOutput
	ToAccountKeyVaultReferencePtrOutputWithContext(context.Context) AccountKeyVaultReferencePtrOutput
}

type accountKeyVaultReferencePtrType AccountKeyVaultReferenceArgs

func AccountKeyVaultReferencePtr(v *AccountKeyVaultReferenceArgs) AccountKeyVaultReferencePtrInput {
	return (*accountKeyVaultReferencePtrType)(v)
}

func (*accountKeyVaultReferencePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AccountKeyVaultReference)(nil)).Elem()
}

func (i *accountKeyVaultReferencePtrType) ToAccountKeyVaultReferencePtrOutput() AccountKeyVaultReferencePtrOutput {
	return i.ToAccountKeyVaultReferencePtrOutputWithContext(context.Background())
}

func (i *accountKeyVaultReferencePtrType) ToAccountKeyVaultReferencePtrOutputWithContext(ctx context.Context) AccountKeyVaultReferencePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccountKeyVaultReferencePtrOutput)
}

type AccountKeyVaultReferenceOutput struct{ *pulumi.OutputState }

func (AccountKeyVaultReferenceOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AccountKeyVaultReference)(nil)).Elem()
}

func (o AccountKeyVaultReferenceOutput) ToAccountKeyVaultReferenceOutput() AccountKeyVaultReferenceOutput {
	return o
}

func (o AccountKeyVaultReferenceOutput) ToAccountKeyVaultReferenceOutputWithContext(ctx context.Context) AccountKeyVaultReferenceOutput {
	return o
}

func (o AccountKeyVaultReferenceOutput) ToAccountKeyVaultReferencePtrOutput() AccountKeyVaultReferencePtrOutput {
	return o.ToAccountKeyVaultReferencePtrOutputWithContext(context.Background())
}

func (o AccountKeyVaultReferenceOutput) ToAccountKeyVaultReferencePtrOutputWithContext(ctx context.Context) AccountKeyVaultReferencePtrOutput {
	return o.ApplyT(func(v AccountKeyVaultReference) *AccountKeyVaultReference {
		return &v
	}).(AccountKeyVaultReferencePtrOutput)
}

// The Azure identifier of the Azure KeyVault to use.
func (o AccountKeyVaultReferenceOutput) Id() pulumi.StringOutput {
	return o.ApplyT(func(v AccountKeyVaultReference) string { return v.Id }).(pulumi.StringOutput)
}

// The HTTPS URL of the Azure KeyVault to use.
func (o AccountKeyVaultReferenceOutput) Url() pulumi.StringOutput {
	return o.ApplyT(func(v AccountKeyVaultReference) string { return v.Url }).(pulumi.StringOutput)
}

type AccountKeyVaultReferencePtrOutput struct{ *pulumi.OutputState }

func (AccountKeyVaultReferencePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AccountKeyVaultReference)(nil)).Elem()
}

func (o AccountKeyVaultReferencePtrOutput) ToAccountKeyVaultReferencePtrOutput() AccountKeyVaultReferencePtrOutput {
	return o
}

func (o AccountKeyVaultReferencePtrOutput) ToAccountKeyVaultReferencePtrOutputWithContext(ctx context.Context) AccountKeyVaultReferencePtrOutput {
	return o
}

func (o AccountKeyVaultReferencePtrOutput) Elem() AccountKeyVaultReferenceOutput {
	return o.ApplyT(func(v *AccountKeyVaultReference) AccountKeyVaultReference { return *v }).(AccountKeyVaultReferenceOutput)
}

// The Azure identifier of the Azure KeyVault to use.
func (o AccountKeyVaultReferencePtrOutput) Id() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccountKeyVaultReference) *string {
		if v == nil {
			return nil
		}
		return &v.Id
	}).(pulumi.StringPtrOutput)
}

// The HTTPS URL of the Azure KeyVault to use.
func (o AccountKeyVaultReferencePtrOutput) Url() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccountKeyVaultReference) *string {
		if v == nil {
			return nil
		}
		return &v.Url
	}).(pulumi.StringPtrOutput)
}

type PoolAutoScale struct {
	// The interval to wait before evaluating if the pool needs to be scaled. Defaults to `PT15M`.
	EvaluationInterval *string `pulumi:"evaluationInterval"`
	// The autoscale formula that needs to be used for scaling the Batch pool.
	Formula string `pulumi:"formula"`
}

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

	ToPoolAutoScaleOutput() PoolAutoScaleOutput
	ToPoolAutoScaleOutputWithContext(context.Context) PoolAutoScaleOutput
}

type PoolAutoScaleArgs struct {
	// The interval to wait before evaluating if the pool needs to be scaled. Defaults to `PT15M`.
	EvaluationInterval pulumi.StringPtrInput `pulumi:"evaluationInterval"`
	// The autoscale formula that needs to be used for scaling the Batch pool.
	Formula pulumi.StringInput `pulumi:"formula"`
}

func (PoolAutoScaleArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolAutoScale)(nil)).Elem()
}

func (i PoolAutoScaleArgs) ToPoolAutoScaleOutput() PoolAutoScaleOutput {
	return i.ToPoolAutoScaleOutputWithContext(context.Background())
}

func (i PoolAutoScaleArgs) ToPoolAutoScaleOutputWithContext(ctx context.Context) PoolAutoScaleOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolAutoScaleOutput)
}

func (i PoolAutoScaleArgs) ToPoolAutoScalePtrOutput() PoolAutoScalePtrOutput {
	return i.ToPoolAutoScalePtrOutputWithContext(context.Background())
}

func (i PoolAutoScaleArgs) ToPoolAutoScalePtrOutputWithContext(ctx context.Context) PoolAutoScalePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolAutoScaleOutput).ToPoolAutoScalePtrOutputWithContext(ctx)
}

// PoolAutoScalePtrInput is an input type that accepts PoolAutoScaleArgs, PoolAutoScalePtr and PoolAutoScalePtrOutput values.
// You can construct a concrete instance of `PoolAutoScalePtrInput` via:
//
//          PoolAutoScaleArgs{...}
//
//  or:
//
//          nil
type PoolAutoScalePtrInput interface {
	pulumi.Input

	ToPoolAutoScalePtrOutput() PoolAutoScalePtrOutput
	ToPoolAutoScalePtrOutputWithContext(context.Context) PoolAutoScalePtrOutput
}

type poolAutoScalePtrType PoolAutoScaleArgs

func PoolAutoScalePtr(v *PoolAutoScaleArgs) PoolAutoScalePtrInput {
	return (*poolAutoScalePtrType)(v)
}

func (*poolAutoScalePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**PoolAutoScale)(nil)).Elem()
}

func (i *poolAutoScalePtrType) ToPoolAutoScalePtrOutput() PoolAutoScalePtrOutput {
	return i.ToPoolAutoScalePtrOutputWithContext(context.Background())
}

func (i *poolAutoScalePtrType) ToPoolAutoScalePtrOutputWithContext(ctx context.Context) PoolAutoScalePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolAutoScalePtrOutput)
}

type PoolAutoScaleOutput struct{ *pulumi.OutputState }

func (PoolAutoScaleOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolAutoScale)(nil)).Elem()
}

func (o PoolAutoScaleOutput) ToPoolAutoScaleOutput() PoolAutoScaleOutput {
	return o
}

func (o PoolAutoScaleOutput) ToPoolAutoScaleOutputWithContext(ctx context.Context) PoolAutoScaleOutput {
	return o
}

func (o PoolAutoScaleOutput) ToPoolAutoScalePtrOutput() PoolAutoScalePtrOutput {
	return o.ToPoolAutoScalePtrOutputWithContext(context.Background())
}

func (o PoolAutoScaleOutput) ToPoolAutoScalePtrOutputWithContext(ctx context.Context) PoolAutoScalePtrOutput {
	return o.ApplyT(func(v PoolAutoScale) *PoolAutoScale {
		return &v
	}).(PoolAutoScalePtrOutput)
}

// The interval to wait before evaluating if the pool needs to be scaled. Defaults to `PT15M`.
func (o PoolAutoScaleOutput) EvaluationInterval() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PoolAutoScale) *string { return v.EvaluationInterval }).(pulumi.StringPtrOutput)
}

// The autoscale formula that needs to be used for scaling the Batch pool.
func (o PoolAutoScaleOutput) Formula() pulumi.StringOutput {
	return o.ApplyT(func(v PoolAutoScale) string { return v.Formula }).(pulumi.StringOutput)
}

type PoolAutoScalePtrOutput struct{ *pulumi.OutputState }

func (PoolAutoScalePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**PoolAutoScale)(nil)).Elem()
}

func (o PoolAutoScalePtrOutput) ToPoolAutoScalePtrOutput() PoolAutoScalePtrOutput {
	return o
}

func (o PoolAutoScalePtrOutput) ToPoolAutoScalePtrOutputWithContext(ctx context.Context) PoolAutoScalePtrOutput {
	return o
}

func (o PoolAutoScalePtrOutput) Elem() PoolAutoScaleOutput {
	return o.ApplyT(func(v *PoolAutoScale) PoolAutoScale { return *v }).(PoolAutoScaleOutput)
}

// The interval to wait before evaluating if the pool needs to be scaled. Defaults to `PT15M`.
func (o PoolAutoScalePtrOutput) EvaluationInterval() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PoolAutoScale) *string {
		if v == nil {
			return nil
		}
		return v.EvaluationInterval
	}).(pulumi.StringPtrOutput)
}

// The autoscale formula that needs to be used for scaling the Batch pool.
func (o PoolAutoScalePtrOutput) Formula() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PoolAutoScale) *string {
		if v == nil {
			return nil
		}
		return &v.Formula
	}).(pulumi.StringPtrOutput)
}

type PoolCertificate struct {
	// The ID of the Batch Certificate to install on the Batch Pool, which must be inside the same Batch Account.
	Id string `pulumi:"id"`
	// The location of the certificate store on the compute node into which to install the certificate. Possible values are `CurrentUser` or `LocalMachine`.
	StoreLocation string `pulumi:"storeLocation"`
	// The name of the certificate store on the compute node into which to install the certificate. This property is applicable only for pools configured with Windows nodes (that is, created with cloudServiceConfiguration, or with virtualMachineConfiguration using a Windows image reference). Common store names include: `My`, `Root`, `CA`, `Trust`, `Disallowed`, `TrustedPeople`, `TrustedPublisher`, `AuthRoot`, `AddressBook`, but any custom store name can also be used. The default value is `My`.
	StoreName *string `pulumi:"storeName"`
	// Which user accounts on the compute node should have access to the private data of the certificate.
	Visibilities []string `pulumi:"visibilities"`
}

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

	ToPoolCertificateOutput() PoolCertificateOutput
	ToPoolCertificateOutputWithContext(context.Context) PoolCertificateOutput
}

type PoolCertificateArgs struct {
	// The ID of the Batch Certificate to install on the Batch Pool, which must be inside the same Batch Account.
	Id pulumi.StringInput `pulumi:"id"`
	// The location of the certificate store on the compute node into which to install the certificate. Possible values are `CurrentUser` or `LocalMachine`.
	StoreLocation pulumi.StringInput `pulumi:"storeLocation"`
	// The name of the certificate store on the compute node into which to install the certificate. This property is applicable only for pools configured with Windows nodes (that is, created with cloudServiceConfiguration, or with virtualMachineConfiguration using a Windows image reference). Common store names include: `My`, `Root`, `CA`, `Trust`, `Disallowed`, `TrustedPeople`, `TrustedPublisher`, `AuthRoot`, `AddressBook`, but any custom store name can also be used. The default value is `My`.
	StoreName pulumi.StringPtrInput `pulumi:"storeName"`
	// Which user accounts on the compute node should have access to the private data of the certificate.
	Visibilities pulumi.StringArrayInput `pulumi:"visibilities"`
}

func (PoolCertificateArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolCertificate)(nil)).Elem()
}

func (i PoolCertificateArgs) ToPoolCertificateOutput() PoolCertificateOutput {
	return i.ToPoolCertificateOutputWithContext(context.Background())
}

func (i PoolCertificateArgs) ToPoolCertificateOutputWithContext(ctx context.Context) PoolCertificateOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolCertificateOutput)
}

// PoolCertificateArrayInput is an input type that accepts PoolCertificateArray and PoolCertificateArrayOutput values.
// You can construct a concrete instance of `PoolCertificateArrayInput` via:
//
//          PoolCertificateArray{ PoolCertificateArgs{...} }
type PoolCertificateArrayInput interface {
	pulumi.Input

	ToPoolCertificateArrayOutput() PoolCertificateArrayOutput
	ToPoolCertificateArrayOutputWithContext(context.Context) PoolCertificateArrayOutput
}

type PoolCertificateArray []PoolCertificateInput

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

func (i PoolCertificateArray) ToPoolCertificateArrayOutput() PoolCertificateArrayOutput {
	return i.ToPoolCertificateArrayOutputWithContext(context.Background())
}

func (i PoolCertificateArray) ToPoolCertificateArrayOutputWithContext(ctx context.Context) PoolCertificateArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolCertificateArrayOutput)
}

type PoolCertificateOutput struct{ *pulumi.OutputState }

func (PoolCertificateOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolCertificate)(nil)).Elem()
}

func (o PoolCertificateOutput) ToPoolCertificateOutput() PoolCertificateOutput {
	return o
}

func (o PoolCertificateOutput) ToPoolCertificateOutputWithContext(ctx context.Context) PoolCertificateOutput {
	return o
}

// The ID of the Batch Certificate to install on the Batch Pool, which must be inside the same Batch Account.
func (o PoolCertificateOutput) Id() pulumi.StringOutput {
	return o.ApplyT(func(v PoolCertificate) string { return v.Id }).(pulumi.StringOutput)
}

// The location of the certificate store on the compute node into which to install the certificate. Possible values are `CurrentUser` or `LocalMachine`.
func (o PoolCertificateOutput) StoreLocation() pulumi.StringOutput {
	return o.ApplyT(func(v PoolCertificate) string { return v.StoreLocation }).(pulumi.StringOutput)
}

// The name of the certificate store on the compute node into which to install the certificate. This property is applicable only for pools configured with Windows nodes (that is, created with cloudServiceConfiguration, or with virtualMachineConfiguration using a Windows image reference). Common store names include: `My`, `Root`, `CA`, `Trust`, `Disallowed`, `TrustedPeople`, `TrustedPublisher`, `AuthRoot`, `AddressBook`, but any custom store name can also be used. The default value is `My`.
func (o PoolCertificateOutput) StoreName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PoolCertificate) *string { return v.StoreName }).(pulumi.StringPtrOutput)
}

// Which user accounts on the compute node should have access to the private data of the certificate.
func (o PoolCertificateOutput) Visibilities() pulumi.StringArrayOutput {
	return o.ApplyT(func(v PoolCertificate) []string { return v.Visibilities }).(pulumi.StringArrayOutput)
}

type PoolCertificateArrayOutput struct{ *pulumi.OutputState }

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

func (o PoolCertificateArrayOutput) ToPoolCertificateArrayOutput() PoolCertificateArrayOutput {
	return o
}

func (o PoolCertificateArrayOutput) ToPoolCertificateArrayOutputWithContext(ctx context.Context) PoolCertificateArrayOutput {
	return o
}

func (o PoolCertificateArrayOutput) Index(i pulumi.IntInput) PoolCertificateOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) PoolCertificate {
		return vs[0].([]PoolCertificate)[vs[1].(int)]
	}).(PoolCertificateOutput)
}

type PoolContainerConfiguration struct {
	// A list of container image names to use, as would be specified by `docker pull`.
	ContainerImageNames []string `pulumi:"containerImageNames"`
	// Additional container registries from which container images can be pulled by the pool's VMs.
	ContainerRegistries []PoolContainerConfigurationContainerRegistry `pulumi:"containerRegistries"`
	// The type of container configuration. Possible value is `DockerCompatible`.
	Type *string `pulumi:"type"`
}

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

	ToPoolContainerConfigurationOutput() PoolContainerConfigurationOutput
	ToPoolContainerConfigurationOutputWithContext(context.Context) PoolContainerConfigurationOutput
}

type PoolContainerConfigurationArgs struct {
	// A list of container image names to use, as would be specified by `docker pull`.
	ContainerImageNames pulumi.StringArrayInput `pulumi:"containerImageNames"`
	// Additional container registries from which container images can be pulled by the pool's VMs.
	ContainerRegistries PoolContainerConfigurationContainerRegistryArrayInput `pulumi:"containerRegistries"`
	// The type of container configuration. Possible value is `DockerCompatible`.
	Type pulumi.StringPtrInput `pulumi:"type"`
}

func (PoolContainerConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolContainerConfiguration)(nil)).Elem()
}

func (i PoolContainerConfigurationArgs) ToPoolContainerConfigurationOutput() PoolContainerConfigurationOutput {
	return i.ToPoolContainerConfigurationOutputWithContext(context.Background())
}

func (i PoolContainerConfigurationArgs) ToPoolContainerConfigurationOutputWithContext(ctx context.Context) PoolContainerConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolContainerConfigurationOutput)
}

func (i PoolContainerConfigurationArgs) ToPoolContainerConfigurationPtrOutput() PoolContainerConfigurationPtrOutput {
	return i.ToPoolContainerConfigurationPtrOutputWithContext(context.Background())
}

func (i PoolContainerConfigurationArgs) ToPoolContainerConfigurationPtrOutputWithContext(ctx context.Context) PoolContainerConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolContainerConfigurationOutput).ToPoolContainerConfigurationPtrOutputWithContext(ctx)
}

// PoolContainerConfigurationPtrInput is an input type that accepts PoolContainerConfigurationArgs, PoolContainerConfigurationPtr and PoolContainerConfigurationPtrOutput values.
// You can construct a concrete instance of `PoolContainerConfigurationPtrInput` via:
//
//          PoolContainerConfigurationArgs{...}
//
//  or:
//
//          nil
type PoolContainerConfigurationPtrInput interface {
	pulumi.Input

	ToPoolContainerConfigurationPtrOutput() PoolContainerConfigurationPtrOutput
	ToPoolContainerConfigurationPtrOutputWithContext(context.Context) PoolContainerConfigurationPtrOutput
}

type poolContainerConfigurationPtrType PoolContainerConfigurationArgs

func PoolContainerConfigurationPtr(v *PoolContainerConfigurationArgs) PoolContainerConfigurationPtrInput {
	return (*poolContainerConfigurationPtrType)(v)
}

func (*poolContainerConfigurationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**PoolContainerConfiguration)(nil)).Elem()
}

func (i *poolContainerConfigurationPtrType) ToPoolContainerConfigurationPtrOutput() PoolContainerConfigurationPtrOutput {
	return i.ToPoolContainerConfigurationPtrOutputWithContext(context.Background())
}

func (i *poolContainerConfigurationPtrType) ToPoolContainerConfigurationPtrOutputWithContext(ctx context.Context) PoolContainerConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolContainerConfigurationPtrOutput)
}

type PoolContainerConfigurationOutput struct{ *pulumi.OutputState }

func (PoolContainerConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolContainerConfiguration)(nil)).Elem()
}

func (o PoolContainerConfigurationOutput) ToPoolContainerConfigurationOutput() PoolContainerConfigurationOutput {
	return o
}

func (o PoolContainerConfigurationOutput) ToPoolContainerConfigurationOutputWithContext(ctx context.Context) PoolContainerConfigurationOutput {
	return o
}

func (o PoolContainerConfigurationOutput) ToPoolContainerConfigurationPtrOutput() PoolContainerConfigurationPtrOutput {
	return o.ToPoolContainerConfigurationPtrOutputWithContext(context.Background())
}

func (o PoolContainerConfigurationOutput) ToPoolContainerConfigurationPtrOutputWithContext(ctx context.Context) PoolContainerConfigurationPtrOutput {
	return o.ApplyT(func(v PoolContainerConfiguration) *PoolContainerConfiguration {
		return &v
	}).(PoolContainerConfigurationPtrOutput)
}

// A list of container image names to use, as would be specified by `docker pull`.
func (o PoolContainerConfigurationOutput) ContainerImageNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v PoolContainerConfiguration) []string { return v.ContainerImageNames }).(pulumi.StringArrayOutput)
}

// Additional container registries from which container images can be pulled by the pool's VMs.
func (o PoolContainerConfigurationOutput) ContainerRegistries() PoolContainerConfigurationContainerRegistryArrayOutput {
	return o.ApplyT(func(v PoolContainerConfiguration) []PoolContainerConfigurationContainerRegistry {
		return v.ContainerRegistries
	}).(PoolContainerConfigurationContainerRegistryArrayOutput)
}

// The type of container configuration. Possible value is `DockerCompatible`.
func (o PoolContainerConfigurationOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PoolContainerConfiguration) *string { return v.Type }).(pulumi.StringPtrOutput)
}

type PoolContainerConfigurationPtrOutput struct{ *pulumi.OutputState }

func (PoolContainerConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**PoolContainerConfiguration)(nil)).Elem()
}

func (o PoolContainerConfigurationPtrOutput) ToPoolContainerConfigurationPtrOutput() PoolContainerConfigurationPtrOutput {
	return o
}

func (o PoolContainerConfigurationPtrOutput) ToPoolContainerConfigurationPtrOutputWithContext(ctx context.Context) PoolContainerConfigurationPtrOutput {
	return o
}

func (o PoolContainerConfigurationPtrOutput) Elem() PoolContainerConfigurationOutput {
	return o.ApplyT(func(v *PoolContainerConfiguration) PoolContainerConfiguration { return *v }).(PoolContainerConfigurationOutput)
}

// A list of container image names to use, as would be specified by `docker pull`.
func (o PoolContainerConfigurationPtrOutput) ContainerImageNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *PoolContainerConfiguration) []string {
		if v == nil {
			return nil
		}
		return v.ContainerImageNames
	}).(pulumi.StringArrayOutput)
}

// Additional container registries from which container images can be pulled by the pool's VMs.
func (o PoolContainerConfigurationPtrOutput) ContainerRegistries() PoolContainerConfigurationContainerRegistryArrayOutput {
	return o.ApplyT(func(v *PoolContainerConfiguration) []PoolContainerConfigurationContainerRegistry {
		if v == nil {
			return nil
		}
		return v.ContainerRegistries
	}).(PoolContainerConfigurationContainerRegistryArrayOutput)
}

// The type of container configuration. Possible value is `DockerCompatible`.
func (o PoolContainerConfigurationPtrOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PoolContainerConfiguration) *string {
		if v == nil {
			return nil
		}
		return v.Type
	}).(pulumi.StringPtrOutput)
}

type PoolContainerConfigurationContainerRegistry struct {
	// The password to log into the registry server. Changing this forces a new resource to be created.
	Password string `pulumi:"password"`
	// The container registry URL. The default is "docker.io". Changing this forces a new resource to be created.
	RegistryServer string `pulumi:"registryServer"`
	// The user name to log into the registry server. Changing this forces a new resource to be created.
	UserName string `pulumi:"userName"`
}

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

	ToPoolContainerConfigurationContainerRegistryOutput() PoolContainerConfigurationContainerRegistryOutput
	ToPoolContainerConfigurationContainerRegistryOutputWithContext(context.Context) PoolContainerConfigurationContainerRegistryOutput
}

type PoolContainerConfigurationContainerRegistryArgs struct {
	// The password to log into the registry server. Changing this forces a new resource to be created.
	Password pulumi.StringInput `pulumi:"password"`
	// The container registry URL. The default is "docker.io". Changing this forces a new resource to be created.
	RegistryServer pulumi.StringInput `pulumi:"registryServer"`
	// The user name to log into the registry server. Changing this forces a new resource to be created.
	UserName pulumi.StringInput `pulumi:"userName"`
}

func (PoolContainerConfigurationContainerRegistryArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolContainerConfigurationContainerRegistry)(nil)).Elem()
}

func (i PoolContainerConfigurationContainerRegistryArgs) ToPoolContainerConfigurationContainerRegistryOutput() PoolContainerConfigurationContainerRegistryOutput {
	return i.ToPoolContainerConfigurationContainerRegistryOutputWithContext(context.Background())
}

func (i PoolContainerConfigurationContainerRegistryArgs) ToPoolContainerConfigurationContainerRegistryOutputWithContext(ctx context.Context) PoolContainerConfigurationContainerRegistryOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolContainerConfigurationContainerRegistryOutput)
}

// PoolContainerConfigurationContainerRegistryArrayInput is an input type that accepts PoolContainerConfigurationContainerRegistryArray and PoolContainerConfigurationContainerRegistryArrayOutput values.
// You can construct a concrete instance of `PoolContainerConfigurationContainerRegistryArrayInput` via:
//
//          PoolContainerConfigurationContainerRegistryArray{ PoolContainerConfigurationContainerRegistryArgs{...} }
type PoolContainerConfigurationContainerRegistryArrayInput interface {
	pulumi.Input

	ToPoolContainerConfigurationContainerRegistryArrayOutput() PoolContainerConfigurationContainerRegistryArrayOutput
	ToPoolContainerConfigurationContainerRegistryArrayOutputWithContext(context.Context) PoolContainerConfigurationContainerRegistryArrayOutput
}

type PoolContainerConfigurationContainerRegistryArray []PoolContainerConfigurationContainerRegistryInput

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

func (i PoolContainerConfigurationContainerRegistryArray) ToPoolContainerConfigurationContainerRegistryArrayOutput() PoolContainerConfigurationContainerRegistryArrayOutput {
	return i.ToPoolContainerConfigurationContainerRegistryArrayOutputWithContext(context.Background())
}

func (i PoolContainerConfigurationContainerRegistryArray) ToPoolContainerConfigurationContainerRegistryArrayOutputWithContext(ctx context.Context) PoolContainerConfigurationContainerRegistryArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolContainerConfigurationContainerRegistryArrayOutput)
}

type PoolContainerConfigurationContainerRegistryOutput struct{ *pulumi.OutputState }

func (PoolContainerConfigurationContainerRegistryOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolContainerConfigurationContainerRegistry)(nil)).Elem()
}

func (o PoolContainerConfigurationContainerRegistryOutput) ToPoolContainerConfigurationContainerRegistryOutput() PoolContainerConfigurationContainerRegistryOutput {
	return o
}

func (o PoolContainerConfigurationContainerRegistryOutput) ToPoolContainerConfigurationContainerRegistryOutputWithContext(ctx context.Context) PoolContainerConfigurationContainerRegistryOutput {
	return o
}

// The password to log into the registry server. Changing this forces a new resource to be created.
func (o PoolContainerConfigurationContainerRegistryOutput) Password() pulumi.StringOutput {
	return o.ApplyT(func(v PoolContainerConfigurationContainerRegistry) string { return v.Password }).(pulumi.StringOutput)
}

// The container registry URL. The default is "docker.io". Changing this forces a new resource to be created.
func (o PoolContainerConfigurationContainerRegistryOutput) RegistryServer() pulumi.StringOutput {
	return o.ApplyT(func(v PoolContainerConfigurationContainerRegistry) string { return v.RegistryServer }).(pulumi.StringOutput)
}

// The user name to log into the registry server. Changing this forces a new resource to be created.
func (o PoolContainerConfigurationContainerRegistryOutput) UserName() pulumi.StringOutput {
	return o.ApplyT(func(v PoolContainerConfigurationContainerRegistry) string { return v.UserName }).(pulumi.StringOutput)
}

type PoolContainerConfigurationContainerRegistryArrayOutput struct{ *pulumi.OutputState }

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

func (o PoolContainerConfigurationContainerRegistryArrayOutput) ToPoolContainerConfigurationContainerRegistryArrayOutput() PoolContainerConfigurationContainerRegistryArrayOutput {
	return o
}

func (o PoolContainerConfigurationContainerRegistryArrayOutput) ToPoolContainerConfigurationContainerRegistryArrayOutputWithContext(ctx context.Context) PoolContainerConfigurationContainerRegistryArrayOutput {
	return o
}

func (o PoolContainerConfigurationContainerRegistryArrayOutput) Index(i pulumi.IntInput) PoolContainerConfigurationContainerRegistryOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) PoolContainerConfigurationContainerRegistry {
		return vs[0].([]PoolContainerConfigurationContainerRegistry)[vs[1].(int)]
	}).(PoolContainerConfigurationContainerRegistryOutput)
}

type PoolFixedScale struct {
	// The timeout for resize operations. Defaults to `PT15M`.
	ResizeTimeout *string `pulumi:"resizeTimeout"`
	// The number of nodes in the Batch pool. Defaults to `1`.
	TargetDedicatedNodes *int `pulumi:"targetDedicatedNodes"`
	// The number of low priority nodes in the Batch pool. Defaults to `0`.
	TargetLowPriorityNodes *int `pulumi:"targetLowPriorityNodes"`
}

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

	ToPoolFixedScaleOutput() PoolFixedScaleOutput
	ToPoolFixedScaleOutputWithContext(context.Context) PoolFixedScaleOutput
}

type PoolFixedScaleArgs struct {
	// The timeout for resize operations. Defaults to `PT15M`.
	ResizeTimeout pulumi.StringPtrInput `pulumi:"resizeTimeout"`
	// The number of nodes in the Batch pool. Defaults to `1`.
	TargetDedicatedNodes pulumi.IntPtrInput `pulumi:"targetDedicatedNodes"`
	// The number of low priority nodes in the Batch pool. Defaults to `0`.
	TargetLowPriorityNodes pulumi.IntPtrInput `pulumi:"targetLowPriorityNodes"`
}

func (PoolFixedScaleArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolFixedScale)(nil)).Elem()
}

func (i PoolFixedScaleArgs) ToPoolFixedScaleOutput() PoolFixedScaleOutput {
	return i.ToPoolFixedScaleOutputWithContext(context.Background())
}

func (i PoolFixedScaleArgs) ToPoolFixedScaleOutputWithContext(ctx context.Context) PoolFixedScaleOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolFixedScaleOutput)
}

func (i PoolFixedScaleArgs) ToPoolFixedScalePtrOutput() PoolFixedScalePtrOutput {
	return i.ToPoolFixedScalePtrOutputWithContext(context.Background())
}

func (i PoolFixedScaleArgs) ToPoolFixedScalePtrOutputWithContext(ctx context.Context) PoolFixedScalePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolFixedScaleOutput).ToPoolFixedScalePtrOutputWithContext(ctx)
}

// PoolFixedScalePtrInput is an input type that accepts PoolFixedScaleArgs, PoolFixedScalePtr and PoolFixedScalePtrOutput values.
// You can construct a concrete instance of `PoolFixedScalePtrInput` via:
//
//          PoolFixedScaleArgs{...}
//
//  or:
//
//          nil
type PoolFixedScalePtrInput interface {
	pulumi.Input

	ToPoolFixedScalePtrOutput() PoolFixedScalePtrOutput
	ToPoolFixedScalePtrOutputWithContext(context.Context) PoolFixedScalePtrOutput
}

type poolFixedScalePtrType PoolFixedScaleArgs

func PoolFixedScalePtr(v *PoolFixedScaleArgs) PoolFixedScalePtrInput {
	return (*poolFixedScalePtrType)(v)
}

func (*poolFixedScalePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**PoolFixedScale)(nil)).Elem()
}

func (i *poolFixedScalePtrType) ToPoolFixedScalePtrOutput() PoolFixedScalePtrOutput {
	return i.ToPoolFixedScalePtrOutputWithContext(context.Background())
}

func (i *poolFixedScalePtrType) ToPoolFixedScalePtrOutputWithContext(ctx context.Context) PoolFixedScalePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolFixedScalePtrOutput)
}

type PoolFixedScaleOutput struct{ *pulumi.OutputState }

func (PoolFixedScaleOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolFixedScale)(nil)).Elem()
}

func (o PoolFixedScaleOutput) ToPoolFixedScaleOutput() PoolFixedScaleOutput {
	return o
}

func (o PoolFixedScaleOutput) ToPoolFixedScaleOutputWithContext(ctx context.Context) PoolFixedScaleOutput {
	return o
}

func (o PoolFixedScaleOutput) ToPoolFixedScalePtrOutput() PoolFixedScalePtrOutput {
	return o.ToPoolFixedScalePtrOutputWithContext(context.Background())
}

func (o PoolFixedScaleOutput) ToPoolFixedScalePtrOutputWithContext(ctx context.Context) PoolFixedScalePtrOutput {
	return o.ApplyT(func(v PoolFixedScale) *PoolFixedScale {
		return &v
	}).(PoolFixedScalePtrOutput)
}

// The timeout for resize operations. Defaults to `PT15M`.
func (o PoolFixedScaleOutput) ResizeTimeout() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PoolFixedScale) *string { return v.ResizeTimeout }).(pulumi.StringPtrOutput)
}

// The number of nodes in the Batch pool. Defaults to `1`.
func (o PoolFixedScaleOutput) TargetDedicatedNodes() pulumi.IntPtrOutput {
	return o.ApplyT(func(v PoolFixedScale) *int { return v.TargetDedicatedNodes }).(pulumi.IntPtrOutput)
}

// The number of low priority nodes in the Batch pool. Defaults to `0`.
func (o PoolFixedScaleOutput) TargetLowPriorityNodes() pulumi.IntPtrOutput {
	return o.ApplyT(func(v PoolFixedScale) *int { return v.TargetLowPriorityNodes }).(pulumi.IntPtrOutput)
}

type PoolFixedScalePtrOutput struct{ *pulumi.OutputState }

func (PoolFixedScalePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**PoolFixedScale)(nil)).Elem()
}

func (o PoolFixedScalePtrOutput) ToPoolFixedScalePtrOutput() PoolFixedScalePtrOutput {
	return o
}

func (o PoolFixedScalePtrOutput) ToPoolFixedScalePtrOutputWithContext(ctx context.Context) PoolFixedScalePtrOutput {
	return o
}

func (o PoolFixedScalePtrOutput) Elem() PoolFixedScaleOutput {
	return o.ApplyT(func(v *PoolFixedScale) PoolFixedScale { return *v }).(PoolFixedScaleOutput)
}

// The timeout for resize operations. Defaults to `PT15M`.
func (o PoolFixedScalePtrOutput) ResizeTimeout() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PoolFixedScale) *string {
		if v == nil {
			return nil
		}
		return v.ResizeTimeout
	}).(pulumi.StringPtrOutput)
}

// The number of nodes in the Batch pool. Defaults to `1`.
func (o PoolFixedScalePtrOutput) TargetDedicatedNodes() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *PoolFixedScale) *int {
		if v == nil {
			return nil
		}
		return v.TargetDedicatedNodes
	}).(pulumi.IntPtrOutput)
}

// The number of low priority nodes in the Batch pool. Defaults to `0`.
func (o PoolFixedScalePtrOutput) TargetLowPriorityNodes() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *PoolFixedScale) *int {
		if v == nil {
			return nil
		}
		return v.TargetLowPriorityNodes
	}).(pulumi.IntPtrOutput)
}

type PoolNetworkConfiguration struct {
	// A list of inbound NAT pools that can be used to address specific ports on an individual compute node externally. Set as documented in the inboundNatPools block below. Changing this forces a new resource to be created.
	EndpointConfigurations []PoolNetworkConfigurationEndpointConfiguration `pulumi:"endpointConfigurations"`
	// A list of public ip ids that will be allocated to nodes. Changing this forces a new resource to be created.
	PublicIps []string `pulumi:"publicIps"`
	// The ARM resource identifier of the virtual network subnet which the compute nodes of the pool will join. Changing this forces a new resource to be created.
	SubnetId string `pulumi:"subnetId"`
}

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

	ToPoolNetworkConfigurationOutput() PoolNetworkConfigurationOutput
	ToPoolNetworkConfigurationOutputWithContext(context.Context) PoolNetworkConfigurationOutput
}

type PoolNetworkConfigurationArgs struct {
	// A list of inbound NAT pools that can be used to address specific ports on an individual compute node externally. Set as documented in the inboundNatPools block below. Changing this forces a new resource to be created.
	EndpointConfigurations PoolNetworkConfigurationEndpointConfigurationArrayInput `pulumi:"endpointConfigurations"`
	// A list of public ip ids that will be allocated to nodes. Changing this forces a new resource to be created.
	PublicIps pulumi.StringArrayInput `pulumi:"publicIps"`
	// The ARM resource identifier of the virtual network subnet which the compute nodes of the pool will join. Changing this forces a new resource to be created.
	SubnetId pulumi.StringInput `pulumi:"subnetId"`
}

func (PoolNetworkConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolNetworkConfiguration)(nil)).Elem()
}

func (i PoolNetworkConfigurationArgs) ToPoolNetworkConfigurationOutput() PoolNetworkConfigurationOutput {
	return i.ToPoolNetworkConfigurationOutputWithContext(context.Background())
}

func (i PoolNetworkConfigurationArgs) ToPoolNetworkConfigurationOutputWithContext(ctx context.Context) PoolNetworkConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolNetworkConfigurationOutput)
}

func (i PoolNetworkConfigurationArgs) ToPoolNetworkConfigurationPtrOutput() PoolNetworkConfigurationPtrOutput {
	return i.ToPoolNetworkConfigurationPtrOutputWithContext(context.Background())
}

func (i PoolNetworkConfigurationArgs) ToPoolNetworkConfigurationPtrOutputWithContext(ctx context.Context) PoolNetworkConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolNetworkConfigurationOutput).ToPoolNetworkConfigurationPtrOutputWithContext(ctx)
}

// PoolNetworkConfigurationPtrInput is an input type that accepts PoolNetworkConfigurationArgs, PoolNetworkConfigurationPtr and PoolNetworkConfigurationPtrOutput values.
// You can construct a concrete instance of `PoolNetworkConfigurationPtrInput` via:
//
//          PoolNetworkConfigurationArgs{...}
//
//  or:
//
//          nil
type PoolNetworkConfigurationPtrInput interface {
	pulumi.Input

	ToPoolNetworkConfigurationPtrOutput() PoolNetworkConfigurationPtrOutput
	ToPoolNetworkConfigurationPtrOutputWithContext(context.Context) PoolNetworkConfigurationPtrOutput
}

type poolNetworkConfigurationPtrType PoolNetworkConfigurationArgs

func PoolNetworkConfigurationPtr(v *PoolNetworkConfigurationArgs) PoolNetworkConfigurationPtrInput {
	return (*poolNetworkConfigurationPtrType)(v)
}

func (*poolNetworkConfigurationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**PoolNetworkConfiguration)(nil)).Elem()
}

func (i *poolNetworkConfigurationPtrType) ToPoolNetworkConfigurationPtrOutput() PoolNetworkConfigurationPtrOutput {
	return i.ToPoolNetworkConfigurationPtrOutputWithContext(context.Background())
}

func (i *poolNetworkConfigurationPtrType) ToPoolNetworkConfigurationPtrOutputWithContext(ctx context.Context) PoolNetworkConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolNetworkConfigurationPtrOutput)
}

type PoolNetworkConfigurationOutput struct{ *pulumi.OutputState }

func (PoolNetworkConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolNetworkConfiguration)(nil)).Elem()
}

func (o PoolNetworkConfigurationOutput) ToPoolNetworkConfigurationOutput() PoolNetworkConfigurationOutput {
	return o
}

func (o PoolNetworkConfigurationOutput) ToPoolNetworkConfigurationOutputWithContext(ctx context.Context) PoolNetworkConfigurationOutput {
	return o
}

func (o PoolNetworkConfigurationOutput) ToPoolNetworkConfigurationPtrOutput() PoolNetworkConfigurationPtrOutput {
	return o.ToPoolNetworkConfigurationPtrOutputWithContext(context.Background())
}

func (o PoolNetworkConfigurationOutput) ToPoolNetworkConfigurationPtrOutputWithContext(ctx context.Context) PoolNetworkConfigurationPtrOutput {
	return o.ApplyT(func(v PoolNetworkConfiguration) *PoolNetworkConfiguration {
		return &v
	}).(PoolNetworkConfigurationPtrOutput)
}

// A list of inbound NAT pools that can be used to address specific ports on an individual compute node externally. Set as documented in the inboundNatPools block below. Changing this forces a new resource to be created.
func (o PoolNetworkConfigurationOutput) EndpointConfigurations() PoolNetworkConfigurationEndpointConfigurationArrayOutput {
	return o.ApplyT(func(v PoolNetworkConfiguration) []PoolNetworkConfigurationEndpointConfiguration {
		return v.EndpointConfigurations
	}).(PoolNetworkConfigurationEndpointConfigurationArrayOutput)
}

// A list of public ip ids that will be allocated to nodes. Changing this forces a new resource to be created.
func (o PoolNetworkConfigurationOutput) PublicIps() pulumi.StringArrayOutput {
	return o.ApplyT(func(v PoolNetworkConfiguration) []string { return v.PublicIps }).(pulumi.StringArrayOutput)
}

// The ARM resource identifier of the virtual network subnet which the compute nodes of the pool will join. Changing this forces a new resource to be created.
func (o PoolNetworkConfigurationOutput) SubnetId() pulumi.StringOutput {
	return o.ApplyT(func(v PoolNetworkConfiguration) string { return v.SubnetId }).(pulumi.StringOutput)
}

type PoolNetworkConfigurationPtrOutput struct{ *pulumi.OutputState }

func (PoolNetworkConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**PoolNetworkConfiguration)(nil)).Elem()
}

func (o PoolNetworkConfigurationPtrOutput) ToPoolNetworkConfigurationPtrOutput() PoolNetworkConfigurationPtrOutput {
	return o
}

func (o PoolNetworkConfigurationPtrOutput) ToPoolNetworkConfigurationPtrOutputWithContext(ctx context.Context) PoolNetworkConfigurationPtrOutput {
	return o
}

func (o PoolNetworkConfigurationPtrOutput) Elem() PoolNetworkConfigurationOutput {
	return o.ApplyT(func(v *PoolNetworkConfiguration) PoolNetworkConfiguration { return *v }).(PoolNetworkConfigurationOutput)
}

// A list of inbound NAT pools that can be used to address specific ports on an individual compute node externally. Set as documented in the inboundNatPools block below. Changing this forces a new resource to be created.
func (o PoolNetworkConfigurationPtrOutput) EndpointConfigurations() PoolNetworkConfigurationEndpointConfigurationArrayOutput {
	return o.ApplyT(func(v *PoolNetworkConfiguration) []PoolNetworkConfigurationEndpointConfiguration {
		if v == nil {
			return nil
		}
		return v.EndpointConfigurations
	}).(PoolNetworkConfigurationEndpointConfigurationArrayOutput)
}

// A list of public ip ids that will be allocated to nodes. Changing this forces a new resource to be created.
func (o PoolNetworkConfigurationPtrOutput) PublicIps() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *PoolNetworkConfiguration) []string {
		if v == nil {
			return nil
		}
		return v.PublicIps
	}).(pulumi.StringArrayOutput)
}

// The ARM resource identifier of the virtual network subnet which the compute nodes of the pool will join. Changing this forces a new resource to be created.
func (o PoolNetworkConfigurationPtrOutput) SubnetId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PoolNetworkConfiguration) *string {
		if v == nil {
			return nil
		}
		return &v.SubnetId
	}).(pulumi.StringPtrOutput)
}

type PoolNetworkConfigurationEndpointConfiguration struct {
	// The port number on the compute node. Acceptable values are between `1` and `65535` except for `29876`, `29877` as these are reserved. Changing this forces a new resource to be created.
	BackendPort int `pulumi:"backendPort"`
	// The range of external ports that will be used to provide inbound access to the backendPort on individual compute nodes in the format of `1000-1100`. Acceptable values range between `1` and `65534` except ports from `50000` to `55000` which are reserved by the Batch service. All ranges within a pool must be distinct and cannot overlap. Values must be a range of at least `100` nodes. Changing this forces a new resource to be created.
	FrontendPortRange string `pulumi:"frontendPortRange"`
	// The name of the endpoint. The name must be unique within a Batch pool, can contain letters, numbers, underscores, periods, and hyphens. Names must start with a letter or number, must end with a letter, number, or underscore, and cannot exceed 77 characters. Changing this forces a new resource to be created.
	Name string `pulumi:"name"`
	// A list of network security group rules that will be applied to the endpoint. The maximum number of rules that can be specified across all the endpoints on a Batch pool is `25`. If no network security group rules are specified, a default rule will be created to allow inbound access to the specified backendPort. Set as documented in the networkSecurityGroupRules block below. Changing this forces a new resource to be created.
	NetworkSecurityGroupRules []PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule `pulumi:"networkSecurityGroupRules"`
	// The protocol of the endpoint. Acceptable values are `TCP` and `UDP`. Changing this forces a new resource to be created.
	Protocol string `pulumi:"protocol"`
}

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

	ToPoolNetworkConfigurationEndpointConfigurationOutput() PoolNetworkConfigurationEndpointConfigurationOutput
	ToPoolNetworkConfigurationEndpointConfigurationOutputWithContext(context.Context) PoolNetworkConfigurationEndpointConfigurationOutput
}

type PoolNetworkConfigurationEndpointConfigurationArgs struct {
	// The port number on the compute node. Acceptable values are between `1` and `65535` except for `29876`, `29877` as these are reserved. Changing this forces a new resource to be created.
	BackendPort pulumi.IntInput `pulumi:"backendPort"`
	// The range of external ports that will be used to provide inbound access to the backendPort on individual compute nodes in the format of `1000-1100`. Acceptable values range between `1` and `65534` except ports from `50000` to `55000` which are reserved by the Batch service. All ranges within a pool must be distinct and cannot overlap. Values must be a range of at least `100` nodes. Changing this forces a new resource to be created.
	FrontendPortRange pulumi.StringInput `pulumi:"frontendPortRange"`
	// The name of the endpoint. The name must be unique within a Batch pool, can contain letters, numbers, underscores, periods, and hyphens. Names must start with a letter or number, must end with a letter, number, or underscore, and cannot exceed 77 characters. Changing this forces a new resource to be created.
	Name pulumi.StringInput `pulumi:"name"`
	// A list of network security group rules that will be applied to the endpoint. The maximum number of rules that can be specified across all the endpoints on a Batch pool is `25`. If no network security group rules are specified, a default rule will be created to allow inbound access to the specified backendPort. Set as documented in the networkSecurityGroupRules block below. Changing this forces a new resource to be created.
	NetworkSecurityGroupRules PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayInput `pulumi:"networkSecurityGroupRules"`
	// The protocol of the endpoint. Acceptable values are `TCP` and `UDP`. Changing this forces a new resource to be created.
	Protocol pulumi.StringInput `pulumi:"protocol"`
}

func (PoolNetworkConfigurationEndpointConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolNetworkConfigurationEndpointConfiguration)(nil)).Elem()
}

func (i PoolNetworkConfigurationEndpointConfigurationArgs) ToPoolNetworkConfigurationEndpointConfigurationOutput() PoolNetworkConfigurationEndpointConfigurationOutput {
	return i.ToPoolNetworkConfigurationEndpointConfigurationOutputWithContext(context.Background())
}

func (i PoolNetworkConfigurationEndpointConfigurationArgs) ToPoolNetworkConfigurationEndpointConfigurationOutputWithContext(ctx context.Context) PoolNetworkConfigurationEndpointConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolNetworkConfigurationEndpointConfigurationOutput)
}

// PoolNetworkConfigurationEndpointConfigurationArrayInput is an input type that accepts PoolNetworkConfigurationEndpointConfigurationArray and PoolNetworkConfigurationEndpointConfigurationArrayOutput values.
// You can construct a concrete instance of `PoolNetworkConfigurationEndpointConfigurationArrayInput` via:
//
//          PoolNetworkConfigurationEndpointConfigurationArray{ PoolNetworkConfigurationEndpointConfigurationArgs{...} }
type PoolNetworkConfigurationEndpointConfigurationArrayInput interface {
	pulumi.Input

	ToPoolNetworkConfigurationEndpointConfigurationArrayOutput() PoolNetworkConfigurationEndpointConfigurationArrayOutput
	ToPoolNetworkConfigurationEndpointConfigurationArrayOutputWithContext(context.Context) PoolNetworkConfigurationEndpointConfigurationArrayOutput
}

type PoolNetworkConfigurationEndpointConfigurationArray []PoolNetworkConfigurationEndpointConfigurationInput

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

func (i PoolNetworkConfigurationEndpointConfigurationArray) ToPoolNetworkConfigurationEndpointConfigurationArrayOutput() PoolNetworkConfigurationEndpointConfigurationArrayOutput {
	return i.ToPoolNetworkConfigurationEndpointConfigurationArrayOutputWithContext(context.Background())
}

func (i PoolNetworkConfigurationEndpointConfigurationArray) ToPoolNetworkConfigurationEndpointConfigurationArrayOutputWithContext(ctx context.Context) PoolNetworkConfigurationEndpointConfigurationArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolNetworkConfigurationEndpointConfigurationArrayOutput)
}

type PoolNetworkConfigurationEndpointConfigurationOutput struct{ *pulumi.OutputState }

func (PoolNetworkConfigurationEndpointConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolNetworkConfigurationEndpointConfiguration)(nil)).Elem()
}

func (o PoolNetworkConfigurationEndpointConfigurationOutput) ToPoolNetworkConfigurationEndpointConfigurationOutput() PoolNetworkConfigurationEndpointConfigurationOutput {
	return o
}

func (o PoolNetworkConfigurationEndpointConfigurationOutput) ToPoolNetworkConfigurationEndpointConfigurationOutputWithContext(ctx context.Context) PoolNetworkConfigurationEndpointConfigurationOutput {
	return o
}

// The port number on the compute node. Acceptable values are between `1` and `65535` except for `29876`, `29877` as these are reserved. Changing this forces a new resource to be created.
func (o PoolNetworkConfigurationEndpointConfigurationOutput) BackendPort() pulumi.IntOutput {
	return o.ApplyT(func(v PoolNetworkConfigurationEndpointConfiguration) int { return v.BackendPort }).(pulumi.IntOutput)
}

// The range of external ports that will be used to provide inbound access to the backendPort on individual compute nodes in the format of `1000-1100`. Acceptable values range between `1` and `65534` except ports from `50000` to `55000` which are reserved by the Batch service. All ranges within a pool must be distinct and cannot overlap. Values must be a range of at least `100` nodes. Changing this forces a new resource to be created.
func (o PoolNetworkConfigurationEndpointConfigurationOutput) FrontendPortRange() pulumi.StringOutput {
	return o.ApplyT(func(v PoolNetworkConfigurationEndpointConfiguration) string { return v.FrontendPortRange }).(pulumi.StringOutput)
}

// The name of the endpoint. The name must be unique within a Batch pool, can contain letters, numbers, underscores, periods, and hyphens. Names must start with a letter or number, must end with a letter, number, or underscore, and cannot exceed 77 characters. Changing this forces a new resource to be created.
func (o PoolNetworkConfigurationEndpointConfigurationOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v PoolNetworkConfigurationEndpointConfiguration) string { return v.Name }).(pulumi.StringOutput)
}

// A list of network security group rules that will be applied to the endpoint. The maximum number of rules that can be specified across all the endpoints on a Batch pool is `25`. If no network security group rules are specified, a default rule will be created to allow inbound access to the specified backendPort. Set as documented in the networkSecurityGroupRules block below. Changing this forces a new resource to be created.
func (o PoolNetworkConfigurationEndpointConfigurationOutput) NetworkSecurityGroupRules() PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput {
	return o.ApplyT(func(v PoolNetworkConfigurationEndpointConfiguration) []PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule {
		return v.NetworkSecurityGroupRules
	}).(PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput)
}

// The protocol of the endpoint. Acceptable values are `TCP` and `UDP`. Changing this forces a new resource to be created.
func (o PoolNetworkConfigurationEndpointConfigurationOutput) Protocol() pulumi.StringOutput {
	return o.ApplyT(func(v PoolNetworkConfigurationEndpointConfiguration) string { return v.Protocol }).(pulumi.StringOutput)
}

type PoolNetworkConfigurationEndpointConfigurationArrayOutput struct{ *pulumi.OutputState }

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

func (o PoolNetworkConfigurationEndpointConfigurationArrayOutput) ToPoolNetworkConfigurationEndpointConfigurationArrayOutput() PoolNetworkConfigurationEndpointConfigurationArrayOutput {
	return o
}

func (o PoolNetworkConfigurationEndpointConfigurationArrayOutput) ToPoolNetworkConfigurationEndpointConfigurationArrayOutputWithContext(ctx context.Context) PoolNetworkConfigurationEndpointConfigurationArrayOutput {
	return o
}

func (o PoolNetworkConfigurationEndpointConfigurationArrayOutput) Index(i pulumi.IntInput) PoolNetworkConfigurationEndpointConfigurationOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) PoolNetworkConfigurationEndpointConfiguration {
		return vs[0].([]PoolNetworkConfigurationEndpointConfiguration)[vs[1].(int)]
	}).(PoolNetworkConfigurationEndpointConfigurationOutput)
}

type PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule struct {
	// The action that should be taken for a specified IP address, subnet range or tag. Acceptable values are `Allow` and `Deny`. Changing this forces a new resource to be created.
	Access string `pulumi:"access"`
	// The priority for this rule. The value must be at least `150`. Changing this forces a new resource to be created.
	Priority int `pulumi:"priority"`
	// The source address prefix or tag to match for the rule. Changing this forces a new resource to be created.
	SourceAddressPrefix string `pulumi:"sourceAddressPrefix"`
}

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

	ToPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput() PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput
	ToPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutputWithContext(context.Context) PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput
}

type PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArgs struct {
	// The action that should be taken for a specified IP address, subnet range or tag. Acceptable values are `Allow` and `Deny`. Changing this forces a new resource to be created.
	Access pulumi.StringInput `pulumi:"access"`
	// The priority for this rule. The value must be at least `150`. Changing this forces a new resource to be created.
	Priority pulumi.IntInput `pulumi:"priority"`
	// The source address prefix or tag to match for the rule. Changing this forces a new resource to be created.
	SourceAddressPrefix pulumi.StringInput `pulumi:"sourceAddressPrefix"`
}

func (PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule)(nil)).Elem()
}

func (i PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArgs) ToPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput() PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput {
	return i.ToPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutputWithContext(context.Background())
}

func (i PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArgs) ToPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutputWithContext(ctx context.Context) PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput)
}

// PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayInput is an input type that accepts PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArray and PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput values.
// You can construct a concrete instance of `PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayInput` via:
//
//          PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArray{ PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArgs{...} }
type PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayInput interface {
	pulumi.Input

	ToPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput() PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput
	ToPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutputWithContext(context.Context) PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput
}

type PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArray []PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleInput

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

func (i PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArray) ToPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput() PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput {
	return i.ToPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutputWithContext(context.Background())
}

func (i PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArray) ToPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutputWithContext(ctx context.Context) PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput)
}

type PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput struct{ *pulumi.OutputState }

func (PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule)(nil)).Elem()
}

func (o PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput) ToPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput() PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput {
	return o
}

func (o PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput) ToPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutputWithContext(ctx context.Context) PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput {
	return o
}

// The action that should be taken for a specified IP address, subnet range or tag. Acceptable values are `Allow` and `Deny`. Changing this forces a new resource to be created.
func (o PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput) Access() pulumi.StringOutput {
	return o.ApplyT(func(v PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule) string { return v.Access }).(pulumi.StringOutput)
}

// The priority for this rule. The value must be at least `150`. Changing this forces a new resource to be created.
func (o PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput) Priority() pulumi.IntOutput {
	return o.ApplyT(func(v PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule) int { return v.Priority }).(pulumi.IntOutput)
}

// The source address prefix or tag to match for the rule. Changing this forces a new resource to be created.
func (o PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput) SourceAddressPrefix() pulumi.StringOutput {
	return o.ApplyT(func(v PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule) string {
		return v.SourceAddressPrefix
	}).(pulumi.StringOutput)
}

type PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput struct{ *pulumi.OutputState }

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

func (o PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput) ToPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput() PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput {
	return o
}

func (o PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput) ToPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutputWithContext(ctx context.Context) PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput {
	return o
}

func (o PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput) Index(i pulumi.IntInput) PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule {
		return vs[0].([]PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule)[vs[1].(int)]
	}).(PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput)
}

type PoolStartTask struct {
	// The command line executed by the start task.
	CommandLine string `pulumi:"commandLine"`
	// A map of strings (key,value) that represents the environment variables to set in the start task.
	Environment map[string]string `pulumi:"environment"`
	// The number of retry count. Defaults to `1`.
	MaxTaskRetryCount *int `pulumi:"maxTaskRetryCount"`
	// One or more `resourceFile` blocks that describe the files to be downloaded to a compute node.
	ResourceFiles []PoolStartTaskResourceFile `pulumi:"resourceFiles"`
	// A `userIdentity` block that describes the user identity under which the start task runs.
	UserIdentity PoolStartTaskUserIdentity `pulumi:"userIdentity"`
	// A flag that indicates if the Batch pool should wait for the start task to be completed. Default to `false`.
	WaitForSuccess *bool `pulumi:"waitForSuccess"`
}

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

	ToPoolStartTaskOutput() PoolStartTaskOutput
	ToPoolStartTaskOutputWithContext(context.Context) PoolStartTaskOutput
}

type PoolStartTaskArgs struct {
	// The command line executed by the start task.
	CommandLine pulumi.StringInput `pulumi:"commandLine"`
	// A map of strings (key,value) that represents the environment variables to set in the start task.
	Environment pulumi.StringMapInput `pulumi:"environment"`
	// The number of retry count. Defaults to `1`.
	MaxTaskRetryCount pulumi.IntPtrInput `pulumi:"maxTaskRetryCount"`
	// One or more `resourceFile` blocks that describe the files to be downloaded to a compute node.
	ResourceFiles PoolStartTaskResourceFileArrayInput `pulumi:"resourceFiles"`
	// A `userIdentity` block that describes the user identity under which the start task runs.
	UserIdentity PoolStartTaskUserIdentityInput `pulumi:"userIdentity"`
	// A flag that indicates if the Batch pool should wait for the start task to be completed. Default to `false`.
	WaitForSuccess pulumi.BoolPtrInput `pulumi:"waitForSuccess"`
}

func (PoolStartTaskArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolStartTask)(nil)).Elem()
}

func (i PoolStartTaskArgs) ToPoolStartTaskOutput() PoolStartTaskOutput {
	return i.ToPoolStartTaskOutputWithContext(context.Background())
}

func (i PoolStartTaskArgs) ToPoolStartTaskOutputWithContext(ctx context.Context) PoolStartTaskOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolStartTaskOutput)
}

func (i PoolStartTaskArgs) ToPoolStartTaskPtrOutput() PoolStartTaskPtrOutput {
	return i.ToPoolStartTaskPtrOutputWithContext(context.Background())
}

func (i PoolStartTaskArgs) ToPoolStartTaskPtrOutputWithContext(ctx context.Context) PoolStartTaskPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolStartTaskOutput).ToPoolStartTaskPtrOutputWithContext(ctx)
}

// PoolStartTaskPtrInput is an input type that accepts PoolStartTaskArgs, PoolStartTaskPtr and PoolStartTaskPtrOutput values.
// You can construct a concrete instance of `PoolStartTaskPtrInput` via:
//
//          PoolStartTaskArgs{...}
//
//  or:
//
//          nil
type PoolStartTaskPtrInput interface {
	pulumi.Input

	ToPoolStartTaskPtrOutput() PoolStartTaskPtrOutput
	ToPoolStartTaskPtrOutputWithContext(context.Context) PoolStartTaskPtrOutput
}

type poolStartTaskPtrType PoolStartTaskArgs

func PoolStartTaskPtr(v *PoolStartTaskArgs) PoolStartTaskPtrInput {
	return (*poolStartTaskPtrType)(v)
}

func (*poolStartTaskPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**PoolStartTask)(nil)).Elem()
}

func (i *poolStartTaskPtrType) ToPoolStartTaskPtrOutput() PoolStartTaskPtrOutput {
	return i.ToPoolStartTaskPtrOutputWithContext(context.Background())
}

func (i *poolStartTaskPtrType) ToPoolStartTaskPtrOutputWithContext(ctx context.Context) PoolStartTaskPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolStartTaskPtrOutput)
}

type PoolStartTaskOutput struct{ *pulumi.OutputState }

func (PoolStartTaskOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolStartTask)(nil)).Elem()
}

func (o PoolStartTaskOutput) ToPoolStartTaskOutput() PoolStartTaskOutput {
	return o
}

func (o PoolStartTaskOutput) ToPoolStartTaskOutputWithContext(ctx context.Context) PoolStartTaskOutput {
	return o
}

func (o PoolStartTaskOutput) ToPoolStartTaskPtrOutput() PoolStartTaskPtrOutput {
	return o.ToPoolStartTaskPtrOutputWithContext(context.Background())
}

func (o PoolStartTaskOutput) ToPoolStartTaskPtrOutputWithContext(ctx context.Context) PoolStartTaskPtrOutput {
	return o.ApplyT(func(v PoolStartTask) *PoolStartTask {
		return &v
	}).(PoolStartTaskPtrOutput)
}

// The command line executed by the start task.
func (o PoolStartTaskOutput) CommandLine() pulumi.StringOutput {
	return o.ApplyT(func(v PoolStartTask) string { return v.CommandLine }).(pulumi.StringOutput)
}

// A map of strings (key,value) that represents the environment variables to set in the start task.
func (o PoolStartTaskOutput) Environment() pulumi.StringMapOutput {
	return o.ApplyT(func(v PoolStartTask) map[string]string { return v.Environment }).(pulumi.StringMapOutput)
}

// The number of retry count. Defaults to `1`.
func (o PoolStartTaskOutput) MaxTaskRetryCount() pulumi.IntPtrOutput {
	return o.ApplyT(func(v PoolStartTask) *int { return v.MaxTaskRetryCount }).(pulumi.IntPtrOutput)
}

// One or more `resourceFile` blocks that describe the files to be downloaded to a compute node.
func (o PoolStartTaskOutput) ResourceFiles() PoolStartTaskResourceFileArrayOutput {
	return o.ApplyT(func(v PoolStartTask) []PoolStartTaskResourceFile { return v.ResourceFiles }).(PoolStartTaskResourceFileArrayOutput)
}

// A `userIdentity` block that describes the user identity under which the start task runs.
func (o PoolStartTaskOutput) UserIdentity() PoolStartTaskUserIdentityOutput {
	return o.ApplyT(func(v PoolStartTask) PoolStartTaskUserIdentity { return v.UserIdentity }).(PoolStartTaskUserIdentityOutput)
}

// A flag that indicates if the Batch pool should wait for the start task to be completed. Default to `false`.
func (o PoolStartTaskOutput) WaitForSuccess() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v PoolStartTask) *bool { return v.WaitForSuccess }).(pulumi.BoolPtrOutput)
}

type PoolStartTaskPtrOutput struct{ *pulumi.OutputState }

func (PoolStartTaskPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**PoolStartTask)(nil)).Elem()
}

func (o PoolStartTaskPtrOutput) ToPoolStartTaskPtrOutput() PoolStartTaskPtrOutput {
	return o
}

func (o PoolStartTaskPtrOutput) ToPoolStartTaskPtrOutputWithContext(ctx context.Context) PoolStartTaskPtrOutput {
	return o
}

func (o PoolStartTaskPtrOutput) Elem() PoolStartTaskOutput {
	return o.ApplyT(func(v *PoolStartTask) PoolStartTask { return *v }).(PoolStartTaskOutput)
}

// The command line executed by the start task.
func (o PoolStartTaskPtrOutput) CommandLine() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PoolStartTask) *string {
		if v == nil {
			return nil
		}
		return &v.CommandLine
	}).(pulumi.StringPtrOutput)
}

// A map of strings (key,value) that represents the environment variables to set in the start task.
func (o PoolStartTaskPtrOutput) Environment() pulumi.StringMapOutput {
	return o.ApplyT(func(v *PoolStartTask) map[string]string {
		if v == nil {
			return nil
		}
		return v.Environment
	}).(pulumi.StringMapOutput)
}

// The number of retry count. Defaults to `1`.
func (o PoolStartTaskPtrOutput) MaxTaskRetryCount() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *PoolStartTask) *int {
		if v == nil {
			return nil
		}
		return v.MaxTaskRetryCount
	}).(pulumi.IntPtrOutput)
}

// One or more `resourceFile` blocks that describe the files to be downloaded to a compute node.
func (o PoolStartTaskPtrOutput) ResourceFiles() PoolStartTaskResourceFileArrayOutput {
	return o.ApplyT(func(v *PoolStartTask) []PoolStartTaskResourceFile {
		if v == nil {
			return nil
		}
		return v.ResourceFiles
	}).(PoolStartTaskResourceFileArrayOutput)
}

// A `userIdentity` block that describes the user identity under which the start task runs.
func (o PoolStartTaskPtrOutput) UserIdentity() PoolStartTaskUserIdentityPtrOutput {
	return o.ApplyT(func(v *PoolStartTask) *PoolStartTaskUserIdentity {
		if v == nil {
			return nil
		}
		return &v.UserIdentity
	}).(PoolStartTaskUserIdentityPtrOutput)
}

// A flag that indicates if the Batch pool should wait for the start task to be completed. Default to `false`.
func (o PoolStartTaskPtrOutput) WaitForSuccess() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *PoolStartTask) *bool {
		if v == nil {
			return nil
		}
		return v.WaitForSuccess
	}).(pulumi.BoolPtrOutput)
}

type PoolStartTaskResourceFile struct {
	// The storage container name in the auto storage account.
	AutoStorageContainerName *string `pulumi:"autoStorageContainerName"`
	// The blob prefix to use when downloading blobs from an Azure Storage container. Only the blobs whose names begin with the specified prefix will be downloaded. The property is valid only when `autoStorageContainerName` or `storageContainerUrl` is used. This prefix can be a partial filename or a subdirectory. If a prefix is not specified, all the files in the container will be downloaded.
	BlobPrefix *string `pulumi:"blobPrefix"`
	// The file permission mode represented as a string in octal format (e.g. `"0644"`). This property applies only to files being downloaded to Linux compute nodes. It will be ignored if it is specified for a `resourceFile` which will be downloaded to a Windows node. If this property is not specified for a Linux node, then a default value of 0770 is applied to the file.
	FileMode *string `pulumi:"fileMode"`
	// The location on the compute node to which to download the file, relative to the task's working directory. If the `httpUrl` property is specified, the `filePath` is required and describes the path which the file will be downloaded to, including the filename. Otherwise, if the `autoStorageContainerName` or `storageContainerUrl` property is specified, `filePath` is optional and is the directory to download the files to. In the case where `filePath` is used as a directory, any directory structure already associated with the input data will be retained in full and appended to the specified filePath directory. The specified relative path cannot break out of the task's working directory (for example by using '..').
	FilePath *string `pulumi:"filePath"`
	// The URL of the file to download. If the URL is Azure Blob Storage, it must be readable using anonymous access; that is, the Batch service does not present any credentials when downloading the blob. There are two ways to get such a URL for a blob in Azure storage: include a Shared Access Signature (SAS) granting read permissions on the blob, or set the ACL for the blob or its container to allow public access.
	HttpUrl *string `pulumi:"httpUrl"`
	// The URL of the blob container within Azure Blob Storage. This URL must be readable and listable using anonymous access; that is, the Batch service does not present any credentials when downloading the blob. There are two ways to get such a URL for a blob in Azure storage: include a Shared Access Signature (SAS) granting read and list permissions on the blob, or set the ACL for the blob or its container to allow public access.
	StorageContainerUrl *string `pulumi:"storageContainerUrl"`
}

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

	ToPoolStartTaskResourceFileOutput() PoolStartTaskResourceFileOutput
	ToPoolStartTaskResourceFileOutputWithContext(context.Context) PoolStartTaskResourceFileOutput
}

type PoolStartTaskResourceFileArgs struct {
	// The storage container name in the auto storage account.
	AutoStorageContainerName pulumi.StringPtrInput `pulumi:"autoStorageContainerName"`
	// The blob prefix to use when downloading blobs from an Azure Storage container. Only the blobs whose names begin with the specified prefix will be downloaded. The property is valid only when `autoStorageContainerName` or `storageContainerUrl` is used. This prefix can be a partial filename or a subdirectory. If a prefix is not specified, all the files in the container will be downloaded.
	BlobPrefix pulumi.StringPtrInput `pulumi:"blobPrefix"`
	// The file permission mode represented as a string in octal format (e.g. `"0644"`). This property applies only to files being downloaded to Linux compute nodes. It will be ignored if it is specified for a `resourceFile` which will be downloaded to a Windows node. If this property is not specified for a Linux node, then a default value of 0770 is applied to the file.
	FileMode pulumi.StringPtrInput `pulumi:"fileMode"`
	// The location on the compute node to which to download the file, relative to the task's working directory. If the `httpUrl` property is specified, the `filePath` is required and describes the path which the file will be downloaded to, including the filename. Otherwise, if the `autoStorageContainerName` or `storageContainerUrl` property is specified, `filePath` is optional and is the directory to download the files to. In the case where `filePath` is used as a directory, any directory structure already associated with the input data will be retained in full and appended to the specified filePath directory. The specified relative path cannot break out of the task's working directory (for example by using '..').
	FilePath pulumi.StringPtrInput `pulumi:"filePath"`
	// The URL of the file to download. If the URL is Azure Blob Storage, it must be readable using anonymous access; that is, the Batch service does not present any credentials when downloading the blob. There are two ways to get such a URL for a blob in Azure storage: include a Shared Access Signature (SAS) granting read permissions on the blob, or set the ACL for the blob or its container to allow public access.
	HttpUrl pulumi.StringPtrInput `pulumi:"httpUrl"`
	// The URL of the blob container within Azure Blob Storage. This URL must be readable and listable using anonymous access; that is, the Batch service does not present any credentials when downloading the blob. There are two ways to get such a URL for a blob in Azure storage: include a Shared Access Signature (SAS) granting read and list permissions on the blob, or set the ACL for the blob or its container to allow public access.
	StorageContainerUrl pulumi.StringPtrInput `pulumi:"storageContainerUrl"`
}

func (PoolStartTaskResourceFileArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolStartTaskResourceFile)(nil)).Elem()
}

func (i PoolStartTaskResourceFileArgs) ToPoolStartTaskResourceFileOutput() PoolStartTaskResourceFileOutput {
	return i.ToPoolStartTaskResourceFileOutputWithContext(context.Background())
}

func (i PoolStartTaskResourceFileArgs) ToPoolStartTaskResourceFileOutputWithContext(ctx context.Context) PoolStartTaskResourceFileOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolStartTaskResourceFileOutput)
}

// PoolStartTaskResourceFileArrayInput is an input type that accepts PoolStartTaskResourceFileArray and PoolStartTaskResourceFileArrayOutput values.
// You can construct a concrete instance of `PoolStartTaskResourceFileArrayInput` via:
//
//          PoolStartTaskResourceFileArray{ PoolStartTaskResourceFileArgs{...} }
type PoolStartTaskResourceFileArrayInput interface {
	pulumi.Input

	ToPoolStartTaskResourceFileArrayOutput() PoolStartTaskResourceFileArrayOutput
	ToPoolStartTaskResourceFileArrayOutputWithContext(context.Context) PoolStartTaskResourceFileArrayOutput
}

type PoolStartTaskResourceFileArray []PoolStartTaskResourceFileInput

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

func (i PoolStartTaskResourceFileArray) ToPoolStartTaskResourceFileArrayOutput() PoolStartTaskResourceFileArrayOutput {
	return i.ToPoolStartTaskResourceFileArrayOutputWithContext(context.Background())
}

func (i PoolStartTaskResourceFileArray) ToPoolStartTaskResourceFileArrayOutputWithContext(ctx context.Context) PoolStartTaskResourceFileArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolStartTaskResourceFileArrayOutput)
}

type PoolStartTaskResourceFileOutput struct{ *pulumi.OutputState }

func (PoolStartTaskResourceFileOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolStartTaskResourceFile)(nil)).Elem()
}

func (o PoolStartTaskResourceFileOutput) ToPoolStartTaskResourceFileOutput() PoolStartTaskResourceFileOutput {
	return o
}

func (o PoolStartTaskResourceFileOutput) ToPoolStartTaskResourceFileOutputWithContext(ctx context.Context) PoolStartTaskResourceFileOutput {
	return o
}

// The storage container name in the auto storage account.
func (o PoolStartTaskResourceFileOutput) AutoStorageContainerName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PoolStartTaskResourceFile) *string { return v.AutoStorageContainerName }).(pulumi.StringPtrOutput)
}

// The blob prefix to use when downloading blobs from an Azure Storage container. Only the blobs whose names begin with the specified prefix will be downloaded. The property is valid only when `autoStorageContainerName` or `storageContainerUrl` is used. This prefix can be a partial filename or a subdirectory. If a prefix is not specified, all the files in the container will be downloaded.
func (o PoolStartTaskResourceFileOutput) BlobPrefix() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PoolStartTaskResourceFile) *string { return v.BlobPrefix }).(pulumi.StringPtrOutput)
}

// The file permission mode represented as a string in octal format (e.g. `"0644"`). This property applies only to files being downloaded to Linux compute nodes. It will be ignored if it is specified for a `resourceFile` which will be downloaded to a Windows node. If this property is not specified for a Linux node, then a default value of 0770 is applied to the file.
func (o PoolStartTaskResourceFileOutput) FileMode() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PoolStartTaskResourceFile) *string { return v.FileMode }).(pulumi.StringPtrOutput)
}

// The location on the compute node to which to download the file, relative to the task's working directory. If the `httpUrl` property is specified, the `filePath` is required and describes the path which the file will be downloaded to, including the filename. Otherwise, if the `autoStorageContainerName` or `storageContainerUrl` property is specified, `filePath` is optional and is the directory to download the files to. In the case where `filePath` is used as a directory, any directory structure already associated with the input data will be retained in full and appended to the specified filePath directory. The specified relative path cannot break out of the task's working directory (for example by using '..').
func (o PoolStartTaskResourceFileOutput) FilePath() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PoolStartTaskResourceFile) *string { return v.FilePath }).(pulumi.StringPtrOutput)
}

// The URL of the file to download. If the URL is Azure Blob Storage, it must be readable using anonymous access; that is, the Batch service does not present any credentials when downloading the blob. There are two ways to get such a URL for a blob in Azure storage: include a Shared Access Signature (SAS) granting read permissions on the blob, or set the ACL for the blob or its container to allow public access.
func (o PoolStartTaskResourceFileOutput) HttpUrl() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PoolStartTaskResourceFile) *string { return v.HttpUrl }).(pulumi.StringPtrOutput)
}

// The URL of the blob container within Azure Blob Storage. This URL must be readable and listable using anonymous access; that is, the Batch service does not present any credentials when downloading the blob. There are two ways to get such a URL for a blob in Azure storage: include a Shared Access Signature (SAS) granting read and list permissions on the blob, or set the ACL for the blob or its container to allow public access.
func (o PoolStartTaskResourceFileOutput) StorageContainerUrl() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PoolStartTaskResourceFile) *string { return v.StorageContainerUrl }).(pulumi.StringPtrOutput)
}

type PoolStartTaskResourceFileArrayOutput struct{ *pulumi.OutputState }

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

func (o PoolStartTaskResourceFileArrayOutput) ToPoolStartTaskResourceFileArrayOutput() PoolStartTaskResourceFileArrayOutput {
	return o
}

func (o PoolStartTaskResourceFileArrayOutput) ToPoolStartTaskResourceFileArrayOutputWithContext(ctx context.Context) PoolStartTaskResourceFileArrayOutput {
	return o
}

func (o PoolStartTaskResourceFileArrayOutput) Index(i pulumi.IntInput) PoolStartTaskResourceFileOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) PoolStartTaskResourceFile {
		return vs[0].([]PoolStartTaskResourceFile)[vs[1].(int)]
	}).(PoolStartTaskResourceFileOutput)
}

type PoolStartTaskUserIdentity struct {
	// A `autoUser` block that describes the user identity under which the start task runs.
	AutoUser *PoolStartTaskUserIdentityAutoUser `pulumi:"autoUser"`
	// The username to be used by the Batch pool start task.
	UserName *string `pulumi:"userName"`
}

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

	ToPoolStartTaskUserIdentityOutput() PoolStartTaskUserIdentityOutput
	ToPoolStartTaskUserIdentityOutputWithContext(context.Context) PoolStartTaskUserIdentityOutput
}

type PoolStartTaskUserIdentityArgs struct {
	// A `autoUser` block that describes the user identity under which the start task runs.
	AutoUser PoolStartTaskUserIdentityAutoUserPtrInput `pulumi:"autoUser"`
	// The username to be used by the Batch pool start task.
	UserName pulumi.StringPtrInput `pulumi:"userName"`
}

func (PoolStartTaskUserIdentityArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolStartTaskUserIdentity)(nil)).Elem()
}

func (i PoolStartTaskUserIdentityArgs) ToPoolStartTaskUserIdentityOutput() PoolStartTaskUserIdentityOutput {
	return i.ToPoolStartTaskUserIdentityOutputWithContext(context.Background())
}

func (i PoolStartTaskUserIdentityArgs) ToPoolStartTaskUserIdentityOutputWithContext(ctx context.Context) PoolStartTaskUserIdentityOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolStartTaskUserIdentityOutput)
}

func (i PoolStartTaskUserIdentityArgs) ToPoolStartTaskUserIdentityPtrOutput() PoolStartTaskUserIdentityPtrOutput {
	return i.ToPoolStartTaskUserIdentityPtrOutputWithContext(context.Background())
}

func (i PoolStartTaskUserIdentityArgs) ToPoolStartTaskUserIdentityPtrOutputWithContext(ctx context.Context) PoolStartTaskUserIdentityPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolStartTaskUserIdentityOutput).ToPoolStartTaskUserIdentityPtrOutputWithContext(ctx)
}

// PoolStartTaskUserIdentityPtrInput is an input type that accepts PoolStartTaskUserIdentityArgs, PoolStartTaskUserIdentityPtr and PoolStartTaskUserIdentityPtrOutput values.
// You can construct a concrete instance of `PoolStartTaskUserIdentityPtrInput` via:
//
//          PoolStartTaskUserIdentityArgs{...}
//
//  or:
//
//          nil
type PoolStartTaskUserIdentityPtrInput interface {
	pulumi.Input

	ToPoolStartTaskUserIdentityPtrOutput() PoolStartTaskUserIdentityPtrOutput
	ToPoolStartTaskUserIdentityPtrOutputWithContext(context.Context) PoolStartTaskUserIdentityPtrOutput
}

type poolStartTaskUserIdentityPtrType PoolStartTaskUserIdentityArgs

func PoolStartTaskUserIdentityPtr(v *PoolStartTaskUserIdentityArgs) PoolStartTaskUserIdentityPtrInput {
	return (*poolStartTaskUserIdentityPtrType)(v)
}

func (*poolStartTaskUserIdentityPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**PoolStartTaskUserIdentity)(nil)).Elem()
}

func (i *poolStartTaskUserIdentityPtrType) ToPoolStartTaskUserIdentityPtrOutput() PoolStartTaskUserIdentityPtrOutput {
	return i.ToPoolStartTaskUserIdentityPtrOutputWithContext(context.Background())
}

func (i *poolStartTaskUserIdentityPtrType) ToPoolStartTaskUserIdentityPtrOutputWithContext(ctx context.Context) PoolStartTaskUserIdentityPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolStartTaskUserIdentityPtrOutput)
}

type PoolStartTaskUserIdentityOutput struct{ *pulumi.OutputState }

func (PoolStartTaskUserIdentityOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolStartTaskUserIdentity)(nil)).Elem()
}

func (o PoolStartTaskUserIdentityOutput) ToPoolStartTaskUserIdentityOutput() PoolStartTaskUserIdentityOutput {
	return o
}

func (o PoolStartTaskUserIdentityOutput) ToPoolStartTaskUserIdentityOutputWithContext(ctx context.Context) PoolStartTaskUserIdentityOutput {
	return o
}

func (o PoolStartTaskUserIdentityOutput) ToPoolStartTaskUserIdentityPtrOutput() PoolStartTaskUserIdentityPtrOutput {
	return o.ToPoolStartTaskUserIdentityPtrOutputWithContext(context.Background())
}

func (o PoolStartTaskUserIdentityOutput) ToPoolStartTaskUserIdentityPtrOutputWithContext(ctx context.Context) PoolStartTaskUserIdentityPtrOutput {
	return o.ApplyT(func(v PoolStartTaskUserIdentity) *PoolStartTaskUserIdentity {
		return &v
	}).(PoolStartTaskUserIdentityPtrOutput)
}

// A `autoUser` block that describes the user identity under which the start task runs.
func (o PoolStartTaskUserIdentityOutput) AutoUser() PoolStartTaskUserIdentityAutoUserPtrOutput {
	return o.ApplyT(func(v PoolStartTaskUserIdentity) *PoolStartTaskUserIdentityAutoUser { return v.AutoUser }).(PoolStartTaskUserIdentityAutoUserPtrOutput)
}

// The username to be used by the Batch pool start task.
func (o PoolStartTaskUserIdentityOutput) UserName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PoolStartTaskUserIdentity) *string { return v.UserName }).(pulumi.StringPtrOutput)
}

type PoolStartTaskUserIdentityPtrOutput struct{ *pulumi.OutputState }

func (PoolStartTaskUserIdentityPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**PoolStartTaskUserIdentity)(nil)).Elem()
}

func (o PoolStartTaskUserIdentityPtrOutput) ToPoolStartTaskUserIdentityPtrOutput() PoolStartTaskUserIdentityPtrOutput {
	return o
}

func (o PoolStartTaskUserIdentityPtrOutput) ToPoolStartTaskUserIdentityPtrOutputWithContext(ctx context.Context) PoolStartTaskUserIdentityPtrOutput {
	return o
}

func (o PoolStartTaskUserIdentityPtrOutput) Elem() PoolStartTaskUserIdentityOutput {
	return o.ApplyT(func(v *PoolStartTaskUserIdentity) PoolStartTaskUserIdentity { return *v }).(PoolStartTaskUserIdentityOutput)
}

// A `autoUser` block that describes the user identity under which the start task runs.
func (o PoolStartTaskUserIdentityPtrOutput) AutoUser() PoolStartTaskUserIdentityAutoUserPtrOutput {
	return o.ApplyT(func(v *PoolStartTaskUserIdentity) *PoolStartTaskUserIdentityAutoUser {
		if v == nil {
			return nil
		}
		return v.AutoUser
	}).(PoolStartTaskUserIdentityAutoUserPtrOutput)
}

// The username to be used by the Batch pool start task.
func (o PoolStartTaskUserIdentityPtrOutput) UserName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PoolStartTaskUserIdentity) *string {
		if v == nil {
			return nil
		}
		return v.UserName
	}).(pulumi.StringPtrOutput)
}

type PoolStartTaskUserIdentityAutoUser struct {
	// The elevation level of the user identity under which the start task runs. Possible values are `Admin` or `NonAdmin`. Defaults to `NonAdmin`.
	ElevationLevel *string `pulumi:"elevationLevel"`
	// The scope of the user identity under which the start task runs. Possible values are `Task` or `Pool`. Defaults to `Task`.
	Scope *string `pulumi:"scope"`
}

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

	ToPoolStartTaskUserIdentityAutoUserOutput() PoolStartTaskUserIdentityAutoUserOutput
	ToPoolStartTaskUserIdentityAutoUserOutputWithContext(context.Context) PoolStartTaskUserIdentityAutoUserOutput
}

type PoolStartTaskUserIdentityAutoUserArgs struct {
	// The elevation level of the user identity under which the start task runs. Possible values are `Admin` or `NonAdmin`. Defaults to `NonAdmin`.
	ElevationLevel pulumi.StringPtrInput `pulumi:"elevationLevel"`
	// The scope of the user identity under which the start task runs. Possible values are `Task` or `Pool`. Defaults to `Task`.
	Scope pulumi.StringPtrInput `pulumi:"scope"`
}

func (PoolStartTaskUserIdentityAutoUserArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolStartTaskUserIdentityAutoUser)(nil)).Elem()
}

func (i PoolStartTaskUserIdentityAutoUserArgs) ToPoolStartTaskUserIdentityAutoUserOutput() PoolStartTaskUserIdentityAutoUserOutput {
	return i.ToPoolStartTaskUserIdentityAutoUserOutputWithContext(context.Background())
}

func (i PoolStartTaskUserIdentityAutoUserArgs) ToPoolStartTaskUserIdentityAutoUserOutputWithContext(ctx context.Context) PoolStartTaskUserIdentityAutoUserOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolStartTaskUserIdentityAutoUserOutput)
}

func (i PoolStartTaskUserIdentityAutoUserArgs) ToPoolStartTaskUserIdentityAutoUserPtrOutput() PoolStartTaskUserIdentityAutoUserPtrOutput {
	return i.ToPoolStartTaskUserIdentityAutoUserPtrOutputWithContext(context.Background())
}

func (i PoolStartTaskUserIdentityAutoUserArgs) ToPoolStartTaskUserIdentityAutoUserPtrOutputWithContext(ctx context.Context) PoolStartTaskUserIdentityAutoUserPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolStartTaskUserIdentityAutoUserOutput).ToPoolStartTaskUserIdentityAutoUserPtrOutputWithContext(ctx)
}

// PoolStartTaskUserIdentityAutoUserPtrInput is an input type that accepts PoolStartTaskUserIdentityAutoUserArgs, PoolStartTaskUserIdentityAutoUserPtr and PoolStartTaskUserIdentityAutoUserPtrOutput values.
// You can construct a concrete instance of `PoolStartTaskUserIdentityAutoUserPtrInput` via:
//
//          PoolStartTaskUserIdentityAutoUserArgs{...}
//
//  or:
//
//          nil
type PoolStartTaskUserIdentityAutoUserPtrInput interface {
	pulumi.Input

	ToPoolStartTaskUserIdentityAutoUserPtrOutput() PoolStartTaskUserIdentityAutoUserPtrOutput
	ToPoolStartTaskUserIdentityAutoUserPtrOutputWithContext(context.Context) PoolStartTaskUserIdentityAutoUserPtrOutput
}

type poolStartTaskUserIdentityAutoUserPtrType PoolStartTaskUserIdentityAutoUserArgs

func PoolStartTaskUserIdentityAutoUserPtr(v *PoolStartTaskUserIdentityAutoUserArgs) PoolStartTaskUserIdentityAutoUserPtrInput {
	return (*poolStartTaskUserIdentityAutoUserPtrType)(v)
}

func (*poolStartTaskUserIdentityAutoUserPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**PoolStartTaskUserIdentityAutoUser)(nil)).Elem()
}

func (i *poolStartTaskUserIdentityAutoUserPtrType) ToPoolStartTaskUserIdentityAutoUserPtrOutput() PoolStartTaskUserIdentityAutoUserPtrOutput {
	return i.ToPoolStartTaskUserIdentityAutoUserPtrOutputWithContext(context.Background())
}

func (i *poolStartTaskUserIdentityAutoUserPtrType) ToPoolStartTaskUserIdentityAutoUserPtrOutputWithContext(ctx context.Context) PoolStartTaskUserIdentityAutoUserPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolStartTaskUserIdentityAutoUserPtrOutput)
}

type PoolStartTaskUserIdentityAutoUserOutput struct{ *pulumi.OutputState }

func (PoolStartTaskUserIdentityAutoUserOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolStartTaskUserIdentityAutoUser)(nil)).Elem()
}

func (o PoolStartTaskUserIdentityAutoUserOutput) ToPoolStartTaskUserIdentityAutoUserOutput() PoolStartTaskUserIdentityAutoUserOutput {
	return o
}

func (o PoolStartTaskUserIdentityAutoUserOutput) ToPoolStartTaskUserIdentityAutoUserOutputWithContext(ctx context.Context) PoolStartTaskUserIdentityAutoUserOutput {
	return o
}

func (o PoolStartTaskUserIdentityAutoUserOutput) ToPoolStartTaskUserIdentityAutoUserPtrOutput() PoolStartTaskUserIdentityAutoUserPtrOutput {
	return o.ToPoolStartTaskUserIdentityAutoUserPtrOutputWithContext(context.Background())
}

func (o PoolStartTaskUserIdentityAutoUserOutput) ToPoolStartTaskUserIdentityAutoUserPtrOutputWithContext(ctx context.Context) PoolStartTaskUserIdentityAutoUserPtrOutput {
	return o.ApplyT(func(v PoolStartTaskUserIdentityAutoUser) *PoolStartTaskUserIdentityAutoUser {
		return &v
	}).(PoolStartTaskUserIdentityAutoUserPtrOutput)
}

// The elevation level of the user identity under which the start task runs. Possible values are `Admin` or `NonAdmin`. Defaults to `NonAdmin`.
func (o PoolStartTaskUserIdentityAutoUserOutput) ElevationLevel() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PoolStartTaskUserIdentityAutoUser) *string { return v.ElevationLevel }).(pulumi.StringPtrOutput)
}

// The scope of the user identity under which the start task runs. Possible values are `Task` or `Pool`. Defaults to `Task`.
func (o PoolStartTaskUserIdentityAutoUserOutput) Scope() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PoolStartTaskUserIdentityAutoUser) *string { return v.Scope }).(pulumi.StringPtrOutput)
}

type PoolStartTaskUserIdentityAutoUserPtrOutput struct{ *pulumi.OutputState }

func (PoolStartTaskUserIdentityAutoUserPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**PoolStartTaskUserIdentityAutoUser)(nil)).Elem()
}

func (o PoolStartTaskUserIdentityAutoUserPtrOutput) ToPoolStartTaskUserIdentityAutoUserPtrOutput() PoolStartTaskUserIdentityAutoUserPtrOutput {
	return o
}

func (o PoolStartTaskUserIdentityAutoUserPtrOutput) ToPoolStartTaskUserIdentityAutoUserPtrOutputWithContext(ctx context.Context) PoolStartTaskUserIdentityAutoUserPtrOutput {
	return o
}

func (o PoolStartTaskUserIdentityAutoUserPtrOutput) Elem() PoolStartTaskUserIdentityAutoUserOutput {
	return o.ApplyT(func(v *PoolStartTaskUserIdentityAutoUser) PoolStartTaskUserIdentityAutoUser { return *v }).(PoolStartTaskUserIdentityAutoUserOutput)
}

// The elevation level of the user identity under which the start task runs. Possible values are `Admin` or `NonAdmin`. Defaults to `NonAdmin`.
func (o PoolStartTaskUserIdentityAutoUserPtrOutput) ElevationLevel() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PoolStartTaskUserIdentityAutoUser) *string {
		if v == nil {
			return nil
		}
		return v.ElevationLevel
	}).(pulumi.StringPtrOutput)
}

// The scope of the user identity under which the start task runs. Possible values are `Task` or `Pool`. Defaults to `Task`.
func (o PoolStartTaskUserIdentityAutoUserPtrOutput) Scope() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PoolStartTaskUserIdentityAutoUser) *string {
		if v == nil {
			return nil
		}
		return v.Scope
	}).(pulumi.StringPtrOutput)
}

type PoolStorageImageReference struct {
	// Specifies the ID of the Custom Image which the virtual machines should be created from. Changing this forces a new resource to be created. See [official documentation](https://docs.microsoft.com/en-us/azure/batch/batch-custom-images) for more details.
	// ---
	Id *string `pulumi:"id"`
	// Specifies the offer of the image used to create the virtual machines. Changing this forces a new resource to be created.
	Offer *string `pulumi:"offer"`
	// Specifies the publisher of the image used to create the virtual machines. Changing this forces a new resource to be created.
	Publisher *string `pulumi:"publisher"`
	// Specifies the SKU of the image used to create the virtual machines. Changing this forces a new resource to be created.
	Sku *string `pulumi:"sku"`
	// Specifies the version of the image used to create the virtual machines. Changing this forces a new resource to be created.
	Version *string `pulumi:"version"`
}

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

	ToPoolStorageImageReferenceOutput() PoolStorageImageReferenceOutput
	ToPoolStorageImageReferenceOutputWithContext(context.Context) PoolStorageImageReferenceOutput
}

type PoolStorageImageReferenceArgs struct {
	// Specifies the ID of the Custom Image which the virtual machines should be created from. Changing this forces a new resource to be created. See [official documentation](https://docs.microsoft.com/en-us/azure/batch/batch-custom-images) for more details.
	// ---
	Id pulumi.StringPtrInput `pulumi:"id"`
	// Specifies the offer of the image used to create the virtual machines. Changing this forces a new resource to be created.
	Offer pulumi.StringPtrInput `pulumi:"offer"`
	// Specifies the publisher of the image used to create the virtual machines. Changing this forces a new resource to be created.
	Publisher pulumi.StringPtrInput `pulumi:"publisher"`
	// Specifies the SKU of the image used to create the virtual machines. Changing this forces a new resource to be created.
	Sku pulumi.StringPtrInput `pulumi:"sku"`
	// Specifies the version of the image used to create the virtual machines. Changing this forces a new resource to be created.
	Version pulumi.StringPtrInput `pulumi:"version"`
}

func (PoolStorageImageReferenceArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolStorageImageReference)(nil)).Elem()
}

func (i PoolStorageImageReferenceArgs) ToPoolStorageImageReferenceOutput() PoolStorageImageReferenceOutput {
	return i.ToPoolStorageImageReferenceOutputWithContext(context.Background())
}

func (i PoolStorageImageReferenceArgs) ToPoolStorageImageReferenceOutputWithContext(ctx context.Context) PoolStorageImageReferenceOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolStorageImageReferenceOutput)
}

func (i PoolStorageImageReferenceArgs) ToPoolStorageImageReferencePtrOutput() PoolStorageImageReferencePtrOutput {
	return i.ToPoolStorageImageReferencePtrOutputWithContext(context.Background())
}

func (i PoolStorageImageReferenceArgs) ToPoolStorageImageReferencePtrOutputWithContext(ctx context.Context) PoolStorageImageReferencePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolStorageImageReferenceOutput).ToPoolStorageImageReferencePtrOutputWithContext(ctx)
}

// PoolStorageImageReferencePtrInput is an input type that accepts PoolStorageImageReferenceArgs, PoolStorageImageReferencePtr and PoolStorageImageReferencePtrOutput values.
// You can construct a concrete instance of `PoolStorageImageReferencePtrInput` via:
//
//          PoolStorageImageReferenceArgs{...}
//
//  or:
//
//          nil
type PoolStorageImageReferencePtrInput interface {
	pulumi.Input

	ToPoolStorageImageReferencePtrOutput() PoolStorageImageReferencePtrOutput
	ToPoolStorageImageReferencePtrOutputWithContext(context.Context) PoolStorageImageReferencePtrOutput
}

type poolStorageImageReferencePtrType PoolStorageImageReferenceArgs

func PoolStorageImageReferencePtr(v *PoolStorageImageReferenceArgs) PoolStorageImageReferencePtrInput {
	return (*poolStorageImageReferencePtrType)(v)
}

func (*poolStorageImageReferencePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**PoolStorageImageReference)(nil)).Elem()
}

func (i *poolStorageImageReferencePtrType) ToPoolStorageImageReferencePtrOutput() PoolStorageImageReferencePtrOutput {
	return i.ToPoolStorageImageReferencePtrOutputWithContext(context.Background())
}

func (i *poolStorageImageReferencePtrType) ToPoolStorageImageReferencePtrOutputWithContext(ctx context.Context) PoolStorageImageReferencePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PoolStorageImageReferencePtrOutput)
}

type PoolStorageImageReferenceOutput struct{ *pulumi.OutputState }

func (PoolStorageImageReferenceOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PoolStorageImageReference)(nil)).Elem()
}

func (o PoolStorageImageReferenceOutput) ToPoolStorageImageReferenceOutput() PoolStorageImageReferenceOutput {
	return o
}

func (o PoolStorageImageReferenceOutput) ToPoolStorageImageReferenceOutputWithContext(ctx context.Context) PoolStorageImageReferenceOutput {
	return o
}

func (o PoolStorageImageReferenceOutput) ToPoolStorageImageReferencePtrOutput() PoolStorageImageReferencePtrOutput {
	return o.ToPoolStorageImageReferencePtrOutputWithContext(context.Background())
}

func (o PoolStorageImageReferenceOutput) ToPoolStorageImageReferencePtrOutputWithContext(ctx context.Context) PoolStorageImageReferencePtrOutput {
	return o.ApplyT(func(v PoolStorageImageReference) *PoolStorageImageReference {
		return &v
	}).(PoolStorageImageReferencePtrOutput)
}

// Specifies the ID of the Custom Image which the virtual machines should be created from. Changing this forces a new resource to be created. See [official documentation](https://docs.microsoft.com/en-us/azure/batch/batch-custom-images) for more details.
// ---
func (o PoolStorageImageReferenceOutput) Id() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PoolStorageImageReference) *string { return v.Id }).(pulumi.StringPtrOutput)
}

// Specifies the offer of the image used to create the virtual machines. Changing this forces a new resource to be created.
func (o PoolStorageImageReferenceOutput) Offer() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PoolStorageImageReference) *string { return v.Offer }).(pulumi.StringPtrOutput)
}

// Specifies the publisher of the image used to create the virtual machines. Changing this forces a new resource to be created.
func (o PoolStorageImageReferenceOutput) Publisher() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PoolStorageImageReference) *string { return v.Publisher }).(pulumi.StringPtrOutput)
}

// Specifies the SKU of the image used to create the virtual machines. Changing this forces a new resource to be created.
func (o PoolStorageImageReferenceOutput) Sku() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PoolStorageImageReference) *string { return v.Sku }).(pulumi.StringPtrOutput)
}

// Specifies the version of the image used to create the virtual machines. Changing this forces a new resource to be created.
func (o PoolStorageImageReferenceOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PoolStorageImageReference) *string { return v.Version }).(pulumi.StringPtrOutput)
}

type PoolStorageImageReferencePtrOutput struct{ *pulumi.OutputState }

func (PoolStorageImageReferencePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**PoolStorageImageReference)(nil)).Elem()
}

func (o PoolStorageImageReferencePtrOutput) ToPoolStorageImageReferencePtrOutput() PoolStorageImageReferencePtrOutput {
	return o
}

func (o PoolStorageImageReferencePtrOutput) ToPoolStorageImageReferencePtrOutputWithContext(ctx context.Context) PoolStorageImageReferencePtrOutput {
	return o
}

func (o PoolStorageImageReferencePtrOutput) Elem() PoolStorageImageReferenceOutput {
	return o.ApplyT(func(v *PoolStorageImageReference) PoolStorageImageReference { return *v }).(PoolStorageImageReferenceOutput)
}

// Specifies the ID of the Custom Image which the virtual machines should be created from. Changing this forces a new resource to be created. See [official documentation](https://docs.microsoft.com/en-us/azure/batch/batch-custom-images) for more details.
// ---
func (o PoolStorageImageReferencePtrOutput) Id() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PoolStorageImageReference) *string {
		if v == nil {
			return nil
		}
		return v.Id
	}).(pulumi.StringPtrOutput)
}

// Specifies the offer of the image used to create the virtual machines. Changing this forces a new resource to be created.
func (o PoolStorageImageReferencePtrOutput) Offer() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PoolStorageImageReference) *string {
		if v == nil {
			return nil
		}
		return v.Offer
	}).(pulumi.StringPtrOutput)
}

// Specifies the publisher of the image used to create the virtual machines. Changing this forces a new resource to be created.
func (o PoolStorageImageReferencePtrOutput) Publisher() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PoolStorageImageReference) *string {
		if v == nil {
			return nil
		}
		return v.Publisher
	}).(pulumi.StringPtrOutput)
}

// Specifies the SKU of the image used to create the virtual machines. Changing this forces a new resource to be created.
func (o PoolStorageImageReferencePtrOutput) Sku() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PoolStorageImageReference) *string {
		if v == nil {
			return nil
		}
		return v.Sku
	}).(pulumi.StringPtrOutput)
}

// Specifies the version of the image used to create the virtual machines. Changing this forces a new resource to be created.
func (o PoolStorageImageReferencePtrOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PoolStorageImageReference) *string {
		if v == nil {
			return nil
		}
		return v.Version
	}).(pulumi.StringPtrOutput)
}

type GetAccountKeyVaultReference struct {
	// The Azure identifier of the Azure KeyVault reference.
	Id string `pulumi:"id"`
	// The HTTPS URL of the Azure KeyVault reference.
	Url string `pulumi:"url"`
}

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

	ToGetAccountKeyVaultReferenceOutput() GetAccountKeyVaultReferenceOutput
	ToGetAccountKeyVaultReferenceOutputWithContext(context.Context) GetAccountKeyVaultReferenceOutput
}

type GetAccountKeyVaultReferenceArgs struct {
	// The Azure identifier of the Azure KeyVault reference.
	Id pulumi.StringInput `pulumi:"id"`
	// The HTTPS URL of the Azure KeyVault reference.
	Url pulumi.StringInput `pulumi:"url"`
}

func (GetAccountKeyVaultReferenceArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetAccountKeyVaultReference)(nil)).Elem()
}

func (i GetAccountKeyVaultReferenceArgs) ToGetAccountKeyVaultReferenceOutput() GetAccountKeyVaultReferenceOutput {
	return i.ToGetAccountKeyVaultReferenceOutputWithContext(context.Background())
}

func (i GetAccountKeyVaultReferenceArgs) ToGetAccountKeyVaultReferenceOutputWithContext(ctx context.Context) GetAccountKeyVaultReferenceOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetAccountKeyVaultReferenceOutput)
}

// GetAccountKeyVaultReferenceArrayInput is an input type that accepts GetAccountKeyVaultReferenceArray and GetAccountKeyVaultReferenceArrayOutput values.
// You can construct a concrete instance of `GetAccountKeyVaultReferenceArrayInput` via:
//
//          GetAccountKeyVaultReferenceArray{ GetAccountKeyVaultReferenceArgs{...} }
type GetAccountKeyVaultReferenceArrayInput interface {
	pulumi.Input

	ToGetAccountKeyVaultReferenceArrayOutput() GetAccountKeyVaultReferenceArrayOutput
	ToGetAccountKeyVaultReferenceArrayOutputWithContext(context.Context) GetAccountKeyVaultReferenceArrayOutput
}

type GetAccountKeyVaultReferenceArray []GetAccountKeyVaultReferenceInput

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

func (i GetAccountKeyVaultReferenceArray) ToGetAccountKeyVaultReferenceArrayOutput() GetAccountKeyVaultReferenceArrayOutput {
	return i.ToGetAccountKeyVaultReferenceArrayOutputWithContext(context.Background())
}

func (i GetAccountKeyVaultReferenceArray) ToGetAccountKeyVaultReferenceArrayOutputWithContext(ctx context.Context) GetAccountKeyVaultReferenceArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetAccountKeyVaultReferenceArrayOutput)
}

type GetAccountKeyVaultReferenceOutput struct{ *pulumi.OutputState }

func (GetAccountKeyVaultReferenceOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetAccountKeyVaultReference)(nil)).Elem()
}

func (o GetAccountKeyVaultReferenceOutput) ToGetAccountKeyVaultReferenceOutput() GetAccountKeyVaultReferenceOutput {
	return o
}

func (o GetAccountKeyVaultReferenceOutput) ToGetAccountKeyVaultReferenceOutputWithContext(ctx context.Context) GetAccountKeyVaultReferenceOutput {
	return o
}

// The Azure identifier of the Azure KeyVault reference.
func (o GetAccountKeyVaultReferenceOutput) Id() pulumi.StringOutput {
	return o.ApplyT(func(v GetAccountKeyVaultReference) string { return v.Id }).(pulumi.StringOutput)
}

// The HTTPS URL of the Azure KeyVault reference.
func (o GetAccountKeyVaultReferenceOutput) Url() pulumi.StringOutput {
	return o.ApplyT(func(v GetAccountKeyVaultReference) string { return v.Url }).(pulumi.StringOutput)
}

type GetAccountKeyVaultReferenceArrayOutput struct{ *pulumi.OutputState }

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

func (o GetAccountKeyVaultReferenceArrayOutput) ToGetAccountKeyVaultReferenceArrayOutput() GetAccountKeyVaultReferenceArrayOutput {
	return o
}

func (o GetAccountKeyVaultReferenceArrayOutput) ToGetAccountKeyVaultReferenceArrayOutputWithContext(ctx context.Context) GetAccountKeyVaultReferenceArrayOutput {
	return o
}

func (o GetAccountKeyVaultReferenceArrayOutput) Index(i pulumi.IntInput) GetAccountKeyVaultReferenceOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetAccountKeyVaultReference {
		return vs[0].([]GetAccountKeyVaultReference)[vs[1].(int)]
	}).(GetAccountKeyVaultReferenceOutput)
}

type GetPoolAutoScale struct {
	// The interval to wait before evaluating if the pool needs to be scaled.
	EvaluationInterval string `pulumi:"evaluationInterval"`
	// The autoscale formula that needs to be used for scaling the Batch pool.
	Formula string `pulumi:"formula"`
}

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

	ToGetPoolAutoScaleOutput() GetPoolAutoScaleOutput
	ToGetPoolAutoScaleOutputWithContext(context.Context) GetPoolAutoScaleOutput
}

type GetPoolAutoScaleArgs struct {
	// The interval to wait before evaluating if the pool needs to be scaled.
	EvaluationInterval pulumi.StringInput `pulumi:"evaluationInterval"`
	// The autoscale formula that needs to be used for scaling the Batch pool.
	Formula pulumi.StringInput `pulumi:"formula"`
}

func (GetPoolAutoScaleArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolAutoScale)(nil)).Elem()
}

func (i GetPoolAutoScaleArgs) ToGetPoolAutoScaleOutput() GetPoolAutoScaleOutput {
	return i.ToGetPoolAutoScaleOutputWithContext(context.Background())
}

func (i GetPoolAutoScaleArgs) ToGetPoolAutoScaleOutputWithContext(ctx context.Context) GetPoolAutoScaleOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolAutoScaleOutput)
}

// GetPoolAutoScaleArrayInput is an input type that accepts GetPoolAutoScaleArray and GetPoolAutoScaleArrayOutput values.
// You can construct a concrete instance of `GetPoolAutoScaleArrayInput` via:
//
//          GetPoolAutoScaleArray{ GetPoolAutoScaleArgs{...} }
type GetPoolAutoScaleArrayInput interface {
	pulumi.Input

	ToGetPoolAutoScaleArrayOutput() GetPoolAutoScaleArrayOutput
	ToGetPoolAutoScaleArrayOutputWithContext(context.Context) GetPoolAutoScaleArrayOutput
}

type GetPoolAutoScaleArray []GetPoolAutoScaleInput

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

func (i GetPoolAutoScaleArray) ToGetPoolAutoScaleArrayOutput() GetPoolAutoScaleArrayOutput {
	return i.ToGetPoolAutoScaleArrayOutputWithContext(context.Background())
}

func (i GetPoolAutoScaleArray) ToGetPoolAutoScaleArrayOutputWithContext(ctx context.Context) GetPoolAutoScaleArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolAutoScaleArrayOutput)
}

type GetPoolAutoScaleOutput struct{ *pulumi.OutputState }

func (GetPoolAutoScaleOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolAutoScale)(nil)).Elem()
}

func (o GetPoolAutoScaleOutput) ToGetPoolAutoScaleOutput() GetPoolAutoScaleOutput {
	return o
}

func (o GetPoolAutoScaleOutput) ToGetPoolAutoScaleOutputWithContext(ctx context.Context) GetPoolAutoScaleOutput {
	return o
}

// The interval to wait before evaluating if the pool needs to be scaled.
func (o GetPoolAutoScaleOutput) EvaluationInterval() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolAutoScale) string { return v.EvaluationInterval }).(pulumi.StringOutput)
}

// The autoscale formula that needs to be used for scaling the Batch pool.
func (o GetPoolAutoScaleOutput) Formula() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolAutoScale) string { return v.Formula }).(pulumi.StringOutput)
}

type GetPoolAutoScaleArrayOutput struct{ *pulumi.OutputState }

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

func (o GetPoolAutoScaleArrayOutput) ToGetPoolAutoScaleArrayOutput() GetPoolAutoScaleArrayOutput {
	return o
}

func (o GetPoolAutoScaleArrayOutput) ToGetPoolAutoScaleArrayOutputWithContext(ctx context.Context) GetPoolAutoScaleArrayOutput {
	return o
}

func (o GetPoolAutoScaleArrayOutput) Index(i pulumi.IntInput) GetPoolAutoScaleOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetPoolAutoScale {
		return vs[0].([]GetPoolAutoScale)[vs[1].(int)]
	}).(GetPoolAutoScaleOutput)
}

type GetPoolCertificate struct {
	// The fully qualified ID of the certificate installed on the pool.
	Id string `pulumi:"id"`
	// The location of the certificate store on the compute node into which the certificate is installed, either `CurrentUser` or `LocalMachine`.
	StoreLocation string `pulumi:"storeLocation"`
	// The name of the certificate store on the compute node into which the certificate is installed.
	StoreName *string `pulumi:"storeName"`
	// Which user accounts on the compute node have access to the private data of the certificate.
	Visibilities []string `pulumi:"visibilities"`
}

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

	ToGetPoolCertificateOutput() GetPoolCertificateOutput
	ToGetPoolCertificateOutputWithContext(context.Context) GetPoolCertificateOutput
}

type GetPoolCertificateArgs struct {
	// The fully qualified ID of the certificate installed on the pool.
	Id pulumi.StringInput `pulumi:"id"`
	// The location of the certificate store on the compute node into which the certificate is installed, either `CurrentUser` or `LocalMachine`.
	StoreLocation pulumi.StringInput `pulumi:"storeLocation"`
	// The name of the certificate store on the compute node into which the certificate is installed.
	StoreName pulumi.StringPtrInput `pulumi:"storeName"`
	// Which user accounts on the compute node have access to the private data of the certificate.
	Visibilities pulumi.StringArrayInput `pulumi:"visibilities"`
}

func (GetPoolCertificateArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolCertificate)(nil)).Elem()
}

func (i GetPoolCertificateArgs) ToGetPoolCertificateOutput() GetPoolCertificateOutput {
	return i.ToGetPoolCertificateOutputWithContext(context.Background())
}

func (i GetPoolCertificateArgs) ToGetPoolCertificateOutputWithContext(ctx context.Context) GetPoolCertificateOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolCertificateOutput)
}

// GetPoolCertificateArrayInput is an input type that accepts GetPoolCertificateArray and GetPoolCertificateArrayOutput values.
// You can construct a concrete instance of `GetPoolCertificateArrayInput` via:
//
//          GetPoolCertificateArray{ GetPoolCertificateArgs{...} }
type GetPoolCertificateArrayInput interface {
	pulumi.Input

	ToGetPoolCertificateArrayOutput() GetPoolCertificateArrayOutput
	ToGetPoolCertificateArrayOutputWithContext(context.Context) GetPoolCertificateArrayOutput
}

type GetPoolCertificateArray []GetPoolCertificateInput

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

func (i GetPoolCertificateArray) ToGetPoolCertificateArrayOutput() GetPoolCertificateArrayOutput {
	return i.ToGetPoolCertificateArrayOutputWithContext(context.Background())
}

func (i GetPoolCertificateArray) ToGetPoolCertificateArrayOutputWithContext(ctx context.Context) GetPoolCertificateArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolCertificateArrayOutput)
}

type GetPoolCertificateOutput struct{ *pulumi.OutputState }

func (GetPoolCertificateOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolCertificate)(nil)).Elem()
}

func (o GetPoolCertificateOutput) ToGetPoolCertificateOutput() GetPoolCertificateOutput {
	return o
}

func (o GetPoolCertificateOutput) ToGetPoolCertificateOutputWithContext(ctx context.Context) GetPoolCertificateOutput {
	return o
}

// The fully qualified ID of the certificate installed on the pool.
func (o GetPoolCertificateOutput) Id() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolCertificate) string { return v.Id }).(pulumi.StringOutput)
}

// The location of the certificate store on the compute node into which the certificate is installed, either `CurrentUser` or `LocalMachine`.
func (o GetPoolCertificateOutput) StoreLocation() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolCertificate) string { return v.StoreLocation }).(pulumi.StringOutput)
}

// The name of the certificate store on the compute node into which the certificate is installed.
func (o GetPoolCertificateOutput) StoreName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v GetPoolCertificate) *string { return v.StoreName }).(pulumi.StringPtrOutput)
}

// Which user accounts on the compute node have access to the private data of the certificate.
func (o GetPoolCertificateOutput) Visibilities() pulumi.StringArrayOutput {
	return o.ApplyT(func(v GetPoolCertificate) []string { return v.Visibilities }).(pulumi.StringArrayOutput)
}

type GetPoolCertificateArrayOutput struct{ *pulumi.OutputState }

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

func (o GetPoolCertificateArrayOutput) ToGetPoolCertificateArrayOutput() GetPoolCertificateArrayOutput {
	return o
}

func (o GetPoolCertificateArrayOutput) ToGetPoolCertificateArrayOutputWithContext(ctx context.Context) GetPoolCertificateArrayOutput {
	return o
}

func (o GetPoolCertificateArrayOutput) Index(i pulumi.IntInput) GetPoolCertificateOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetPoolCertificate {
		return vs[0].([]GetPoolCertificate)[vs[1].(int)]
	}).(GetPoolCertificateOutput)
}

type GetPoolContainerConfiguration struct {
	// A list of container image names to use, as would be specified by `docker pull`.
	ContainerImageNames []string `pulumi:"containerImageNames"`
	// Additional container registries from which container images can be pulled by the pool's VMs.
	ContainerRegistries []GetPoolContainerConfigurationContainerRegistry `pulumi:"containerRegistries"`
	// The type of container configuration.
	Type string `pulumi:"type"`
}

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

	ToGetPoolContainerConfigurationOutput() GetPoolContainerConfigurationOutput
	ToGetPoolContainerConfigurationOutputWithContext(context.Context) GetPoolContainerConfigurationOutput
}

type GetPoolContainerConfigurationArgs struct {
	// A list of container image names to use, as would be specified by `docker pull`.
	ContainerImageNames pulumi.StringArrayInput `pulumi:"containerImageNames"`
	// Additional container registries from which container images can be pulled by the pool's VMs.
	ContainerRegistries GetPoolContainerConfigurationContainerRegistryArrayInput `pulumi:"containerRegistries"`
	// The type of container configuration.
	Type pulumi.StringInput `pulumi:"type"`
}

func (GetPoolContainerConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolContainerConfiguration)(nil)).Elem()
}

func (i GetPoolContainerConfigurationArgs) ToGetPoolContainerConfigurationOutput() GetPoolContainerConfigurationOutput {
	return i.ToGetPoolContainerConfigurationOutputWithContext(context.Background())
}

func (i GetPoolContainerConfigurationArgs) ToGetPoolContainerConfigurationOutputWithContext(ctx context.Context) GetPoolContainerConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolContainerConfigurationOutput)
}

// GetPoolContainerConfigurationArrayInput is an input type that accepts GetPoolContainerConfigurationArray and GetPoolContainerConfigurationArrayOutput values.
// You can construct a concrete instance of `GetPoolContainerConfigurationArrayInput` via:
//
//          GetPoolContainerConfigurationArray{ GetPoolContainerConfigurationArgs{...} }
type GetPoolContainerConfigurationArrayInput interface {
	pulumi.Input

	ToGetPoolContainerConfigurationArrayOutput() GetPoolContainerConfigurationArrayOutput
	ToGetPoolContainerConfigurationArrayOutputWithContext(context.Context) GetPoolContainerConfigurationArrayOutput
}

type GetPoolContainerConfigurationArray []GetPoolContainerConfigurationInput

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

func (i GetPoolContainerConfigurationArray) ToGetPoolContainerConfigurationArrayOutput() GetPoolContainerConfigurationArrayOutput {
	return i.ToGetPoolContainerConfigurationArrayOutputWithContext(context.Background())
}

func (i GetPoolContainerConfigurationArray) ToGetPoolContainerConfigurationArrayOutputWithContext(ctx context.Context) GetPoolContainerConfigurationArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolContainerConfigurationArrayOutput)
}

type GetPoolContainerConfigurationOutput struct{ *pulumi.OutputState }

func (GetPoolContainerConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolContainerConfiguration)(nil)).Elem()
}

func (o GetPoolContainerConfigurationOutput) ToGetPoolContainerConfigurationOutput() GetPoolContainerConfigurationOutput {
	return o
}

func (o GetPoolContainerConfigurationOutput) ToGetPoolContainerConfigurationOutputWithContext(ctx context.Context) GetPoolContainerConfigurationOutput {
	return o
}

// A list of container image names to use, as would be specified by `docker pull`.
func (o GetPoolContainerConfigurationOutput) ContainerImageNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v GetPoolContainerConfiguration) []string { return v.ContainerImageNames }).(pulumi.StringArrayOutput)
}

// Additional container registries from which container images can be pulled by the pool's VMs.
func (o GetPoolContainerConfigurationOutput) ContainerRegistries() GetPoolContainerConfigurationContainerRegistryArrayOutput {
	return o.ApplyT(func(v GetPoolContainerConfiguration) []GetPoolContainerConfigurationContainerRegistry {
		return v.ContainerRegistries
	}).(GetPoolContainerConfigurationContainerRegistryArrayOutput)
}

// The type of container configuration.
func (o GetPoolContainerConfigurationOutput) Type() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolContainerConfiguration) string { return v.Type }).(pulumi.StringOutput)
}

type GetPoolContainerConfigurationArrayOutput struct{ *pulumi.OutputState }

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

func (o GetPoolContainerConfigurationArrayOutput) ToGetPoolContainerConfigurationArrayOutput() GetPoolContainerConfigurationArrayOutput {
	return o
}

func (o GetPoolContainerConfigurationArrayOutput) ToGetPoolContainerConfigurationArrayOutputWithContext(ctx context.Context) GetPoolContainerConfigurationArrayOutput {
	return o
}

func (o GetPoolContainerConfigurationArrayOutput) Index(i pulumi.IntInput) GetPoolContainerConfigurationOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetPoolContainerConfiguration {
		return vs[0].([]GetPoolContainerConfiguration)[vs[1].(int)]
	}).(GetPoolContainerConfigurationOutput)
}

type GetPoolContainerConfigurationContainerRegistry struct {
	// The password to log into the registry server.
	Password string `pulumi:"password"`
	// The container registry URL. The default is "docker.io".
	RegistryServer string `pulumi:"registryServer"`
	// The user name to log into the registry server.
	UserName string `pulumi:"userName"`
}

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

	ToGetPoolContainerConfigurationContainerRegistryOutput() GetPoolContainerConfigurationContainerRegistryOutput
	ToGetPoolContainerConfigurationContainerRegistryOutputWithContext(context.Context) GetPoolContainerConfigurationContainerRegistryOutput
}

type GetPoolContainerConfigurationContainerRegistryArgs struct {
	// The password to log into the registry server.
	Password pulumi.StringInput `pulumi:"password"`
	// The container registry URL. The default is "docker.io".
	RegistryServer pulumi.StringInput `pulumi:"registryServer"`
	// The user name to log into the registry server.
	UserName pulumi.StringInput `pulumi:"userName"`
}

func (GetPoolContainerConfigurationContainerRegistryArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolContainerConfigurationContainerRegistry)(nil)).Elem()
}

func (i GetPoolContainerConfigurationContainerRegistryArgs) ToGetPoolContainerConfigurationContainerRegistryOutput() GetPoolContainerConfigurationContainerRegistryOutput {
	return i.ToGetPoolContainerConfigurationContainerRegistryOutputWithContext(context.Background())
}

func (i GetPoolContainerConfigurationContainerRegistryArgs) ToGetPoolContainerConfigurationContainerRegistryOutputWithContext(ctx context.Context) GetPoolContainerConfigurationContainerRegistryOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolContainerConfigurationContainerRegistryOutput)
}

// GetPoolContainerConfigurationContainerRegistryArrayInput is an input type that accepts GetPoolContainerConfigurationContainerRegistryArray and GetPoolContainerConfigurationContainerRegistryArrayOutput values.
// You can construct a concrete instance of `GetPoolContainerConfigurationContainerRegistryArrayInput` via:
//
//          GetPoolContainerConfigurationContainerRegistryArray{ GetPoolContainerConfigurationContainerRegistryArgs{...} }
type GetPoolContainerConfigurationContainerRegistryArrayInput interface {
	pulumi.Input

	ToGetPoolContainerConfigurationContainerRegistryArrayOutput() GetPoolContainerConfigurationContainerRegistryArrayOutput
	ToGetPoolContainerConfigurationContainerRegistryArrayOutputWithContext(context.Context) GetPoolContainerConfigurationContainerRegistryArrayOutput
}

type GetPoolContainerConfigurationContainerRegistryArray []GetPoolContainerConfigurationContainerRegistryInput

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

func (i GetPoolContainerConfigurationContainerRegistryArray) ToGetPoolContainerConfigurationContainerRegistryArrayOutput() GetPoolContainerConfigurationContainerRegistryArrayOutput {
	return i.ToGetPoolContainerConfigurationContainerRegistryArrayOutputWithContext(context.Background())
}

func (i GetPoolContainerConfigurationContainerRegistryArray) ToGetPoolContainerConfigurationContainerRegistryArrayOutputWithContext(ctx context.Context) GetPoolContainerConfigurationContainerRegistryArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolContainerConfigurationContainerRegistryArrayOutput)
}

type GetPoolContainerConfigurationContainerRegistryOutput struct{ *pulumi.OutputState }

func (GetPoolContainerConfigurationContainerRegistryOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolContainerConfigurationContainerRegistry)(nil)).Elem()
}

func (o GetPoolContainerConfigurationContainerRegistryOutput) ToGetPoolContainerConfigurationContainerRegistryOutput() GetPoolContainerConfigurationContainerRegistryOutput {
	return o
}

func (o GetPoolContainerConfigurationContainerRegistryOutput) ToGetPoolContainerConfigurationContainerRegistryOutputWithContext(ctx context.Context) GetPoolContainerConfigurationContainerRegistryOutput {
	return o
}

// The password to log into the registry server.
func (o GetPoolContainerConfigurationContainerRegistryOutput) Password() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolContainerConfigurationContainerRegistry) string { return v.Password }).(pulumi.StringOutput)
}

// The container registry URL. The default is "docker.io".
func (o GetPoolContainerConfigurationContainerRegistryOutput) RegistryServer() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolContainerConfigurationContainerRegistry) string { return v.RegistryServer }).(pulumi.StringOutput)
}

// The user name to log into the registry server.
func (o GetPoolContainerConfigurationContainerRegistryOutput) UserName() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolContainerConfigurationContainerRegistry) string { return v.UserName }).(pulumi.StringOutput)
}

type GetPoolContainerConfigurationContainerRegistryArrayOutput struct{ *pulumi.OutputState }

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

func (o GetPoolContainerConfigurationContainerRegistryArrayOutput) ToGetPoolContainerConfigurationContainerRegistryArrayOutput() GetPoolContainerConfigurationContainerRegistryArrayOutput {
	return o
}

func (o GetPoolContainerConfigurationContainerRegistryArrayOutput) ToGetPoolContainerConfigurationContainerRegistryArrayOutputWithContext(ctx context.Context) GetPoolContainerConfigurationContainerRegistryArrayOutput {
	return o
}

func (o GetPoolContainerConfigurationContainerRegistryArrayOutput) Index(i pulumi.IntInput) GetPoolContainerConfigurationContainerRegistryOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetPoolContainerConfigurationContainerRegistry {
		return vs[0].([]GetPoolContainerConfigurationContainerRegistry)[vs[1].(int)]
	}).(GetPoolContainerConfigurationContainerRegistryOutput)
}

type GetPoolFixedScale struct {
	// The timeout for resize operations.
	ResizeTimeout string `pulumi:"resizeTimeout"`
	// The number of nodes in the Batch pool.
	TargetDedicatedNodes int `pulumi:"targetDedicatedNodes"`
	// The number of low priority nodes in the Batch pool.
	TargetLowPriorityNodes int `pulumi:"targetLowPriorityNodes"`
}

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

	ToGetPoolFixedScaleOutput() GetPoolFixedScaleOutput
	ToGetPoolFixedScaleOutputWithContext(context.Context) GetPoolFixedScaleOutput
}

type GetPoolFixedScaleArgs struct {
	// The timeout for resize operations.
	ResizeTimeout pulumi.StringInput `pulumi:"resizeTimeout"`
	// The number of nodes in the Batch pool.
	TargetDedicatedNodes pulumi.IntInput `pulumi:"targetDedicatedNodes"`
	// The number of low priority nodes in the Batch pool.
	TargetLowPriorityNodes pulumi.IntInput `pulumi:"targetLowPriorityNodes"`
}

func (GetPoolFixedScaleArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolFixedScale)(nil)).Elem()
}

func (i GetPoolFixedScaleArgs) ToGetPoolFixedScaleOutput() GetPoolFixedScaleOutput {
	return i.ToGetPoolFixedScaleOutputWithContext(context.Background())
}

func (i GetPoolFixedScaleArgs) ToGetPoolFixedScaleOutputWithContext(ctx context.Context) GetPoolFixedScaleOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolFixedScaleOutput)
}

// GetPoolFixedScaleArrayInput is an input type that accepts GetPoolFixedScaleArray and GetPoolFixedScaleArrayOutput values.
// You can construct a concrete instance of `GetPoolFixedScaleArrayInput` via:
//
//          GetPoolFixedScaleArray{ GetPoolFixedScaleArgs{...} }
type GetPoolFixedScaleArrayInput interface {
	pulumi.Input

	ToGetPoolFixedScaleArrayOutput() GetPoolFixedScaleArrayOutput
	ToGetPoolFixedScaleArrayOutputWithContext(context.Context) GetPoolFixedScaleArrayOutput
}

type GetPoolFixedScaleArray []GetPoolFixedScaleInput

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

func (i GetPoolFixedScaleArray) ToGetPoolFixedScaleArrayOutput() GetPoolFixedScaleArrayOutput {
	return i.ToGetPoolFixedScaleArrayOutputWithContext(context.Background())
}

func (i GetPoolFixedScaleArray) ToGetPoolFixedScaleArrayOutputWithContext(ctx context.Context) GetPoolFixedScaleArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolFixedScaleArrayOutput)
}

type GetPoolFixedScaleOutput struct{ *pulumi.OutputState }

func (GetPoolFixedScaleOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolFixedScale)(nil)).Elem()
}

func (o GetPoolFixedScaleOutput) ToGetPoolFixedScaleOutput() GetPoolFixedScaleOutput {
	return o
}

func (o GetPoolFixedScaleOutput) ToGetPoolFixedScaleOutputWithContext(ctx context.Context) GetPoolFixedScaleOutput {
	return o
}

// The timeout for resize operations.
func (o GetPoolFixedScaleOutput) ResizeTimeout() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolFixedScale) string { return v.ResizeTimeout }).(pulumi.StringOutput)
}

// The number of nodes in the Batch pool.
func (o GetPoolFixedScaleOutput) TargetDedicatedNodes() pulumi.IntOutput {
	return o.ApplyT(func(v GetPoolFixedScale) int { return v.TargetDedicatedNodes }).(pulumi.IntOutput)
}

// The number of low priority nodes in the Batch pool.
func (o GetPoolFixedScaleOutput) TargetLowPriorityNodes() pulumi.IntOutput {
	return o.ApplyT(func(v GetPoolFixedScale) int { return v.TargetLowPriorityNodes }).(pulumi.IntOutput)
}

type GetPoolFixedScaleArrayOutput struct{ *pulumi.OutputState }

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

func (o GetPoolFixedScaleArrayOutput) ToGetPoolFixedScaleArrayOutput() GetPoolFixedScaleArrayOutput {
	return o
}

func (o GetPoolFixedScaleArrayOutput) ToGetPoolFixedScaleArrayOutputWithContext(ctx context.Context) GetPoolFixedScaleArrayOutput {
	return o
}

func (o GetPoolFixedScaleArrayOutput) Index(i pulumi.IntInput) GetPoolFixedScaleOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetPoolFixedScale {
		return vs[0].([]GetPoolFixedScale)[vs[1].(int)]
	}).(GetPoolFixedScaleOutput)
}

type GetPoolNetworkConfiguration struct {
	// The inbound NAT pools that are used to address specific ports on the individual compute node externally.
	EndpointConfiguration GetPoolNetworkConfigurationEndpointConfiguration `pulumi:"endpointConfiguration"`
	// The ARM resource identifier of the virtual network subnet which the compute nodes of the pool are joined too.
	SubnetId string `pulumi:"subnetId"`
}

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

	ToGetPoolNetworkConfigurationOutput() GetPoolNetworkConfigurationOutput
	ToGetPoolNetworkConfigurationOutputWithContext(context.Context) GetPoolNetworkConfigurationOutput
}

type GetPoolNetworkConfigurationArgs struct {
	// The inbound NAT pools that are used to address specific ports on the individual compute node externally.
	EndpointConfiguration GetPoolNetworkConfigurationEndpointConfigurationInput `pulumi:"endpointConfiguration"`
	// The ARM resource identifier of the virtual network subnet which the compute nodes of the pool are joined too.
	SubnetId pulumi.StringInput `pulumi:"subnetId"`
}

func (GetPoolNetworkConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolNetworkConfiguration)(nil)).Elem()
}

func (i GetPoolNetworkConfigurationArgs) ToGetPoolNetworkConfigurationOutput() GetPoolNetworkConfigurationOutput {
	return i.ToGetPoolNetworkConfigurationOutputWithContext(context.Background())
}

func (i GetPoolNetworkConfigurationArgs) ToGetPoolNetworkConfigurationOutputWithContext(ctx context.Context) GetPoolNetworkConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolNetworkConfigurationOutput)
}

type GetPoolNetworkConfigurationOutput struct{ *pulumi.OutputState }

func (GetPoolNetworkConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolNetworkConfiguration)(nil)).Elem()
}

func (o GetPoolNetworkConfigurationOutput) ToGetPoolNetworkConfigurationOutput() GetPoolNetworkConfigurationOutput {
	return o
}

func (o GetPoolNetworkConfigurationOutput) ToGetPoolNetworkConfigurationOutputWithContext(ctx context.Context) GetPoolNetworkConfigurationOutput {
	return o
}

// The inbound NAT pools that are used to address specific ports on the individual compute node externally.
func (o GetPoolNetworkConfigurationOutput) EndpointConfiguration() GetPoolNetworkConfigurationEndpointConfigurationOutput {
	return o.ApplyT(func(v GetPoolNetworkConfiguration) GetPoolNetworkConfigurationEndpointConfiguration {
		return v.EndpointConfiguration
	}).(GetPoolNetworkConfigurationEndpointConfigurationOutput)
}

// The ARM resource identifier of the virtual network subnet which the compute nodes of the pool are joined too.
func (o GetPoolNetworkConfigurationOutput) SubnetId() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolNetworkConfiguration) string { return v.SubnetId }).(pulumi.StringOutput)
}

type GetPoolNetworkConfigurationEndpointConfiguration struct {
	// The port number on the compute node.
	BackendPort int `pulumi:"backendPort"`
	// The range of external ports that are used to provide inbound access to the backendPort on the individual compute nodes in the format of `1000-1100`.
	FrontendPortRange string `pulumi:"frontendPortRange"`
	// The name of the endpoint.
	Name string `pulumi:"name"`
	// The list of network security group rules that are applied to the endpoint.
	NetworkSecurityGroupRules []GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule `pulumi:"networkSecurityGroupRules"`
	// The protocol of the endpoint.
	Protocol string `pulumi:"protocol"`
}

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

	ToGetPoolNetworkConfigurationEndpointConfigurationOutput() GetPoolNetworkConfigurationEndpointConfigurationOutput
	ToGetPoolNetworkConfigurationEndpointConfigurationOutputWithContext(context.Context) GetPoolNetworkConfigurationEndpointConfigurationOutput
}

type GetPoolNetworkConfigurationEndpointConfigurationArgs struct {
	// The port number on the compute node.
	BackendPort pulumi.IntInput `pulumi:"backendPort"`
	// The range of external ports that are used to provide inbound access to the backendPort on the individual compute nodes in the format of `1000-1100`.
	FrontendPortRange pulumi.StringInput `pulumi:"frontendPortRange"`
	// The name of the endpoint.
	Name pulumi.StringInput `pulumi:"name"`
	// The list of network security group rules that are applied to the endpoint.
	NetworkSecurityGroupRules GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayInput `pulumi:"networkSecurityGroupRules"`
	// The protocol of the endpoint.
	Protocol pulumi.StringInput `pulumi:"protocol"`
}

func (GetPoolNetworkConfigurationEndpointConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolNetworkConfigurationEndpointConfiguration)(nil)).Elem()
}

func (i GetPoolNetworkConfigurationEndpointConfigurationArgs) ToGetPoolNetworkConfigurationEndpointConfigurationOutput() GetPoolNetworkConfigurationEndpointConfigurationOutput {
	return i.ToGetPoolNetworkConfigurationEndpointConfigurationOutputWithContext(context.Background())
}

func (i GetPoolNetworkConfigurationEndpointConfigurationArgs) ToGetPoolNetworkConfigurationEndpointConfigurationOutputWithContext(ctx context.Context) GetPoolNetworkConfigurationEndpointConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolNetworkConfigurationEndpointConfigurationOutput)
}

type GetPoolNetworkConfigurationEndpointConfigurationOutput struct{ *pulumi.OutputState }

func (GetPoolNetworkConfigurationEndpointConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolNetworkConfigurationEndpointConfiguration)(nil)).Elem()
}

func (o GetPoolNetworkConfigurationEndpointConfigurationOutput) ToGetPoolNetworkConfigurationEndpointConfigurationOutput() GetPoolNetworkConfigurationEndpointConfigurationOutput {
	return o
}

func (o GetPoolNetworkConfigurationEndpointConfigurationOutput) ToGetPoolNetworkConfigurationEndpointConfigurationOutputWithContext(ctx context.Context) GetPoolNetworkConfigurationEndpointConfigurationOutput {
	return o
}

// The port number on the compute node.
func (o GetPoolNetworkConfigurationEndpointConfigurationOutput) BackendPort() pulumi.IntOutput {
	return o.ApplyT(func(v GetPoolNetworkConfigurationEndpointConfiguration) int { return v.BackendPort }).(pulumi.IntOutput)
}

// The range of external ports that are used to provide inbound access to the backendPort on the individual compute nodes in the format of `1000-1100`.
func (o GetPoolNetworkConfigurationEndpointConfigurationOutput) FrontendPortRange() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolNetworkConfigurationEndpointConfiguration) string { return v.FrontendPortRange }).(pulumi.StringOutput)
}

// The name of the endpoint.
func (o GetPoolNetworkConfigurationEndpointConfigurationOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolNetworkConfigurationEndpointConfiguration) string { return v.Name }).(pulumi.StringOutput)
}

// The list of network security group rules that are applied to the endpoint.
func (o GetPoolNetworkConfigurationEndpointConfigurationOutput) NetworkSecurityGroupRules() GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput {
	return o.ApplyT(func(v GetPoolNetworkConfigurationEndpointConfiguration) []GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule {
		return v.NetworkSecurityGroupRules
	}).(GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput)
}

// The protocol of the endpoint.
func (o GetPoolNetworkConfigurationEndpointConfigurationOutput) Protocol() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolNetworkConfigurationEndpointConfiguration) string { return v.Protocol }).(pulumi.StringOutput)
}

type GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule struct {
	// The action that should be taken for a specified IP address, subnet range or tag.
	Access string `pulumi:"access"`
	// The priority for this rule.
	Priority int `pulumi:"priority"`
	// The source address prefix or tag to match for the rule.
	SourceAddressPrefix string `pulumi:"sourceAddressPrefix"`
}

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

	ToGetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput() GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput
	ToGetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutputWithContext(context.Context) GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput
}

type GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArgs struct {
	// The action that should be taken for a specified IP address, subnet range or tag.
	Access pulumi.StringInput `pulumi:"access"`
	// The priority for this rule.
	Priority pulumi.IntInput `pulumi:"priority"`
	// The source address prefix or tag to match for the rule.
	SourceAddressPrefix pulumi.StringInput `pulumi:"sourceAddressPrefix"`
}

func (GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule)(nil)).Elem()
}

func (i GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArgs) ToGetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput() GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput {
	return i.ToGetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutputWithContext(context.Background())
}

func (i GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArgs) ToGetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutputWithContext(ctx context.Context) GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput)
}

// GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayInput is an input type that accepts GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArray and GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput values.
// You can construct a concrete instance of `GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayInput` via:
//
//          GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArray{ GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArgs{...} }
type GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayInput interface {
	pulumi.Input

	ToGetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput() GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput
	ToGetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutputWithContext(context.Context) GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput
}

type GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArray []GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleInput

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

func (i GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArray) ToGetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput() GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput {
	return i.ToGetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutputWithContext(context.Background())
}

func (i GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArray) ToGetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutputWithContext(ctx context.Context) GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput)
}

type GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput struct{ *pulumi.OutputState }

func (GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule)(nil)).Elem()
}

func (o GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput) ToGetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput() GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput {
	return o
}

func (o GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput) ToGetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutputWithContext(ctx context.Context) GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput {
	return o
}

// The action that should be taken for a specified IP address, subnet range or tag.
func (o GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput) Access() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule) string {
		return v.Access
	}).(pulumi.StringOutput)
}

// The priority for this rule.
func (o GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput) Priority() pulumi.IntOutput {
	return o.ApplyT(func(v GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule) int {
		return v.Priority
	}).(pulumi.IntOutput)
}

// The source address prefix or tag to match for the rule.
func (o GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput) SourceAddressPrefix() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule) string {
		return v.SourceAddressPrefix
	}).(pulumi.StringOutput)
}

type GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput struct{ *pulumi.OutputState }

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

func (o GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput) ToGetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput() GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput {
	return o
}

func (o GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput) ToGetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutputWithContext(ctx context.Context) GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput {
	return o
}

func (o GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput) Index(i pulumi.IntInput) GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule {
		return vs[0].([]GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRule)[vs[1].(int)]
	}).(GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput)
}

type GetPoolStartTask struct {
	// The command line executed by the start task.
	CommandLine string `pulumi:"commandLine"`
	// A map of strings (key,value) that represents the environment variables to set in the start task.
	Environment map[string]string `pulumi:"environment"`
	// The number of retry count.
	MaxTaskRetryCount *int `pulumi:"maxTaskRetryCount"`
	// One or more `resourceFile` blocks that describe the files to be downloaded to a compute node.
	ResourceFiles []GetPoolStartTaskResourceFile `pulumi:"resourceFiles"`
	// A `userIdentity` block that describes the user identity under which the start task runs.
	UserIdentities []GetPoolStartTaskUserIdentity `pulumi:"userIdentities"`
	// A flag that indicates if the Batch pool should wait for the start task to be completed.
	WaitForSuccess *bool `pulumi:"waitForSuccess"`
}

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

	ToGetPoolStartTaskOutput() GetPoolStartTaskOutput
	ToGetPoolStartTaskOutputWithContext(context.Context) GetPoolStartTaskOutput
}

type GetPoolStartTaskArgs struct {
	// The command line executed by the start task.
	CommandLine pulumi.StringInput `pulumi:"commandLine"`
	// A map of strings (key,value) that represents the environment variables to set in the start task.
	Environment pulumi.StringMapInput `pulumi:"environment"`
	// The number of retry count.
	MaxTaskRetryCount pulumi.IntPtrInput `pulumi:"maxTaskRetryCount"`
	// One or more `resourceFile` blocks that describe the files to be downloaded to a compute node.
	ResourceFiles GetPoolStartTaskResourceFileArrayInput `pulumi:"resourceFiles"`
	// A `userIdentity` block that describes the user identity under which the start task runs.
	UserIdentities GetPoolStartTaskUserIdentityArrayInput `pulumi:"userIdentities"`
	// A flag that indicates if the Batch pool should wait for the start task to be completed.
	WaitForSuccess pulumi.BoolPtrInput `pulumi:"waitForSuccess"`
}

func (GetPoolStartTaskArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolStartTask)(nil)).Elem()
}

func (i GetPoolStartTaskArgs) ToGetPoolStartTaskOutput() GetPoolStartTaskOutput {
	return i.ToGetPoolStartTaskOutputWithContext(context.Background())
}

func (i GetPoolStartTaskArgs) ToGetPoolStartTaskOutputWithContext(ctx context.Context) GetPoolStartTaskOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolStartTaskOutput)
}

type GetPoolStartTaskOutput struct{ *pulumi.OutputState }

func (GetPoolStartTaskOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolStartTask)(nil)).Elem()
}

func (o GetPoolStartTaskOutput) ToGetPoolStartTaskOutput() GetPoolStartTaskOutput {
	return o
}

func (o GetPoolStartTaskOutput) ToGetPoolStartTaskOutputWithContext(ctx context.Context) GetPoolStartTaskOutput {
	return o
}

// The command line executed by the start task.
func (o GetPoolStartTaskOutput) CommandLine() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolStartTask) string { return v.CommandLine }).(pulumi.StringOutput)
}

// A map of strings (key,value) that represents the environment variables to set in the start task.
func (o GetPoolStartTaskOutput) Environment() pulumi.StringMapOutput {
	return o.ApplyT(func(v GetPoolStartTask) map[string]string { return v.Environment }).(pulumi.StringMapOutput)
}

// The number of retry count.
func (o GetPoolStartTaskOutput) MaxTaskRetryCount() pulumi.IntPtrOutput {
	return o.ApplyT(func(v GetPoolStartTask) *int { return v.MaxTaskRetryCount }).(pulumi.IntPtrOutput)
}

// One or more `resourceFile` blocks that describe the files to be downloaded to a compute node.
func (o GetPoolStartTaskOutput) ResourceFiles() GetPoolStartTaskResourceFileArrayOutput {
	return o.ApplyT(func(v GetPoolStartTask) []GetPoolStartTaskResourceFile { return v.ResourceFiles }).(GetPoolStartTaskResourceFileArrayOutput)
}

// A `userIdentity` block that describes the user identity under which the start task runs.
func (o GetPoolStartTaskOutput) UserIdentities() GetPoolStartTaskUserIdentityArrayOutput {
	return o.ApplyT(func(v GetPoolStartTask) []GetPoolStartTaskUserIdentity { return v.UserIdentities }).(GetPoolStartTaskUserIdentityArrayOutput)
}

// A flag that indicates if the Batch pool should wait for the start task to be completed.
func (o GetPoolStartTaskOutput) WaitForSuccess() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v GetPoolStartTask) *bool { return v.WaitForSuccess }).(pulumi.BoolPtrOutput)
}

type GetPoolStartTaskResourceFile struct {
	// The storage container name in the auto storage account.
	AutoStorageContainerName string `pulumi:"autoStorageContainerName"`
	// The blob prefix used when downloading blobs from an Azure Storage container.
	BlobPrefix string `pulumi:"blobPrefix"`
	// The file permission mode attribute represented as a string in octal format (e.g. `"0644"`).
	FileMode string `pulumi:"fileMode"`
	// The location on the compute node to which to download the file, relative to the task's working directory. If the `httpUrl` property is specified, the `filePath` is required and describes the path which the file will be downloaded to, including the filename. Otherwise, if the `autoStorageContainerName` or `storageContainerUrl` property is specified.
	FilePath string `pulumi:"filePath"`
	// The URL of the file to download. If the URL is Azure Blob Storage, it must be readable using anonymous access.
	HttpUrl string `pulumi:"httpUrl"`
	// The URL of the blob container within Azure Blob Storage.
	StorageContainerUrl string `pulumi:"storageContainerUrl"`
}

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

	ToGetPoolStartTaskResourceFileOutput() GetPoolStartTaskResourceFileOutput
	ToGetPoolStartTaskResourceFileOutputWithContext(context.Context) GetPoolStartTaskResourceFileOutput
}

type GetPoolStartTaskResourceFileArgs struct {
	// The storage container name in the auto storage account.
	AutoStorageContainerName pulumi.StringInput `pulumi:"autoStorageContainerName"`
	// The blob prefix used when downloading blobs from an Azure Storage container.
	BlobPrefix pulumi.StringInput `pulumi:"blobPrefix"`
	// The file permission mode attribute represented as a string in octal format (e.g. `"0644"`).
	FileMode pulumi.StringInput `pulumi:"fileMode"`
	// The location on the compute node to which to download the file, relative to the task's working directory. If the `httpUrl` property is specified, the `filePath` is required and describes the path which the file will be downloaded to, including the filename. Otherwise, if the `autoStorageContainerName` or `storageContainerUrl` property is specified.
	FilePath pulumi.StringInput `pulumi:"filePath"`
	// The URL of the file to download. If the URL is Azure Blob Storage, it must be readable using anonymous access.
	HttpUrl pulumi.StringInput `pulumi:"httpUrl"`
	// The URL of the blob container within Azure Blob Storage.
	StorageContainerUrl pulumi.StringInput `pulumi:"storageContainerUrl"`
}

func (GetPoolStartTaskResourceFileArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolStartTaskResourceFile)(nil)).Elem()
}

func (i GetPoolStartTaskResourceFileArgs) ToGetPoolStartTaskResourceFileOutput() GetPoolStartTaskResourceFileOutput {
	return i.ToGetPoolStartTaskResourceFileOutputWithContext(context.Background())
}

func (i GetPoolStartTaskResourceFileArgs) ToGetPoolStartTaskResourceFileOutputWithContext(ctx context.Context) GetPoolStartTaskResourceFileOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolStartTaskResourceFileOutput)
}

// GetPoolStartTaskResourceFileArrayInput is an input type that accepts GetPoolStartTaskResourceFileArray and GetPoolStartTaskResourceFileArrayOutput values.
// You can construct a concrete instance of `GetPoolStartTaskResourceFileArrayInput` via:
//
//          GetPoolStartTaskResourceFileArray{ GetPoolStartTaskResourceFileArgs{...} }
type GetPoolStartTaskResourceFileArrayInput interface {
	pulumi.Input

	ToGetPoolStartTaskResourceFileArrayOutput() GetPoolStartTaskResourceFileArrayOutput
	ToGetPoolStartTaskResourceFileArrayOutputWithContext(context.Context) GetPoolStartTaskResourceFileArrayOutput
}

type GetPoolStartTaskResourceFileArray []GetPoolStartTaskResourceFileInput

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

func (i GetPoolStartTaskResourceFileArray) ToGetPoolStartTaskResourceFileArrayOutput() GetPoolStartTaskResourceFileArrayOutput {
	return i.ToGetPoolStartTaskResourceFileArrayOutputWithContext(context.Background())
}

func (i GetPoolStartTaskResourceFileArray) ToGetPoolStartTaskResourceFileArrayOutputWithContext(ctx context.Context) GetPoolStartTaskResourceFileArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolStartTaskResourceFileArrayOutput)
}

type GetPoolStartTaskResourceFileOutput struct{ *pulumi.OutputState }

func (GetPoolStartTaskResourceFileOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolStartTaskResourceFile)(nil)).Elem()
}

func (o GetPoolStartTaskResourceFileOutput) ToGetPoolStartTaskResourceFileOutput() GetPoolStartTaskResourceFileOutput {
	return o
}

func (o GetPoolStartTaskResourceFileOutput) ToGetPoolStartTaskResourceFileOutputWithContext(ctx context.Context) GetPoolStartTaskResourceFileOutput {
	return o
}

// The storage container name in the auto storage account.
func (o GetPoolStartTaskResourceFileOutput) AutoStorageContainerName() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolStartTaskResourceFile) string { return v.AutoStorageContainerName }).(pulumi.StringOutput)
}

// The blob prefix used when downloading blobs from an Azure Storage container.
func (o GetPoolStartTaskResourceFileOutput) BlobPrefix() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolStartTaskResourceFile) string { return v.BlobPrefix }).(pulumi.StringOutput)
}

// The file permission mode attribute represented as a string in octal format (e.g. `"0644"`).
func (o GetPoolStartTaskResourceFileOutput) FileMode() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolStartTaskResourceFile) string { return v.FileMode }).(pulumi.StringOutput)
}

// The location on the compute node to which to download the file, relative to the task's working directory. If the `httpUrl` property is specified, the `filePath` is required and describes the path which the file will be downloaded to, including the filename. Otherwise, if the `autoStorageContainerName` or `storageContainerUrl` property is specified.
func (o GetPoolStartTaskResourceFileOutput) FilePath() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolStartTaskResourceFile) string { return v.FilePath }).(pulumi.StringOutput)
}

// The URL of the file to download. If the URL is Azure Blob Storage, it must be readable using anonymous access.
func (o GetPoolStartTaskResourceFileOutput) HttpUrl() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolStartTaskResourceFile) string { return v.HttpUrl }).(pulumi.StringOutput)
}

// The URL of the blob container within Azure Blob Storage.
func (o GetPoolStartTaskResourceFileOutput) StorageContainerUrl() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolStartTaskResourceFile) string { return v.StorageContainerUrl }).(pulumi.StringOutput)
}

type GetPoolStartTaskResourceFileArrayOutput struct{ *pulumi.OutputState }

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

func (o GetPoolStartTaskResourceFileArrayOutput) ToGetPoolStartTaskResourceFileArrayOutput() GetPoolStartTaskResourceFileArrayOutput {
	return o
}

func (o GetPoolStartTaskResourceFileArrayOutput) ToGetPoolStartTaskResourceFileArrayOutputWithContext(ctx context.Context) GetPoolStartTaskResourceFileArrayOutput {
	return o
}

func (o GetPoolStartTaskResourceFileArrayOutput) Index(i pulumi.IntInput) GetPoolStartTaskResourceFileOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetPoolStartTaskResourceFile {
		return vs[0].([]GetPoolStartTaskResourceFile)[vs[1].(int)]
	}).(GetPoolStartTaskResourceFileOutput)
}

type GetPoolStartTaskUserIdentity struct {
	// A `autoUser` block that describes the user identity under which the start task runs.
	AutoUsers []GetPoolStartTaskUserIdentityAutoUser `pulumi:"autoUsers"`
	// The user name to log into the registry server.
	UserName string `pulumi:"userName"`
}

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

	ToGetPoolStartTaskUserIdentityOutput() GetPoolStartTaskUserIdentityOutput
	ToGetPoolStartTaskUserIdentityOutputWithContext(context.Context) GetPoolStartTaskUserIdentityOutput
}

type GetPoolStartTaskUserIdentityArgs struct {
	// A `autoUser` block that describes the user identity under which the start task runs.
	AutoUsers GetPoolStartTaskUserIdentityAutoUserArrayInput `pulumi:"autoUsers"`
	// The user name to log into the registry server.
	UserName pulumi.StringInput `pulumi:"userName"`
}

func (GetPoolStartTaskUserIdentityArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolStartTaskUserIdentity)(nil)).Elem()
}

func (i GetPoolStartTaskUserIdentityArgs) ToGetPoolStartTaskUserIdentityOutput() GetPoolStartTaskUserIdentityOutput {
	return i.ToGetPoolStartTaskUserIdentityOutputWithContext(context.Background())
}

func (i GetPoolStartTaskUserIdentityArgs) ToGetPoolStartTaskUserIdentityOutputWithContext(ctx context.Context) GetPoolStartTaskUserIdentityOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolStartTaskUserIdentityOutput)
}

// GetPoolStartTaskUserIdentityArrayInput is an input type that accepts GetPoolStartTaskUserIdentityArray and GetPoolStartTaskUserIdentityArrayOutput values.
// You can construct a concrete instance of `GetPoolStartTaskUserIdentityArrayInput` via:
//
//          GetPoolStartTaskUserIdentityArray{ GetPoolStartTaskUserIdentityArgs{...} }
type GetPoolStartTaskUserIdentityArrayInput interface {
	pulumi.Input

	ToGetPoolStartTaskUserIdentityArrayOutput() GetPoolStartTaskUserIdentityArrayOutput
	ToGetPoolStartTaskUserIdentityArrayOutputWithContext(context.Context) GetPoolStartTaskUserIdentityArrayOutput
}

type GetPoolStartTaskUserIdentityArray []GetPoolStartTaskUserIdentityInput

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

func (i GetPoolStartTaskUserIdentityArray) ToGetPoolStartTaskUserIdentityArrayOutput() GetPoolStartTaskUserIdentityArrayOutput {
	return i.ToGetPoolStartTaskUserIdentityArrayOutputWithContext(context.Background())
}

func (i GetPoolStartTaskUserIdentityArray) ToGetPoolStartTaskUserIdentityArrayOutputWithContext(ctx context.Context) GetPoolStartTaskUserIdentityArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolStartTaskUserIdentityArrayOutput)
}

type GetPoolStartTaskUserIdentityOutput struct{ *pulumi.OutputState }

func (GetPoolStartTaskUserIdentityOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolStartTaskUserIdentity)(nil)).Elem()
}

func (o GetPoolStartTaskUserIdentityOutput) ToGetPoolStartTaskUserIdentityOutput() GetPoolStartTaskUserIdentityOutput {
	return o
}

func (o GetPoolStartTaskUserIdentityOutput) ToGetPoolStartTaskUserIdentityOutputWithContext(ctx context.Context) GetPoolStartTaskUserIdentityOutput {
	return o
}

// A `autoUser` block that describes the user identity under which the start task runs.
func (o GetPoolStartTaskUserIdentityOutput) AutoUsers() GetPoolStartTaskUserIdentityAutoUserArrayOutput {
	return o.ApplyT(func(v GetPoolStartTaskUserIdentity) []GetPoolStartTaskUserIdentityAutoUser { return v.AutoUsers }).(GetPoolStartTaskUserIdentityAutoUserArrayOutput)
}

// The user name to log into the registry server.
func (o GetPoolStartTaskUserIdentityOutput) UserName() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolStartTaskUserIdentity) string { return v.UserName }).(pulumi.StringOutput)
}

type GetPoolStartTaskUserIdentityArrayOutput struct{ *pulumi.OutputState }

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

func (o GetPoolStartTaskUserIdentityArrayOutput) ToGetPoolStartTaskUserIdentityArrayOutput() GetPoolStartTaskUserIdentityArrayOutput {
	return o
}

func (o GetPoolStartTaskUserIdentityArrayOutput) ToGetPoolStartTaskUserIdentityArrayOutputWithContext(ctx context.Context) GetPoolStartTaskUserIdentityArrayOutput {
	return o
}

func (o GetPoolStartTaskUserIdentityArrayOutput) Index(i pulumi.IntInput) GetPoolStartTaskUserIdentityOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetPoolStartTaskUserIdentity {
		return vs[0].([]GetPoolStartTaskUserIdentity)[vs[1].(int)]
	}).(GetPoolStartTaskUserIdentityOutput)
}

type GetPoolStartTaskUserIdentityAutoUser struct {
	// The elevation level of the user identity under which the start task runs.
	ElevationLevel string `pulumi:"elevationLevel"`
	// The scope of the user identity under which the start task runs.
	Scope string `pulumi:"scope"`
}

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

	ToGetPoolStartTaskUserIdentityAutoUserOutput() GetPoolStartTaskUserIdentityAutoUserOutput
	ToGetPoolStartTaskUserIdentityAutoUserOutputWithContext(context.Context) GetPoolStartTaskUserIdentityAutoUserOutput
}

type GetPoolStartTaskUserIdentityAutoUserArgs struct {
	// The elevation level of the user identity under which the start task runs.
	ElevationLevel pulumi.StringInput `pulumi:"elevationLevel"`
	// The scope of the user identity under which the start task runs.
	Scope pulumi.StringInput `pulumi:"scope"`
}

func (GetPoolStartTaskUserIdentityAutoUserArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolStartTaskUserIdentityAutoUser)(nil)).Elem()
}

func (i GetPoolStartTaskUserIdentityAutoUserArgs) ToGetPoolStartTaskUserIdentityAutoUserOutput() GetPoolStartTaskUserIdentityAutoUserOutput {
	return i.ToGetPoolStartTaskUserIdentityAutoUserOutputWithContext(context.Background())
}

func (i GetPoolStartTaskUserIdentityAutoUserArgs) ToGetPoolStartTaskUserIdentityAutoUserOutputWithContext(ctx context.Context) GetPoolStartTaskUserIdentityAutoUserOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolStartTaskUserIdentityAutoUserOutput)
}

// GetPoolStartTaskUserIdentityAutoUserArrayInput is an input type that accepts GetPoolStartTaskUserIdentityAutoUserArray and GetPoolStartTaskUserIdentityAutoUserArrayOutput values.
// You can construct a concrete instance of `GetPoolStartTaskUserIdentityAutoUserArrayInput` via:
//
//          GetPoolStartTaskUserIdentityAutoUserArray{ GetPoolStartTaskUserIdentityAutoUserArgs{...} }
type GetPoolStartTaskUserIdentityAutoUserArrayInput interface {
	pulumi.Input

	ToGetPoolStartTaskUserIdentityAutoUserArrayOutput() GetPoolStartTaskUserIdentityAutoUserArrayOutput
	ToGetPoolStartTaskUserIdentityAutoUserArrayOutputWithContext(context.Context) GetPoolStartTaskUserIdentityAutoUserArrayOutput
}

type GetPoolStartTaskUserIdentityAutoUserArray []GetPoolStartTaskUserIdentityAutoUserInput

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

func (i GetPoolStartTaskUserIdentityAutoUserArray) ToGetPoolStartTaskUserIdentityAutoUserArrayOutput() GetPoolStartTaskUserIdentityAutoUserArrayOutput {
	return i.ToGetPoolStartTaskUserIdentityAutoUserArrayOutputWithContext(context.Background())
}

func (i GetPoolStartTaskUserIdentityAutoUserArray) ToGetPoolStartTaskUserIdentityAutoUserArrayOutputWithContext(ctx context.Context) GetPoolStartTaskUserIdentityAutoUserArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolStartTaskUserIdentityAutoUserArrayOutput)
}

type GetPoolStartTaskUserIdentityAutoUserOutput struct{ *pulumi.OutputState }

func (GetPoolStartTaskUserIdentityAutoUserOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolStartTaskUserIdentityAutoUser)(nil)).Elem()
}

func (o GetPoolStartTaskUserIdentityAutoUserOutput) ToGetPoolStartTaskUserIdentityAutoUserOutput() GetPoolStartTaskUserIdentityAutoUserOutput {
	return o
}

func (o GetPoolStartTaskUserIdentityAutoUserOutput) ToGetPoolStartTaskUserIdentityAutoUserOutputWithContext(ctx context.Context) GetPoolStartTaskUserIdentityAutoUserOutput {
	return o
}

// The elevation level of the user identity under which the start task runs.
func (o GetPoolStartTaskUserIdentityAutoUserOutput) ElevationLevel() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolStartTaskUserIdentityAutoUser) string { return v.ElevationLevel }).(pulumi.StringOutput)
}

// The scope of the user identity under which the start task runs.
func (o GetPoolStartTaskUserIdentityAutoUserOutput) Scope() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolStartTaskUserIdentityAutoUser) string { return v.Scope }).(pulumi.StringOutput)
}

type GetPoolStartTaskUserIdentityAutoUserArrayOutput struct{ *pulumi.OutputState }

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

func (o GetPoolStartTaskUserIdentityAutoUserArrayOutput) ToGetPoolStartTaskUserIdentityAutoUserArrayOutput() GetPoolStartTaskUserIdentityAutoUserArrayOutput {
	return o
}

func (o GetPoolStartTaskUserIdentityAutoUserArrayOutput) ToGetPoolStartTaskUserIdentityAutoUserArrayOutputWithContext(ctx context.Context) GetPoolStartTaskUserIdentityAutoUserArrayOutput {
	return o
}

func (o GetPoolStartTaskUserIdentityAutoUserArrayOutput) Index(i pulumi.IntInput) GetPoolStartTaskUserIdentityAutoUserOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetPoolStartTaskUserIdentityAutoUser {
		return vs[0].([]GetPoolStartTaskUserIdentityAutoUser)[vs[1].(int)]
	}).(GetPoolStartTaskUserIdentityAutoUserOutput)
}

type GetPoolStorageImageReference struct {
	// The fully qualified ID of the certificate installed on the pool.
	Id        string `pulumi:"id"`
	Offer     string `pulumi:"offer"`
	Publisher string `pulumi:"publisher"`
	Sku       string `pulumi:"sku"`
	Version   string `pulumi:"version"`
}

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

	ToGetPoolStorageImageReferenceOutput() GetPoolStorageImageReferenceOutput
	ToGetPoolStorageImageReferenceOutputWithContext(context.Context) GetPoolStorageImageReferenceOutput
}

type GetPoolStorageImageReferenceArgs struct {
	// The fully qualified ID of the certificate installed on the pool.
	Id        pulumi.StringInput `pulumi:"id"`
	Offer     pulumi.StringInput `pulumi:"offer"`
	Publisher pulumi.StringInput `pulumi:"publisher"`
	Sku       pulumi.StringInput `pulumi:"sku"`
	Version   pulumi.StringInput `pulumi:"version"`
}

func (GetPoolStorageImageReferenceArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolStorageImageReference)(nil)).Elem()
}

func (i GetPoolStorageImageReferenceArgs) ToGetPoolStorageImageReferenceOutput() GetPoolStorageImageReferenceOutput {
	return i.ToGetPoolStorageImageReferenceOutputWithContext(context.Background())
}

func (i GetPoolStorageImageReferenceArgs) ToGetPoolStorageImageReferenceOutputWithContext(ctx context.Context) GetPoolStorageImageReferenceOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolStorageImageReferenceOutput)
}

// GetPoolStorageImageReferenceArrayInput is an input type that accepts GetPoolStorageImageReferenceArray and GetPoolStorageImageReferenceArrayOutput values.
// You can construct a concrete instance of `GetPoolStorageImageReferenceArrayInput` via:
//
//          GetPoolStorageImageReferenceArray{ GetPoolStorageImageReferenceArgs{...} }
type GetPoolStorageImageReferenceArrayInput interface {
	pulumi.Input

	ToGetPoolStorageImageReferenceArrayOutput() GetPoolStorageImageReferenceArrayOutput
	ToGetPoolStorageImageReferenceArrayOutputWithContext(context.Context) GetPoolStorageImageReferenceArrayOutput
}

type GetPoolStorageImageReferenceArray []GetPoolStorageImageReferenceInput

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

func (i GetPoolStorageImageReferenceArray) ToGetPoolStorageImageReferenceArrayOutput() GetPoolStorageImageReferenceArrayOutput {
	return i.ToGetPoolStorageImageReferenceArrayOutputWithContext(context.Background())
}

func (i GetPoolStorageImageReferenceArray) ToGetPoolStorageImageReferenceArrayOutputWithContext(ctx context.Context) GetPoolStorageImageReferenceArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPoolStorageImageReferenceArrayOutput)
}

type GetPoolStorageImageReferenceOutput struct{ *pulumi.OutputState }

func (GetPoolStorageImageReferenceOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPoolStorageImageReference)(nil)).Elem()
}

func (o GetPoolStorageImageReferenceOutput) ToGetPoolStorageImageReferenceOutput() GetPoolStorageImageReferenceOutput {
	return o
}

func (o GetPoolStorageImageReferenceOutput) ToGetPoolStorageImageReferenceOutputWithContext(ctx context.Context) GetPoolStorageImageReferenceOutput {
	return o
}

// The fully qualified ID of the certificate installed on the pool.
func (o GetPoolStorageImageReferenceOutput) Id() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolStorageImageReference) string { return v.Id }).(pulumi.StringOutput)
}

func (o GetPoolStorageImageReferenceOutput) Offer() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolStorageImageReference) string { return v.Offer }).(pulumi.StringOutput)
}

func (o GetPoolStorageImageReferenceOutput) Publisher() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolStorageImageReference) string { return v.Publisher }).(pulumi.StringOutput)
}

func (o GetPoolStorageImageReferenceOutput) Sku() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolStorageImageReference) string { return v.Sku }).(pulumi.StringOutput)
}

func (o GetPoolStorageImageReferenceOutput) Version() pulumi.StringOutput {
	return o.ApplyT(func(v GetPoolStorageImageReference) string { return v.Version }).(pulumi.StringOutput)
}

type GetPoolStorageImageReferenceArrayOutput struct{ *pulumi.OutputState }

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

func (o GetPoolStorageImageReferenceArrayOutput) ToGetPoolStorageImageReferenceArrayOutput() GetPoolStorageImageReferenceArrayOutput {
	return o
}

func (o GetPoolStorageImageReferenceArrayOutput) ToGetPoolStorageImageReferenceArrayOutputWithContext(ctx context.Context) GetPoolStorageImageReferenceArrayOutput {
	return o
}

func (o GetPoolStorageImageReferenceArrayOutput) Index(i pulumi.IntInput) GetPoolStorageImageReferenceOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetPoolStorageImageReference {
		return vs[0].([]GetPoolStorageImageReference)[vs[1].(int)]
	}).(GetPoolStorageImageReferenceOutput)
}

func init() {
	pulumi.RegisterOutputType(AccountKeyVaultReferenceOutput{})
	pulumi.RegisterOutputType(AccountKeyVaultReferencePtrOutput{})
	pulumi.RegisterOutputType(PoolAutoScaleOutput{})
	pulumi.RegisterOutputType(PoolAutoScalePtrOutput{})
	pulumi.RegisterOutputType(PoolCertificateOutput{})
	pulumi.RegisterOutputType(PoolCertificateArrayOutput{})
	pulumi.RegisterOutputType(PoolContainerConfigurationOutput{})
	pulumi.RegisterOutputType(PoolContainerConfigurationPtrOutput{})
	pulumi.RegisterOutputType(PoolContainerConfigurationContainerRegistryOutput{})
	pulumi.RegisterOutputType(PoolContainerConfigurationContainerRegistryArrayOutput{})
	pulumi.RegisterOutputType(PoolFixedScaleOutput{})
	pulumi.RegisterOutputType(PoolFixedScalePtrOutput{})
	pulumi.RegisterOutputType(PoolNetworkConfigurationOutput{})
	pulumi.RegisterOutputType(PoolNetworkConfigurationPtrOutput{})
	pulumi.RegisterOutputType(PoolNetworkConfigurationEndpointConfigurationOutput{})
	pulumi.RegisterOutputType(PoolNetworkConfigurationEndpointConfigurationArrayOutput{})
	pulumi.RegisterOutputType(PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput{})
	pulumi.RegisterOutputType(PoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput{})
	pulumi.RegisterOutputType(PoolStartTaskOutput{})
	pulumi.RegisterOutputType(PoolStartTaskPtrOutput{})
	pulumi.RegisterOutputType(PoolStartTaskResourceFileOutput{})
	pulumi.RegisterOutputType(PoolStartTaskResourceFileArrayOutput{})
	pulumi.RegisterOutputType(PoolStartTaskUserIdentityOutput{})
	pulumi.RegisterOutputType(PoolStartTaskUserIdentityPtrOutput{})
	pulumi.RegisterOutputType(PoolStartTaskUserIdentityAutoUserOutput{})
	pulumi.RegisterOutputType(PoolStartTaskUserIdentityAutoUserPtrOutput{})
	pulumi.RegisterOutputType(PoolStorageImageReferenceOutput{})
	pulumi.RegisterOutputType(PoolStorageImageReferencePtrOutput{})
	pulumi.RegisterOutputType(GetAccountKeyVaultReferenceOutput{})
	pulumi.RegisterOutputType(GetAccountKeyVaultReferenceArrayOutput{})
	pulumi.RegisterOutputType(GetPoolAutoScaleOutput{})
	pulumi.RegisterOutputType(GetPoolAutoScaleArrayOutput{})
	pulumi.RegisterOutputType(GetPoolCertificateOutput{})
	pulumi.RegisterOutputType(GetPoolCertificateArrayOutput{})
	pulumi.RegisterOutputType(GetPoolContainerConfigurationOutput{})
	pulumi.RegisterOutputType(GetPoolContainerConfigurationArrayOutput{})
	pulumi.RegisterOutputType(GetPoolContainerConfigurationContainerRegistryOutput{})
	pulumi.RegisterOutputType(GetPoolContainerConfigurationContainerRegistryArrayOutput{})
	pulumi.RegisterOutputType(GetPoolFixedScaleOutput{})
	pulumi.RegisterOutputType(GetPoolFixedScaleArrayOutput{})
	pulumi.RegisterOutputType(GetPoolNetworkConfigurationOutput{})
	pulumi.RegisterOutputType(GetPoolNetworkConfigurationEndpointConfigurationOutput{})
	pulumi.RegisterOutputType(GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleOutput{})
	pulumi.RegisterOutputType(GetPoolNetworkConfigurationEndpointConfigurationNetworkSecurityGroupRuleArrayOutput{})
	pulumi.RegisterOutputType(GetPoolStartTaskOutput{})
	pulumi.RegisterOutputType(GetPoolStartTaskResourceFileOutput{})
	pulumi.RegisterOutputType(GetPoolStartTaskResourceFileArrayOutput{})
	pulumi.RegisterOutputType(GetPoolStartTaskUserIdentityOutput{})
	pulumi.RegisterOutputType(GetPoolStartTaskUserIdentityArrayOutput{})
	pulumi.RegisterOutputType(GetPoolStartTaskUserIdentityAutoUserOutput{})
	pulumi.RegisterOutputType(GetPoolStartTaskUserIdentityAutoUserArrayOutput{})
	pulumi.RegisterOutputType(GetPoolStorageImageReferenceOutput{})
	pulumi.RegisterOutputType(GetPoolStorageImageReferenceArrayOutput{})
}