cwp

package
v0.1.16 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 23, 2023 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type GetMachinesSimpleArgs 

type GetMachinesSimpleArgs struct {
	Filters          []GetMachinesSimpleFilter `pulumi:"filters"`
	MachineRegion    string                    `pulumi:"machineRegion"`
	MachineType      string                    `pulumi:"machineType"`
	ProjectIds       []int                     `pulumi:"projectIds"`
	ResultOutputFile *string                   `pulumi:"resultOutputFile"`
}

A collection of arguments for invoking getMachinesSimple.

type GetMachinesSimpleFilter 

type GetMachinesSimpleFilter struct {
	ExactMatch *bool    `pulumi:"exactMatch"`
	Name       string   `pulumi:"name"`
	Values     []string `pulumi:"values"`
}

type GetMachinesSimpleFilterArgs 

type GetMachinesSimpleFilterArgs struct {
	ExactMatch pulumi.BoolPtrInput     `pulumi:"exactMatch"`
	Name       pulumi.StringInput      `pulumi:"name"`
	Values     pulumi.StringArrayInput `pulumi:"values"`
}

func (GetMachinesSimpleFilterArgs) ElementType 

func (GetMachinesSimpleFilterArgs) ElementType() reflect.Type

func (GetMachinesSimpleFilterArgs) ToGetMachinesSimpleFilterOutput 

func (i GetMachinesSimpleFilterArgs) ToGetMachinesSimpleFilterOutput() GetMachinesSimpleFilterOutput

func (GetMachinesSimpleFilterArgs) ToGetMachinesSimpleFilterOutputWithContext 

func (i GetMachinesSimpleFilterArgs) ToGetMachinesSimpleFilterOutputWithContext(ctx context.Context) GetMachinesSimpleFilterOutput

type GetMachinesSimpleFilterArray 

type GetMachinesSimpleFilterArray []GetMachinesSimpleFilterInput

func (GetMachinesSimpleFilterArray) ElementType 

func (GetMachinesSimpleFilterArray) ElementType() reflect.Type

func (GetMachinesSimpleFilterArray) ToGetMachinesSimpleFilterArrayOutput 

func (i GetMachinesSimpleFilterArray) ToGetMachinesSimpleFilterArrayOutput() GetMachinesSimpleFilterArrayOutput

func (GetMachinesSimpleFilterArray) ToGetMachinesSimpleFilterArrayOutputWithContext 

func (i GetMachinesSimpleFilterArray) ToGetMachinesSimpleFilterArrayOutputWithContext(ctx context.Context) GetMachinesSimpleFilterArrayOutput

type GetMachinesSimpleFilterArrayInput 

type GetMachinesSimpleFilterArrayInput interface {
	pulumi.Input

	ToGetMachinesSimpleFilterArrayOutput() GetMachinesSimpleFilterArrayOutput
	ToGetMachinesSimpleFilterArrayOutputWithContext(context.Context) GetMachinesSimpleFilterArrayOutput
}

GetMachinesSimpleFilterArrayInput is an input type that accepts GetMachinesSimpleFilterArray and GetMachinesSimpleFilterArrayOutput values. You can construct a concrete instance of `GetMachinesSimpleFilterArrayInput` via: 

GetMachinesSimpleFilterArray{ GetMachinesSimpleFilterArgs{...} }

type GetMachinesSimpleFilterArrayOutput 

type GetMachinesSimpleFilterArrayOutput struct{ *pulumi.OutputState }

func (GetMachinesSimpleFilterArrayOutput) ElementType 

func (GetMachinesSimpleFilterArrayOutput) ElementType() reflect.Type

func (GetMachinesSimpleFilterArrayOutput) Index 

func (o GetMachinesSimpleFilterArrayOutput) Index(i pulumi.IntInput) GetMachinesSimpleFilterOutput

func (GetMachinesSimpleFilterArrayOutput) ToGetMachinesSimpleFilterArrayOutput 

func (o GetMachinesSimpleFilterArrayOutput) ToGetMachinesSimpleFilterArrayOutput() GetMachinesSimpleFilterArrayOutput

func (GetMachinesSimpleFilterArrayOutput) ToGetMachinesSimpleFilterArrayOutputWithContext 

func (o GetMachinesSimpleFilterArrayOutput) ToGetMachinesSimpleFilterArrayOutputWithContext(ctx context.Context) GetMachinesSimpleFilterArrayOutput

type GetMachinesSimpleFilterInput 

type GetMachinesSimpleFilterInput interface {
	pulumi.Input

	ToGetMachinesSimpleFilterOutput() GetMachinesSimpleFilterOutput
	ToGetMachinesSimpleFilterOutputWithContext(context.Context) GetMachinesSimpleFilterOutput
}

GetMachinesSimpleFilterInput is an input type that accepts GetMachinesSimpleFilterArgs and GetMachinesSimpleFilterOutput values. You can construct a concrete instance of `GetMachinesSimpleFilterInput` via: 

GetMachinesSimpleFilterArgs{...}

type GetMachinesSimpleFilterOutput 

type GetMachinesSimpleFilterOutput struct{ *pulumi.OutputState }

func (GetMachinesSimpleFilterOutput) ElementType 

func (GetMachinesSimpleFilterOutput) ElementType() reflect.Type

func (GetMachinesSimpleFilterOutput) ExactMatch 

func (o GetMachinesSimpleFilterOutput) ExactMatch() pulumi.BoolPtrOutput

func (GetMachinesSimpleFilterOutput) Name 

func (o GetMachinesSimpleFilterOutput) Name() pulumi.StringOutput

func (GetMachinesSimpleFilterOutput) ToGetMachinesSimpleFilterOutput 

func (o GetMachinesSimpleFilterOutput) ToGetMachinesSimpleFilterOutput() GetMachinesSimpleFilterOutput

func (GetMachinesSimpleFilterOutput) ToGetMachinesSimpleFilterOutputWithContext 

func (o GetMachinesSimpleFilterOutput) ToGetMachinesSimpleFilterOutputWithContext(ctx context.Context) GetMachinesSimpleFilterOutput

func (GetMachinesSimpleFilterOutput) Values 

func (o GetMachinesSimpleFilterOutput) Values() pulumi.StringArrayOutput

type GetMachinesSimpleMachine 

type GetMachinesSimpleMachine struct {
	CloudTags     []GetMachinesSimpleMachineCloudTag     `pulumi:"cloudTags"`
	InstanceId    string                                 `pulumi:"instanceId"`
	InstanceState string                                 `pulumi:"instanceState"`
	IsProVersion  bool                                   `pulumi:"isProVersion"`
	KernelVersion string                                 `pulumi:"kernelVersion"`
	LicenseOrders []GetMachinesSimpleMachineLicenseOrder `pulumi:"licenseOrders"`
	MachineIp     string                                 `pulumi:"machineIp"`
	MachineName   string                                 `pulumi:"machineName"`
	MachineOs     string                                 `pulumi:"machineOs"`
	MachineType   string                                 `pulumi:"machineType"`
	MachineWanIp  string                                 `pulumi:"machineWanIp"`
	PayMode       string                                 `pulumi:"payMode"`
	ProjectId     int                                    `pulumi:"projectId"`
	ProtectType   string                                 `pulumi:"protectType"`
	Quuid         string                                 `pulumi:"quuid"`
	RegionInfos   []GetMachinesSimpleMachineRegionInfo   `pulumi:"regionInfos"`
	Tags          []GetMachinesSimpleMachineTag          `pulumi:"tags"`
	Uuid          string                                 `pulumi:"uuid"`
}

type GetMachinesSimpleMachineArgs 

type GetMachinesSimpleMachineArgs struct {
	CloudTags     GetMachinesSimpleMachineCloudTagArrayInput     `pulumi:"cloudTags"`
	InstanceId    pulumi.StringInput                             `pulumi:"instanceId"`
	InstanceState pulumi.StringInput                             `pulumi:"instanceState"`
	IsProVersion  pulumi.BoolInput                               `pulumi:"isProVersion"`
	KernelVersion pulumi.StringInput                             `pulumi:"kernelVersion"`
	LicenseOrders GetMachinesSimpleMachineLicenseOrderArrayInput `pulumi:"licenseOrders"`
	MachineIp     pulumi.StringInput                             `pulumi:"machineIp"`
	MachineName   pulumi.StringInput                             `pulumi:"machineName"`
	MachineOs     pulumi.StringInput                             `pulumi:"machineOs"`
	MachineType   pulumi.StringInput                             `pulumi:"machineType"`
	MachineWanIp  pulumi.StringInput                             `pulumi:"machineWanIp"`
	PayMode       pulumi.StringInput                             `pulumi:"payMode"`
	ProjectId     pulumi.IntInput                                `pulumi:"projectId"`
	ProtectType   pulumi.StringInput                             `pulumi:"protectType"`
	Quuid         pulumi.StringInput                             `pulumi:"quuid"`
	RegionInfos   GetMachinesSimpleMachineRegionInfoArrayInput   `pulumi:"regionInfos"`
	Tags          GetMachinesSimpleMachineTagArrayInput          `pulumi:"tags"`
	Uuid          pulumi.StringInput                             `pulumi:"uuid"`
}

func (GetMachinesSimpleMachineArgs) ElementType 

func (GetMachinesSimpleMachineArgs) ElementType() reflect.Type

func (GetMachinesSimpleMachineArgs) ToGetMachinesSimpleMachineOutput 

func (i GetMachinesSimpleMachineArgs) ToGetMachinesSimpleMachineOutput() GetMachinesSimpleMachineOutput

func (GetMachinesSimpleMachineArgs) ToGetMachinesSimpleMachineOutputWithContext 

func (i GetMachinesSimpleMachineArgs) ToGetMachinesSimpleMachineOutputWithContext(ctx context.Context) GetMachinesSimpleMachineOutput

type GetMachinesSimpleMachineArray 

type GetMachinesSimpleMachineArray []GetMachinesSimpleMachineInput

func (GetMachinesSimpleMachineArray) ElementType 

func (GetMachinesSimpleMachineArray) ElementType() reflect.Type

func (GetMachinesSimpleMachineArray) ToGetMachinesSimpleMachineArrayOutput 

func (i GetMachinesSimpleMachineArray) ToGetMachinesSimpleMachineArrayOutput() GetMachinesSimpleMachineArrayOutput

func (GetMachinesSimpleMachineArray) ToGetMachinesSimpleMachineArrayOutputWithContext 

func (i GetMachinesSimpleMachineArray) ToGetMachinesSimpleMachineArrayOutputWithContext(ctx context.Context) GetMachinesSimpleMachineArrayOutput

type GetMachinesSimpleMachineArrayInput 

type GetMachinesSimpleMachineArrayInput interface {
	pulumi.Input

	ToGetMachinesSimpleMachineArrayOutput() GetMachinesSimpleMachineArrayOutput
	ToGetMachinesSimpleMachineArrayOutputWithContext(context.Context) GetMachinesSimpleMachineArrayOutput
}

GetMachinesSimpleMachineArrayInput is an input type that accepts GetMachinesSimpleMachineArray and GetMachinesSimpleMachineArrayOutput values. You can construct a concrete instance of `GetMachinesSimpleMachineArrayInput` via: 

GetMachinesSimpleMachineArray{ GetMachinesSimpleMachineArgs{...} }

type GetMachinesSimpleMachineArrayOutput 

type GetMachinesSimpleMachineArrayOutput struct{ *pulumi.OutputState }

func (GetMachinesSimpleMachineArrayOutput) ElementType 

func (GetMachinesSimpleMachineArrayOutput) ElementType() reflect.Type

func (GetMachinesSimpleMachineArrayOutput) Index 

func (o GetMachinesSimpleMachineArrayOutput) Index(i pulumi.IntInput) GetMachinesSimpleMachineOutput

func (GetMachinesSimpleMachineArrayOutput) ToGetMachinesSimpleMachineArrayOutput 

func (o GetMachinesSimpleMachineArrayOutput) ToGetMachinesSimpleMachineArrayOutput() GetMachinesSimpleMachineArrayOutput

func (GetMachinesSimpleMachineArrayOutput) ToGetMachinesSimpleMachineArrayOutputWithContext 

func (o GetMachinesSimpleMachineArrayOutput) ToGetMachinesSimpleMachineArrayOutputWithContext(ctx context.Context) GetMachinesSimpleMachineArrayOutput

type GetMachinesSimpleMachineCloudTag 

type GetMachinesSimpleMachineCloudTag struct {
	TagKey   string `pulumi:"tagKey"`
	TagValue string `pulumi:"tagValue"`
}

type GetMachinesSimpleMachineCloudTagArgs 

type GetMachinesSimpleMachineCloudTagArgs struct {
	TagKey   pulumi.StringInput `pulumi:"tagKey"`
	TagValue pulumi.StringInput `pulumi:"tagValue"`
}

func (GetMachinesSimpleMachineCloudTagArgs) ElementType 

func (GetMachinesSimpleMachineCloudTagArgs) ElementType() reflect.Type

func (GetMachinesSimpleMachineCloudTagArgs) ToGetMachinesSimpleMachineCloudTagOutput 

func (i GetMachinesSimpleMachineCloudTagArgs) ToGetMachinesSimpleMachineCloudTagOutput() GetMachinesSimpleMachineCloudTagOutput

func (GetMachinesSimpleMachineCloudTagArgs) ToGetMachinesSimpleMachineCloudTagOutputWithContext 

func (i GetMachinesSimpleMachineCloudTagArgs) ToGetMachinesSimpleMachineCloudTagOutputWithContext(ctx context.Context) GetMachinesSimpleMachineCloudTagOutput

type GetMachinesSimpleMachineCloudTagArray 

type GetMachinesSimpleMachineCloudTagArray []GetMachinesSimpleMachineCloudTagInput

func (GetMachinesSimpleMachineCloudTagArray) ElementType 

func (GetMachinesSimpleMachineCloudTagArray) ElementType() reflect.Type

func (GetMachinesSimpleMachineCloudTagArray) ToGetMachinesSimpleMachineCloudTagArrayOutput 

func (i GetMachinesSimpleMachineCloudTagArray) ToGetMachinesSimpleMachineCloudTagArrayOutput() GetMachinesSimpleMachineCloudTagArrayOutput

func (GetMachinesSimpleMachineCloudTagArray) ToGetMachinesSimpleMachineCloudTagArrayOutputWithContext 

func (i GetMachinesSimpleMachineCloudTagArray) ToGetMachinesSimpleMachineCloudTagArrayOutputWithContext(ctx context.Context) GetMachinesSimpleMachineCloudTagArrayOutput

type GetMachinesSimpleMachineCloudTagArrayInput 

type GetMachinesSimpleMachineCloudTagArrayInput interface {
	pulumi.Input

	ToGetMachinesSimpleMachineCloudTagArrayOutput() GetMachinesSimpleMachineCloudTagArrayOutput
	ToGetMachinesSimpleMachineCloudTagArrayOutputWithContext(context.Context) GetMachinesSimpleMachineCloudTagArrayOutput
}

GetMachinesSimpleMachineCloudTagArrayInput is an input type that accepts GetMachinesSimpleMachineCloudTagArray and GetMachinesSimpleMachineCloudTagArrayOutput values. You can construct a concrete instance of `GetMachinesSimpleMachineCloudTagArrayInput` via: 

GetMachinesSimpleMachineCloudTagArray{ GetMachinesSimpleMachineCloudTagArgs{...} }

type GetMachinesSimpleMachineCloudTagArrayOutput 

type GetMachinesSimpleMachineCloudTagArrayOutput struct{ *pulumi.OutputState }

func (GetMachinesSimpleMachineCloudTagArrayOutput) ElementType 

func (GetMachinesSimpleMachineCloudTagArrayOutput) ElementType() reflect.Type

func (GetMachinesSimpleMachineCloudTagArrayOutput) Index 

func (o GetMachinesSimpleMachineCloudTagArrayOutput) Index(i pulumi.IntInput) GetMachinesSimpleMachineCloudTagOutput

func (GetMachinesSimpleMachineCloudTagArrayOutput) ToGetMachinesSimpleMachineCloudTagArrayOutput 

func (o GetMachinesSimpleMachineCloudTagArrayOutput) ToGetMachinesSimpleMachineCloudTagArrayOutput() GetMachinesSimpleMachineCloudTagArrayOutput

func (GetMachinesSimpleMachineCloudTagArrayOutput) ToGetMachinesSimpleMachineCloudTagArrayOutputWithContext 

func (o GetMachinesSimpleMachineCloudTagArrayOutput) ToGetMachinesSimpleMachineCloudTagArrayOutputWithContext(ctx context.Context) GetMachinesSimpleMachineCloudTagArrayOutput

type GetMachinesSimpleMachineCloudTagInput 

type GetMachinesSimpleMachineCloudTagInput interface {
	pulumi.Input

	ToGetMachinesSimpleMachineCloudTagOutput() GetMachinesSimpleMachineCloudTagOutput
	ToGetMachinesSimpleMachineCloudTagOutputWithContext(context.Context) GetMachinesSimpleMachineCloudTagOutput
}

GetMachinesSimpleMachineCloudTagInput is an input type that accepts GetMachinesSimpleMachineCloudTagArgs and GetMachinesSimpleMachineCloudTagOutput values. You can construct a concrete instance of `GetMachinesSimpleMachineCloudTagInput` via: 

GetMachinesSimpleMachineCloudTagArgs{...}

type GetMachinesSimpleMachineCloudTagOutput 

type GetMachinesSimpleMachineCloudTagOutput struct{ *pulumi.OutputState }

func (GetMachinesSimpleMachineCloudTagOutput) ElementType 

func (GetMachinesSimpleMachineCloudTagOutput) ElementType() reflect.Type

func (GetMachinesSimpleMachineCloudTagOutput) TagKey 

func (o GetMachinesSimpleMachineCloudTagOutput) TagKey() pulumi.StringOutput

func (GetMachinesSimpleMachineCloudTagOutput) TagValue 

func (o GetMachinesSimpleMachineCloudTagOutput) TagValue() pulumi.StringOutput

func (GetMachinesSimpleMachineCloudTagOutput) ToGetMachinesSimpleMachineCloudTagOutput 

func (o GetMachinesSimpleMachineCloudTagOutput) ToGetMachinesSimpleMachineCloudTagOutput() GetMachinesSimpleMachineCloudTagOutput

func (GetMachinesSimpleMachineCloudTagOutput) ToGetMachinesSimpleMachineCloudTagOutputWithContext 

func (o GetMachinesSimpleMachineCloudTagOutput) ToGetMachinesSimpleMachineCloudTagOutputWithContext(ctx context.Context) GetMachinesSimpleMachineCloudTagOutput

type GetMachinesSimpleMachineInput 

type GetMachinesSimpleMachineInput interface {
	pulumi.Input

	ToGetMachinesSimpleMachineOutput() GetMachinesSimpleMachineOutput
	ToGetMachinesSimpleMachineOutputWithContext(context.Context) GetMachinesSimpleMachineOutput
}

GetMachinesSimpleMachineInput is an input type that accepts GetMachinesSimpleMachineArgs and GetMachinesSimpleMachineOutput values. You can construct a concrete instance of `GetMachinesSimpleMachineInput` via: 

GetMachinesSimpleMachineArgs{...}

type GetMachinesSimpleMachineLicenseOrder 

type GetMachinesSimpleMachineLicenseOrder struct {
	LicenseId   int    `pulumi:"licenseId"`
	LicenseType int    `pulumi:"licenseType"`
	ResourceId  string `pulumi:"resourceId"`
	SourceType  int    `pulumi:"sourceType"`
	Status      int    `pulumi:"status"`
}

type GetMachinesSimpleMachineLicenseOrderArgs 

type GetMachinesSimpleMachineLicenseOrderArgs struct {
	LicenseId   pulumi.IntInput    `pulumi:"licenseId"`
	LicenseType pulumi.IntInput    `pulumi:"licenseType"`
	ResourceId  pulumi.StringInput `pulumi:"resourceId"`
	SourceType  pulumi.IntInput    `pulumi:"sourceType"`
	Status      pulumi.IntInput    `pulumi:"status"`
}

func (GetMachinesSimpleMachineLicenseOrderArgs) ElementType 

func (GetMachinesSimpleMachineLicenseOrderArgs) ElementType() reflect.Type

func (GetMachinesSimpleMachineLicenseOrderArgs) ToGetMachinesSimpleMachineLicenseOrderOutput 

func (i GetMachinesSimpleMachineLicenseOrderArgs) ToGetMachinesSimpleMachineLicenseOrderOutput() GetMachinesSimpleMachineLicenseOrderOutput

func (GetMachinesSimpleMachineLicenseOrderArgs) ToGetMachinesSimpleMachineLicenseOrderOutputWithContext 

func (i GetMachinesSimpleMachineLicenseOrderArgs) ToGetMachinesSimpleMachineLicenseOrderOutputWithContext(ctx context.Context) GetMachinesSimpleMachineLicenseOrderOutput

type GetMachinesSimpleMachineLicenseOrderArray 

type GetMachinesSimpleMachineLicenseOrderArray []GetMachinesSimpleMachineLicenseOrderInput

func (GetMachinesSimpleMachineLicenseOrderArray) ElementType 

func (GetMachinesSimpleMachineLicenseOrderArray) ElementType() reflect.Type

func (GetMachinesSimpleMachineLicenseOrderArray) ToGetMachinesSimpleMachineLicenseOrderArrayOutput 

func (i GetMachinesSimpleMachineLicenseOrderArray) ToGetMachinesSimpleMachineLicenseOrderArrayOutput() GetMachinesSimpleMachineLicenseOrderArrayOutput

func (GetMachinesSimpleMachineLicenseOrderArray) ToGetMachinesSimpleMachineLicenseOrderArrayOutputWithContext 

func (i GetMachinesSimpleMachineLicenseOrderArray) ToGetMachinesSimpleMachineLicenseOrderArrayOutputWithContext(ctx context.Context) GetMachinesSimpleMachineLicenseOrderArrayOutput

type GetMachinesSimpleMachineLicenseOrderArrayInput 

type GetMachinesSimpleMachineLicenseOrderArrayInput interface {
	pulumi.Input

	ToGetMachinesSimpleMachineLicenseOrderArrayOutput() GetMachinesSimpleMachineLicenseOrderArrayOutput
	ToGetMachinesSimpleMachineLicenseOrderArrayOutputWithContext(context.Context) GetMachinesSimpleMachineLicenseOrderArrayOutput
}

GetMachinesSimpleMachineLicenseOrderArrayInput is an input type that accepts GetMachinesSimpleMachineLicenseOrderArray and GetMachinesSimpleMachineLicenseOrderArrayOutput values. You can construct a concrete instance of `GetMachinesSimpleMachineLicenseOrderArrayInput` via: 

GetMachinesSimpleMachineLicenseOrderArray{ GetMachinesSimpleMachineLicenseOrderArgs{...} }

type GetMachinesSimpleMachineLicenseOrderArrayOutput 

type GetMachinesSimpleMachineLicenseOrderArrayOutput struct{ *pulumi.OutputState }

func (GetMachinesSimpleMachineLicenseOrderArrayOutput) ElementType 

func (GetMachinesSimpleMachineLicenseOrderArrayOutput) ElementType() reflect.Type

func (GetMachinesSimpleMachineLicenseOrderArrayOutput) Index 

func (o GetMachinesSimpleMachineLicenseOrderArrayOutput) Index(i pulumi.IntInput) GetMachinesSimpleMachineLicenseOrderOutput

func (GetMachinesSimpleMachineLicenseOrderArrayOutput) ToGetMachinesSimpleMachineLicenseOrderArrayOutput 

func (o GetMachinesSimpleMachineLicenseOrderArrayOutput) ToGetMachinesSimpleMachineLicenseOrderArrayOutput() GetMachinesSimpleMachineLicenseOrderArrayOutput

func (GetMachinesSimpleMachineLicenseOrderArrayOutput) ToGetMachinesSimpleMachineLicenseOrderArrayOutputWithContext 

func (o GetMachinesSimpleMachineLicenseOrderArrayOutput) ToGetMachinesSimpleMachineLicenseOrderArrayOutputWithContext(ctx context.Context) GetMachinesSimpleMachineLicenseOrderArrayOutput

type GetMachinesSimpleMachineLicenseOrderInput 

type GetMachinesSimpleMachineLicenseOrderInput interface {
	pulumi.Input

	ToGetMachinesSimpleMachineLicenseOrderOutput() GetMachinesSimpleMachineLicenseOrderOutput
	ToGetMachinesSimpleMachineLicenseOrderOutputWithContext(context.Context) GetMachinesSimpleMachineLicenseOrderOutput
}

GetMachinesSimpleMachineLicenseOrderInput is an input type that accepts GetMachinesSimpleMachineLicenseOrderArgs and GetMachinesSimpleMachineLicenseOrderOutput values. You can construct a concrete instance of `GetMachinesSimpleMachineLicenseOrderInput` via: 

GetMachinesSimpleMachineLicenseOrderArgs{...}

type GetMachinesSimpleMachineLicenseOrderOutput 

type GetMachinesSimpleMachineLicenseOrderOutput struct{ *pulumi.OutputState }

func (GetMachinesSimpleMachineLicenseOrderOutput) ElementType 

func (GetMachinesSimpleMachineLicenseOrderOutput) ElementType() reflect.Type

func (GetMachinesSimpleMachineLicenseOrderOutput) LicenseId 

func (o GetMachinesSimpleMachineLicenseOrderOutput) LicenseId() pulumi.IntOutput

func (GetMachinesSimpleMachineLicenseOrderOutput) LicenseType 

func (o GetMachinesSimpleMachineLicenseOrderOutput) LicenseType() pulumi.IntOutput

func (GetMachinesSimpleMachineLicenseOrderOutput) ResourceId 

func (o GetMachinesSimpleMachineLicenseOrderOutput) ResourceId() pulumi.StringOutput

func (GetMachinesSimpleMachineLicenseOrderOutput) SourceType 

func (o GetMachinesSimpleMachineLicenseOrderOutput) SourceType() pulumi.IntOutput

func (GetMachinesSimpleMachineLicenseOrderOutput) Status 

func (o GetMachinesSimpleMachineLicenseOrderOutput) Status() pulumi.IntOutput

func (GetMachinesSimpleMachineLicenseOrderOutput) ToGetMachinesSimpleMachineLicenseOrderOutput 

func (o GetMachinesSimpleMachineLicenseOrderOutput) ToGetMachinesSimpleMachineLicenseOrderOutput() GetMachinesSimpleMachineLicenseOrderOutput

func (GetMachinesSimpleMachineLicenseOrderOutput) ToGetMachinesSimpleMachineLicenseOrderOutputWithContext 

func (o GetMachinesSimpleMachineLicenseOrderOutput) ToGetMachinesSimpleMachineLicenseOrderOutputWithContext(ctx context.Context) GetMachinesSimpleMachineLicenseOrderOutput

type GetMachinesSimpleMachineOutput 

type GetMachinesSimpleMachineOutput struct{ *pulumi.OutputState }

func (GetMachinesSimpleMachineOutput) CloudTags 

func (o GetMachinesSimpleMachineOutput) CloudTags() GetMachinesSimpleMachineCloudTagArrayOutput

func (GetMachinesSimpleMachineOutput) ElementType 

func (GetMachinesSimpleMachineOutput) ElementType() reflect.Type

func (GetMachinesSimpleMachineOutput) InstanceId 

func (o GetMachinesSimpleMachineOutput) InstanceId() pulumi.StringOutput

func (GetMachinesSimpleMachineOutput) InstanceState 

func (o GetMachinesSimpleMachineOutput) InstanceState() pulumi.StringOutput

func (GetMachinesSimpleMachineOutput) IsProVersion 

func (o GetMachinesSimpleMachineOutput) IsProVersion() pulumi.BoolOutput

func (GetMachinesSimpleMachineOutput) KernelVersion 

func (o GetMachinesSimpleMachineOutput) KernelVersion() pulumi.StringOutput

func (GetMachinesSimpleMachineOutput) LicenseOrders 

func (o GetMachinesSimpleMachineOutput) LicenseOrders() GetMachinesSimpleMachineLicenseOrderArrayOutput

func (GetMachinesSimpleMachineOutput) MachineIp 

func (o GetMachinesSimpleMachineOutput) MachineIp() pulumi.StringOutput

func (GetMachinesSimpleMachineOutput) MachineName 

func (o GetMachinesSimpleMachineOutput) MachineName() pulumi.StringOutput

func (GetMachinesSimpleMachineOutput) MachineOs 

func (o GetMachinesSimpleMachineOutput) MachineOs() pulumi.StringOutput

func (GetMachinesSimpleMachineOutput) MachineType 

func (o GetMachinesSimpleMachineOutput) MachineType() pulumi.StringOutput

func (GetMachinesSimpleMachineOutput) MachineWanIp 

func (o GetMachinesSimpleMachineOutput) MachineWanIp() pulumi.StringOutput

func (GetMachinesSimpleMachineOutput) PayMode 

func (o GetMachinesSimpleMachineOutput) PayMode() pulumi.StringOutput

func (GetMachinesSimpleMachineOutput) ProjectId 

func (o GetMachinesSimpleMachineOutput) ProjectId() pulumi.IntOutput

func (GetMachinesSimpleMachineOutput) ProtectType 

func (o GetMachinesSimpleMachineOutput) ProtectType() pulumi.StringOutput

func (GetMachinesSimpleMachineOutput) Quuid 

func (o GetMachinesSimpleMachineOutput) Quuid() pulumi.StringOutput

func (GetMachinesSimpleMachineOutput) RegionInfos 

func (o GetMachinesSimpleMachineOutput) RegionInfos() GetMachinesSimpleMachineRegionInfoArrayOutput

func (GetMachinesSimpleMachineOutput) Tags 

func (o GetMachinesSimpleMachineOutput) Tags() GetMachinesSimpleMachineTagArrayOutput

func (GetMachinesSimpleMachineOutput) ToGetMachinesSimpleMachineOutput 

func (o GetMachinesSimpleMachineOutput) ToGetMachinesSimpleMachineOutput() GetMachinesSimpleMachineOutput

func (GetMachinesSimpleMachineOutput) ToGetMachinesSimpleMachineOutputWithContext 

func (o GetMachinesSimpleMachineOutput) ToGetMachinesSimpleMachineOutputWithContext(ctx context.Context) GetMachinesSimpleMachineOutput

func (GetMachinesSimpleMachineOutput) Uuid 

func (o GetMachinesSimpleMachineOutput) Uuid() pulumi.StringOutput

type GetMachinesSimpleMachineRegionInfo 

type GetMachinesSimpleMachineRegionInfo struct {
	Region       string `pulumi:"region"`
	RegionCode   string `pulumi:"regionCode"`
	RegionId     int    `pulumi:"regionId"`
	RegionName   string `pulumi:"regionName"`
	RegionNameEn string `pulumi:"regionNameEn"`
}

type GetMachinesSimpleMachineRegionInfoArgs 

type GetMachinesSimpleMachineRegionInfoArgs struct {
	Region       pulumi.StringInput `pulumi:"region"`
	RegionCode   pulumi.StringInput `pulumi:"regionCode"`
	RegionId     pulumi.IntInput    `pulumi:"regionId"`
	RegionName   pulumi.StringInput `pulumi:"regionName"`
	RegionNameEn pulumi.StringInput `pulumi:"regionNameEn"`
}

func (GetMachinesSimpleMachineRegionInfoArgs) ElementType 

func (GetMachinesSimpleMachineRegionInfoArgs) ElementType() reflect.Type

func (GetMachinesSimpleMachineRegionInfoArgs) ToGetMachinesSimpleMachineRegionInfoOutput 

func (i GetMachinesSimpleMachineRegionInfoArgs) ToGetMachinesSimpleMachineRegionInfoOutput() GetMachinesSimpleMachineRegionInfoOutput

func (GetMachinesSimpleMachineRegionInfoArgs) ToGetMachinesSimpleMachineRegionInfoOutputWithContext 

func (i GetMachinesSimpleMachineRegionInfoArgs) ToGetMachinesSimpleMachineRegionInfoOutputWithContext(ctx context.Context) GetMachinesSimpleMachineRegionInfoOutput

type GetMachinesSimpleMachineRegionInfoArray 

type GetMachinesSimpleMachineRegionInfoArray []GetMachinesSimpleMachineRegionInfoInput

func (GetMachinesSimpleMachineRegionInfoArray) ElementType 

func (GetMachinesSimpleMachineRegionInfoArray) ElementType() reflect.Type

func (GetMachinesSimpleMachineRegionInfoArray) ToGetMachinesSimpleMachineRegionInfoArrayOutput 

func (i GetMachinesSimpleMachineRegionInfoArray) ToGetMachinesSimpleMachineRegionInfoArrayOutput() GetMachinesSimpleMachineRegionInfoArrayOutput

func (GetMachinesSimpleMachineRegionInfoArray) ToGetMachinesSimpleMachineRegionInfoArrayOutputWithContext 

func (i GetMachinesSimpleMachineRegionInfoArray) ToGetMachinesSimpleMachineRegionInfoArrayOutputWithContext(ctx context.Context) GetMachinesSimpleMachineRegionInfoArrayOutput

type GetMachinesSimpleMachineRegionInfoArrayInput 

type GetMachinesSimpleMachineRegionInfoArrayInput interface {
	pulumi.Input

	ToGetMachinesSimpleMachineRegionInfoArrayOutput() GetMachinesSimpleMachineRegionInfoArrayOutput
	ToGetMachinesSimpleMachineRegionInfoArrayOutputWithContext(context.Context) GetMachinesSimpleMachineRegionInfoArrayOutput
}

GetMachinesSimpleMachineRegionInfoArrayInput is an input type that accepts GetMachinesSimpleMachineRegionInfoArray and GetMachinesSimpleMachineRegionInfoArrayOutput values. You can construct a concrete instance of `GetMachinesSimpleMachineRegionInfoArrayInput` via: 

GetMachinesSimpleMachineRegionInfoArray{ GetMachinesSimpleMachineRegionInfoArgs{...} }

type GetMachinesSimpleMachineRegionInfoArrayOutput 

type GetMachinesSimpleMachineRegionInfoArrayOutput struct{ *pulumi.OutputState }

func (GetMachinesSimpleMachineRegionInfoArrayOutput) ElementType 

func (GetMachinesSimpleMachineRegionInfoArrayOutput) ElementType() reflect.Type

func (GetMachinesSimpleMachineRegionInfoArrayOutput) Index 

func (o GetMachinesSimpleMachineRegionInfoArrayOutput) Index(i pulumi.IntInput) GetMachinesSimpleMachineRegionInfoOutput

func (GetMachinesSimpleMachineRegionInfoArrayOutput) ToGetMachinesSimpleMachineRegionInfoArrayOutput 

func (o GetMachinesSimpleMachineRegionInfoArrayOutput) ToGetMachinesSimpleMachineRegionInfoArrayOutput() GetMachinesSimpleMachineRegionInfoArrayOutput

func (GetMachinesSimpleMachineRegionInfoArrayOutput) ToGetMachinesSimpleMachineRegionInfoArrayOutputWithContext 

func (o GetMachinesSimpleMachineRegionInfoArrayOutput) ToGetMachinesSimpleMachineRegionInfoArrayOutputWithContext(ctx context.Context) GetMachinesSimpleMachineRegionInfoArrayOutput

type GetMachinesSimpleMachineRegionInfoInput 

type GetMachinesSimpleMachineRegionInfoInput interface {
	pulumi.Input

	ToGetMachinesSimpleMachineRegionInfoOutput() GetMachinesSimpleMachineRegionInfoOutput
	ToGetMachinesSimpleMachineRegionInfoOutputWithContext(context.Context) GetMachinesSimpleMachineRegionInfoOutput
}

GetMachinesSimpleMachineRegionInfoInput is an input type that accepts GetMachinesSimpleMachineRegionInfoArgs and GetMachinesSimpleMachineRegionInfoOutput values. You can construct a concrete instance of `GetMachinesSimpleMachineRegionInfoInput` via: 

GetMachinesSimpleMachineRegionInfoArgs{...}

type GetMachinesSimpleMachineRegionInfoOutput 

type GetMachinesSimpleMachineRegionInfoOutput struct{ *pulumi.OutputState }

func (GetMachinesSimpleMachineRegionInfoOutput) ElementType 

func (GetMachinesSimpleMachineRegionInfoOutput) ElementType() reflect.Type

func (GetMachinesSimpleMachineRegionInfoOutput) Region 

func (o GetMachinesSimpleMachineRegionInfoOutput) Region() pulumi.StringOutput

func (GetMachinesSimpleMachineRegionInfoOutput) RegionCode 

func (o GetMachinesSimpleMachineRegionInfoOutput) RegionCode() pulumi.StringOutput

func (GetMachinesSimpleMachineRegionInfoOutput) RegionId 

func (o GetMachinesSimpleMachineRegionInfoOutput) RegionId() pulumi.IntOutput

func (GetMachinesSimpleMachineRegionInfoOutput) RegionName 

func (o GetMachinesSimpleMachineRegionInfoOutput) RegionName() pulumi.StringOutput

func (GetMachinesSimpleMachineRegionInfoOutput) RegionNameEn 

func (o GetMachinesSimpleMachineRegionInfoOutput) RegionNameEn() pulumi.StringOutput

func (GetMachinesSimpleMachineRegionInfoOutput) ToGetMachinesSimpleMachineRegionInfoOutput 

func (o GetMachinesSimpleMachineRegionInfoOutput) ToGetMachinesSimpleMachineRegionInfoOutput() GetMachinesSimpleMachineRegionInfoOutput

func (GetMachinesSimpleMachineRegionInfoOutput) ToGetMachinesSimpleMachineRegionInfoOutputWithContext 

func (o GetMachinesSimpleMachineRegionInfoOutput) ToGetMachinesSimpleMachineRegionInfoOutputWithContext(ctx context.Context) GetMachinesSimpleMachineRegionInfoOutput

type GetMachinesSimpleMachineTag 

type GetMachinesSimpleMachineTag struct {
	Name  string `pulumi:"name"`
	Rid   int    `pulumi:"rid"`
	TagId int    `pulumi:"tagId"`
}

type GetMachinesSimpleMachineTagArgs 

type GetMachinesSimpleMachineTagArgs struct {
	Name  pulumi.StringInput `pulumi:"name"`
	Rid   pulumi.IntInput    `pulumi:"rid"`
	TagId pulumi.IntInput    `pulumi:"tagId"`
}

func (GetMachinesSimpleMachineTagArgs) ElementType 

func (GetMachinesSimpleMachineTagArgs) ElementType() reflect.Type

func (GetMachinesSimpleMachineTagArgs) ToGetMachinesSimpleMachineTagOutput 

func (i GetMachinesSimpleMachineTagArgs) ToGetMachinesSimpleMachineTagOutput() GetMachinesSimpleMachineTagOutput

func (GetMachinesSimpleMachineTagArgs) ToGetMachinesSimpleMachineTagOutputWithContext 

func (i GetMachinesSimpleMachineTagArgs) ToGetMachinesSimpleMachineTagOutputWithContext(ctx context.Context) GetMachinesSimpleMachineTagOutput

type GetMachinesSimpleMachineTagArray 

type GetMachinesSimpleMachineTagArray []GetMachinesSimpleMachineTagInput

func (GetMachinesSimpleMachineTagArray) ElementType 

func (GetMachinesSimpleMachineTagArray) ElementType() reflect.Type

func (GetMachinesSimpleMachineTagArray) ToGetMachinesSimpleMachineTagArrayOutput 

func (i GetMachinesSimpleMachineTagArray) ToGetMachinesSimpleMachineTagArrayOutput() GetMachinesSimpleMachineTagArrayOutput

func (GetMachinesSimpleMachineTagArray) ToGetMachinesSimpleMachineTagArrayOutputWithContext 

func (i GetMachinesSimpleMachineTagArray) ToGetMachinesSimpleMachineTagArrayOutputWithContext(ctx context.Context) GetMachinesSimpleMachineTagArrayOutput

type GetMachinesSimpleMachineTagArrayInput 

type GetMachinesSimpleMachineTagArrayInput interface {
	pulumi.Input

	ToGetMachinesSimpleMachineTagArrayOutput() GetMachinesSimpleMachineTagArrayOutput
	ToGetMachinesSimpleMachineTagArrayOutputWithContext(context.Context) GetMachinesSimpleMachineTagArrayOutput
}

GetMachinesSimpleMachineTagArrayInput is an input type that accepts GetMachinesSimpleMachineTagArray and GetMachinesSimpleMachineTagArrayOutput values. You can construct a concrete instance of `GetMachinesSimpleMachineTagArrayInput` via: 

GetMachinesSimpleMachineTagArray{ GetMachinesSimpleMachineTagArgs{...} }

type GetMachinesSimpleMachineTagArrayOutput 

type GetMachinesSimpleMachineTagArrayOutput struct{ *pulumi.OutputState }

func (GetMachinesSimpleMachineTagArrayOutput) ElementType 

func (GetMachinesSimpleMachineTagArrayOutput) ElementType() reflect.Type

func (GetMachinesSimpleMachineTagArrayOutput) Index 

func (o GetMachinesSimpleMachineTagArrayOutput) Index(i pulumi.IntInput) GetMachinesSimpleMachineTagOutput

func (GetMachinesSimpleMachineTagArrayOutput) ToGetMachinesSimpleMachineTagArrayOutput 

func (o GetMachinesSimpleMachineTagArrayOutput) ToGetMachinesSimpleMachineTagArrayOutput() GetMachinesSimpleMachineTagArrayOutput

func (GetMachinesSimpleMachineTagArrayOutput) ToGetMachinesSimpleMachineTagArrayOutputWithContext 

func (o GetMachinesSimpleMachineTagArrayOutput) ToGetMachinesSimpleMachineTagArrayOutputWithContext(ctx context.Context) GetMachinesSimpleMachineTagArrayOutput

type GetMachinesSimpleMachineTagInput 

type GetMachinesSimpleMachineTagInput interface {
	pulumi.Input

	ToGetMachinesSimpleMachineTagOutput() GetMachinesSimpleMachineTagOutput
	ToGetMachinesSimpleMachineTagOutputWithContext(context.Context) GetMachinesSimpleMachineTagOutput
}

GetMachinesSimpleMachineTagInput is an input type that accepts GetMachinesSimpleMachineTagArgs and GetMachinesSimpleMachineTagOutput values. You can construct a concrete instance of `GetMachinesSimpleMachineTagInput` via: 

GetMachinesSimpleMachineTagArgs{...}

type GetMachinesSimpleMachineTagOutput 

type GetMachinesSimpleMachineTagOutput struct{ *pulumi.OutputState }

func (GetMachinesSimpleMachineTagOutput) ElementType 

func (GetMachinesSimpleMachineTagOutput) ElementType() reflect.Type

func (GetMachinesSimpleMachineTagOutput) Name 

func (o GetMachinesSimpleMachineTagOutput) Name() pulumi.StringOutput

func (GetMachinesSimpleMachineTagOutput) Rid 

func (o GetMachinesSimpleMachineTagOutput) Rid() pulumi.IntOutput

func (GetMachinesSimpleMachineTagOutput) TagId 

func (o GetMachinesSimpleMachineTagOutput) TagId() pulumi.IntOutput

func (GetMachinesSimpleMachineTagOutput) ToGetMachinesSimpleMachineTagOutput 

func (o GetMachinesSimpleMachineTagOutput) ToGetMachinesSimpleMachineTagOutput() GetMachinesSimpleMachineTagOutput

func (GetMachinesSimpleMachineTagOutput) ToGetMachinesSimpleMachineTagOutputWithContext 

func (o GetMachinesSimpleMachineTagOutput) ToGetMachinesSimpleMachineTagOutputWithContext(ctx context.Context) GetMachinesSimpleMachineTagOutput

type GetMachinesSimpleOutputArgs 

type GetMachinesSimpleOutputArgs struct {
	Filters          GetMachinesSimpleFilterArrayInput `pulumi:"filters"`
	MachineRegion    pulumi.StringInput                `pulumi:"machineRegion"`
	MachineType      pulumi.StringInput                `pulumi:"machineType"`
	ProjectIds       pulumi.IntArrayInput              `pulumi:"projectIds"`
	ResultOutputFile pulumi.StringPtrInput             `pulumi:"resultOutputFile"`
}

A collection of arguments for invoking getMachinesSimple.

func (GetMachinesSimpleOutputArgs) ElementType 

func (GetMachinesSimpleOutputArgs) ElementType() reflect.Type

type GetMachinesSimpleResult 

type GetMachinesSimpleResult struct {
	Filters []GetMachinesSimpleFilter `pulumi:"filters"`
	// The provider-assigned unique ID for this managed resource.
	Id               string                     `pulumi:"id"`
	MachineRegion    string                     `pulumi:"machineRegion"`
	MachineType      string                     `pulumi:"machineType"`
	Machines         []GetMachinesSimpleMachine `pulumi:"machines"`
	ProjectIds       []int                      `pulumi:"projectIds"`
	ResultOutputFile *string                    `pulumi:"resultOutputFile"`
}

A collection of values returned by getMachinesSimple.

func GetMachinesSimple 

func GetMachinesSimple(ctx *pulumi.Context, args *GetMachinesSimpleArgs, opts ...pulumi.InvokeOption) (*GetMachinesSimpleResult, error)

type GetMachinesSimpleResultOutput 

type GetMachinesSimpleResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getMachinesSimple.

func GetMachinesSimpleOutput 

func GetMachinesSimpleOutput(ctx *pulumi.Context, args GetMachinesSimpleOutputArgs, opts ...pulumi.InvokeOption) GetMachinesSimpleResultOutput

func (GetMachinesSimpleResultOutput) ElementType 

func (GetMachinesSimpleResultOutput) ElementType() reflect.Type

func (GetMachinesSimpleResultOutput) Filters 

func (o GetMachinesSimpleResultOutput) Filters() GetMachinesSimpleFilterArrayOutput

func (GetMachinesSimpleResultOutput) Id 

func (o GetMachinesSimpleResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (GetMachinesSimpleResultOutput) MachineRegion 

func (o GetMachinesSimpleResultOutput) MachineRegion() pulumi.StringOutput

func (GetMachinesSimpleResultOutput) MachineType 

func (o GetMachinesSimpleResultOutput) MachineType() pulumi.StringOutput

func (GetMachinesSimpleResultOutput) Machines 

func (o GetMachinesSimpleResultOutput) Machines() GetMachinesSimpleMachineArrayOutput

func (GetMachinesSimpleResultOutput) ProjectIds 

func (o GetMachinesSimpleResultOutput) ProjectIds() pulumi.IntArrayOutput

func (GetMachinesSimpleResultOutput) ResultOutputFile 

func (o GetMachinesSimpleResultOutput) ResultOutputFile() pulumi.StringPtrOutput

func (GetMachinesSimpleResultOutput) ToGetMachinesSimpleResultOutput 

func (o GetMachinesSimpleResultOutput) ToGetMachinesSimpleResultOutput() GetMachinesSimpleResultOutput

func (GetMachinesSimpleResultOutput) ToGetMachinesSimpleResultOutputWithContext 

func (o GetMachinesSimpleResultOutput) ToGetMachinesSimpleResultOutputWithContext(ctx context.Context) GetMachinesSimpleResultOutput

type LicenseBindAttachment 

type LicenseBindAttachment struct {
	pulumi.CustomResourceState

	// agent status.
	AgentStatus pulumi.StringOutput `pulumi:"agentStatus"`
	// Is it allowed to change the binding, false is not allowed to change the binding.
	IsSwitchBind pulumi.BoolOutput `pulumi:"isSwitchBind"`
	// Allow unbinding, false does not allow unbinding.
	IsUnbind pulumi.BoolOutput `pulumi:"isUnbind"`
	// License ID.
	LicenseId pulumi.IntOutput `pulumi:"licenseId"`
	// LicenseType, 0 CWP Pro - Pay as you go, 1 CWP Pro - Monthly subscription, 2 CWP Ultimate - Monthly subscription. Default
	// is 0.
	LicenseType pulumi.IntOutput `pulumi:"licenseType"`
	// machine ip.
	MachineIp pulumi.StringOutput `pulumi:"machineIp"`
	// machine name.
	MachineName pulumi.StringOutput `pulumi:"machineName"`
	// machine wan ip.
	MachineWanIp pulumi.StringOutput `pulumi:"machineWanIp"`
	// Machine quota that needs to be bound.
	Quuid pulumi.StringOutput `pulumi:"quuid"`
	// Resource ID.
	ResourceId pulumi.StringOutput `pulumi:"resourceId"`
	// uuid.
	Uuid pulumi.StringOutput `pulumi:"uuid"`
}

func GetLicenseBindAttachment 

func GetLicenseBindAttachment(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *LicenseBindAttachmentState, opts ...pulumi.ResourceOption) (*LicenseBindAttachment, error)

GetLicenseBindAttachment gets an existing LicenseBindAttachment resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewLicenseBindAttachment 

func NewLicenseBindAttachment(ctx *pulumi.Context,
	name string, args *LicenseBindAttachmentArgs, opts ...pulumi.ResourceOption) (*LicenseBindAttachment, error)

NewLicenseBindAttachment registers a new resource with the given unique name, arguments, and options.

func (*LicenseBindAttachment) ElementType 

func (*LicenseBindAttachment) ElementType() reflect.Type

func (*LicenseBindAttachment) ToLicenseBindAttachmentOutput 

func (i *LicenseBindAttachment) ToLicenseBindAttachmentOutput() LicenseBindAttachmentOutput

func (*LicenseBindAttachment) ToLicenseBindAttachmentOutputWithContext 

func (i *LicenseBindAttachment) ToLicenseBindAttachmentOutputWithContext(ctx context.Context) LicenseBindAttachmentOutput

type LicenseBindAttachmentArgs 

type LicenseBindAttachmentArgs struct {
	// License ID.
	LicenseId pulumi.IntInput
	// LicenseType, 0 CWP Pro - Pay as you go, 1 CWP Pro - Monthly subscription, 2 CWP Ultimate - Monthly subscription. Default
	// is 0.
	LicenseType pulumi.IntInput
	// Machine quota that needs to be bound.
	Quuid pulumi.StringInput
	// Resource ID.
	ResourceId pulumi.StringInput
}

The set of arguments for constructing a LicenseBindAttachment resource.

func (LicenseBindAttachmentArgs) ElementType 

func (LicenseBindAttachmentArgs) ElementType() reflect.Type

type LicenseBindAttachmentArray 

type LicenseBindAttachmentArray []LicenseBindAttachmentInput

func (LicenseBindAttachmentArray) ElementType 

func (LicenseBindAttachmentArray) ElementType() reflect.Type

func (LicenseBindAttachmentArray) ToLicenseBindAttachmentArrayOutput 

func (i LicenseBindAttachmentArray) ToLicenseBindAttachmentArrayOutput() LicenseBindAttachmentArrayOutput

func (LicenseBindAttachmentArray) ToLicenseBindAttachmentArrayOutputWithContext 

func (i LicenseBindAttachmentArray) ToLicenseBindAttachmentArrayOutputWithContext(ctx context.Context) LicenseBindAttachmentArrayOutput

type LicenseBindAttachmentArrayInput 

type LicenseBindAttachmentArrayInput interface {
	pulumi.Input

	ToLicenseBindAttachmentArrayOutput() LicenseBindAttachmentArrayOutput
	ToLicenseBindAttachmentArrayOutputWithContext(context.Context) LicenseBindAttachmentArrayOutput
}

LicenseBindAttachmentArrayInput is an input type that accepts LicenseBindAttachmentArray and LicenseBindAttachmentArrayOutput values. You can construct a concrete instance of `LicenseBindAttachmentArrayInput` via: 

LicenseBindAttachmentArray{ LicenseBindAttachmentArgs{...} }

type LicenseBindAttachmentArrayOutput 

type LicenseBindAttachmentArrayOutput struct{ *pulumi.OutputState }

func (LicenseBindAttachmentArrayOutput) ElementType 

func (LicenseBindAttachmentArrayOutput) ElementType() reflect.Type

func (LicenseBindAttachmentArrayOutput) Index 

func (o LicenseBindAttachmentArrayOutput) Index(i pulumi.IntInput) LicenseBindAttachmentOutput

func (LicenseBindAttachmentArrayOutput) ToLicenseBindAttachmentArrayOutput 

func (o LicenseBindAttachmentArrayOutput) ToLicenseBindAttachmentArrayOutput() LicenseBindAttachmentArrayOutput

func (LicenseBindAttachmentArrayOutput) ToLicenseBindAttachmentArrayOutputWithContext 

func (o LicenseBindAttachmentArrayOutput) ToLicenseBindAttachmentArrayOutputWithContext(ctx context.Context) LicenseBindAttachmentArrayOutput

type LicenseBindAttachmentInput 

type LicenseBindAttachmentInput interface {
	pulumi.Input

	ToLicenseBindAttachmentOutput() LicenseBindAttachmentOutput
	ToLicenseBindAttachmentOutputWithContext(ctx context.Context) LicenseBindAttachmentOutput
}

type LicenseBindAttachmentMap 

type LicenseBindAttachmentMap map[string]LicenseBindAttachmentInput

func (LicenseBindAttachmentMap) ElementType 

func (LicenseBindAttachmentMap) ElementType() reflect.Type

func (LicenseBindAttachmentMap) ToLicenseBindAttachmentMapOutput 

func (i LicenseBindAttachmentMap) ToLicenseBindAttachmentMapOutput() LicenseBindAttachmentMapOutput

func (LicenseBindAttachmentMap) ToLicenseBindAttachmentMapOutputWithContext 

func (i LicenseBindAttachmentMap) ToLicenseBindAttachmentMapOutputWithContext(ctx context.Context) LicenseBindAttachmentMapOutput

type LicenseBindAttachmentMapInput 

type LicenseBindAttachmentMapInput interface {
	pulumi.Input

	ToLicenseBindAttachmentMapOutput() LicenseBindAttachmentMapOutput
	ToLicenseBindAttachmentMapOutputWithContext(context.Context) LicenseBindAttachmentMapOutput
}

LicenseBindAttachmentMapInput is an input type that accepts LicenseBindAttachmentMap and LicenseBindAttachmentMapOutput values. You can construct a concrete instance of `LicenseBindAttachmentMapInput` via: 

LicenseBindAttachmentMap{ "key": LicenseBindAttachmentArgs{...} }

type LicenseBindAttachmentMapOutput 

type LicenseBindAttachmentMapOutput struct{ *pulumi.OutputState }

func (LicenseBindAttachmentMapOutput) ElementType 

func (LicenseBindAttachmentMapOutput) ElementType() reflect.Type

func (LicenseBindAttachmentMapOutput) MapIndex 

func (o LicenseBindAttachmentMapOutput) MapIndex(k pulumi.StringInput) LicenseBindAttachmentOutput

func (LicenseBindAttachmentMapOutput) ToLicenseBindAttachmentMapOutput 

func (o LicenseBindAttachmentMapOutput) ToLicenseBindAttachmentMapOutput() LicenseBindAttachmentMapOutput

func (LicenseBindAttachmentMapOutput) ToLicenseBindAttachmentMapOutputWithContext 

func (o LicenseBindAttachmentMapOutput) ToLicenseBindAttachmentMapOutputWithContext(ctx context.Context) LicenseBindAttachmentMapOutput

type LicenseBindAttachmentOutput 

type LicenseBindAttachmentOutput struct{ *pulumi.OutputState }

func (LicenseBindAttachmentOutput) AgentStatus 

func (o LicenseBindAttachmentOutput) AgentStatus() pulumi.StringOutput

agent status.

func (LicenseBindAttachmentOutput) ElementType 

func (LicenseBindAttachmentOutput) ElementType() reflect.Type

func (LicenseBindAttachmentOutput) IsSwitchBind 

func (o LicenseBindAttachmentOutput) IsSwitchBind() pulumi.BoolOutput

Is it allowed to change the binding, false is not allowed to change the binding.

func (LicenseBindAttachmentOutput) IsUnbind 

func (o LicenseBindAttachmentOutput) IsUnbind() pulumi.BoolOutput

Allow unbinding, false does not allow unbinding.

func (LicenseBindAttachmentOutput) LicenseId 

func (o LicenseBindAttachmentOutput) LicenseId() pulumi.IntOutput

License ID.

func (LicenseBindAttachmentOutput) LicenseType 

func (o LicenseBindAttachmentOutput) LicenseType() pulumi.IntOutput

LicenseType, 0 CWP Pro - Pay as you go, 1 CWP Pro - Monthly subscription, 2 CWP Ultimate - Monthly subscription. Default is 0.

func (LicenseBindAttachmentOutput) MachineIp 

func (o LicenseBindAttachmentOutput) MachineIp() pulumi.StringOutput

machine ip.

func (LicenseBindAttachmentOutput) MachineName 

func (o LicenseBindAttachmentOutput) MachineName() pulumi.StringOutput

machine name.

func (LicenseBindAttachmentOutput) MachineWanIp 

func (o LicenseBindAttachmentOutput) MachineWanIp() pulumi.StringOutput

machine wan ip.

func (LicenseBindAttachmentOutput) Quuid 

func (o LicenseBindAttachmentOutput) Quuid() pulumi.StringOutput

Machine quota that needs to be bound.

func (LicenseBindAttachmentOutput) ResourceId 

func (o LicenseBindAttachmentOutput) ResourceId() pulumi.StringOutput

Resource ID.

func (LicenseBindAttachmentOutput) ToLicenseBindAttachmentOutput 

func (o LicenseBindAttachmentOutput) ToLicenseBindAttachmentOutput() LicenseBindAttachmentOutput

func (LicenseBindAttachmentOutput) ToLicenseBindAttachmentOutputWithContext 

func (o LicenseBindAttachmentOutput) ToLicenseBindAttachmentOutputWithContext(ctx context.Context) LicenseBindAttachmentOutput

func (LicenseBindAttachmentOutput) Uuid 

func (o LicenseBindAttachmentOutput) Uuid() pulumi.StringOutput

uuid.

type LicenseBindAttachmentState 

type LicenseBindAttachmentState struct {
	// agent status.
	AgentStatus pulumi.StringPtrInput
	// Is it allowed to change the binding, false is not allowed to change the binding.
	IsSwitchBind pulumi.BoolPtrInput
	// Allow unbinding, false does not allow unbinding.
	IsUnbind pulumi.BoolPtrInput
	// License ID.
	LicenseId pulumi.IntPtrInput
	// LicenseType, 0 CWP Pro - Pay as you go, 1 CWP Pro - Monthly subscription, 2 CWP Ultimate - Monthly subscription. Default
	// is 0.
	LicenseType pulumi.IntPtrInput
	// machine ip.
	MachineIp pulumi.StringPtrInput
	// machine name.
	MachineName pulumi.StringPtrInput
	// machine wan ip.
	MachineWanIp pulumi.StringPtrInput
	// Machine quota that needs to be bound.
	Quuid pulumi.StringPtrInput
	// Resource ID.
	ResourceId pulumi.StringPtrInput
	// uuid.
	Uuid pulumi.StringPtrInput
}

func (LicenseBindAttachmentState) ElementType 

func (LicenseBindAttachmentState) ElementType() reflect.Type

type LicenseOrder 

type LicenseOrder struct {
	pulumi.CustomResourceState

	// Resource alias.
	Alias pulumi.StringOutput `pulumi:"alias"`
	// license id.
	LicenseId pulumi.IntOutput `pulumi:"licenseId"`
	// License quantity, Quantity to be purchased.Default is 1.
	LicenseNum pulumi.IntPtrOutput `pulumi:"licenseNum"`
	// LicenseType, 0 CWP Pro - Pay as you go, 1 CWP Pro - Monthly subscription, 2 CWP Ultimate - Monthly subscription. Default
	// is 0.
	LicenseType pulumi.IntPtrOutput `pulumi:"licenseType"`
	// Project ID. Default is 0.
	ProjectId pulumi.IntPtrOutput `pulumi:"projectId"`
	// Purchase order region, only 1 Guangzhou, 9 Singapore is supported here. Guangzhou is recommended. Singapore is
	// whitelisted. Default is 1.
	RegionId pulumi.IntPtrOutput `pulumi:"regionId"`
	// resource id.
	ResourceId pulumi.StringOutput `pulumi:"resourceId"`
	// Tags of the license order.
	Tags pulumi.MapOutput `pulumi:"tags"`
}

func GetLicenseOrder 

func GetLicenseOrder(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *LicenseOrderState, opts ...pulumi.ResourceOption) (*LicenseOrder, error)

GetLicenseOrder gets an existing LicenseOrder resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewLicenseOrder 

func NewLicenseOrder(ctx *pulumi.Context,
	name string, args *LicenseOrderArgs, opts ...pulumi.ResourceOption) (*LicenseOrder, error)

NewLicenseOrder registers a new resource with the given unique name, arguments, and options.

func (*LicenseOrder) ElementType 

func (*LicenseOrder) ElementType() reflect.Type

func (*LicenseOrder) ToLicenseOrderOutput 

func (i *LicenseOrder) ToLicenseOrderOutput() LicenseOrderOutput

func (*LicenseOrder) ToLicenseOrderOutputWithContext 

func (i *LicenseOrder) ToLicenseOrderOutputWithContext(ctx context.Context) LicenseOrderOutput

type LicenseOrderArgs 

type LicenseOrderArgs struct {
	// Resource alias.
	Alias pulumi.StringPtrInput
	// License quantity, Quantity to be purchased.Default is 1.
	LicenseNum pulumi.IntPtrInput
	// LicenseType, 0 CWP Pro - Pay as you go, 1 CWP Pro - Monthly subscription, 2 CWP Ultimate - Monthly subscription. Default
	// is 0.
	LicenseType pulumi.IntPtrInput
	// Project ID. Default is 0.
	ProjectId pulumi.IntPtrInput
	// Purchase order region, only 1 Guangzhou, 9 Singapore is supported here. Guangzhou is recommended. Singapore is
	// whitelisted. Default is 1.
	RegionId pulumi.IntPtrInput
	// Tags of the license order.
	Tags pulumi.MapInput
}

The set of arguments for constructing a LicenseOrder resource.

func (LicenseOrderArgs) ElementType 

func (LicenseOrderArgs) ElementType() reflect.Type

type LicenseOrderArray 

type LicenseOrderArray []LicenseOrderInput

func (LicenseOrderArray) ElementType 

func (LicenseOrderArray) ElementType() reflect.Type

func (LicenseOrderArray) ToLicenseOrderArrayOutput 

func (i LicenseOrderArray) ToLicenseOrderArrayOutput() LicenseOrderArrayOutput

func (LicenseOrderArray) ToLicenseOrderArrayOutputWithContext 

func (i LicenseOrderArray) ToLicenseOrderArrayOutputWithContext(ctx context.Context) LicenseOrderArrayOutput

type LicenseOrderArrayInput 

type LicenseOrderArrayInput interface {
	pulumi.Input

	ToLicenseOrderArrayOutput() LicenseOrderArrayOutput
	ToLicenseOrderArrayOutputWithContext(context.Context) LicenseOrderArrayOutput
}

LicenseOrderArrayInput is an input type that accepts LicenseOrderArray and LicenseOrderArrayOutput values. You can construct a concrete instance of `LicenseOrderArrayInput` via: 

LicenseOrderArray{ LicenseOrderArgs{...} }

type LicenseOrderArrayOutput 

type LicenseOrderArrayOutput struct{ *pulumi.OutputState }

func (LicenseOrderArrayOutput) ElementType 

func (LicenseOrderArrayOutput) ElementType() reflect.Type

func (LicenseOrderArrayOutput) Index 

func (o LicenseOrderArrayOutput) Index(i pulumi.IntInput) LicenseOrderOutput

func (LicenseOrderArrayOutput) ToLicenseOrderArrayOutput 

func (o LicenseOrderArrayOutput) ToLicenseOrderArrayOutput() LicenseOrderArrayOutput

func (LicenseOrderArrayOutput) ToLicenseOrderArrayOutputWithContext 

func (o LicenseOrderArrayOutput) ToLicenseOrderArrayOutputWithContext(ctx context.Context) LicenseOrderArrayOutput

type LicenseOrderInput 

type LicenseOrderInput interface {
	pulumi.Input

	ToLicenseOrderOutput() LicenseOrderOutput
	ToLicenseOrderOutputWithContext(ctx context.Context) LicenseOrderOutput
}

type LicenseOrderMap 

type LicenseOrderMap map[string]LicenseOrderInput

func (LicenseOrderMap) ElementType 

func (LicenseOrderMap) ElementType() reflect.Type

func (LicenseOrderMap) ToLicenseOrderMapOutput 

func (i LicenseOrderMap) ToLicenseOrderMapOutput() LicenseOrderMapOutput

func (LicenseOrderMap) ToLicenseOrderMapOutputWithContext 

func (i LicenseOrderMap) ToLicenseOrderMapOutputWithContext(ctx context.Context) LicenseOrderMapOutput

type LicenseOrderMapInput 

type LicenseOrderMapInput interface {
	pulumi.Input

	ToLicenseOrderMapOutput() LicenseOrderMapOutput
	ToLicenseOrderMapOutputWithContext(context.Context) LicenseOrderMapOutput
}

LicenseOrderMapInput is an input type that accepts LicenseOrderMap and LicenseOrderMapOutput values. You can construct a concrete instance of `LicenseOrderMapInput` via: 

LicenseOrderMap{ "key": LicenseOrderArgs{...} }

type LicenseOrderMapOutput 

type LicenseOrderMapOutput struct{ *pulumi.OutputState }

func (LicenseOrderMapOutput) ElementType 

func (LicenseOrderMapOutput) ElementType() reflect.Type

func (LicenseOrderMapOutput) MapIndex 

func (o LicenseOrderMapOutput) MapIndex(k pulumi.StringInput) LicenseOrderOutput

func (LicenseOrderMapOutput) ToLicenseOrderMapOutput 

func (o LicenseOrderMapOutput) ToLicenseOrderMapOutput() LicenseOrderMapOutput

func (LicenseOrderMapOutput) ToLicenseOrderMapOutputWithContext 

func (o LicenseOrderMapOutput) ToLicenseOrderMapOutputWithContext(ctx context.Context) LicenseOrderMapOutput

type LicenseOrderOutput 

type LicenseOrderOutput struct{ *pulumi.OutputState }

func (LicenseOrderOutput) Alias 

func (o LicenseOrderOutput) Alias() pulumi.StringOutput

Resource alias.

func (LicenseOrderOutput) ElementType 

func (LicenseOrderOutput) ElementType() reflect.Type

func (LicenseOrderOutput) LicenseId 

func (o LicenseOrderOutput) LicenseId() pulumi.IntOutput

license id.

func (LicenseOrderOutput) LicenseNum 

func (o LicenseOrderOutput) LicenseNum() pulumi.IntPtrOutput

License quantity, Quantity to be purchased.Default is 1.

func (LicenseOrderOutput) LicenseType 

func (o LicenseOrderOutput) LicenseType() pulumi.IntPtrOutput

LicenseType, 0 CWP Pro - Pay as you go, 1 CWP Pro - Monthly subscription, 2 CWP Ultimate - Monthly subscription. Default is 0.

func (LicenseOrderOutput) ProjectId 

func (o LicenseOrderOutput) ProjectId() pulumi.IntPtrOutput

Project ID. Default is 0.

func (LicenseOrderOutput) RegionId 

func (o LicenseOrderOutput) RegionId() pulumi.IntPtrOutput

Purchase order region, only 1 Guangzhou, 9 Singapore is supported here. Guangzhou is recommended. Singapore is whitelisted. Default is 1.

func (LicenseOrderOutput) ResourceId 

func (o LicenseOrderOutput) ResourceId() pulumi.StringOutput

resource id.

func (LicenseOrderOutput) Tags 

func (o LicenseOrderOutput) Tags() pulumi.MapOutput

Tags of the license order.

func (LicenseOrderOutput) ToLicenseOrderOutput 

func (o LicenseOrderOutput) ToLicenseOrderOutput() LicenseOrderOutput

func (LicenseOrderOutput) ToLicenseOrderOutputWithContext 

func (o LicenseOrderOutput) ToLicenseOrderOutputWithContext(ctx context.Context) LicenseOrderOutput

type LicenseOrderState 

type LicenseOrderState struct {
	// Resource alias.
	Alias pulumi.StringPtrInput
	// license id.
	LicenseId pulumi.IntPtrInput
	// License quantity, Quantity to be purchased.Default is 1.
	LicenseNum pulumi.IntPtrInput
	// LicenseType, 0 CWP Pro - Pay as you go, 1 CWP Pro - Monthly subscription, 2 CWP Ultimate - Monthly subscription. Default
	// is 0.
	LicenseType pulumi.IntPtrInput
	// Project ID. Default is 0.
	ProjectId pulumi.IntPtrInput
	// Purchase order region, only 1 Guangzhou, 9 Singapore is supported here. Guangzhou is recommended. Singapore is
	// whitelisted. Default is 1.
	RegionId pulumi.IntPtrInput
	// resource id.
	ResourceId pulumi.StringPtrInput
	// Tags of the license order.
	Tags pulumi.MapInput
}

func (LicenseOrderState) ElementType 

func (LicenseOrderState) ElementType() reflect.Type

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.