cwp

package
v0.1.8 Latest Latest
Warning

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

 Go to latest Published: Jan 26, 2024 License: Apache-2.0 Imports: 11 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func PkgVersion 

func PkgVersion() (semver.Version, error)

PkgVersion uses reflection to determine the version of the current package. If a version cannot be determined, v1 will be assumed. The second return value is always nil.

Types

type GetMachinesSimpleArgs 

type GetMachinesSimpleArgs struct {
	// filter list.
	Filters []GetMachinesSimpleFilter `pulumi:"filters"`
	// The area where the machine belongs,Such as: ap-guangzhou, ap-shanghai, all-regions: All server region types.
	MachineRegion string `pulumi:"machineRegion"`
	// Service types. -CVM: Cloud Virtual Machine; -ECM: Edge Computing Machine; -LH: Lighthouse; -Other: Mixed cloud; -ALL: All server types.
	MachineType string `pulumi:"machineType"`
	// Project id list.
	ProjectIds []int `pulumi:"projectIds"`
	// Used to save results.
	ResultOutputFile *string `pulumi:"resultOutputFile"`
}

A collection of arguments for invoking getMachinesSimple.

type GetMachinesSimpleFilter 

type GetMachinesSimpleFilter struct {
	// exact match. true or false.
	ExactMatch *bool `pulumi:"exactMatch"`
	// Only supported Keywords, Version and TagId.
	Name string `pulumi:"name"`
	// If `name` is `Keywords`: enter keyword query; If `name` is `Version`: enter PRO_VERSION: Professional Edition | BASIC_VERSION: Basic | Flagship: Flagship | ProtectedMachines: Professional+Flagship | UnFlagship: Non Flagship | PRO_POST_PAY: Professional Edition Pay by Volume | PRO_PRE_PAY: Professional Edition Monthly Package query; If `name` is `TagId`: enter tag ID query.
	Values []string `pulumi:"values"`
}

type GetMachinesSimpleFilterArgs 

type GetMachinesSimpleFilterArgs struct {
	// exact match. true or false.
	ExactMatch pulumi.BoolPtrInput `pulumi:"exactMatch"`
	// Only supported Keywords, Version and TagId.
	Name pulumi.StringInput `pulumi:"name"`
	// If `name` is `Keywords`: enter keyword query; If `name` is `Version`: enter PRO_VERSION: Professional Edition | BASIC_VERSION: Basic | Flagship: Flagship | ProtectedMachines: Professional+Flagship | UnFlagship: Non Flagship | PRO_POST_PAY: Professional Edition Pay by Volume | PRO_PRE_PAY: Professional Edition Monthly Package query; If `name` is `TagId`: enter tag ID query.
	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

exact match. true or false.

func (GetMachinesSimpleFilterOutput) Name 

func (o GetMachinesSimpleFilterOutput) Name() pulumi.StringOutput

Only supported Keywords, Version and TagId.

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

If `name` is `Keywords`: enter keyword query; If `name` is `Version`: enter PRO_VERSION: Professional Edition | BASIC_VERSION: Basic | Flagship: Flagship | ProtectedMachines: Professional+Flagship | UnFlagship: Non Flagship | PRO_POST_PAY: Professional Edition Pay by Volume | PRO_PRE_PAY: Professional Edition Monthly Package query; If `name` is `TagId`: enter tag ID query.

type GetMachinesSimpleMachine 

type GetMachinesSimpleMachine struct {
	// Cloud tags detailNote: This field may return null, indicating that a valid value cannot be obtained.
	CloudTags []GetMachinesSimpleMachineCloudTag `pulumi:"cloudTags"`
	// Instance IDNote: This field may return null, indicating that a valid value cannot be obtained.
	InstanceId string `pulumi:"instanceId"`
	// Instance status.
	InstanceState string `pulumi:"instanceState"`
	// Paid version or not. true: yes; false: no.
	IsProVersion bool `pulumi:"isProVersion"`
	// Core Version.
	KernelVersion string `pulumi:"kernelVersion"`
	// License Order ObjectNote: This field may return null, indicating that a valid value cannot be obtained.
	LicenseOrders []GetMachinesSimpleMachineLicenseOrder `pulumi:"licenseOrders"`
	// Machine Internal net IP.
	MachineIp string `pulumi:"machineIp"`
	// Machine name.
	MachineName string `pulumi:"machineName"`
	// Machine OS System.
	MachineOs string `pulumi:"machineOs"`
	// Service types. -CVM: Cloud Virtual Machine; -ECM: Edge Computing Machine; -LH: Lighthouse; -Other: Mixed cloud; -ALL: All server types.
	MachineType string `pulumi:"machineType"`
	// Machine Outer net IP.
	MachineWanIp string `pulumi:"machineWanIp"`
	// Payment model. POSTPAY: Pay as you go; PREPAY: Monthly subscription.
	PayMode string `pulumi:"payMode"`
	// Project ID.
	ProjectId int `pulumi:"projectId"`
	// Protection Version. -BASIC_VERSION: Basic Version; -PRO_VERSION: Pro Version -Flagship: Flagship Version; -GENERAL_DISCOUNT: CWP-LH Version.
	ProtectType string `pulumi:"protectType"`
	// Cloud server sole UUID.
	Quuid string `pulumi:"quuid"`
	// Region detail.
	RegionInfos []GetMachinesSimpleMachineRegionInfo `pulumi:"regionInfos"`
	// Tag.
	Tags []GetMachinesSimpleMachineTag `pulumi:"tags"`
	// Cwp client sole UUID.
	Uuid string `pulumi:"uuid"`
}

type GetMachinesSimpleMachineArgs 

type GetMachinesSimpleMachineArgs struct {
	// Cloud tags detailNote: This field may return null, indicating that a valid value cannot be obtained.
	CloudTags GetMachinesSimpleMachineCloudTagArrayInput `pulumi:"cloudTags"`
	// Instance IDNote: This field may return null, indicating that a valid value cannot be obtained.
	InstanceId pulumi.StringInput `pulumi:"instanceId"`
	// Instance status.
	InstanceState pulumi.StringInput `pulumi:"instanceState"`
	// Paid version or not. true: yes; false: no.
	IsProVersion pulumi.BoolInput `pulumi:"isProVersion"`
	// Core Version.
	KernelVersion pulumi.StringInput `pulumi:"kernelVersion"`
	// License Order ObjectNote: This field may return null, indicating that a valid value cannot be obtained.
	LicenseOrders GetMachinesSimpleMachineLicenseOrderArrayInput `pulumi:"licenseOrders"`
	// Machine Internal net IP.
	MachineIp pulumi.StringInput `pulumi:"machineIp"`
	// Machine name.
	MachineName pulumi.StringInput `pulumi:"machineName"`
	// Machine OS System.
	MachineOs pulumi.StringInput `pulumi:"machineOs"`
	// Service types. -CVM: Cloud Virtual Machine; -ECM: Edge Computing Machine; -LH: Lighthouse; -Other: Mixed cloud; -ALL: All server types.
	MachineType pulumi.StringInput `pulumi:"machineType"`
	// Machine Outer net IP.
	MachineWanIp pulumi.StringInput `pulumi:"machineWanIp"`
	// Payment model. POSTPAY: Pay as you go; PREPAY: Monthly subscription.
	PayMode pulumi.StringInput `pulumi:"payMode"`
	// Project ID.
	ProjectId pulumi.IntInput `pulumi:"projectId"`
	// Protection Version. -BASIC_VERSION: Basic Version; -PRO_VERSION: Pro Version -Flagship: Flagship Version; -GENERAL_DISCOUNT: CWP-LH Version.
	ProtectType pulumi.StringInput `pulumi:"protectType"`
	// Cloud server sole UUID.
	Quuid pulumi.StringInput `pulumi:"quuid"`
	// Region detail.
	RegionInfos GetMachinesSimpleMachineRegionInfoArrayInput `pulumi:"regionInfos"`
	// Tag.
	Tags GetMachinesSimpleMachineTagArrayInput `pulumi:"tags"`
	// Cwp client sole UUID.
	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 {
	// Tag key.
	TagKey string `pulumi:"tagKey"`
	// Tag value.
	TagValue string `pulumi:"tagValue"`
}

type GetMachinesSimpleMachineCloudTagArgs 

type GetMachinesSimpleMachineCloudTagArgs struct {
	// Tag key.
	TagKey pulumi.StringInput `pulumi:"tagKey"`
	// Tag value.
	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

Tag key.

func (GetMachinesSimpleMachineCloudTagOutput) TagValue 

func (o GetMachinesSimpleMachineCloudTagOutput) TagValue() pulumi.StringOutput

Tag value.

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 {
	// License ID.
	LicenseId int `pulumi:"licenseId"`
	// License Types.
	LicenseType int `pulumi:"licenseType"`
	// Resource ID.
	ResourceId string `pulumi:"resourceId"`
	// Order types.
	SourceType int `pulumi:"sourceType"`
	// License Order Status.
	Status int `pulumi:"status"`
}

type GetMachinesSimpleMachineLicenseOrderArgs 

type GetMachinesSimpleMachineLicenseOrderArgs struct {
	// License ID.
	LicenseId pulumi.IntInput `pulumi:"licenseId"`
	// License Types.
	LicenseType pulumi.IntInput `pulumi:"licenseType"`
	// Resource ID.
	ResourceId pulumi.StringInput `pulumi:"resourceId"`
	// Order types.
	SourceType pulumi.IntInput `pulumi:"sourceType"`
	// License Order Status.
	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

License ID.

func (GetMachinesSimpleMachineLicenseOrderOutput) LicenseType 

func (o GetMachinesSimpleMachineLicenseOrderOutput) LicenseType() pulumi.IntOutput

License Types.

func (GetMachinesSimpleMachineLicenseOrderOutput) ResourceId 

func (o GetMachinesSimpleMachineLicenseOrderOutput) ResourceId() pulumi.StringOutput

Resource ID.

func (GetMachinesSimpleMachineLicenseOrderOutput) SourceType 

func (o GetMachinesSimpleMachineLicenseOrderOutput) SourceType() pulumi.IntOutput

Order types.

func (GetMachinesSimpleMachineLicenseOrderOutput) Status 

func (o GetMachinesSimpleMachineLicenseOrderOutput) Status() pulumi.IntOutput

License Order Status.

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

Cloud tags detailNote: This field may return null, indicating that a valid value cannot be obtained.

func (GetMachinesSimpleMachineOutput) ElementType 

func (GetMachinesSimpleMachineOutput) ElementType() reflect.Type

func (GetMachinesSimpleMachineOutput) InstanceId 

func (o GetMachinesSimpleMachineOutput) InstanceId() pulumi.StringOutput

Instance IDNote: This field may return null, indicating that a valid value cannot be obtained.

func (GetMachinesSimpleMachineOutput) InstanceState 

func (o GetMachinesSimpleMachineOutput) InstanceState() pulumi.StringOutput

Instance status.

func (GetMachinesSimpleMachineOutput) IsProVersion 

func (o GetMachinesSimpleMachineOutput) IsProVersion() pulumi.BoolOutput

Paid version or not. true: yes; false: no.

func (GetMachinesSimpleMachineOutput) KernelVersion 

func (o GetMachinesSimpleMachineOutput) KernelVersion() pulumi.StringOutput

Core Version.

func (GetMachinesSimpleMachineOutput) LicenseOrders 

func (o GetMachinesSimpleMachineOutput) LicenseOrders() GetMachinesSimpleMachineLicenseOrderArrayOutput

License Order ObjectNote: This field may return null, indicating that a valid value cannot be obtained.

func (GetMachinesSimpleMachineOutput) MachineIp 

func (o GetMachinesSimpleMachineOutput) MachineIp() pulumi.StringOutput

Machine Internal net IP.

func (GetMachinesSimpleMachineOutput) MachineName 

func (o GetMachinesSimpleMachineOutput) MachineName() pulumi.StringOutput

Machine name.

func (GetMachinesSimpleMachineOutput) MachineOs 

func (o GetMachinesSimpleMachineOutput) MachineOs() pulumi.StringOutput

Machine OS System.

func (GetMachinesSimpleMachineOutput) MachineType 

func (o GetMachinesSimpleMachineOutput) MachineType() pulumi.StringOutput

Service types. -CVM: Cloud Virtual Machine; -ECM: Edge Computing Machine; -LH: Lighthouse; -Other: Mixed cloud; -ALL: All server types.

func (GetMachinesSimpleMachineOutput) MachineWanIp 

func (o GetMachinesSimpleMachineOutput) MachineWanIp() pulumi.StringOutput

Machine Outer net IP.

func (GetMachinesSimpleMachineOutput) PayMode 

func (o GetMachinesSimpleMachineOutput) PayMode() pulumi.StringOutput

Payment model. POSTPAY: Pay as you go; PREPAY: Monthly subscription.

func (GetMachinesSimpleMachineOutput) ProjectId 

func (o GetMachinesSimpleMachineOutput) ProjectId() pulumi.IntOutput

Project ID.

func (GetMachinesSimpleMachineOutput) ProtectType 

func (o GetMachinesSimpleMachineOutput) ProtectType() pulumi.StringOutput

Protection Version. -BASIC_VERSION: Basic Version; -PRO_VERSION: Pro Version -Flagship: Flagship Version; -GENERAL_DISCOUNT: CWP-LH Version.

func (GetMachinesSimpleMachineOutput) Quuid 

func (o GetMachinesSimpleMachineOutput) Quuid() pulumi.StringOutput

Cloud server sole UUID.

func (GetMachinesSimpleMachineOutput) RegionInfos 

func (o GetMachinesSimpleMachineOutput) RegionInfos() GetMachinesSimpleMachineRegionInfoArrayOutput

Region detail.

func (GetMachinesSimpleMachineOutput) Tags 

func (o GetMachinesSimpleMachineOutput) Tags() GetMachinesSimpleMachineTagArrayOutput

Tag.

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

Cwp client sole UUID.

type GetMachinesSimpleMachineRegionInfo 

type GetMachinesSimpleMachineRegionInfo struct {
	// Region, Such as ap-guangzhou, ap-shanghai, ap-beijing.
	Region string `pulumi:"region"`
	// Region Code.
	RegionCode string `pulumi:"regionCode"`
	// Region ID.
	RegionId int `pulumi:"regionId"`
	// Regional Chinese name.
	RegionName string `pulumi:"regionName"`
	// Regional English name.
	RegionNameEn string `pulumi:"regionNameEn"`
}

type GetMachinesSimpleMachineRegionInfoArgs 

type GetMachinesSimpleMachineRegionInfoArgs struct {
	// Region, Such as ap-guangzhou, ap-shanghai, ap-beijing.
	Region pulumi.StringInput `pulumi:"region"`
	// Region Code.
	RegionCode pulumi.StringInput `pulumi:"regionCode"`
	// Region ID.
	RegionId pulumi.IntInput `pulumi:"regionId"`
	// Regional Chinese name.
	RegionName pulumi.StringInput `pulumi:"regionName"`
	// Regional English name.
	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

Region, Such as ap-guangzhou, ap-shanghai, ap-beijing.

func (GetMachinesSimpleMachineRegionInfoOutput) RegionCode 

func (o GetMachinesSimpleMachineRegionInfoOutput) RegionCode() pulumi.StringOutput

Region Code.

func (GetMachinesSimpleMachineRegionInfoOutput) RegionId 

func (o GetMachinesSimpleMachineRegionInfoOutput) RegionId() pulumi.IntOutput

Region ID.

func (GetMachinesSimpleMachineRegionInfoOutput) RegionName 

func (o GetMachinesSimpleMachineRegionInfoOutput) RegionName() pulumi.StringOutput

Regional Chinese name.

func (GetMachinesSimpleMachineRegionInfoOutput) RegionNameEn 

func (o GetMachinesSimpleMachineRegionInfoOutput) RegionNameEn() pulumi.StringOutput

Regional English name.

func (GetMachinesSimpleMachineRegionInfoOutput) ToGetMachinesSimpleMachineRegionInfoOutput 

func (o GetMachinesSimpleMachineRegionInfoOutput) ToGetMachinesSimpleMachineRegionInfoOutput() GetMachinesSimpleMachineRegionInfoOutput

func (GetMachinesSimpleMachineRegionInfoOutput) ToGetMachinesSimpleMachineRegionInfoOutputWithContext 

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

type GetMachinesSimpleMachineTag 

type GetMachinesSimpleMachineTag struct {
	// Only supported Keywords, Version and TagId.
	Name string `pulumi:"name"`
	// Relevance tag id.
	Rid int `pulumi:"rid"`
	// Tag ID.
	TagId int `pulumi:"tagId"`
}

type GetMachinesSimpleMachineTagArgs 

type GetMachinesSimpleMachineTagArgs struct {
	// Only supported Keywords, Version and TagId.
	Name pulumi.StringInput `pulumi:"name"`
	// Relevance tag id.
	Rid pulumi.IntInput `pulumi:"rid"`
	// Tag ID.
	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

Only supported Keywords, Version and TagId.

func (GetMachinesSimpleMachineTagOutput) Rid 

func (o GetMachinesSimpleMachineTagOutput) Rid() pulumi.IntOutput

Relevance tag id.

func (GetMachinesSimpleMachineTagOutput) TagId 

func (o GetMachinesSimpleMachineTagOutput) TagId() pulumi.IntOutput

Tag ID.

func (GetMachinesSimpleMachineTagOutput) ToGetMachinesSimpleMachineTagOutput 

func (o GetMachinesSimpleMachineTagOutput) ToGetMachinesSimpleMachineTagOutput() GetMachinesSimpleMachineTagOutput

func (GetMachinesSimpleMachineTagOutput) ToGetMachinesSimpleMachineTagOutputWithContext 

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

type GetMachinesSimpleOutputArgs 

type GetMachinesSimpleOutputArgs struct {
	// filter list.
	Filters GetMachinesSimpleFilterArrayInput `pulumi:"filters"`
	// The area where the machine belongs,Such as: ap-guangzhou, ap-shanghai, all-regions: All server region types.
	MachineRegion pulumi.StringInput `pulumi:"machineRegion"`
	// Service types. -CVM: Cloud Virtual Machine; -ECM: Edge Computing Machine; -LH: Lighthouse; -Other: Mixed cloud; -ALL: All server types.
	MachineType pulumi.StringInput `pulumi:"machineType"`
	// Project id list.
	ProjectIds pulumi.IntArrayInput `pulumi:"projectIds"`
	// Used to save results.
	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"`
	// Service types. -CVM: Cloud Virtual Machine; -ECM: Edge Computing Machine -LH: Lighthouse; -Other: Mixed cloud; -ALL: All server types.
	MachineType string `pulumi:"machineType"`
	// Machine list.
	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)

Use this data source to query detailed information of cwp machinesSimple

## Example Usage ### Query by TagId filter

```go package main

import ( 

"github.com/pulumi/pulumi-tencentcloud/sdk/go/tencentcloud/Cwp"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
"github.com/tencentcloudstack/pulumi-tencentcloud/sdk/go/tencentcloud/Cwp"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := Cwp.GetMachinesSimple(ctx, &cwp.GetMachinesSimpleArgs{
			Filters: []cwp.GetMachinesSimpleFilter{
				cwp.GetMachinesSimpleFilter{
					ExactMatch: pulumi.BoolRef(true),
					Name:       "TagId",
					Values: []string{
						"13771",
					},
				},
			},
			MachineRegion: "all-regions",
			MachineType:   "ALL",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

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

Service types. -CVM: Cloud Virtual Machine; -ECM: Edge Computing Machine -LH: Lighthouse; -Other: Mixed cloud; -ALL: All server types.

func (GetMachinesSimpleResultOutput) Machines 

func (o GetMachinesSimpleResultOutput) Machines() GetMachinesSimpleMachineArrayOutput

Machine list.

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"`
}

Provides a resource to create a cwp licenseBindAttachment

## Import

cwp license_bind_attachment can be imported using the id, e.g.

```sh 

$ pulumi import tencentcloud:Cwp/licenseBindAttachment:LicenseBindAttachment example cwplic-ab3edffa#44#2c7e5cce-1cec-4456-8d18-018f160dd987#0

```

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"`
}

Provides a resource to create a cwp licenseOrder

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
"github.com/tencentcloudstack/pulumi-tencentcloud/sdk/go/tencentcloud/Cwp"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := Cwp.NewLicenseOrder(ctx, "example", &Cwp.LicenseOrderArgs{
			Alias:       pulumi.String("tf_example"),
			LicenseNum:  pulumi.Int(1),
			LicenseType: pulumi.Int(0),
			ProjectId:   pulumi.Int(0),
			RegionId:    pulumi.Int(1),
			Tags: pulumi.AnyMap{
				"createdBy": pulumi.Any("terraform"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

cwp license_order can be imported using the id, e.g.

```sh 

$ pulumi import tencentcloud:Cwp/licenseOrder:LicenseOrder example cwplic-130715d2#1

```

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.