text:
.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o OsTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e *OsType) *string {
		if e == nil {
			return nil
		}
		v := string(*e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type OsTypeInput interface {
	pulumi.Input

	ToOsTypeOutput() OsTypeOutput
	ToOsTypeOutputWithContext(context.Context) OsTypeOutput
}

var osTypePtrType = reflect.TypeOf((**OsType)(nil)).Elem()

type OsTypePtrInput interface {
	pulumi.Input

	ToOsTypePtrOutput() OsTypePtrOutput
	ToOsTypePtrOutputWithContext(context.Context) OsTypePtrOutput
}

type osTypePtr string

func OsTypePtr(v string) OsTypePtrInput {
	return (*osTypePtr)(&v)
}

func (*osTypePtr) ElementType() reflect.Type {
	return osTypePtrType
}

func (in *osTypePtr) ToOsTypePtrOutput() OsTypePtrOutput {
	return pulumi.ToOutput(in).(OsTypePtrOutput)
}

func (in *osTypePtr) ToOsTypePtrOutputWithContext(ctx context.Context) OsTypePtrOutput {
	return pulumi.ToOutputWithContext(ctx, in).(OsTypePtrOutput)
}

type PrivateEndpointServiceConnectionStatus string

const (
	PrivateEndpointServiceConnectionStatusPending      = PrivateEndpointServiceConnectionStatus("Pending")
	PrivateEndpointServiceConnectionStatusApproved     = PrivateEndpointServiceConnectionStatus("Approved")
	PrivateEndpointServiceConnectionStatusRejected     = PrivateEndpointServiceConnectionStatus("Rejected")
	PrivateEndpointServiceConnectionStatusDisconnected = PrivateEndpointServiceConnectionStatus("Disconnected")
	PrivateEndpointServiceConnectionStatusTimeout      = PrivateEndpointServiceConnectionStatus("Timeout")
)

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

func (e PrivateEndpointServiceConnectionStatus) ToPrivateEndpointServiceConnectionStatusOutput() PrivateEndpointServiceConnectionStatusOutput {
	return pulumi.ToOutput(e).(PrivateEndpointServiceConnectionStatusOutput)
}

func (e PrivateEndpointServiceConnectionStatus) ToPrivateEndpointServiceConnectionStatusOutputWithContext(ctx context.Context) PrivateEndpointServiceConnectionStatusOutput {
	return pulumi.ToOutputWithContext(ctx, e).(PrivateEndpointServiceConnectionStatusOutput)
}

func (e PrivateEndpointServiceConnectionStatus) ToPrivateEndpointServiceConnectionStatusPtrOutput() PrivateEndpointServiceConnectionStatusPtrOutput {
	return e.ToPrivateEndpointServiceConnectionStatusPtrOutputWithContext(context.Background())
}

func (e PrivateEndpointServiceConnectionStatus) ToPrivateEndpointServiceConnectionStatusPtrOutputWithContext(ctx context.Context) PrivateEndpointServiceConnectionStatusPtrOutput {
	return PrivateEndpointServiceConnectionStatus(e).ToPrivateEndpointServiceConnectionStatusOutputWithContext(ctx).ToPrivateEndpointServiceConnectionStatusPtrOutputWithContext(ctx)
}

func (e PrivateEndpointServiceConnectionStatus) ToStringOutput() pulumi.StringOutput {
	return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput)
}

func (e PrivateEndpointServiceConnectionStatus) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput)
}

func (e PrivateEndpointServiceConnectionStatus) ToStringPtrOutput() pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringPtrOutputWithContext(context.Background())
}

func (e PrivateEndpointServiceConnectionStatus) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx)
}

type PrivateEndpointServiceConnectionStatusOutput struct{ *pulumi.OutputState }

func (PrivateEndpointServiceConnectionStatusOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PrivateEndpointServiceConnectionStatus)(nil)).Elem()
}

func (o PrivateEndpointServiceConnectionStatusOutput) ToPrivateEndpointServiceConnectionStatusOutput() PrivateEndpointServiceConnectionStatusOutput {
	return o
}

func (o PrivateEndpointServiceConnectionStatusOutput) ToPrivateEndpointServiceConnectionStatusOutputWithContext(ctx context.Context) PrivateEndpointServiceConnectionStatusOutput {
	return o
}

func (o PrivateEndpointServiceConnectionStatusOutput) ToPrivateEndpointServiceConnectionStatusPtrOutput() PrivateEndpointServiceConnectionStatusPtrOutput {
	return o.ToPrivateEndpointServiceConnectionStatusPtrOutputWithContext(context.Background())
}

func (o PrivateEndpointServiceConnectionStatusOutput) ToPrivateEndpointServiceConnectionStatusPtrOutputWithContext(ctx context.Context) PrivateEndpointServiceConnectionStatusPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v PrivateEndpointServiceConnectionStatus) *PrivateEndpointServiceConnectionStatus {
		return &v
	}).(PrivateEndpointServiceConnectionStatusPtrOutput)
}

func (o PrivateEndpointServiceConnectionStatusOutput) ToStringOutput() pulumi.StringOutput {
	return o.ToStringOutputWithContext(context.Background())
}

func (o PrivateEndpointServiceConnectionStatusOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e PrivateEndpointServiceConnectionStatus) string {
		return string(e)
	}).(pulumi.StringOutput)
}

func (o PrivateEndpointServiceConnectionStatusOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o PrivateEndpointServiceConnectionStatusOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e PrivateEndpointServiceConnectionStatus) *string {
		v := string(e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type PrivateEndpointServiceConnectionStatusPtrOutput struct{ *pulumi.OutputState }

func (PrivateEndpointServiceConnectionStatusPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**PrivateEndpointServiceConnectionStatus)(nil)).Elem()
}

func (o PrivateEndpointServiceConnectionStatusPtrOutput) ToPrivateEndpointServiceConnectionStatusPtrOutput() PrivateEndpointServiceConnectionStatusPtrOutput {
	return o
}

func (o PrivateEndpointServiceConnectionStatusPtrOutput) ToPrivateEndpointServiceConnectionStatusPtrOutputWithContext(ctx context.Context) PrivateEndpointServiceConnectionStatusPtrOutput {
	return o
}

func (o PrivateEndpointServiceConnectionStatusPtrOutput) Elem() PrivateEndpointServiceConnectionStatusOutput {
	return o.ApplyT(func(v *PrivateEndpointServiceConnectionStatus) PrivateEndpointServiceConnectionStatus {
		if v != nil {
			return *v
		}
		var ret PrivateEndpointServiceConnectionStatus
		return ret
	}).(PrivateEndpointServiceConnectionStatusOutput)
}

func (o PrivateEndpointServiceConnectionStatusPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o PrivateEndpointServiceConnectionStatusPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e *PrivateEndpointServiceConnectionStatus) *string {
		if e == nil {
			return nil
		}
		v := string(*e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type PrivateEndpointServiceConnectionStatusInput interface {
	pulumi.Input

	ToPrivateEndpointServiceConnectionStatusOutput() PrivateEndpointServiceConnectionStatusOutput
	ToPrivateEndpointServiceConnectionStatusOutputWithContext(context.Context) PrivateEndpointServiceConnectionStatusOutput
}

var privateEndpointServiceConnectionStatusPtrType = reflect.TypeOf((**PrivateEndpointServiceConnectionStatus)(nil)).Elem()

type PrivateEndpointServiceConnectionStatusPtrInput interface {
	pulumi.Input

	ToPrivateEndpointServiceConnectionStatusPtrOutput() PrivateEndpointServiceConnectionStatusPtrOutput
	ToPrivateEndpointServiceConnectionStatusPtrOutputWithContext(context.Context) PrivateEndpointServiceConnectionStatusPtrOutput
}

type privateEndpointServiceConnectionStatusPtr string

func PrivateEndpointServiceConnectionStatusPtr(v string) PrivateEndpointServiceConnectionStatusPtrInput {
	return (*privateEndpointServiceConnectionStatusPtr)(&v)
}

func (*privateEndpointServiceConnectionStatusPtr) ElementType() reflect.Type {
	return privateEndpointServiceConnectionStatusPtrType
}

func (in *privateEndpointServiceConnectionStatusPtr) ToPrivateEndpointServiceConnectionStatusPtrOutput() PrivateEndpointServiceConnectionStatusPtrOutput {
	return pulumi.ToOutput(in).(PrivateEndpointServiceConnectionStatusPtrOutput)
}

func (in *privateEndpointServiceConnectionStatusPtr) ToPrivateEndpointServiceConnectionStatusPtrOutputWithContext(ctx context.Context) PrivateEndpointServiceConnectionStatusPtrOutput {
	return pulumi.ToOutputWithContext(ctx, in).(PrivateEndpointServiceConnectionStatusPtrOutput)
}

type ReferenceType string

const (
	ReferenceTypeId         = ReferenceType("Id")
	ReferenceTypeDataPath   = ReferenceType("DataPath")
	ReferenceTypeOutputPath = ReferenceType("OutputPath")
)

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

func (e ReferenceType) ToReferenceTypeOutput() ReferenceTypeOutput {
	return pulumi.ToOutput(e).(ReferenceTypeOutput)
}

func (e ReferenceType) ToReferenceTypeOutputWithContext(ctx context.Context) ReferenceTypeOutput {
	return pulumi.ToOutputWithContext(ctx, e).(ReferenceTypeOutput)
}

func (e ReferenceType) ToReferenceTypePtrOutput() ReferenceTypePtrOutput {
	return e.ToReferenceTypePtrOutputWithContext(context.Background())
}

func (e ReferenceType) ToReferenceTypePtrOutputWithContext(ctx context.Context) ReferenceTypePtrOutput {
	return ReferenceType(e).ToReferenceTypeOutputWithContext(ctx).ToReferenceTypePtrOutputWithContext(ctx)
}

func (e ReferenceType) ToStringOutput() pulumi.StringOutput {
	return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput)
}

func (e ReferenceType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput)
}

func (e ReferenceType) ToStringPtrOutput() pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringPtrOutputWithContext(context.Background())
}

func (e ReferenceType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx)
}

type ReferenceTypeOutput struct{ *pulumi.OutputState }

func (ReferenceTypeOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ReferenceType)(nil)).Elem()
}

func (o ReferenceTypeOutput) ToReferenceTypeOutput() ReferenceTypeOutput {
	return o
}

func (o ReferenceTypeOutput) ToReferenceTypeOutputWithContext(ctx context.Context) ReferenceTypeOutput {
	return o
}

func (o ReferenceTypeOutput) ToReferenceTypePtrOutput() ReferenceTypePtrOutput {
	return o.ToReferenceTypePtrOutputWithContext(context.Background())
}

func (o ReferenceTypeOutput) ToReferenceTypePtrOutputWithContext(ctx context.Context) ReferenceTypePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ReferenceType) *ReferenceType {
		return &v
	}).(ReferenceTypePtrOutput)
}

func (o ReferenceTypeOutput) ToStringOutput() pulumi.StringOutput {
	return o.ToStringOutputWithContext(context.Background())
}

func (o ReferenceTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e ReferenceType) string {
		return string(e)
	}).(pulumi.StringOutput)
}

func (o ReferenceTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o ReferenceTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e ReferenceType) *string {
		v := string(e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type ReferenceTypePtrOutput struct{ *pulumi.OutputState }

func (ReferenceTypePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ReferenceType)(nil)).Elem()
}

func (o ReferenceTypePtrOutput) ToReferenceTypePtrOutput() ReferenceTypePtrOutput {
	return o
}

func (o ReferenceTypePtrOutput) ToReferenceTypePtrOutputWithContext(ctx context.Context) ReferenceTypePtrOutput {
	return o
}

func (o ReferenceTypePtrOutput) Elem() ReferenceTypeOutput {
	return o.ApplyT(func(v *ReferenceType) ReferenceType {
		if v != nil {
			return *v
		}
		var ret ReferenceType
		return ret
	}).(ReferenceTypeOutput)
}

func (o ReferenceTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o ReferenceTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e *ReferenceType) *string {
		if e == nil {
			return nil
		}
		v := string(*e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type ReferenceTypeInput interface {
	pulumi.Input

	ToReferenceTypeOutput() ReferenceTypeOutput
	ToReferenceTypeOutputWithContext(context.Context) ReferenceTypeOutput
}

var referenceTypePtrType = reflect.TypeOf((**ReferenceType)(nil)).Elem()

type ReferenceTypePtrInput interface {
	pulumi.Input

	ToReferenceTypePtrOutput() ReferenceTypePtrOutput
	ToReferenceTypePtrOutputWithContext(context.Context) ReferenceTypePtrOutput
}

type referenceTypePtr string

func ReferenceTypePtr(v string) ReferenceTypePtrInput {
	return (*referenceTypePtr)(&v)
}

func (*referenceTypePtr) ElementType() reflect.Type {
	return referenceTypePtrType
}

func (in *referenceTypePtr) ToReferenceTypePtrOutput() ReferenceTypePtrOutput {
	return pulumi.ToOutput(in).(ReferenceTypePtrOutput)
}

func (in *referenceTypePtr) ToReferenceTypePtrOutputWithContext(ctx context.Context) ReferenceTypePtrOutput {
	return pulumi.ToOutputWithContext(ctx, in).(ReferenceTypePtrOutput)
}

type RemoteLoginPortPublicAccess string

const (
	RemoteLoginPortPublicAccessEnabled      = RemoteLoginPortPublicAccess("Enabled")
	RemoteLoginPortPublicAccessDisabled     = RemoteLoginPortPublicAccess("Disabled")
	RemoteLoginPortPublicAccessNotSpecified = RemoteLoginPortPublicAccess("NotSpecified")
)

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

func (e RemoteLoginPortPublicAccess) ToRemoteLoginPortPublicAccessOutput() RemoteLoginPortPublicAccessOutput {
	return pulumi.ToOutput(e).(RemoteLoginPortPublicAccessOutput)
}

func (e RemoteLoginPortPublicAccess) ToRemoteLoginPortPublicAccessOutputWithContext(ctx context.Context) RemoteLoginPortPublicAccessOutput {
	return pulumi.ToOutputWithContext(ctx, e).(RemoteLoginPortPublicAccessOutput)
}

func (e RemoteLoginPortPublicAccess) ToRemoteLoginPortPublicAccessPtrOutput() RemoteLoginPortPublicAccessPtrOutput {
	return e.ToRemoteLoginPortPublicAccessPtrOutputWithContext(context.Background())
}

func (e RemoteLoginPortPublicAccess) ToRemoteLoginPortPublicAccessPtrOutputWithContext(ctx context.Context) RemoteLoginPortPublicAccessPtrOutput {
	return RemoteLoginPortPublicAccess(e).ToRemoteLoginPortPublicAccessOutputWithContext(ctx).ToRemoteLoginPortPublicAccessPtrOutputWithContext(ctx)
}

func (e RemoteLoginPortPublicAccess) ToStringOutput() pulumi.StringOutput {
	return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput)
}

func (e RemoteLoginPortPublicAccess) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput)
}

func (e RemoteLoginPortPublicAccess) ToStringPtrOutput() pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringPtrOutputWithContext(context.Background())
}

func (e RemoteLoginPortPublicAccess) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx)
}

type RemoteLoginPortPublicAccessOutput struct{ *pulumi.OutputState }

func (RemoteLoginPortPublicAccessOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*RemoteLoginPortPublicAccess)(nil)).Elem()
}

func (o RemoteLoginPortPublicAccessOutput) ToRemoteLoginPortPublicAccessOutput() RemoteLoginPortPublicAccessOutput {
	return o
}

func (o RemoteLoginPortPublicAccessOutput) ToRemoteLoginPortPublicAccessOutputWithContext(ctx context.Context) RemoteLoginPortPublicAccessOutput {
	return o
}

func (o RemoteLoginPortPublicAccessOutput) ToRemoteLoginPortPublicAccessPtrOutput() RemoteLoginPortPublicAccessPtrOutput {
	return o.ToRemoteLoginPortPublicAccessPtrOutputWithContext(context.Background())
}

func (o RemoteLoginPortPublicAccessOutput) ToRemoteLoginPortPublicAccessPtrOutputWithContext(ctx context.Context) RemoteLoginPortPublicAccessPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v RemoteLoginPortPublicAccess) *RemoteLoginPortPublicAccess {
		return &v
	}).(RemoteLoginPortPublicAccessPtrOutput)
}

func (o RemoteLoginPortPublicAccessOutput) ToStringOutput() pulumi.StringOutput {
	return o.ToStringOutputWithContext(context.Background())
}

func (o RemoteLoginPortPublicAccessOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e RemoteLoginPortPublicAccess) string {
		return string(e)
	}).(pulumi.StringOutput)
}

func (o RemoteLoginPortPublicAccessOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o RemoteLoginPortPublicAccessOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e RemoteLoginPortPublicAccess) *string {
		v := string(e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type RemoteLoginPortPublicAccessPtrOutput struct{ *pulumi.OutputState }

func (RemoteLoginPortPublicAccessPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**RemoteLoginPortPublicAccess)(nil)).Elem()
}

func (o RemoteLoginPortPublicAccessPtrOutput) ToRemoteLoginPortPublicAccessPtrOutput() RemoteLoginPortPublicAccessPtrOutput {
	return o
}

func (o RemoteLoginPortPublicAccessPtrOutput) ToRemoteLoginPortPublicAccessPtrOutputWithContext(ctx context.Context) RemoteLoginPortPublicAccessPtrOutput {
	return o
}

func (o RemoteLoginPortPublicAccessPtrOutput) Elem() RemoteLoginPortPublicAccessOutput {
	return o.ApplyT(func(v *RemoteLoginPortPublicAccess) RemoteLoginPortPublicAccess {
		if v != nil {
			return *v
		}
		var ret RemoteLoginPortPublicAccess
		return ret
	}).(RemoteLoginPortPublicAccessOutput)
}

func (o RemoteLoginPortPublicAccessPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o RemoteLoginPortPublicAccessPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e *RemoteLoginPortPublicAccess) *string {
		if e == nil {
			return nil
		}
		v := string(*e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type RemoteLoginPortPublicAccessInput interface {
	pulumi.Input

	ToRemoteLoginPortPublicAccessOutput() RemoteLoginPortPublicAccessOutput
	ToRemoteLoginPortPublicAccessOutputWithContext(context.Context) RemoteLoginPortPublicAccessOutput
}

var remoteLoginPortPublicAccessPtrType = reflect.TypeOf((**RemoteLoginPortPublicAccess)(nil)).Elem()

type RemoteLoginPortPublicAccessPtrInput interface {
	pulumi.Input

	ToRemoteLoginPortPublicAccessPtrOutput() RemoteLoginPortPublicAccessPtrOutput
	ToRemoteLoginPortPublicAccessPtrOutputWithContext(context.Context) RemoteLoginPortPublicAccessPtrOutput
}

type remoteLoginPortPublicAccessPtr string

func RemoteLoginPortPublicAccessPtr(v string) RemoteLoginPortPublicAccessPtrInput {
	return (*remoteLoginPortPublicAccessPtr)(&v)
}

func (*remoteLoginPortPublicAccessPtr) ElementType() reflect.Type {
	return remoteLoginPortPublicAccessPtrType
}

func (in *remoteLoginPortPublicAccessPtr) ToRemoteLoginPortPublicAccessPtrOutput() RemoteLoginPortPublicAccessPtrOutput {
	return pulumi.ToOutput(in).(RemoteLoginPortPublicAccessPtrOutput)
}

func (in *remoteLoginPortPublicAccessPtr) ToRemoteLoginPortPublicAccessPtrOutputWithContext(ctx context.Context) RemoteLoginPortPublicAccessPtrOutput {
	return pulumi.ToOutputWithContext(ctx, in).(RemoteLoginPortPublicAccessPtrOutput)
}

type ResourceIdentityAssignment string

const (
	ResourceIdentityAssignmentSystemAssigned               = ResourceIdentityAssignment("SystemAssigned")
	ResourceIdentityAssignmentUserAssigned                 = ResourceIdentityAssignment("UserAssigned")
	ResourceIdentityAssignment_SystemAssigned_UserAssigned = ResourceIdentityAssignment("SystemAssigned,UserAssigned")
	ResourceIdentityAssignmentNone                         = ResourceIdentityAssignment("None")
)

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

func (e ResourceIdentityAssignment) ToResourceIdentityAssignmentOutput() ResourceIdentityAssignmentOutput {
	return pulumi.ToOutput(e).(ResourceIdentityAssignmentOutput)
}

func (e ResourceIdentityAssignment) ToResourceIdentityAssignmentOutputWithContext(ctx context.Context) ResourceIdentityAssignmentOutput {
	return pulumi.ToOutputWithContext(ctx, e).(ResourceIdentityAssignmentOutput)
}

func (e ResourceIdentityAssignment) ToResourceIdentityAssignmentPtrOutput() ResourceIdentityAssignmentPtrOutput {
	return e.ToResourceIdentityAssignmentPtrOutputWithContext(context.Background())
}

func (e ResourceIdentityAssignment) ToResourceIdentityAssignmentPtrOutputWithContext(ctx context.Context) ResourceIdentityAssignmentPtrOutput {
	return ResourceIdentityAssignment(e).ToResourceIdentityAssignmentOutputWithContext(ctx).ToResourceIdentityAssignmentPtrOutputWithContext(ctx)
}

func (e ResourceIdentityAssignment) ToStringOutput() pulumi.StringOutput {
	return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput)
}

func (e ResourceIdentityAssignment) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput)
}

func (e ResourceIdentityAssignment) ToStringPtrOutput() pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringPtrOutputWithContext(context.Background())
}

func (e ResourceIdentityAssignment) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx)
}

type ResourceIdentityAssignmentOutput struct{ *pulumi.OutputState }

func (ResourceIdentityAssignmentOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceIdentityAssignment)(nil)).Elem()
}

func (o ResourceIdentityAssignmentOutput) ToResourceIdentityAssignmentOutput() ResourceIdentityAssignmentOutput {
	return o
}

func (o ResourceIdentityAssignmentOutput) ToResourceIdentityAssignmentOutputWithContext(ctx context.Context) ResourceIdentityAssignmentOutput {
	return o
}

func (o ResourceIdentityAssignmentOutput) ToResourceIdentityAssignmentPtrOutput() ResourceIdentityAssignmentPtrOutput {
	return o.ToResourceIdentityAssignmentPtrOutputWithContext(context.Background())
}

func (o ResourceIdentityAssignmentOutput) ToResourceIdentityAssignmentPtrOutputWithContext(ctx context.Context) ResourceIdentityAssignmentPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ResourceIdentityAssignment) *ResourceIdentityAssignment {
		return &v
	}).(ResourceIdentityAssignmentPtrOutput)
}

func (o ResourceIdentityAssignmentOutput) ToStringOutput() pulumi.StringOutput {
	return o.ToStringOutputWithContext(context.Background())
}

func (o ResourceIdentityAssignmentOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e ResourceIdentityAssignment) string {
		return string(e)
	}).(pulumi.StringOutput)
}

func (o ResourceIdentityAssignmentOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o ResourceIdentityAssignmentOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e ResourceIdentityAssignment) *string {
		v := string(e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type ResourceIdentityAssignmentPtrOutput struct{ *pulumi.OutputState }

func (ResourceIdentityAssignmentPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceIdentityAssignment)(nil)).Elem()
}

func (o ResourceIdentityAssignmentPtrOutput) ToResourceIdentityAssignmentPtrOutput() ResourceIdentityAssignmentPtrOutput {
	return o
}

func (o ResourceIdentityAssignmentPtrOutput) ToResourceIdentityAssignmentPtrOutputWithContext(ctx context.Context) ResourceIdentityAssignmentPtrOutput {
	return o
}

func (o ResourceIdentityAssignmentPtrOutput) Elem() ResourceIdentityAssignmentOutput {
	return o.ApplyT(func(v *ResourceIdentityAssignment) ResourceIdentityAssignment {
		if v != nil {
			return *v
		}
		var ret ResourceIdentityAssignment
		return ret
	}).(ResourceIdentityAssignmentOutput)
}

func (o ResourceIdentityAssignmentPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o ResourceIdentityAssignmentPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e *ResourceIdentityAssignment) *string {
		if e == nil {
			return nil
		}
		v := string(*e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type ResourceIdentityAssignmentInput interface {
	pulumi.Input

	ToResourceIdentityAssignmentOutput() ResourceIdentityAssignmentOutput
	ToResourceIdentityAssignmentOutputWithContext(context.Context) ResourceIdentityAssignmentOutput
}

var resourceIdentityAssignmentPtrType = reflect.TypeOf((**ResourceIdentityAssignment)(nil)).Elem()

type ResourceIdentityAssignmentPtrInput interface {
	pulumi.Input

	ToResourceIdentityAssignmentPtrOutput() ResourceIdentityAssignmentPtrOutput
	ToResourceIdentityAssignmentPtrOutputWithContext(context.Context) ResourceIdentityAssignmentPtrOutput
}

type resourceIdentityAssignmentPtr string

func ResourceIdentityAssignmentPtr(v string) ResourceIdentityAssignmentPtrInput {
	return (*resourceIdentityAssignmentPtr)(&v)
}

func (*resourceIdentityAssignmentPtr) ElementType() reflect.Type {
	return resourceIdentityAssignmentPtrType
}

func (in *resourceIdentityAssignmentPtr) ToResourceIdentityAssignmentPtrOutput() ResourceIdentityAssignmentPtrOutput {
	return pulumi.ToOutput(in).(ResourceIdentityAssignmentPtrOutput)
}

func (in *resourceIdentityAssignmentPtr) ToResourceIdentityAssignmentPtrOutputWithContext(ctx context.Context) ResourceIdentityAssignmentPtrOutput {
	return pulumi.ToOutputWithContext(ctx, in).(ResourceIdentityAssignmentPtrOutput)
}

type ResourceIdentityType string

const (
	ResourceIdentityTypeSystemAssigned               = ResourceIdentityType("SystemAssigned")
	ResourceIdentityType_SystemAssigned_UserAssigned = ResourceIdentityType("SystemAssigned,UserAssigned")
	ResourceIdentityTypeUserAssigned                 = ResourceIdentityType("UserAssigned")
	ResourceIdentityTypeNone                         = ResourceIdentityType("None")
)

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

func (e ResourceIdentityType) ToResourceIdentityTypeOutput() ResourceIdentityTypeOutput {
	return pulumi.ToOutput(e).(ResourceIdentityTypeOutput)
}

func (e ResourceIdentityType) ToResourceIdentityTypeOutputWithContext(ctx context.Context) ResourceIdentityTypeOutput {
	return pulumi.ToOutputWithContext(ctx, e).(ResourceIdentityTypeOutput)
}

func (e ResourceIdentityType) ToResourceIdentityTypePtrOutput() ResourceIdentityTypePtrOutput {
	return e.ToResourceIdentityTypePtrOutputWithContext(context.Background())
}

func (e ResourceIdentityType) ToResourceIdentityTypePtrOutputWithContext(ctx context.Context) ResourceIdentityTypePtrOutput {
	return ResourceIdentityType(e).ToResourceIdentityTypeOutputWithContext(ctx).ToResourceIdentityTypePtrOutputWithContext(ctx)
}

func (e ResourceIdentityType) ToStringOutput() pulumi.StringOutput {
	return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput)
}

func (e ResourceIdentityType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput)
}

func (e ResourceIdentityType) ToStringPtrOutput() pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringPtrOutputWithContext(context.Background())
}

func (e ResourceIdentityType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx)
}

type ResourceIdentityTypeOutput struct{ *pulumi.OutputState }

func (ResourceIdentityTypeOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceIdentityType)(nil)).Elem()
}

func (o ResourceIdentityTypeOutput) ToResourceIdentityTypeOutput() ResourceIdentityTypeOutput {
	return o
}

func (o ResourceIdentityTypeOutput) ToResourceIdentityTypeOutputWithContext(ctx context.Context) ResourceIdentityTypeOutput {
	return o
}

func (o ResourceIdentityTypeOutput) ToResourceIdentityTypePtrOutput() ResourceIdentityTypePtrOutput {
	return o.ToResourceIdentityTypePtrOutputWithContext(context.Background())
}

func (o ResourceIdentityTypeOutput) ToResourceIdentityTypePtrOutputWithContext(ctx context.Context) ResourceIdentityTypePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ResourceIdentityType) *ResourceIdentityType {
		return &v
	}).(ResourceIdentityTypePtrOutput)
}

func (o ResourceIdentityTypeOutput) ToStringOutput() pulumi.StringOutput {
	return o.ToStringOutputWithContext(context.Background())
}

func (o ResourceIdentityTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e ResourceIdentityType) string {
		return string(e)
	}).(pulumi.StringOutput)
}

func (o ResourceIdentityTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o ResourceIdentityTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e ResourceIdentityType) *string {
		v := string(e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type ResourceIdentityTypePtrOutput struct{ *pulumi.OutputState }

func (ResourceIdentityTypePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceIdentityType)(nil)).Elem()
}

func (o ResourceIdentityTypePtrOutput) ToResourceIdentityTypePtrOutput() ResourceIdentityTypePtrOutput {
	return o
}

func (o ResourceIdentityTypePtrOutput) ToResourceIdentityTypePtrOutputWithContext(ctx context.Context) ResourceIdentityTypePtrOutput {
	return o
}

func (o ResourceIdentityTypePtrOutput) Elem() ResourceIdentityTypeOutput {
	return o.ApplyT(func(v *ResourceIdentityType) ResourceIdentityType {
		if v != nil {
			return *v
		}
		var ret ResourceIdentityType
		return ret
	}).(ResourceIdentityTypeOutput)
}

func (o ResourceIdentityTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o ResourceIdentityTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e *ResourceIdentityType) *string {
		if e == nil {
			return nil
		}
		v := string(*e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type ResourceIdentityTypeInput interface {
	pulumi.Input

	ToResourceIdentityTypeOutput() ResourceIdentityTypeOutput
	ToResourceIdentityTypeOutputWithContext(context.Context) ResourceIdentityTypeOutput
}

var resourceIdentityTypePtrType = reflect.TypeOf((**ResourceIdentityType)(nil)).Elem()

type ResourceIdentityTypePtrInput interface {
	pulumi.Input

	ToResourceIdentityTypePtrOutput() ResourceIdentityTypePtrOutput
	ToResourceIdentityTypePtrOutputWithContext(context.Context) ResourceIdentityTypePtrOutput
}

type resourceIdentityTypePtr string

func ResourceIdentityTypePtr(v string) ResourceIdentityTypePtrInput {
	return (*resourceIdentityTypePtr)(&v)
}

func (*resourceIdentityTypePtr) ElementType() reflect.Type {
	return resourceIdentityTypePtrType
}

func (in *resourceIdentityTypePtr) ToResourceIdentityTypePtrOutput() ResourceIdentityTypePtrOutput {
	return pulumi.ToOutput(in).(ResourceIdentityTypePtrOutput)
}

func (in *resourceIdentityTypePtr) ToResourceIdentityTypePtrOutputWithContext(ctx context.Context) ResourceIdentityTypePtrOutput {
	return pulumi.ToOutputWithContext(ctx, in).(ResourceIdentityTypePtrOutput)
}

type SamplingAlgorithm string

const (
	SamplingAlgorithmGrid     = SamplingAlgorithm("Grid")
	SamplingAlgorithmRandom   = SamplingAlgorithm("Random")
	SamplingAlgorithmBayesian = SamplingAlgorithm("Bayesian")
)

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

func (e SamplingAlgorithm) ToSamplingAlgorithmOutput() SamplingAlgorithmOutput {
	return pulumi.ToOutput(e).(SamplingAlgorithmOutput)
}

func (e SamplingAlgorithm) ToSamplingAlgorithmOutputWithContext(ctx context.Context) SamplingAlgorithmOutput {
	return pulumi.ToOutputWithContext(ctx, e).(SamplingAlgorithmOutput)
}

func (e SamplingAlgorithm) ToSamplingAlgorithmPtrOutput() SamplingAlgorithmPtrOutput {
	return e.ToSamplingAlgorithmPtrOutputWithContext(context.Background())
}

func (e SamplingAlgorithm) ToSamplingAlgorithmPtrOutputWithContext(ctx context.Context) SamplingAlgorithmPtrOutput {
	return SamplingAlgorithm(e).ToSamplingAlgorithmOutputWithContext(ctx).ToSamplingAlgorithmPtrOutputWithContext(ctx)
}

func (e SamplingAlgorithm) ToStringOutput() pulumi.StringOutput {
	return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput)
}

func (e SamplingAlgorithm) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput)
}

func (e SamplingAlgorithm) ToStringPtrOutput() pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringPtrOutputWithContext(context.Background())
}

func (e SamplingAlgorithm) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx)
}

type SamplingAlgorithmOutput struct{ *pulumi.OutputState }

func (SamplingAlgorithmOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SamplingAlgorithm)(nil)).Elem()
}

func (o SamplingAlgorithmOutput) ToSamplingAlgorithmOutput() SamplingAlgorithmOutput {
	return o
}

func (o SamplingAlgorithmOutput) ToSamplingAlgorithmOutputWithContext(ctx context.Context) SamplingAlgorithmOutput {
	return o
}

func (o SamplingAlgorithmOutput) ToSamplingAlgorithmPtrOutput() SamplingAlgorithmPtrOutput {
	return o.ToSamplingAlgorithmPtrOutputWithContext(context.Background())
}

func (o SamplingAlgorithmOutput) ToSamplingAlgorithmPtrOutputWithContext(ctx context.Context) SamplingAlgorithmPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v SamplingAlgorithm) *SamplingAlgorithm {
		return &v
	}).(SamplingAlgorithmPtrOutput)
}

func (o SamplingAlgorithmOutput) ToStringOutput() pulumi.StringOutput {
	return o.ToStringOutputWithContext(context.Background())
}

func (o SamplingAlgorithmOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e SamplingAlgorithm) string {
		return string(e)
	}).(pulumi.StringOutput)
}

func (o SamplingAlgorithmOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o SamplingAlgorithmOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e SamplingAlgorithm) *string {
		v := string(e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type SamplingAlgorithmPtrOutput struct{ *pulumi.OutputState }

func (SamplingAlgorithmPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**SamplingAlgorithm)(nil)).Elem()
}

func (o SamplingAlgorithmPtrOutput) ToSamplingAlgorithmPtrOutput() SamplingAlgorithmPtrOutput {
	return o
}

func (o SamplingAlgorithmPtrOutput) ToSamplingAlgorithmPtrOutputWithContext(ctx context.Context) SamplingAlgorithmPtrOutput {
	return o
}

func (o SamplingAlgorithmPtrOutput) Elem() SamplingAlgorithmOutput {
	return o.ApplyT(func(v *SamplingAlgorithm) SamplingAlgorithm {
		if v != nil {
			return *v
		}
		var ret SamplingAlgorithm
		return ret
	}).(SamplingAlgorithmOutput)
}

func (o SamplingAlgorithmPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o SamplingAlgorithmPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e *SamplingAlgorithm) *string {
		if e == nil {
			return nil
		}
		v := string(*e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type SamplingAlgorithmInput interface {
	pulumi.Input

	ToSamplingAlgorithmOutput() SamplingAlgorithmOutput
	ToSamplingAlgorithmOutputWithContext(context.Context) SamplingAlgorithmOutput
}

var samplingAlgorithmPtrType = reflect.TypeOf((**SamplingAlgorithm)(nil)).Elem()

type SamplingAlgorithmPtrInput interface {
	pulumi.Input

	ToSamplingAlgorithmPtrOutput() SamplingAlgorithmPtrOutput
	ToSamplingAlgorithmPtrOutputWithContext(context.Context) SamplingAlgorithmPtrOutput
}

type samplingAlgorithmPtr string

func SamplingAlgorithmPtr(v string) SamplingAlgorithmPtrInput {
	return (*samplingAlgorithmPtr)(&v)
}

func (*samplingAlgorithmPtr) ElementType() reflect.Type {
	return samplingAlgorithmPtrType
}

func (in *samplingAlgorithmPtr) ToSamplingAlgorithmPtrOutput() SamplingAlgorithmPtrOutput {
	return pulumi.ToOutput(in).(SamplingAlgorithmPtrOutput)
}

func (in *samplingAlgorithmPtr) ToSamplingAlgorithmPtrOutputWithContext(ctx context.Context) SamplingAlgorithmPtrOutput {
	return pulumi.ToOutputWithContext(ctx, in).(SamplingAlgorithmPtrOutput)
}

type ScaleType string

const (
	ScaleTypeAuto   = ScaleType("Auto")
	ScaleTypeManual = ScaleType("Manual")
)

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

func (e ScaleType) ToScaleTypeOutput() ScaleTypeOutput {
	return pulumi.ToOutput(e).(ScaleTypeOutput)
}

func (e ScaleType) ToScaleTypeOutputWithContext(ctx context.Context) ScaleTypeOutput {
	return pulumi.ToOutputWithContext(ctx, e).(ScaleTypeOutput)
}

func (e ScaleType) ToScaleTypePtrOutput() ScaleTypePtrOutput {
	return e.ToScaleTypePtrOutputWithContext(context.Background())
}

func (e ScaleType) ToScaleTypePtrOutputWithContext(ctx context.Context) ScaleTypePtrOutput {
	return ScaleType(e).ToScaleTypeOutputWithContext(ctx).ToScaleTypePtrOutputWithContext(ctx)
}

func (e ScaleType) ToStringOutput() pulumi.StringOutput {
	return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput)
}

func (e ScaleType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput)
}

func (e ScaleType) ToStringPtrOutput() pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringPtrOutputWithContext(context.Background())
}

func (e ScaleType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx)
}

type ScaleTypeOutput struct{ *pulumi.OutputState }

func (ScaleTypeOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ScaleType)(nil)).Elem()
}

func (o ScaleTypeOutput) ToScaleTypeOutput() ScaleTypeOutput {
	return o
}

func (o ScaleTypeOutput) ToScaleTypeOutputWithContext(ctx context.Context) ScaleTypeOutput {
	return o
}

func (o ScaleTypeOutput) ToScaleTypePtrOutput() ScaleTypePtrOutput {
	return o.ToScaleTypePtrOutputWithContext(context.Background())
}

func (o ScaleTypeOutput) ToScaleTypePtrOutputWithContext(ctx context.Context) ScaleTypePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ScaleType) *ScaleType {
		return &v
	}).(ScaleTypePtrOutput)
}

func (o ScaleTypeOutput) ToStringOutput() pulumi.StringOutput {
	return o.ToStringOutputWithContext(context.Background())
}

func (o ScaleTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e ScaleType) string {
		return string(e)
	}).(pulumi.StringOutput)
}

func (o ScaleTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o ScaleTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e ScaleType) *string {
		v := string(e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type ScaleTypePtrOutput struct{ *pulumi.OutputState }

func (ScaleTypePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ScaleType)(nil)).Elem()
}

func (o ScaleTypePtrOutput) ToScaleTypePtrOutput() ScaleTypePtrOutput {
	return o
}

func (o ScaleTypePtrOutput) ToScaleTypePtrOutputWithContext(ctx context.Context) ScaleTypePtrOutput {
	return o
}

func (o ScaleTypePtrOutput) Elem() ScaleTypeOutput {
	return o.ApplyT(func(v *ScaleType) ScaleType {
		if v != nil {
			return *v
		}
		var ret ScaleType
		return ret
	}).(ScaleTypeOutput)
}

func (o ScaleTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o ScaleTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e *ScaleType) *string {
		if e == nil {
			return nil
		}
		v := string(*e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type ScaleTypeInput interface {
	pulumi.Input

	ToScaleTypeOutput() ScaleTypeOutput
	ToScaleTypeOutputWithContext(context.Context) ScaleTypeOutput
}

var scaleTypePtrType = reflect.TypeOf((**ScaleType)(nil)).Elem()

type ScaleTypePtrInput interface {
	pulumi.Input

	ToScaleTypePtrOutput() ScaleTypePtrOutput
	ToScaleTypePtrOutputWithContext(context.Context) ScaleTypePtrOutput
}

type scaleTypePtr string

func ScaleTypePtr(v string) ScaleTypePtrInput {
	return (*scaleTypePtr)(&v)
}

func (*scaleTypePtr) ElementType() reflect.Type {
	return scaleTypePtrType
}

func (in *scaleTypePtr) ToScaleTypePtrOutput() ScaleTypePtrOutput {
	return pulumi.ToOutput(in).(ScaleTypePtrOutput)
}

func (in *scaleTypePtr) ToScaleTypePtrOutputWithContext(ctx context.Context) ScaleTypePtrOutput {
	return pulumi.ToOutputWithContext(ctx, in).(ScaleTypePtrOutput)
}

type SourceType string

const (
	SourceType_Delimited_files  = SourceType("delimited_files")
	SourceType_Json_lines_files = SourceType("json_lines_files")
	SourceType_Parquet_files    = SourceType("parquet_files")
)

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

func (e SourceType) ToSourceTypeOutput() SourceTypeOutput {
	return pulumi.ToOutput(e).(SourceTypeOutput)
}

func (e SourceType) ToSourceTypeOutputWithContext(ctx context.Context) SourceTypeOutput {
	return pulumi.ToOutputWithContext(ctx, e).(SourceTypeOutput)
}

func (e SourceType) ToSourceTypePtrOutput() SourceTypePtrOutput {
	return e.ToSourceTypePtrOutputWithContext(context.Background())
}

func (e SourceType) ToSourceTypePtrOutputWithContext(ctx context.Context) SourceTypePtrOutput {
	return SourceType(e).ToSourceTypeOutputWithContext(ctx).ToSourceTypePtrOutputWithContext(ctx)
}

func (e SourceType) ToStringOutput() pulumi.StringOutput {
	return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput)
}

func (e SourceType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput)
}

func (e SourceType) ToStringPtrOutput() pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringPtrOutputWithContext(context.Background())
}

func (e SourceType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx)
}

type SourceTypeOutput struct{ *pulumi.OutputState }

func (SourceTypeOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SourceType)(nil)).Elem()
}

func (o SourceTypeOutput) ToSourceTypeOutput() SourceTypeOutput {
	return o
}

func (o SourceTypeOutput) ToSourceTypeOutputWithContext(ctx context.Context) SourceTypeOutput {
	return o
}

func (o SourceTypeOutput) ToSourceTypePtrOutput() SourceTypePtrOutput {
	return o.ToSourceTypePtrOutputWithContext(context.Background())
}

func (o SourceTypeOutput) ToSourceTypePtrOutputWithContext(ctx context.Context) SourceTypePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v SourceType) *SourceType {
		return &v
	}).(SourceTypePtrOutput)
}

func (o SourceTypeOutput) ToStringOutput() pulumi.StringOutput {
	return o.ToStringOutputWithContext(context.Background())
}

func (o SourceTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e SourceType) string {
		return string(e)
	}).(pulumi.StringOutput)
}

func (o SourceTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o SourceTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e SourceType) *string {
		v := string(e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type SourceTypePtrOutput struct{ *pulumi.OutputState }

func (SourceTypePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**SourceType)(nil)).Elem()
}

func (o SourceTypePtrOutput) ToSourceTypePtrOutput() SourceTypePtrOutput {
	return o
}

func (o SourceTypePtrOutput) ToSourceTypePtrOutputWithContext(ctx context.Context) SourceTypePtrOutput {
	return o
}

func (o SourceTypePtrOutput) Elem() SourceTypeOutput {
	return o.ApplyT(func(v *SourceType) SourceType {
		if v != nil {
			return *v
		}
		var ret SourceType
		return ret
	}).(SourceTypeOutput)
}

func (o SourceTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o SourceTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e *SourceType) *string {
		if e == nil {
			return nil
		}
		v := string(*e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type SourceTypeInput interface {
	pulumi.Input

	ToSourceTypeOutput() SourceTypeOutput
	ToSourceTypeOutputWithContext(context.Context) SourceTypeOutput
}

var sourceTypePtrType = reflect.TypeOf((**SourceType)(nil)).Elem()

type SourceTypePtrInput interface {
	pulumi.Input

	ToSourceTypePtrOutput() SourceTypePtrOutput
	ToSourceTypePtrOutputWithContext(context.Context) SourceTypePtrOutput
}

type sourceTypePtr string

func SourceTypePtr(v string) SourceTypePtrInput {
	return (*sourceTypePtr)(&v)
}

func (*sourceTypePtr) ElementType() reflect.Type {
	return sourceTypePtrType
}

func (in *sourceTypePtr) ToSourceTypePtrOutput() SourceTypePtrOutput {
	return pulumi.ToOutput(in).(SourceTypePtrOutput)
}

func (in *sourceTypePtr) ToSourceTypePtrOutputWithContext(ctx context.Context) SourceTypePtrOutput {
	return pulumi.ToOutputWithContext(ctx, in).(SourceTypePtrOutput)
}

type SshPublicAccess string

const (
	SshPublicAccessEnabled  = SshPublicAccess("Enabled")
	SshPublicAccessDisabled = SshPublicAccess("Disabled")
)

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

func (e SshPublicAccess) ToSshPublicAccessOutput() SshPublicAccessOutput {
	return pulumi.ToOutput(e).(SshPublicAccessOutput)
}

func (e SshPublicAccess) ToSshPublicAccessOutputWithContext(ctx context.Context) SshPublicAccessOutput {
	return pulumi.ToOutputWithContext(ctx, e).(SshPublicAccessOutput)
}

func (e SshPublicAccess) ToSshPublicAccessPtrOutput() SshPublicAccessPtrOutput {
	return e.ToSshPublicAccessPtrOutputWithContext(context.Background())
}

func (e SshPublicAccess) ToSshPublicAccessPtrOutputWithContext(ctx context.Context) SshPublicAccessPtrOutput {
	return SshPublicAccess(e).ToSshPublicAccessOutputWithContext(ctx).ToSshPublicAccessPtrOutputWithContext(ctx)
}

func (e SshPublicAccess) ToStringOutput() pulumi.StringOutput {
	return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput)
}

func (e SshPublicAccess) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput)
}

func (e SshPublicAccess) ToStringPtrOutput() pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringPtrOutputWithContext(context.Background())
}

func (e SshPublicAccess) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx)
}

type SshPublicAccessOutput struct{ *pulumi.OutputState }

func (SshPublicAccessOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*SshPublicAccess)(nil)).Elem()
}

func (o SshPublicAccessOutput) ToSshPublicAccessOutput() SshPublicAccessOutput {
	return o
}

func (o SshPublicAccessOutput) ToSshPublicAccessOutputWithContext(ctx context.Context) SshPublicAccessOutput {
	return o
}

func (o SshPublicAccessOutput) ToSshPublicAccessPtrOutput() SshPublicAccessPtrOutput {
	return o.ToSshPublicAccessPtrOutputWithContext(context.Background())
}

func (o SshPublicAccessOutput) ToSshPublicAccessPtrOutputWithContext(ctx context.Context) SshPublicAccessPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v SshPublicAccess) *SshPublicAccess {
		return &v
	}).(SshPublicAccessPtrOutput)
}

func (o SshPublicAccessOutput) ToStringOutput() pulumi.StringOutput {
	return o.ToStringOutputWithContext(context.Background())
}

func (o SshPublicAccessOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e SshPublicAccess) string {
		return string(e)
	}).(pulumi.StringOutput)
}

func (o SshPublicAccessOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o SshPublicAccessOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e SshPublicAccess) *string {
		v := string(e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type SshPublicAccessPtrOutput struct{ *pulumi.OutputState }

func (SshPublicAccessPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**SshPublicAccess)(nil)).Elem()
}

func (o SshPublicAccessPtrOutput) ToSshPublicAccessPtrOutput() SshPublicAccessPtrOutput {
	return o
}

func (o SshPublicAccessPtrOutput) ToSshPublicAccessPtrOutputWithContext(ctx context.Context) SshPublicAccessPtrOutput {
	return o
}

func (o SshPublicAccessPtrOutput) Elem() SshPublicAccessOutput {
	return o.ApplyT(func(v *SshPublicAccess) SshPublicAccess {
		if v != nil {
			return *v
		}
		var ret SshPublicAccess
		return ret
	}).(SshPublicAccessOutput)
}

func (o SshPublicAccessPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o SshPublicAccessPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e *SshPublicAccess) *string {
		if e == nil {
			return nil
		}
		v := string(*e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type SshPublicAccessInput interface {
	pulumi.Input

	ToSshPublicAccessOutput() SshPublicAccessOutput
	ToSshPublicAccessOutputWithContext(context.Context) SshPublicAccessOutput
}

var sshPublicAccessPtrType = reflect.TypeOf((**SshPublicAccess)(nil)).Elem()

type SshPublicAccessPtrInput interface {
	pulumi.Input

	ToSshPublicAccessPtrOutput() SshPublicAccessPtrOutput
	ToSshPublicAccessPtrOutputWithContext(context.Context) SshPublicAccessPtrOutput
}

type sshPublicAccessPtr string

func SshPublicAccessPtr(v string) SshPublicAccessPtrInput {
	return (*sshPublicAccessPtr)(&v)
}

func (*sshPublicAccessPtr) ElementType() reflect.Type {
	return sshPublicAccessPtrType
}

func (in *sshPublicAccessPtr) ToSshPublicAccessPtrOutput() SshPublicAccessPtrOutput {
	return pulumi.ToOutput(in).(SshPublicAccessPtrOutput)
}

func (in *sshPublicAccessPtr) ToSshPublicAccessPtrOutputWithContext(ctx context.Context) SshPublicAccessPtrOutput {
	return pulumi.ToOutputWithContext(ctx, in).(SshPublicAccessPtrOutput)
}

type ValueFormat string

const (
	ValueFormatJSON = ValueFormat("JSON")
)

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

func (e ValueFormat) ToValueFormatOutput() ValueFormatOutput {
	return pulumi.ToOutput(e).(ValueFormatOutput)
}

func (e ValueFormat) ToValueFormatOutputWithContext(ctx context.Context) ValueFormatOutput {
	return pulumi.ToOutputWithContext(ctx, e).(ValueFormatOutput)
}

func (e ValueFormat) ToValueFormatPtrOutput() ValueFormatPtrOutput {
	return e.ToValueFormatPtrOutputWithContext(context.Background())
}

func (e ValueFormat) ToValueFormatPtrOutputWithContext(ctx context.Context) ValueFormatPtrOutput {
	return ValueFormat(e).ToValueFormatOutputWithContext(ctx).ToValueFormatPtrOutputWithContext(ctx)
}

func (e ValueFormat) ToStringOutput() pulumi.StringOutput {
	return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput)
}

func (e ValueFormat) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput)
}

func (e ValueFormat) ToStringPtrOutput() pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringPtrOutputWithContext(context.Background())
}

func (e ValueFormat) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx)
}

type ValueFormatOutput struct{ *pulumi.OutputState }

func (ValueFormatOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ValueFormat)(nil)).Elem()
}

func (o ValueFormatOutput) ToValueFormatOutput() ValueFormatOutput {
	return o
}

func (o ValueFormatOutput) ToValueFormatOutputWithContext(ctx context.Context) ValueFormatOutput {
	return o
}

func (o ValueFormatOutput) ToValueFormatPtrOutput() ValueFormatPtrOutput {
	return o.ToValueFormatPtrOutputWithContext(context.Background())
}

func (o ValueFormatOutput) ToValueFormatPtrOutputWithContext(ctx context.Context) ValueFormatPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ValueFormat) *ValueFormat {
		return &v
	}).(ValueFormatPtrOutput)
}

func (o ValueFormatOutput) ToStringOutput() pulumi.StringOutput {
	return o.ToStringOutputWithContext(context.Background())
}

func (o ValueFormatOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e ValueFormat) string {
		return string(e)
	}).(pulumi.StringOutput)
}

func (o ValueFormatOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o ValueFormatOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e ValueFormat) *string {
		v := string(e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type ValueFormatPtrOutput struct{ *pulumi.OutputState }

func (ValueFormatPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ValueFormat)(nil)).Elem()
}

func (o ValueFormatPtrOutput) ToValueFormatPtrOutput() ValueFormatPtrOutput {
	return o
}

func (o ValueFormatPtrOutput) ToValueFormatPtrOutputWithContext(ctx context.Context) ValueFormatPtrOutput {
	return o
}

func (o ValueFormatPtrOutput) Elem() ValueFormatOutput {
	return o.ApplyT(func(v *ValueFormat) ValueFormat {
		if v != nil {
			return *v
		}
		var ret ValueFormat
		return ret
	}).(ValueFormatOutput)
}

func (o ValueFormatPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o ValueFormatPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e *ValueFormat) *string {
		if e == nil {
			return nil
		}
		v := string(*e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type ValueFormatInput interface {
	pulumi.Input

	ToValueFormatOutput() ValueFormatOutput
	ToValueFormatOutputWithContext(context.Context) ValueFormatOutput
}

var valueFormatPtrType = reflect.TypeOf((**ValueFormat)(nil)).Elem()

type ValueFormatPtrInput interface {
	pulumi.Input

	ToValueFormatPtrOutput() ValueFormatPtrOutput
	ToValueFormatPtrOutputWithContext(context.Context) ValueFormatPtrOutput
}

type valueFormatPtr string

func ValueFormatPtr(v string) ValueFormatPtrInput {
	return (*valueFormatPtr)(&v)
}

func (*valueFormatPtr) ElementType() reflect.Type {
	return valueFormatPtrType
}

func (in *valueFormatPtr) ToValueFormatPtrOutput() ValueFormatPtrOutput {
	return pulumi.ToOutput(in).(ValueFormatPtrOutput)
}

func (in *valueFormatPtr) ToValueFormatPtrOutputWithContext(ctx context.Context) ValueFormatPtrOutput {
	return pulumi.ToOutputWithContext(ctx, in).(ValueFormatPtrOutput)
}

type VariantType string

const (
	VariantTypeControl   = VariantType("Control")
	VariantTypeTreatment = VariantType("Treatment")
)

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

func (e VariantType) ToVariantTypeOutput() VariantTypeOutput {
	return pulumi.ToOutput(e).(VariantTypeOutput)
}

func (e VariantType) ToVariantTypeOutputWithContext(ctx context.Context) VariantTypeOutput {
	return pulumi.ToOutputWithContext(ctx, e).(VariantTypeOutput)
}

func (e VariantType) ToVariantTypePtrOutput() VariantTypePtrOutput {
	return e.ToVariantTypePtrOutputWithContext(context.Background())
}

func (e VariantType) ToVariantTypePtrOutputWithContext(ctx context.Context) VariantTypePtrOutput {
	return VariantType(e).ToVariantTypeOutputWithContext(ctx).ToVariantTypePtrOutputWithContext(ctx)
}

func (e VariantType) ToStringOutput() pulumi.StringOutput {
	return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput)
}

func (e VariantType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput)
}

func (e VariantType) ToStringPtrOutput() pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringPtrOutputWithContext(context.Background())
}

func (e VariantType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx)
}

type VariantTypeOutput struct{ *pulumi.OutputState }

func (VariantTypeOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*VariantType)(nil)).Elem()
}

func (o VariantTypeOutput) ToVariantTypeOutput() VariantTypeOutput {
	return o
}

func (o VariantTypeOutput) ToVariantTypeOutputWithContext(ctx context.Context) VariantTypeOutput {
	return o
}

func (o VariantTypeOutput) ToVariantTypePtrOutput() VariantTypePtrOutput {
	return o.ToVariantTypePtrOutputWithContext(context.Background())
}

func (o VariantTypeOutput) ToVariantTypePtrOutputWithContext(ctx context.Context) VariantTypePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v VariantType) *VariantType {
		return &v
	}).(VariantTypePtrOutput)
}

func (o VariantTypeOutput) ToStringOutput() pulumi.StringOutput {
	return o.ToStringOutputWithContext(context.Background())
}

func (o VariantTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e VariantType) string {
		return string(e)
	}).(pulumi.StringOutput)
}

func (o VariantTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o VariantTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e VariantType) *string {
		v := string(e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type VariantTypePtrOutput struct{ *pulumi.OutputState }

func (VariantTypePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**VariantType)(nil)).Elem()
}

func (o VariantTypePtrOutput) ToVariantTypePtrOutput() VariantTypePtrOutput {
	return o
}

func (o VariantTypePtrOutput) ToVariantTypePtrOutputWithContext(ctx context.Context) VariantTypePtrOutput {
	return o
}

func (o VariantTypePtrOutput) Elem() VariantTypeOutput {
	return o.ApplyT(func(v *VariantType) VariantType {
		if v != nil {
			return *v
		}
		var ret VariantType
		return ret
	}).(VariantTypeOutput)
}

func (o VariantTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o VariantTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e *VariantType) *string {
		if e == nil {
			return nil
		}
		v := string(*e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type VariantTypeInput interface {
	pulumi.Input

	ToVariantTypeOutput() VariantTypeOutput
	ToVariantTypeOutputWithContext(context.Context) VariantTypeOutput
}

var variantTypePtrType = reflect.TypeOf((**VariantType)(nil)).Elem()

type VariantTypePtrInput interface {
	pulumi.Input

	ToVariantTypePtrOutput() VariantTypePtrOutput
	ToVariantTypePtrOutputWithContext(context.Context) VariantTypePtrOutput
}

type variantTypePtr string

func VariantTypePtr(v string) VariantTypePtrInput {
	return (*variantTypePtr)(&v)
}

func (*variantTypePtr) ElementType() reflect.Type {
	return variantTypePtrType
}

func (in *variantTypePtr) ToVariantTypePtrOutput() VariantTypePtrOutput {
	return pulumi.ToOutput(in).(VariantTypePtrOutput)
}

func (in *variantTypePtr) ToVariantTypePtrOutputWithContext(ctx context.Context) VariantTypePtrOutput {
	return pulumi.ToOutputWithContext(ctx, in).(VariantTypePtrOutput)
}

type VmPriority string

const (
	VmPriorityDedicated   = VmPriority("Dedicated")
	VmPriorityLowPriority = VmPriority("LowPriority")
)

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

func (e VmPriority) ToVmPriorityOutput() VmPriorityOutput {
	return pulumi.ToOutput(e).(VmPriorityOutput)
}

func (e VmPriority) ToVmPriorityOutputWithContext(ctx context.Context) VmPriorityOutput {
	return pulumi.ToOutputWithContext(ctx, e).(VmPriorityOutput)
}

func (e VmPriority) ToVmPriorityPtrOutput() VmPriorityPtrOutput {
	return e.ToVmPriorityPtrOutputWithContext(context.Background())
}

func (e VmPriority) ToVmPriorityPtrOutputWithContext(ctx context.Context) VmPriorityPtrOutput {
	return VmPriority(e).ToVmPriorityOutputWithContext(ctx).ToVmPriorityPtrOutputWithContext(ctx)
}

func (e VmPriority) ToStringOutput() pulumi.StringOutput {
	return pulumi.ToOutput(pulumi.String(e)).(pulumi.StringOutput)
}

func (e VmPriority) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return pulumi.ToOutputWithContext(ctx, pulumi.String(e)).(pulumi.StringOutput)
}

func (e VmPriority) ToStringPtrOutput() pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringPtrOutputWithContext(context.Background())
}

func (e VmPriority) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return pulumi.String(e).ToStringOutputWithContext(ctx).ToStringPtrOutputWithContext(ctx)
}

type VmPriorityOutput struct{ *pulumi.OutputState }

func (VmPriorityOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*VmPriority)(nil)).Elem()
}

func (o VmPriorityOutput) ToVmPriorityOutput() VmPriorityOutput {
	return o
}

func (o VmPriorityOutput) ToVmPriorityOutputWithContext(ctx context.Context) VmPriorityOutput {
	return o
}

func (o VmPriorityOutput) ToVmPriorityPtrOutput() VmPriorityPtrOutput {
	return o.ToVmPriorityPtrOutputWithContext(context.Background())
}

func (o VmPriorityOutput) ToVmPriorityPtrOutputWithContext(ctx context.Context) VmPriorityPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v VmPriority) *VmPriority {
		return &v
	}).(VmPriorityPtrOutput)
}

func (o VmPriorityOutput) ToStringOutput() pulumi.StringOutput {
	return o.ToStringOutputWithContext(context.Background())
}

func (o VmPriorityOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e VmPriority) string {
		return string(e)
	}).(pulumi.StringOutput)
}

func (o VmPriorityOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o VmPriorityOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e VmPriority) *string {
		v := string(e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type VmPriorityPtrOutput struct{ *pulumi.OutputState }

func (VmPriorityPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**VmPriority)(nil)).Elem()
}

func (o VmPriorityPtrOutput) ToVmPriorityPtrOutput() VmPriorityPtrOutput {
	return o
}

func (o VmPriorityPtrOutput) ToVmPriorityPtrOutputWithContext(ctx context.Context) VmPriorityPtrOutput {
	return o
}

func (o VmPriorityPtrOutput) Elem() VmPriorityOutput {
	return o.ApplyT(func(v *VmPriority) VmPriority {
		if v != nil {
			return *v
		}
		var ret VmPriority
		return ret
	}).(VmPriorityOutput)
}

func (o VmPriorityPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput {
	return o.ToStringPtrOutputWithContext(context.Background())
}

func (o VmPriorityPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, e *VmPriority) *string {
		if e == nil {
			return nil
		}
		v := string(*e)
		return &v
	}).(pulumi.StringPtrOutput)
}

type VmPriorityInput interface {
	pulumi.Input

	ToVmPriorityOutput() VmPriorityOutput
	ToVmPriorityOutputWithContext(context.Context) VmPriorityOutput
}

var vmPriorityPtrType = reflect.TypeOf((**VmPriority)(nil)).Elem()

type VmPriorityPtrInput interface {
	pulumi.Input

	ToVmPriorityPtrOutput() VmPriorityPtrOutput
	ToVmPriorityPtrOutputWithContext(context.Context) VmPriorityPtrOutput
}

type vmPriorityPtr string

func VmPriorityPtr(v string) VmPriorityPtrInput {
	return (*vmPriorityPtr)(&v)
}

func (*vmPriorityPtr) ElementType() reflect.Type {
	return vmPriorityPtrType
}

func (in *vmPriorityPtr) ToVmPriorityPtrOutput() VmPriorityPtrOutput {
	return pulumi.ToOutput(in).(VmPriorityPtrOutput)
}

func (in *vmPriorityPtr) ToVmPriorityPtrOutputWithContext(ctx context.Context) VmPriorityPtrOutput {
	return pulumi.ToOutputWithContext(ctx, in).(VmPriorityPtrOutput)
}

func init() {
	pulumi.RegisterOutputType(ApplicationSharingPolicyOutput{})
	pulumi.RegisterOutputType(ApplicationSharingPolicyPtrOutput{})
	pulumi.RegisterOutputType(BatchLoggingLevelOutput{})
	pulumi.RegisterOutputType(BatchLoggingLevelPtrOutput{})
	pulumi.RegisterOutputType(BatchOutputActionOutput{})
	pulumi.RegisterOutputType(BatchOutputActionPtrOutput{})
	pulumi.RegisterOutputType(ClusterPurposeOutput{})
	pulumi.RegisterOutputType(ClusterPurposePtrOutput{})
	pulumi.RegisterOutputType(ComputeEnvironmentTypeOutput{})
	pulumi.RegisterOutputType(ComputeEnvironmentTypePtrOutput{})
	pulumi.RegisterOutputType(ComputeInstanceAuthorizationTypeOutput{})
	pulumi.RegisterOutputType(ComputeInstanceAuthorizationTypePtrOutput{})
	pulumi.RegisterOutputType(ComputeTypeOutput{})
	pulumi.RegisterOutputType(ComputeTypePtrOutput{})
	pulumi.RegisterOutputType(ContainerTypeOutput{})
	pulumi.RegisterOutputType(ContainerTypePtrOutput{})
	pulumi.RegisterOutputType(DataBindingModeOutput{})
	pulumi.RegisterOutputType(DataBindingModePtrOutput{})
	pulumi.RegisterOutputType(DatasetTypeOutput{})
	pulumi.RegisterOutputType(DatasetTypePtrOutput{})
	pulumi.RegisterOutputType(DatastoreTypeArmOutput{})
	pulumi.RegisterOutputType(DatastoreTypeArmPtrOutput{})
	pulumi.RegisterOutputType(DistributionTypeOutput{})
	pulumi.RegisterOutputType(DistributionTypePtrOutput{})
	pulumi.RegisterOutputType(DockerSpecificationTypeOutput{})
	pulumi.RegisterOutputType(DockerSpecificationTypePtrOutput{})
	pulumi.RegisterOutputType(EarlyTerminationPolicyTypeOutput{})
	pulumi.RegisterOutputType(EarlyTerminationPolicyTypePtrOutput{})
	pulumi.RegisterOutputType(EncryptionStatusOutput{})
	pulumi.RegisterOutputType(EncryptionStatusPtrOutput{})
	pulumi.RegisterOutputType(EndpointAuthModeOutput{})
	pulumi.RegisterOutputType(EndpointAuthModePtrOutput{})
	pulumi.RegisterOutputType(EndpointComputeTypeOutput{})
	pulumi.RegisterOutputType(EndpointComputeTypePtrOutput{})
	pulumi.RegisterOutputType(GoalOutput{})
	pulumi.RegisterOutputType(GoalPtrOutput{})
	pulumi.RegisterOutputType(HeaderOutput{})
	pulumi.RegisterOutputType(HeaderPtrOutput{})
	pulumi.RegisterOutputType(IdentityConfigurationTypeOutput{})
	pulumi.RegisterOutputType(IdentityConfigurationTypePtrOutput{})
	pulumi.RegisterOutputType(ImageAnnotationTypeOutput{})
	pulumi.RegisterOutputType(ImageAnnotationTypePtrOutput{})
	pulumi.RegisterOutputType(JobTypeOutput{})
	pulumi.RegisterOutputType(JobTypePtrOutput{})
	pulumi.RegisterOutputType(LinkedServiceLinkTypeOutput{})
	pulumi.RegisterOutputType(LinkedServiceLinkTypePtrOutput{})
	pulumi.RegisterOutputType(MediaTypeOutput{})
	pulumi.RegisterOutputType(MediaTypePtrOutput{})
	pulumi.RegisterOutputType(OperatingSystemTypeOutput{})
	pulumi.RegisterOutputType(OperatingSystemTypePtrOutput{})
	pulumi.RegisterOutputType(OsTypeOutput{})
	pulumi.RegisterOutputType(OsTypePtrOutput{})
	pulumi.RegisterOutputType(PrivateEndpointServiceConnectionStatusOutput{})
	pulumi.RegisterOutputType(PrivateEndpointServiceConnectionStatusPtrOutput{})
	pulumi.RegisterOutputType(ReferenceTypeOutput{})
	pulumi.RegisterOutputType(ReferenceTypePtrOutput{})
	pulumi.RegisterOutputType(RemoteLoginPortPublicAccessOutput{})
	pulumi.RegisterOutputType(RemoteLoginPortPublicAccessPtrOutput{})
	pulumi.RegisterOutputType(ResourceIdentityAssignmentOutput{})
	pulumi.RegisterOutputType(ResourceIdentityAssignmentPtrOutput{})
	pulumi.RegisterOutputType(ResourceIdentityTypeOutput{})
	pulumi.RegisterOutputType(ResourceIdentityTypePtrOutput{})
	pulumi.RegisterOutputType(SamplingAlgorithmOutput{})
	pulumi.RegisterOutputType(SamplingAlgorithmPtrOutput{})
	pulumi.RegisterOutputType(ScaleTypeOutput{})
	pulumi.RegisterOutputType(ScaleTypePtrOutput{})
	pulumi.RegisterOutputType(SourceTypeOutput{})
	pulumi.RegisterOutputType(SourceTypePtrOutput{})
	pulumi.RegisterOutputType(SshPublicAccessOutput{})
	pulumi.RegisterOutputType(SshPublicAccessPtrOutput{})
	pulumi.RegisterOutputType(ValueFormatOutput{})
	pulumi.RegisterOutputType(ValueFormatPtrOutput{})
	pulumi.RegisterOutputType(VariantTypeOutput{})
	pulumi.RegisterOutputType(VariantTypePtrOutput{})
	pulumi.RegisterOutputType(VmPriorityOutput{})
	pulumi.RegisterOutputType(VmPriorityPtrOutput{})
}

license_type: permissive

branch_name: refs/heads/master

extension: go


text:
@misc{	algorithm-zoo,
       author = {Stephen Jordan},
       title = {Quantum Algorithm Zoo},
       year = {2020},
       url = {https://quantumalgorithmzoo.org/},
}

@unpublished{  kon:20,
       author        = {Konstantinos Meichanetzidis and Stefano Gogioso and Giovanni De Felice and Nicolò Chiappori and Alexis Toumi and Bob Coecke},
       title = {Quantum Natural Language Processing on Near-Term Quantum Computers},
       year = {2020},
       Note = {arXiv:2005.04147},
}

@article{campbell:19,
  doi = {10.22331/q-2019-07-18-167},
  url = {https://doi.org/10.22331/q-2019-07-18-167},
  title = {Applying quantum algorithms to constraint satisfaction problems},
  author = {Campbell, Earl and Khurana, Ankur and Montanaro, Ashley},
  journal = {{Quantum}},
  issn = {2521-327X},
  publisher = {{Verein zur F{\"{o}}rderung des Open Access Publizierens in den Quantenwissenschaften}},
  volume = {3},
  pages = {167},
  month = jul,
  year = {2019}
}

@InProceedings{  kybartas:17,
  title         = {Story and plot generation},
  author        = {Kybartas, B},
  pages = {309},
  booktitle     = {Procedural Generation in Game Design},
  publisher = {CRC Press},
  year          = {2017}
}

@InProceedings{  backus:17,
  title         = {Managing output: Boredom versus chaos},
  author        = {Backus, K},
  pages = {45},
  booktitle     = {Procedural Generation in Game Design},
  publisher = {CRC Press},
  year          = {2017}
}

@article{montanaro:16,
  title = {Quantum-walk speedup of backtracking algorithms},
  author = {Montanaro, A.},
  journal = {Theory of Computing},
  volume = {14},
  issue = {15},
  pages = {1-24},
  year = {2016},
}

@misc{	qiskit-textbook,
       author = {Abraham Asfaw and Luciano Bello and Yael Ben-Haim and Sergey Bravyi and Lauren Capelluto and Almudena Carrera Vazquez and Jack Ceroni and
       Jay Gambetta and Shelly Garion and Leron Gil and Salvador De La Puente Gonzalez and David McKay and Zlatko Minev and Paul Nation and Anna Phan
               and Arthur Rattew and Joachim Schaefer and Javad Shabani and John Smolin and Kristan Temme and Madeleine Tod and James Wootton.},
       title = {Learn Quantum Computation Using Qiskit},
       year = {2020},
       url = {https://qiskit.org/textbook},
}

@misc{	wootton:battleships,
       author = {Wootton, James R.},
       title = {How to program a quantum computer},
       year = {2017},
       url = {https://medium.com/qiskit/how-to-program-a-quantum-computer-982a9329ed02},
}

@misc{	wootton:history,
       author = {Wootton, James R.},
       title = {The History of Games for Quantum Computers},
       year = {2019},
       url = {https://medium.com/@decodoku/the-history-of-games-for-quantum-computers-a1de98859b5a},
}

@unpublished{	wootton:awesomeness,
       author = {Wootton, James R.},
       title = {Benchmarking of quantum processors with random circuits},
       year = {2018},
       Note = {arXiv:1806.02736},
}

@misc{ qiskit,
       author = {{Qiskit Contributors}},
       title = {Qiskit: An Open-source Framework for Quantum Computing},
       year = {2019},
       doi = {10.5281/zenodo.2562110}
}

@InProceedings{  aloupis:14,
  title         = {Classic Nintendo Games Are (Computationally) Hard},
  author        = {Aloupis, G. and Demaine, E.D. and Guo, A. and Viglietta, G.},
  booktitle     = {Fun with Algorithms. FUN 2014. Lecture Notes in Computer Science, vol 8496},
  publisher = {Springer, Cham},
  year          = {2014}
}

@Unpublished{     andersen:19,
  author        = {Kraglund Andersen {\em et al.}, Christian},
  title         = "{{Repeated Quantum Error Detection in a Surface Code}}",
  note          = {arXiv:1907.04507},
  year          = {2019}
}

@Unpublished{     gong:19,
  author        = {Gong {\em et al.}, Ming },
  title         = "{{Experimental verification of five-qubit quantum error correction with superconducting qubits}}",
  note          = {arXiv:1912.09410
},
  year          = {2019}
}

@article{	endo:18,
  title = {Practical Quantum Error Mitigation for Near-Future Applications},
  author = {Endo, Suguru and Benjamin, Simon C. and Li, Ying},
  journal = {Phys. Rev. X},
  volume = {8},
  issue = {3},
  pages = {031027},
  numpages = {21},
  year = {2018},
  month = {Jul},
  publisher = {American Physical Society},
  doi = {10.1103/PhysRevX.8.031027},
  url = {https://link.aps.org/doi/10.1103/PhysRevX.8.031027}
}

@article{	wootton:18,
  title = {Repetition code of 15 qubits},
  author = {Wootton, James R. and Loss, Daniel},
  journal = {Phys. Rev. A},
  volume = {97},
  issue = {5},
  pages = {052313},
  numpages = {7},
  year = {2018},
  month = {May},
  publisher = {American Physical Society},
  doi = {10.1103/PhysRevA.97.052313},
  url = {https://link.aps.org/doi/10.1103/PhysRevA.97.052313}
}

@InProceedings{   naveh:18,
  title         = {Theoretical and Practical Aspects of Verification of Quantum Computers},
  author        = {Naveh, Y. and Kashefi, E. and Wootton, J. R. and Bertels, K.},
  booktitle     = {Proceedings of the 2018 Design, Automation \& Test in Europe (DATE)},
  year          = {2018}
}

@article{	takita:17,
  title = {Experimental Demonstration of Fault-Tolerant State Preparation with Superconducting Qubits},
  author = {Takita, Maika and Cross, Andrew W. and C\'orcoles, A. D. and Chow, Jerry M. and Gambetta, Jay M.},
  journal = {Phys. Rev. Lett.},
  volume = {119},
  issue = {18},
  pages = {180501},
  numpages = {5},
  year = {2017},
  month = {Oct},
  publisher = {American Physical Society},
  doi = {10.1103/PhysRevLett.119.180501},
  url = {https://link.aps.org/doi/10.1103/PhysRevLett.119.180501}
}

@Unpublished{     decodoku,
  author        = {James R. Wootton},
  title         = "{{Getting the public involved in Quantum Error Correction}}",
  note          = {arXiv:1712.09649},
  year          = {2017}
}

@article{	vuillot:18,
  title = {Error detection is already helpful on the IBM 5Q chip},
  author = {Vuillot, C.},
  journal = {Quant. Inf. Comp.},
  volume = {18},
  issue = {11 \& 12},
  pages = {0949},
  year = {2018},
}

@article {	linke:17,
	author = {Linke, Norbert M. and Gutierrez, Mauricio and Landsman, Kevin A. and Figgatt, Caroline and Debnath, Shantanu and Brown, Kenneth R. and Monroe, Christopher},
	title = {Fault-tolerant quantum error detection},
	volume = {3},
	number = {10},
	elocation-id = {e1701074},
	year = {2017},
	doi = {10.1126/sciadv.1701074},
	publisher = {American Association for the Advancement of Science},
	journal = {Science Advances}
}

@article{     winkler:17,
  title = {Proposal for a minimal surface code experiment},
  author = {Wootton, James R. and Peter, Andreas and Winkler, J\'anos R. and Loss, Daniel},
  journal = {Phys. Rev. A},
  volume = {96},
  issue = {3},
  pages = {032338},
  numpages = {8},
  year = {2017},
  month = {Sep},
  publisher = {American Physical Society},
  doi = {10.1103/PhysRevA.96.032338},
}

@article{	wootton:majorana,
  author={James R Wootton},
  title={Demonstrating non-Abelian braiding of surface code defects in a five qubit experiment},
  journal={Quantum Science and Technology},
  volume={2},
  number={1},
  pages={015006},
  year={2017}
}

@article{	takita:16,
  title = {Demonstration of Weight-Four Parity Measurements in the Surface Code Architecture},
  author = {Takita, Maika and C\'orcoles, A. D. and Magesan, Easwar and Abdo, Baleegh and Brink, Markus and Cross, Andrew and Chow, Jerry M. and Gambetta, Jay M.},
  journal = {Phys. Rev. Lett.},
  volume = {117},
  issue = {21},
  pages = {210505},
  numpages = {5},
  year = {2016},
  month = {Nov},
  publisher = {American Physical Society},
  doi = {10.1103/PhysRevLett.117.210505},
}

@article{	temme:16,
  title = {Error Mitigation for Short-Depth Quantum Circuits},
  author = {Temme, Kristan and Bravyi, Sergey and Gambetta, Jay M.},
  journal = {Phys. Rev. Lett.},
  volume = {119},
  issue = {18},
  pages = {180509},
  numpages = {5},
  year = {2017},
  month = {Nov},
  publisher = {American Physical Society},
  doi = {10.1103/PhysRevLett.119.180509},
}

@article{	wootton:15,
	doi = {10.1088/1751-8113/48/21/215302},
	year = 2015,
	month = {may},
	publisher = {{IOP} Publishing},
	volume = {48},
	number = {21},
	pages = {215302},
	author = {James R Wootton},
	title = {A family of stabilizer codes for {\textdollar}D($\lbrace$$\lbrace${\textbackslash}mathbb$\lbrace$Z$\rbrace$$\rbrace${\_}$\lbrace$2$\rbrace$$\rbrace$){\textdollar} anyons and Majorana modes},
	journal = {Journal of Physics A: Mathematical and Theoretical}
}

@article {	corcoles:15,
	author = {Corcoles {\em et al.}, A. D.},
	title = {Demonstration of a quantum error detection code using a square lattice of four superconducting qubits},
	volume = {6},
	number = {6979},
	year = {2015},
	doi = {doi:10.1038/ncomms7979},
	journal = {Nature Communications }
}

@article{	fowler:15,
  title = {Minimum weight perfect matching of fault-tolerant topological quantum error correction in average O(1) parallel time},
  author = {Fowler, Austin G.},
  journal = {Quant. Inf. Comp.},
  volume = {15},
  issue = {1 \& 2},
  pages = {0145},
  year = {2015},
  month = {Jan},
}

@article{	riste:15,
	Author = {Rist{\`e}, D. and Poletto, S. and Huang, M. -Z. and Bruno, A. and Vesterinen, V. and Saira, O. -P. and DiCarlo, L.},
	Da = {2015/04/29},
	Date-Added = {2020-01-21 14:02:20 +0000},
	Date-Modified = {2020-01-21 14:02:20 +0000},
	Doi = {10.1038/ncomms7983},
	Id = {Rist{\`e}2015},
	Isbn = {2041-1723},
	Journal = {Nature Communications},
	Number = {1},
	Pages = {6983},
	Title = {Detecting bit-flip errors in a logical qubit using stabilizer measurements},
	Ty = {JOUR},
	Volume = {6},
	Year = {2015},
}

@article {	kelly:14,
	author = {Kelly {\em et al.}, J.},
	title = {State preservation by repetitive error detection in a superconducting quantum circuit},
	volume = {519},
	number = {7541},
	pages = {66--69},
	year = {2014},
	doi = {doi:10.1038/nature14270},
	journal = {Nature}
}

@article{	svore:14,
  title = {Low-distance surface codes under realistic quantum noise},
  author = {Tomita, Yu and Svore, Krysta M.},
  journal = {Phys. Rev. A},
  volume = {90},
  issue = {6},
  pages = {062320},
  numpages = {15},
  year = {2014},
  month = {Dec},
  publisher = {American Physical Society},
}

@article{	delfosse:14,
  title = {Decoding color codes by projection onto surface codes},
  author = {Delfosse, Nicolas},
  journal = {Phys. Rev. A},
  volume = {89},
  issue = {1},
  pages = {012317},
  numpages = {12},
  year = {2014},
  month = {Jan},
  publisher = {American Physical Society},
  doi = {10.1103/PhysRevA.89.012317},
}

@article{	bravyi-haah,
  title = {Quantum Self-Correction in the 3D Cubic Code Model},
  author = {Bravyi, Sergey and Haah, Jeongwan},
  journal = {Phys. Rev. Lett.},
  volume = {111},
  issue = {20},
  pages = {200501},
  numpages = {5},
  year = {2013},
  month = {Nov},
  publisher = {American Physical Society},
  doi = {10.1103/PhysRevLett.111.200501}
}

@Book{            lidar:13,
  address       = {{Cambride, UK}},
  editor        = {Lidar, D. A. and Brun, T. A.},
  publisher     = {Cambridge University Press},
  title         = {{Quantum Error Correction}},
  year          = {2013}
}

@article{	fowler:12,
  title = {Proof of Finite Surface Code Threshold for Matching},
  author = {Fowler, Austin G.},
  journal = {Phys. Rev. Lett.},
  volume = {109},
  issue = {18},
  pages = {180502},
  numpages = {4},
  year = {2012},
  month = {Nov},
  publisher = {American Physical Society},
  doi = {10.1103/PhysRevLett.109.180502},
}

@article{	bombin:06,
  title = {Topological Quantum Distillation},
  author = {Bombin, H. and Martin-Delgado, M. A.},
  journal = {Phys. Rev. Lett.},
  volume = {97},
  issue = {18},
  pages = {180501},
  numpages = {4},
  year = {2006},
  month = {Oct},
  publisher = {American Physical Society},
  doi = {10.1103/PhysRevLett.97.180501},
}

@Article{         dennis,
  author        = {Dennis, E. and Kitaev, A. and Landahl, A. and Preskill, J.},
  title         = "{Topological quantum memory}",
  journal       = {J. Math. Phys.},
  year          = {2002},
  volume        = {43},
  pages         = {4452}
}

@Article{	  double,
  author	= {Kitaev, A. Yu.},
  journal	= {Ann. Phys.},
  volume	= {303},
  pages		= {2},
  year		= {2003},
  title		= {{Fault-tolerant quantum computation by anyons}}
}

@Article{         gottesman:96,
  author        = {Gottesman, D.},
  title         = "{{Class of quantum error-correcting codes saturating the
                  quantum Hamming bound}}",
  journal       = {Phys. Rev. A},
  year          = {1996},
  volume        = {54},
  pages         = {1862}
}

@Book{            ike-mike,
  author        = {Nielsen, M.~A. and Chuang, I.~L.},
  publisher     = {{Cambridge University Press}},
  title         = {Quantum Computation and Quantum Information},
  year          = {2000},
  address       = {Cambridge}
}

@article{	google-supremacy,
	author	= {Arute, Frank and Arya, Kunal and Babbush, Ryan and Bacon, Dave and Bardin, Joseph C. and Barends, Rami and Biswas, Rupak and Boixo, Sergio and Brandao, Fernando G. S. L. and Buell, David A. and Burkett, Brian and Chen, Yu and Chen, Zijun and Chiaro, Ben and Collins, Roberto and Courtney, William and Dunsworth, Andrew and Farhi, Edward and Foxen, Brooks and Fowler, Austin and Gidney, Craig and Giustina, Marissa and Graff, Rob and Guerin, Keith and Habegger, Steve and Harrigan, Matthew P. and Hartmann, Michael J. and Ho, Alan and Hoffmann, Markus and Huang, Trent and Humble, Travis S. and Isakov, Sergei V. and Jeffrey, Evan and Jiang, Zhang and Kafri, Dvir and Kechedzhi, Kostyantyn and Kelly, Julian and Klimov, Paul V. and Knysh, Sergey and Korotkov, Alexander and Kostritsa, Fedor and Landhuis, David and Lindmark, Mike and Lucero, Erik and Lyakh, Dmitry and Mandrà, Salvatore and McClean, Jarrod R. and McEwen, Matthew and Megrant, Anthony and Mi, Xiao and Michielsen, Kristel and Mohseni, Masoud and Mutus, Josh and Naaman, Ofer and Neeley, Matthew and Neill, Charles and Niu, Murphy Yuezhen and Ostby, Eric and Petukhov, Andre and Platt, John C. and Quintana, Chris and Rieffel, Eleanor G. and Roushan, Pedram and Rubin, Nicholas C. and Sank, Daniel and Satzinger, Kevin J. and Smelyanskiy, Vadim and Sung, Kevin J. and Trevithick, Matthew D. and Vainsencher, Amit and Villalonga, Benjamin and White, Theodore and Yao, Z. Jamie and Yeh, Ping and Zalcman, Adam and Neven, Hartmut and Martinis, John M.},
	Doi = {10.1038/s41586-019-1666-5},
	Id = {Arute2019},
	Isbn = {1476-4687},
	Journal = {Nature},
	Number = {7779},
	Pages = {505--510},
	Title = {Quantum supremacy using a programmable superconducting processor},
	Ty = {JOUR},
	Url = {https://doi.org/10.1038/s41586-019-1666-5},
	Volume = {574},
	Year = {2019}
}

@Unpublished{     ibm-summit,
  author        = {Edwin Pednault and John A. Gunnels and Giacomo Nannicini and Lior Horesh and Robert Wisnieff},
  title         = "{{Leveraging Secondary Storage to Simulate Deep 54-qubit Sycamore Circuits}}",
  note          = {arXiv:1910.09534},
  year          = {2019}
}

@article{	nisq,
  doi = {10.22331/q-2018-08-06-79},
  url = {https://doi.org/10.22331/q-2018-08-06-79},
  title = {Quantum {C}omputing in the {NISQ} era and beyond},
  author = {Preskill, John},
  journal = {{Quantum}},
  issn = {2521-327X},
  publisher = {{Verein zur F{\"{o}}rderung des Open Access Publizierens in den Quantenwissenschaften}},
  volume = {2},
  pages = {79},
  month = aug,
  year = {2018}
}

@article{	quantum-volume,
  title = {Validating quantum computers using randomized model circuits},
  author = {Cross, Andrew W. and Bishop, Lev S. and Sheldon, Sarah and Nation, Paul D. and Gambetta, Jay M.},
  journal = {Phys. Rev. A},
  volume = {100},
  issue = {3},
  pages = {032328},
  numpages = {11},
  year = {2019},
  month = {Sep},
  publisher = {American Physical Society},
  doi = {10.1103/PhysRevA.100.032328},
  url = {https://link.aps.org/doi/10.1103/PhysRevA.100.032328}
}

@Unpublished{     ibm-nisq,
  author        = {A. D. Corcoles and A. Kandala and A. Javadi-Abhari and D. T. McClure and A. W. Cross and K. Temme and P. D. Nation and M. Steffen and J. M. Gambetta},
  title         = "{{Challenges and Opportunities of Near-Term Quantum Computing Systems}}",
  note          = {arXiv:1910.02894},
  year          = {2019}
}

@article{	horsman:13,
  author    = {Dominic Horsman and
               Susan Stepney and
               Robert C. Wagner and
               Viv Kendon},
  title     = {When does a physical system compute?},
  journal   = {CoRR},
  volume    = {abs/1309.7979},
  year      = {2013},
  url       = {http://arxiv.org/abs/1309.7979},
  archivePrefix = {arXiv},
  eprint    = {1309.7979},
  timestamp = {Mon, 13 Aug 2018 16:48:57 +0200},
  biburl    = {https://dblp.org/rec/journals/corr/HorsmanSWK13.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{benioff,
	Abstract = {In this paper a microscopic quantum mechanical model of computers as represented by Turing machines is constructed. It is shown that for each numberN and Turing machineQ there exists a HamiltonianHNQ and a class of appropriate initial states such that if c is such an initial state, thenψQN(t)=exp(−1HNQt)ψQN(0) correctly describes at timest3,t6,⋯,t3N model states that correspond to the completion of the first, second, ⋯, Nth computation step ofQ. The model parameters can be adjusted so that for an arbitrary time intervalΔaroundt3,t6,⋯,t3N, the ``machine''part ofψQN(t) is stationary.},
	Author = {Benioff, Paul},
	Da = {1980/05/01},
	Date-Added = {2020-03-09 09:04:38 +0000},
	Date-Modified = {2020-03-09 09:04:38 +0000},
	Doi = {10.1007/BF01011339},
	Id = {Benioff1980},
	Isbn = {1572-9613},
	Journal = {Journal of Statistical Physics},
	Number = {5},
	Pages = {563--591},
	Title = {The computer as a physical system: A microscopic quantum mechanical Hamiltonian model of computers as represented by Turing machines},
	Ty = {JOUR},
	Url = {https://doi.org/10.1007/BF01011339},
	Volume = {22},
	Year = {1980},
	Bdsk-Url-1 = {https://doi.org/10.1007/BF01011339}}

@article{feynman,
	Author = {Feynman, Richard P. },
	Da = {1982/06/01},
	Date-Added = {2020-03-09 09:05:59 +0000},
	Date-Modified = {2020-03-09 09:05:59 +0000},
	Doi = {10.1007/BF02650179},
	Id = {Feynman1982},
	Isbn = {1572-9575},
	Journal = {International Journal of Theoretical Physics},
	Number = {6},
	Pages = {467--488},
	Title = {Simulating physics with computers},
	Ty = {JOUR},
	Url = {https://doi.org/10.1007/BF02650179},
	Volume = {21},
	Year = {1982},
	Bdsk-Url-1 = {https://doi.org/10.1007/BF02650179}}

@INPROCEEDINGS{deutsch,
    author = {David Deutsch and Richard Jozsat},
    title = {Rapid solution of problems by quantum computation},
    booktitle = {IN PROC},
    year = {1992},
    pages = {553--558},
    publisher = {}
}

@inproceedings{grover,
  author    = {Lov K. Grover},
  editor    = {Gary L. Miller},
  title     = {A Fast Quantum Mechanical Algorithm for Database Search},
  booktitle = {Proceedings of the Twenty-Eighth Annual {ACM} Symposium on the Theory
               of Computing, Philadelphia, Pennsylvania, USA, May 22-24, 1996},
  pages     = {212--219},
  publisher = {{ACM}},
  year      = {1996},
  url       = {https://doi.org/10.1145/237814.237866},
  doi       = {10.1145/237814.237866},
  timestamp = {Mon, 26 Nov 2018 15:05:57 +0100},
  biburl    = {https://dblp.org/rec/conf/stoc/Grover96.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{shor,
  author    = {Peter W. Shor},
  title     = {Polynomial-Time Algorithms for Prime Factorization and Discrete Logarithms
               on a Quantum Computer},
  journal   = {{SIAM} Review},
  volume    = {41},
  number    = {2},
  pages     = {303--332},
  year      = {1999},
  url       = {https://doi.org/10.1137/S0036144598347011},
  doi       = {10.1137/S0036144598347011},
  timestamp = {Wed, 14 Nov 2018 00:00:00 +0100},
  biburl    = {https://dblp.org/rec/journals/siamrev/Shor99.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{montanaro,
	Abstract = {Quantum computers are designed to outperform standard computers by running quantum algorithms. Areas in which quantum algorithms can be applied include cryptography, search and optimisation, simulation of quantum systems and solving large systems of linear equations. Here we briefly survey some known quantum algorithms, with an emphasis on a broad overview of their applications rather than their technical details. We include a discussion of recent developments and near-term applications of quantum algorithms.},
	Author = {Montanaro, Ashley},
	Da = {2016/01/12},
	Date-Added = {2020-03-09 09:18:25 +0000},
	Date-Modified = {2020-03-09 09:18:25 +0000},
	Doi = {10.1038/npjqi.2015.23},
	Id = {Montanaro2016},
	Isbn = {2056-6387},
	Journal = {npj Quantum Information},
	Number = {1},
	Pages = {15023},
	Title = {Quantum algorithms: an overview},
	Ty = {JOUR},
	Url = {https://doi.org/10.1038/npjqi.2015.23},
	Volume = {2},
	Year = {2016},
	Bdsk-Url-1 = {https://doi.org/10.1038/npjqi.2015.23}}

@article{kandala:17,
	Author = {Kandala, Abhinav and Mezzacapo, Antonio and Temme, Kristan and Takita, Maika and Brink, Markus and Chow, Jerry M. and Gambetta, Jay M.},
	Da = {2017/09/01},
	Date-Added = {2020-03-09 11:55:25 +0000},
	Date-Modified = {2020-03-09 11:55:25 +0000},
	Doi = {10.1038/nature23879},
	Id = {Kandala2017},
	Isbn = {1476-4687},
	Journal = {Nature},
	Number = {7671},
	Pages = {242--246},
	Title = {Hardware-efficient variational quantum eigensolver for small molecules and quantum magnets},
	Ty = {JOUR},
	Url = {https://doi.org/10.1038/nature23879},
	Volume = {549},
	Year = {2017},
	Bdsk-Url-1 = {https://doi.org/10.1038/nature23879}}

@article{murali:19,
  author    = {Prakash Murali and
               Ali Javadi{-}Abhari and
               Frederic T. Chong and
               Margaret Martonosi},
  title     = {Formal constraint-based compilation for noisy intermediate-scale quantum
               systems},
  journal   = {Microprocess. Microsystems},
  volume    = {66},
  pages     = {102--112},
  year      = {2019},
  url       = {https://doi.org/10.1016/j.micpro.2019.02.005},
  doi       = {10.1016/j.micpro.2019.02.005},
  timestamp = {Sat, 22 Feb 2020 19:25:18 +0100},
  biburl    = {https://dblp.org/rec/journals/mam/MuraliJCM19.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

@article{mckay:19,
  title = {Three-Qubit Randomized Benchmarking},
  author = {McKay, David C. and Sheldon, Sarah and Smolin, John A. and Chow, Jerry M. and Gambetta, Jay M.},
  journal = {Phys. Rev. Lett.},
  volume = {122},
  issue = {20},
  pages = {200502},
  numpages = {6},
  year = {2019},
  month = {May},
  publisher = {American Physical Society},
  doi = {10.1103/PhysRevLett.122.200502},
  url = {https://link.aps.org/doi/10.1103/PhysRevLett.122.200502}
}

@unpublished{	garciaperez:19,
       author = {Guillermo Garcia-Perez and Matteo A. C. Rossi and Boris Sokolov and Elsi-Mari Borrelli and Sabrina Maniscalco},
       title = {Pairwise tomography networks for many-body quantum systems},
       year = {2019},
       Note = {arXiv:1909.12814},
}

@article{	ganzhorn:19,
  title = {Gate-Efficient Simulation of Molecular Eigenstates on a Quantum Computer},
  author = {Ganzhorn, M. and Egger, D.J. and Barkoutsos, P. and Ollitrault, P. and Salis, G. and Moll, N. and Roth, M. and Fuhrer, A. and Mueller, P. and Woerner, S. and Tavernelli, I. and Filipp, S.},
  journal = {Phys. Rev. Applied},
  volume = {11},
  issue = {4},
  pages = {044092},
  numpages = {7},
  year = {2019},
  month = {Apr},
  publisher = {American Physical Society},
  doi = {10.1103/PhysRevApplied.11.044092},
  url = {https://link.aps.org/doi/10.1103/PhysRevApplied.11.044092}
}

@article{	kybartas:14,
  author    = {Ben A. Kybartas and
               Clark Verbrugge},
  title     = {Analysis of ReGEN as a Graph-Rewriting System for Quest Generation},
  journal   = {{IEEE} Trans. Comput. Intellig. and {AI} in Games},
  volume    = {6},
  number    = {2},
  pages     = {228--242},
  year      = {2014},
  url       = {https://doi.org/10.1109/TCIAIG.2013.2290088},
  doi       = {10.1109/TCIAIG.2013.2290088},
  timestamp = {Tue, 05 Feb 2019 12:34:20 +0100},
  biburl    = {https://dblp.org/rec/journals/tciaig/KybartasV14.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}

repository: quantumjim/QuantumGraph

repo_name: quantumjim/QuantumGraph

gha_language: Jupyter Notebook

extension: bib


text:
// pbrt is Copyright(c) 1998-2020 Matt Pharr, Wenzel Jakob, and Greg Humphreys.
// The pbrt source code is licensed under the Apache License, Version 2.0.
// SPDX: Apache-2.0

#ifndef PBRT_BASE_MATERIAL_H
#define PBRT_BASE_MATERIAL_H

#include <pbrt/pbrt.h>

#include <pbrt/base/bssrdf.h>
#include <pbrt/base/texture.h>
#include <pbrt/util/taggedptr.h>

#include <map>
#include <string>

namespace pbrt {

struct MaterialEvalContext;

// Material Declarations
class CoatedDiffuseMaterial;
class CoatedConductorMaterial;
class ConductorMaterial;
class DielectricMaterial;
class DiffuseMaterial;
class DiffuseTransmissionMaterial;
class HairMaterial;
class MeasuredMaterial;
class SubsurfaceMaterial;
class ThinDielectricMaterial;
class MixMaterial;

// Material Definition
class Material
    : public TaggedPointer<  // Material Types
          CoatedDiffuseMaterial, CoatedConductorMaterial, ConductorMaterial,
          DielectricMaterial, DiffuseMaterial, DiffuseTransmissionMaterial, HairMaterial,
          MeasuredMaterial, SubsurfaceMaterial, ThinDielectricMaterial, MixMaterial

          > {
  public:
    // Material Interface
    using TaggedPointer::TaggedPointer;

    static Material Create(const std::string &name,
                           const TextureParameterDictionary &parameters, Image *normalMap,
                           /*const */ std::map<std::string, Material> &namedMaterials,
                           const FileLoc *loc, Allocator alloc);

    std::string ToString() const;

    template <typename TextureEvaluator>
    inline BSDF GetBSDF(TextureEvaluator texEval, MaterialEvalContext ctx,
                        SampledWavelengths &lambda, ScratchBuffer &buf) const;

    template <typename TextureEvaluator>
    inline BSSRDF GetBSSRDF(TextureEvaluator texEval, MaterialEvalContext ctx,
                            SampledWavelengths &lambda, ScratchBuffer &buf) const;

    template <typename TextureEvaluator>
    PBRT_CPU_GPU inline bool CanEvaluateTextures(TextureEvaluator texEval) const;

    PBRT_CPU_GPU inline const Image *GetNormalMap() const;

    PBRT_CPU_GPU inline FloatTexture GetDisplacement() const;

    PBRT_CPU_GPU inline bool HasSubsurfaceScattering() const;
};

}  // namespace pbrt

#endif  // PBRT_BASE_MATERIAL_H

extension: h


text:
SUMMARY = "backport of Python 3.4's enum package"
LICENSE = "BSD-3-Clause"
LIC_FILES_CHKSUM = "file://enum/LICENSE;md5=0a97a53a514564c20efd7b2e8976c87e"

SRC_URI[md5sum] = "ac80f432ac9373e7d162834b264034b6"
SRC_URI[sha256sum] = "d3c19f26a6a34629c18c775f59dfc5dd595764c722b57a2da56ebfb69b94e447"

inherit pypi

license: MIT

branch_name: refs/heads/fido

gha_license_id: MIT

gha_language: BitBake

extension: bb