model

package
v0.1.67 Latest Latest
Warning

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

 Go to latest Published: Nov 16, 2023 License: Apache-2.0, BSD-2-Clause, BSD-3-Clause Imports: 4 Imported by: 1

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AdministrationAgencyNamePrimitiveTypeHolder added in v0.1.61 

type AdministrationAgencyNamePrimitiveTypeHolder struct {

	// 管理委托名称  资源编排服务使用该委托获取成员账号委托给管理账号的权限  当用户定义SELF_MANAGED权限类型时，administration_agency_name和administration_agency_urn 必须有且只有一个存在。  推荐用户在使用v5委托时给与administration_agency_urn，administration_agency_name只支持接收v3委托名称，若给与了v5委托名称，则会在部署模板时失败。  当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400。  [创建委托及授权方式](https://support.huaweicloud.com/usermanual-iam/iam_06_0002.html)
	AdministrationAgencyName *string `json:"administration_agency_name,omitempty"`
}

func (AdministrationAgencyNamePrimitiveTypeHolder) String added in v0.1.61 

func (o AdministrationAgencyNamePrimitiveTypeHolder) String() string

type AdministrationAgencyUrnPrimitiveTypeHolder added in v0.1.61 

type AdministrationAgencyUrnPrimitiveTypeHolder struct {

	// 管理委托URN  资源编排服务使用该委托获取成员账号委托给管理账号的权限  当用户定义SELF_MANAGED权限类型时，administration_agency_name和administration_agency_urn 必须有且只有一个存在。  推荐用户在使用v5委托时给与administration_agency_urn，administration_agency_name只支持接收普通委托名称，若给与了v5委托名称，则会在部署模板时失败。  当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400。
	AdministrationAgencyUrn *string `json:"administration_agency_urn,omitempty"`
}

func (AdministrationAgencyUrnPrimitiveTypeHolder) String added in v0.1.61 

func (o AdministrationAgencyUrnPrimitiveTypeHolder) String() string

type AgenciesPrimitiveTypeHolder 

type AgenciesPrimitiveTypeHolder struct {

	// 委托授权的信息。  RFS仅在创建资源栈（触发部署）、创建执行计划、部署资源栈、删除资源栈等涉及资源操作的请求中使用委托，且该委托仅作用于与之绑定的Provider对资源的操作中。若委托中提供的权限不足，有可能导致相关资源操作失败。  [创建委托及授权方式](https://support.huaweicloud.com/usermanual-iam/iam_06_0002.html)
	Agencies *[]Agency `json:"agencies,omitempty"`
}

func (AgenciesPrimitiveTypeHolder) String 

func (o AgenciesPrimitiveTypeHolder) String() string

type Agency 

type Agency struct {

	// 用户使用的provider的名字。如果用户给与的provider_name含有重复的值，则返回400
	ProviderName string `json:"provider_name"`

	// 对应provider所使用的IAM委托名称，资源编排服务会使用此委托的权限去访问、创建对应provider的资源。agency_name和agency_urn必须有且只有一个存在
	AgencyName *string `json:"agency_name,omitempty"`

	// 委托URN  当用户定义Agency时，agency_name和agency_urn 必须有且只有一个存在。  推荐用户在使用v5委托时给与agency_urn，agency_name只支持接收普通委托名称，若给与了v5委托名称，则会在部署模板时失败。
	AgencyUrn *string `json:"agency_urn,omitempty"`
}

Agency 委托授权的信息

func (Agency) String 

func (o Agency) String() string

type ApplyExecutionPlanRequest 

type ApplyExecutionPlanRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	// 执行计划的名称。此名字在domain_id+区域+project_id+stack_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	ExecutionPlanName string `json:"execution_plan_name"`

	Body *ApplyExecutionPlanRequestBody `json:"body,omitempty"`
}

ApplyExecutionPlanRequest Request Object

func (ApplyExecutionPlanRequest) String 

func (o ApplyExecutionPlanRequest) String() string

type ApplyExecutionPlanRequestBody 

type ApplyExecutionPlanRequestBody struct {

	// 执行计划（execution_plan）的唯一Id。  此Id由资源编排服务在生成执行计划的时候生成，为UUID。  由于执行计划名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的执行计划，删除，再重新创建一个同名执行计划。  对于团队并行开发，用户可能希望确保，当前我操作的执行计划就是我认为的那个，而不是其他队友删除后创建的同名执行计划。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的执行计划所对应的ID都不相同，更新不会影响ID。如果给与的execution_plan_id和当前执行计划的ID不一致，则返回400
	ExecutionPlanId *string `json:"execution_plan_id,omitempty"`

	// 资源栈（stack）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`
}

func (ApplyExecutionPlanRequestBody) String 

func (o ApplyExecutionPlanRequestBody) String() string

type ApplyExecutionPlanResponse 

type ApplyExecutionPlanResponse struct {

	// 标识部署的唯一Id，此Id由资源编排服务在触发部署、回滚等操作时生成，为UUID。
	DeploymentId   *string `json:"deployment_id,omitempty"`
	HttpStatusCode int     `json:"-"`
}

ApplyExecutionPlanResponse Response Object

func (ApplyExecutionPlanResponse) String 

func (o ApplyExecutionPlanResponse) String() string

type BaseTemplate added in v0.1.30 

type BaseTemplate struct {

	// 模板的唯一ID，由模板服务随机生成
	TemplateId string `json:"template_id"`

	// 用户希望创建的模板名称
	TemplateName string `json:"template_name"`

	// 模板的描述。可用于客户识别自己的模板
	TemplateDescription *string `json:"template_description,omitempty"`

	// 模板的生成时间，格式遵循RFC3339，即yyyy-mm-ddTHH:MM:SSZ，如1970-01-01T00:00:00Z
	CreateTime string `json:"create_time"`

	// 模板的更新时间，格式遵循RFC3339，即yyyy-mm-ddTHH:MM:SSZ，如1970-01-01T00:00:00Z
	UpdateTime string `json:"update_time"`
}

BaseTemplate 模板基本信息

func (BaseTemplate) String added in v0.1.30 

func (o BaseTemplate) String() string

type BaseTemplateVersion added in v0.1.30 

type BaseTemplateVersion struct {

	// 模板的唯一ID，由模板服务随机生成
	TemplateId string `json:"template_id"`

	// 用户希望创建的模板名称
	TemplateName string `json:"template_name"`

	// 模板版本的描述。可用于客户识别自己的模板版本
	VersionDescription *string `json:"version_description,omitempty"`

	// 版本创建时间，格式遵循RFC3339，即yyyy-mm-ddTHH:MM:SSZ，如1970-01-01T00:00:00Z
	CreateTime string `json:"create_time"`
}

BaseTemplateVersion 模板版本基本信息

func (BaseTemplateVersion) String added in v0.1.30 

func (o BaseTemplateVersion) String() string

type ContinueDeployStackRequest added in v0.1.39 

type ContinueDeployStackRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	Body *ContinueDeployStackRequestBody `json:"body,omitempty"`
}

ContinueDeployStackRequest Request Object

func (ContinueDeployStackRequest) String added in v0.1.39 

func (o ContinueDeployStackRequest) String() string

type ContinueDeployStackRequestBody added in v0.1.39 

type ContinueDeployStackRequestBody struct {

	// 资源栈（stack）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`
}

func (ContinueDeployStackRequestBody) String added in v0.1.39 

func (o ContinueDeployStackRequestBody) String() string

type ContinueDeployStackResponse added in v0.1.39 

type ContinueDeployStackResponse struct {

	// 部署ID
	DeploymentId   *string `json:"deployment_id,omitempty"`
	HttpStatusCode int     `json:"-"`
}

ContinueDeployStackResponse Response Object

func (ContinueDeployStackResponse) String added in v0.1.39 

func (o ContinueDeployStackResponse) String() string

type ContinueRollbackStackRequest 

type ContinueRollbackStackRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	Body *ContinueRollbackStackRequestBody `json:"body,omitempty"`
}

ContinueRollbackStackRequest Request Object

func (ContinueRollbackStackRequest) String 

func (o ContinueRollbackStackRequest) String() string

type ContinueRollbackStackRequestBody 

type ContinueRollbackStackRequestBody struct {

	// 资源栈（stack）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`
}

func (ContinueRollbackStackRequestBody) String 

func (o ContinueRollbackStackRequestBody) String() string

type ContinueRollbackStackResponse 

type ContinueRollbackStackResponse struct {

	// 继续回滚触发部署生成的唯一的deployment_id，由资源编排服务生成，通常为UUID
	DeploymentId   *string `json:"deployment_id,omitempty"`
	HttpStatusCode int     `json:"-"`
}

ContinueRollbackStackResponse Response Object

func (ContinueRollbackStackResponse) String 

func (o ContinueRollbackStackResponse) String() string

type CreateExecutionPlanRequest 

type CreateExecutionPlanRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	Body *CreateExecutionPlanRequestBody `json:"body,omitempty"`
}

CreateExecutionPlanRequest Request Object

func (CreateExecutionPlanRequest) String 

func (o CreateExecutionPlanRequest) String() string

type CreateExecutionPlanRequestBody 

type CreateExecutionPlanRequestBody struct {

	// 资源栈（stack）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`

	// HCL模板，描述了资源的目标状态。资源编排服务将比较此模板与当前远程资源的状态之间的区别。  template_body和template_uri 必须有且只有一个存在  **注意：**   * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储对应的template_body
	TemplateBody *string `json:"template_body,omitempty"`

	// HCL模板的OBS地址，该模板描述了资源的目标状态。资源编排服务将比较此模板与当前远程资源的状态之间的区别  OBS地址支持同类型Region之间进行互相访问（Region分为通用Region和专属Region，通用Region指面向公共租户提供通用云服务的Region；专属Region指只承载同一类业务或只面向特定租户提供业务服务的专用Region）  对应的文件应该是纯tf文件或zip压缩包  纯tf文件需要以“.tf”或者“.tf.json”结尾，并遵守HCL语法，且文件的编码格式须为UTF-8  压缩包目前只支持zip格式，文件需要以\".zip\"结尾。解压后的文件不得包含\".tfvars\"文件。解压前最大支持1MB，解压后最大支持1MB。zip压缩包文件数量不能超过100个  template_body和template_uri 必须有且只有一个存在  **注意：**   * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储template_uri对应的模板文件内容。   * template_uri对应的模板文件若为zip类型，则内部的文件或文件夹名称长度不得超过255个字节，最深路径长度不得超过2048字节，zip包大小不得超过1MB
	TemplateUri *string `json:"template_uri,omitempty"`

	// 执行计划的名称。此名字在domain_id+区域+project_id+stack_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	ExecutionPlanName string `json:"execution_plan_name"`

	// 执行计划的描述。可用于客户识别自己的执行计划。
	Description *string `json:"description,omitempty"`

	// HCL参数结构。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  * var_structure可以允许客户提交最简单的字符串类型的参数  * 资源编排服务支持vars_structure，vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * vars_structure中的值只支持简单的字符串类型，如果需要使用其他类型，需要用户自己在HCL引用时转换， 或者用户可以使用vars_uri、vars_body，vars_uri和vars_body中支持HCL支持的各种类型以及复杂结构  * 如果vars_structure过大，可以使用vars_uri  * 注意：vars_structure中默认不应该含有任何敏感信息，资源编排服务会直接明文使用、log、展示、存储对应的vars。如为敏感信息，建议设置encryption字段开启加密
	VarsStructure *[]VarsStructure `json:"vars_structure,omitempty"`

	// HCL参数文件的内容。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  * vars_body使用HCL的tfvars格式，用户可以将“.tfvars”中的内容提交到vars_body中  * 资源编排服务支持vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * 如果vars_body过大，可以使用vars_uri  * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储对应的vars_body。
	VarsBody *string `json:"vars_body,omitempty"`

	// HCL参数文件的OBS地址。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  OBS地址支持同类型Region之间进行互相访问（Region分为通用Region和专属Region，通用Region指面向公共租户提供通用云服务的Region；专属Region指只承载同一类业务或只面向特定租户提供业务服务的专用Region）  * vars_uri需要指向一个OBS的pre-signed URL地址，其他地址暂不支持  * 资源编排服务支持vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * vars_uri中的内容使用HCL的tfvars格式，用户可以将“.tfvars”中的内容保存到文件并上传到OBS中，并将OBS pre-signed URL传递给vars_uri  * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储vars_uri对应的参数文件内容
	VarsUri *string `json:"vars_uri,omitempty"`
}

func (CreateExecutionPlanRequestBody) String 

func (o CreateExecutionPlanRequestBody) String() string

type CreateExecutionPlanResponse 

type CreateExecutionPlanResponse struct {

	// 执行计划（execution_plan）的唯一Id。  此Id由资源编排服务在生成执行计划的时候生成，为UUID。  由于执行计划名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的执行计划，删除，再重新创建一个同名执行计划。  对于团队并行开发，用户可能希望确保，当前我操作的执行计划就是我认为的那个，而不是其他队友删除后创建的同名执行计划。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的执行计划所对应的ID都不相同，更新不会影响ID。如果给与的execution_plan_id和当前执行计划的ID不一致，则返回400
	ExecutionPlanId *string `json:"execution_plan_id,omitempty"`
	HttpStatusCode  int     `json:"-"`
}

CreateExecutionPlanResponse Response Object

func (CreateExecutionPlanResponse) String 

func (o CreateExecutionPlanResponse) String() string

type CreateStackInstanceRequest added in v0.1.61 

type CreateStackInstanceRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈集的名称。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackSetName string `json:"stack_set_name"`

	Body *CreateStackInstanceRequestBody `json:"body,omitempty"`
}

CreateStackInstanceRequest Request Object

func (CreateStackInstanceRequest) String added in v0.1.61 

func (o CreateStackInstanceRequest) String() string

type CreateStackInstanceRequestBody added in v0.1.61 

type CreateStackInstanceRequestBody struct {

	// 资源栈集（stack_set）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈集名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈集，删除，在重新创建一个同名资源栈集。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈集就是我以为的那个，而不是又其他队友删除后创建的同名资源栈集。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈集所对应的ID都不相同，更新不会影响ID。如果给与的stack_set_id和当前资源栈集的ID不一致，则返回400
	StackSetId *string `json:"stack_set_id,omitempty"`

	DeploymentTargets *DeploymentTargets `json:"deployment_targets"`

	VarOverrides *VarOverridesPrimitiveTypeHolderVarOverrides `json:"var_overrides,omitempty"`
}

func (CreateStackInstanceRequestBody) String added in v0.1.61 

func (o CreateStackInstanceRequestBody) String() string

type CreateStackInstanceResponse added in v0.1.61 

type CreateStackInstanceResponse struct {

	// 资源栈集操作（operation）的唯一Id。  此Id由资源编排服务在生成资源栈集操作的时候生成，为UUID。
	StackSetOperationId *string `json:"stack_set_operation_id,omitempty"`
	HttpStatusCode      int     `json:"-"`
}

CreateStackInstanceResponse Response Object

func (CreateStackInstanceResponse) String added in v0.1.61 

func (o CreateStackInstanceResponse) String() string

type CreateStackRequest 

type CreateStackRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	Body *CreateStackRequestBody `json:"body,omitempty"`
}

CreateStackRequest Request Object

func (CreateStackRequest) String 

func (o CreateStackRequest) String() string

type CreateStackRequestBody 

type CreateStackRequestBody struct {

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	// 委托授权的信息。  RFS仅在创建资源栈（触发部署）、创建执行计划、部署资源栈、删除资源栈等涉及资源操作的请求中使用委托，且该委托仅作用于与之绑定的Provider对资源的操作中。若委托中提供的权限不足，有可能导致相关资源操作失败。  [创建委托及授权方式](https://support.huaweicloud.com/usermanual-iam/iam_06_0002.html)
	Agencies *[]Agency `json:"agencies,omitempty"`

	// 资源栈的描述。可用于客户识别自己的资源栈。
	Description *string `json:"description,omitempty"`

	// 删除保护的标识位，如果不传默认为false，即默认不开启资源栈删除保护（删除保护开启后资源栈不允许被删除）  *在UpdateStack API中，若该参数未在RequestBody中给予，则不会对资源栈的删除保护属性进行更新*
	EnableDeletionProtection *bool `json:"enable_deletion_protection,omitempty"`

	// 自动回滚的标识位，如果不传默认为false，即默认不开启资源栈自动回滚（自动回滚开启后，如果部署失败，则会自动回滚，并返回上一个稳定状态）  *在UpdateStack API中，若该参数未在RequestBody中给予，则不会对资源栈的自动回滚属性进行更新* *该属性与使用模板导入资源功能互斥，如果堆栈的自动回滚设置为true，则不允许部署包含导入资源的模板*
	EnableAutoRollback *bool `json:"enable_auto_rollback,omitempty"`

	// HCL模板，描述了资源的目标状态。资源编排服务将比较此模板与当前远程资源的状态之间的区别。  template_body和template_uri 必须有且只有一个存在  **注意：**   * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储对应的template_body
	TemplateBody *string `json:"template_body,omitempty"`

	// HCL模板的OBS地址，该模板描述了资源的目标状态。资源编排服务将比较此模板与当前远程资源的状态之间的区别  OBS地址支持同类型Region之间进行互相访问（Region分为通用Region和专属Region，通用Region指面向公共租户提供通用云服务的Region；专属Region指只承载同一类业务或只面向特定租户提供业务服务的专用Region）  对应的文件应该是纯tf文件或zip压缩包  纯tf文件需要以“.tf”或者“.tf.json”结尾，并遵守HCL语法，且文件的编码格式须为UTF-8  压缩包目前只支持zip格式，文件需要以\".zip\"结尾。解压后的文件不得包含\".tfvars\"文件。解压前最大支持1MB，解压后最大支持1MB。zip压缩包文件数量不能超过100个  template_body和template_uri 必须有且只有一个存在  **注意：**   * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储template_uri对应的模板文件内容。   * template_uri对应的模板文件若为zip类型，则内部的文件或文件夹名称长度不得超过255个字节，最深路径长度不得超过2048字节，zip包大小不得超过1MB
	TemplateUri *string `json:"template_uri,omitempty"`

	// HCL参数文件的内容。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  * vars_body使用HCL的tfvars格式，用户可以将“.tfvars”中的内容提交到vars_body中  * 资源编排服务支持vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * 如果vars_body过大，可以使用vars_uri  * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储对应的vars_body。
	VarsBody *string `json:"vars_body,omitempty"`

	// HCL参数结构。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  * var_structure可以允许客户提交最简单的字符串类型的参数  * 资源编排服务支持vars_structure，vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * vars_structure中的值只支持简单的字符串类型，如果需要使用其他类型，需要用户自己在HCL引用时转换， 或者用户可以使用vars_uri、vars_body，vars_uri和vars_body中支持HCL支持的各种类型以及复杂结构  * 如果vars_structure过大，可以使用vars_uri  * 注意：vars_structure中默认不应该含有任何敏感信息，资源编排服务会直接明文使用、log、展示、存储对应的vars。如为敏感信息，建议设置encryption字段开启加密
	VarsStructure *[]VarsStructure `json:"vars_structure,omitempty"`

	// HCL参数文件的OBS地址。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  OBS地址支持同类型Region之间进行互相访问（Region分为通用Region和专属Region，通用Region指面向公共租户提供通用云服务的Region；专属Region指只承载同一类业务或只面向特定租户提供业务服务的专用Region）  * vars_uri需要指向一个OBS的pre-signed URL地址，其他地址暂不支持  * 资源编排服务支持vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * vars_uri中的内容使用HCL的tfvars格式，用户可以将“.tfvars”中的内容保存到文件并上传到OBS中，并将OBS pre-signed URL传递给vars_uri  * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储vars_uri对应的参数文件内容
	VarsUri *string `json:"vars_uri,omitempty"`
}

func (CreateStackRequestBody) String 

func (o CreateStackRequestBody) String() string

type CreateStackResponse 

type CreateStackResponse struct {

	// 资源栈（stack）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`

	// 部署ID
	DeploymentId   *string `json:"deployment_id,omitempty"`
	HttpStatusCode int     `json:"-"`
}

CreateStackResponse Response Object

func (CreateStackResponse) String 

func (o CreateStackResponse) String() string

type CreateStackSetRequest added in v0.1.61 

type CreateStackSetRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	Body *CreateStackSetRequestBody `json:"body,omitempty"`
}

CreateStackSetRequest Request Object

func (CreateStackSetRequest) String added in v0.1.61 

func (o CreateStackSetRequest) String() string

type CreateStackSetRequestBody added in v0.1.61 

type CreateStackSetRequestBody struct {

	// 资源栈集（stack_set）的名字。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackSetName string `json:"stack_set_name"`

	// 资源栈集的描述。可用于客户识别自己的资源栈集。
	StackSetDescription *string `json:"stack_set_description,omitempty"`

	// 权限模型，定义了RFS操作资源栈集时所需委托的创建方式，枚举值    * `SELF_MANAGED` - 基于部署需求，用户需要提前手动创建委托，既包含管理账号给RFS的委托，也包含成员账号创建给管理账号的委托。如果委托不存在或错误，创建资源栈集不会失败，部署资源栈集或部署资源栈实例的时候才会报错。
	PermissionModel *CreateStackSetRequestBodyPermissionModel `json:"permission_model,omitempty"`

	// 管理委托名称  资源编排服务使用该委托获取成员账号委托给管理账号的权限  当用户定义SELF_MANAGED权限类型时，administration_agency_name和administration_agency_urn 必须有且只有一个存在。  推荐用户在使用v5委托时给与administration_agency_urn，administration_agency_name只支持接收v3委托名称，若给与了v5委托名称，则会在部署模板时失败。  当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400。  [创建委托及授权方式](https://support.huaweicloud.com/usermanual-iam/iam_06_0002.html)
	AdministrationAgencyName *string `json:"administration_agency_name,omitempty"`

	// 被管理的委托名称。  资源编排服务会使用该委托获取实际部署资源所需要的权限  不同成员账号委托给管理账号的委托名称需要保持一致。暂不支持根据不同provider定义不同委托权限  当用户定义SELF_MANAGED权限类型时，必须指定该参数。当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400  [创建委托及授权方式](https://support.huaweicloud.com/usermanual-iam/iam_06_0002.html)
	ManagedAgencyName *string `json:"managed_agency_name,omitempty"`

	// HCL模板，描述了资源的目标状态。资源编排服务将比较此模板与当前远程资源的状态之间的区别。  template_body和template_uri 必须有且只有一个存在  **注意：**   * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储对应的template_body
	TemplateBody *string `json:"template_body,omitempty"`

	// HCL模板的OBS地址，该模板描述了资源的目标状态。资源编排服务将比较此模板与当前远程资源的状态之间的区别  OBS地址支持同类型Region之间进行互相访问（Region分为通用Region和专属Region，通用Region指面向公共租户提供通用云服务的Region；专属Region指只承载同一类业务或只面向特定租户提供业务服务的专用Region）  对应的文件应该是纯tf文件或zip压缩包  纯tf文件需要以“.tf”或者“.tf.json”结尾，并遵守HCL语法，且文件的编码格式须为UTF-8  压缩包目前只支持zip格式，文件需要以\".zip\"结尾。解压后的文件不得包含\".tfvars\"文件。解压前最大支持1MB，解压后最大支持1MB。zip压缩包文件数量不能超过100个  template_body和template_uri 必须有且只有一个存在  **注意：**   * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储template_uri对应的模板文件内容。   * template_uri对应的模板文件若为zip类型，则内部的文件或文件夹名称长度不得超过255个字节，最深路径长度不得超过2048字节，zip包大小不得超过1MB
	TemplateUri *string `json:"template_uri,omitempty"`

	// HCL参数文件的OBS地址。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  OBS地址支持同类型Region之间进行互相访问（Region分为通用Region和专属Region，通用Region指面向公共租户提供通用云服务的Region；专属Region指只承载同一类业务或只面向特定租户提供业务服务的专用Region）  * vars_uri需要指向一个OBS的pre-signed URL地址，其他地址暂不支持  * 资源编排服务支持vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * vars_uri中的内容使用HCL的tfvars格式，用户可以将“.tfvars”中的内容保存到文件并上传到OBS中，并将OBS pre-signed URL传递给vars_uri  * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储vars_uri对应的参数文件内容
	VarsUri *string `json:"vars_uri,omitempty"`

	// HCL参数文件的内容。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  * vars_body使用HCL的tfvars格式，用户可以将“.tfvars”中的内容提交到vars_body中  * 资源编排服务支持vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * 如果vars_body过大，可以使用vars_uri  * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储对应的vars_body。
	VarsBody *string `json:"vars_body,omitempty"`

	// 初始化资源栈描述。可用于客户识别被资源栈集所管理的资源栈。  资源栈集下的资源栈仅在创建时统一使用该描述。客户想要更新初始化资源栈描述，可以通过UpdateStackSet API。  后续更新资源栈集描述将不会同步更新已管理的资源栈描述。
	InitialStackDescription *string `json:"initial_stack_description,omitempty"`

	// 管理委托URN  资源编排服务使用该委托获取成员账号委托给管理账号的权限  当用户定义SELF_MANAGED权限类型时，administration_agency_name和administration_agency_urn 必须有且只有一个存在。  推荐用户在使用v5委托时给与administration_agency_urn，administration_agency_name只支持接收普通委托名称，若给与了v5委托名称，则会在部署模板时失败。  当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400。
	AdministrationAgencyUrn *string `json:"administration_agency_urn,omitempty"`
}

func (CreateStackSetRequestBody) String added in v0.1.61 

func (o CreateStackSetRequestBody) String() string

type CreateStackSetRequestBodyPermissionModel added in v0.1.61 

type CreateStackSetRequestBodyPermissionModel struct {
	// contains filtered or unexported fields
}

func (CreateStackSetRequestBodyPermissionModel) MarshalJSON added in v0.1.61 

func (c CreateStackSetRequestBodyPermissionModel) MarshalJSON() ([]byte, error)

func (*CreateStackSetRequestBodyPermissionModel) UnmarshalJSON added in v0.1.61 

func (c *CreateStackSetRequestBodyPermissionModel) UnmarshalJSON(b []byte) error

func (CreateStackSetRequestBodyPermissionModel) Value added in v0.1.61 

func (c CreateStackSetRequestBodyPermissionModel) Value() string

type CreateStackSetRequestBodyPermissionModelEnum added in v0.1.61 

type CreateStackSetRequestBodyPermissionModelEnum struct {
	SELF_MANAGED CreateStackSetRequestBodyPermissionModel
}

func GetCreateStackSetRequestBodyPermissionModelEnum added in v0.1.61 

func GetCreateStackSetRequestBodyPermissionModelEnum() CreateStackSetRequestBodyPermissionModelEnum

type CreateStackSetResponse added in v0.1.61 

type CreateStackSetResponse struct {

	// 资源栈集（stack_set）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈集名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈集，删除，在重新创建一个同名资源栈集。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈集就是我以为的那个，而不是又其他队友删除后创建的同名资源栈集。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈集所对应的ID都不相同，更新不会影响ID。如果给与的stack_set_id和当前资源栈集的ID不一致，则返回400
	StackSetId     *string `json:"stack_set_id,omitempty"`
	HttpStatusCode int     `json:"-"`
}

CreateStackSetResponse Response Object

func (CreateStackSetResponse) String added in v0.1.61 

func (o CreateStackSetResponse) String() string

type DeleteExecutionPlanRequest added in v0.1.15 

type DeleteExecutionPlanRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	// 执行计划的名称。此名字在domain_id+区域+project_id+stack_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	ExecutionPlanName string `json:"execution_plan_name"`

	// 资源栈（stack）的唯一Id。  此Id由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`

	// 执行计划（execution_plan）的唯一Id。  此Id由资源编排服务在生成执行计划的时候生成，为UUID。  由于执行计划名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的执行计划，删除，再重新创建一个同名执行计划。  对于团队并行开发，用户可能希望确保，当前我操作的执行计划就是我认为的那个，而不是其他队友删除后创建的同名执行计划。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的执行计划所对应的ID都不相同，更新不会影响ID。如果给与的execution_plan_id和当前执行计划的ID不一致，则返回400
	ExecutionPlanId *string `json:"execution_plan_id,omitempty"`
}

DeleteExecutionPlanRequest Request Object

func (DeleteExecutionPlanRequest) String added in v0.1.15 

func (o DeleteExecutionPlanRequest) String() string

type DeleteExecutionPlanResponse added in v0.1.15 

type DeleteExecutionPlanResponse struct {
	HttpStatusCode int `json:"-"`
}

DeleteExecutionPlanResponse Response Object

func (DeleteExecutionPlanResponse) String added in v0.1.15 

func (o DeleteExecutionPlanResponse) String() string

type DeleteStackEnhancedRequest added in v0.1.58 

type DeleteStackEnhancedRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	Body *DeleteStackEnhancedRequestBody `json:"body,omitempty"`
}

DeleteStackEnhancedRequest Request Object

func (DeleteStackEnhancedRequest) String added in v0.1.58 

func (o DeleteStackEnhancedRequest) String() string

type DeleteStackEnhancedRequestBody added in v0.1.58 

type DeleteStackEnhancedRequestBody struct {

	// 资源栈（stack）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`

	// 删除资源栈是否保留资源的标志位，如果不传默认为false，即默认不保留资源（删除资源栈后会删除资源栈中的资源）  * DeleteStackEnhanced API中，若该参数未在RequestBody中给予，则删除时不会保留资源栈中的资源*
	RetainAllResources *bool `json:"retain_all_resources,omitempty"`
}

func (DeleteStackEnhancedRequestBody) String added in v0.1.58 

func (o DeleteStackEnhancedRequestBody) String() string

type DeleteStackEnhancedResponse added in v0.1.58 

type DeleteStackEnhancedResponse struct {
	HttpStatusCode int `json:"-"`
}

DeleteStackEnhancedResponse Response Object

func (DeleteStackEnhancedResponse) String added in v0.1.58 

func (o DeleteStackEnhancedResponse) String() string

type DeleteStackInstanceRequest added in v0.1.61 

type DeleteStackInstanceRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈集的名称。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackSetName string `json:"stack_set_name"`

	Body *DeleteStackInstanceRequestBody `json:"body,omitempty"`
}

DeleteStackInstanceRequest Request Object

func (DeleteStackInstanceRequest) String added in v0.1.61 

func (o DeleteStackInstanceRequest) String() string

type DeleteStackInstanceRequestBody added in v0.1.61 

type DeleteStackInstanceRequestBody struct {

	// 资源栈集（stack_set）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈集名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈集，删除，在重新创建一个同名资源栈集。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈集就是我以为的那个，而不是又其他队友删除后创建的同名资源栈集。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈集所对应的ID都不相同，更新不会影响ID。如果给与的stack_set_id和当前资源栈集的ID不一致，则返回400
	StackSetId *string `json:"stack_set_id,omitempty"`

	DeploymentTargets *DeploymentTargets `json:"deployment_targets"`
}

func (DeleteStackInstanceRequestBody) String added in v0.1.61 

func (o DeleteStackInstanceRequestBody) String() string

type DeleteStackInstanceResponse added in v0.1.61 

type DeleteStackInstanceResponse struct {

	// 资源栈集操作（operation）的唯一Id。  此Id由资源编排服务在生成资源栈集操作的时候生成，为UUID。
	StackSetOperationId *string `json:"stack_set_operation_id,omitempty"`
	HttpStatusCode      int     `json:"-"`
}

DeleteStackInstanceResponse Response Object

func (DeleteStackInstanceResponse) String added in v0.1.61 

func (o DeleteStackInstanceResponse) String() string

type DeleteStackRequest added in v0.1.12 

type DeleteStackRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	// 资源栈（stack）的唯一Id。  此Id由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`
}

DeleteStackRequest Request Object

func (DeleteStackRequest) String added in v0.1.12 

func (o DeleteStackRequest) String() string

type DeleteStackResponse added in v0.1.12 

type DeleteStackResponse struct {
	HttpStatusCode int `json:"-"`
}

DeleteStackResponse Response Object

func (DeleteStackResponse) String added in v0.1.12 

func (o DeleteStackResponse) String() string

type DeleteStackSetRequest added in v0.1.61 

type DeleteStackSetRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈集的名称。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackSetName string `json:"stack_set_name"`

	// 资源栈集（stack-set）的唯一ID。  此ID由资源编排服务在生成资源栈集的时候生成，为UUID。  由于资源栈集名称仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈集，删除，再重新创建一个同名资源栈集。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈集就是我认为的那个，而不是其他队友删除后创建的同名资源栈集。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈集所对应的ID都不相同，更新不会影响ID。如果给与的stack_set_id和当前资源栈集的ID不一致，则返回400
	StackSetId *string `json:"stack_set_id,omitempty"`
}

DeleteStackSetRequest Request Object

func (DeleteStackSetRequest) String added in v0.1.61 

func (o DeleteStackSetRequest) String() string

type DeleteStackSetResponse added in v0.1.61 

type DeleteStackSetResponse struct {
	HttpStatusCode int `json:"-"`
}

DeleteStackSetResponse Response Object

func (DeleteStackSetResponse) String added in v0.1.61 

func (o DeleteStackSetResponse) String() string

type DeleteTemplateRequest added in v0.1.30 

type DeleteTemplateRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 用户希望创建的模板名称
	TemplateName string `json:"template_name"`

	// 模板的ID。当template_id存在时，模板服务会检查template_id是否和template_name匹配，不匹配会返回400
	TemplateId *string `json:"template_id,omitempty"`
}

DeleteTemplateRequest Request Object

func (DeleteTemplateRequest) String added in v0.1.30 

func (o DeleteTemplateRequest) String() string

type DeleteTemplateResponse added in v0.1.30 

type DeleteTemplateResponse struct {

	// 空响应体
	Body           *string `json:"body,omitempty"`
	HttpStatusCode int     `json:"-"`
}

DeleteTemplateResponse Response Object

func (DeleteTemplateResponse) String added in v0.1.30 

func (o DeleteTemplateResponse) String() string

type DeleteTemplateVersionRequest added in v0.1.30 

type DeleteTemplateVersionRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 用户希望创建的模板名称
	TemplateName string `json:"template_name"`

	// 模板版本ID，以大写V开头，每次创建模板版本，模板版本ID数字部分会自增加一
	VersionId string `json:"version_id"`

	// 模板的ID。当template_id存在时，模板服务会检查template_id是否和template_name匹配，不匹配会返回400
	TemplateId *string `json:"template_id,omitempty"`
}

DeleteTemplateVersionRequest Request Object

func (DeleteTemplateVersionRequest) String added in v0.1.30 

func (o DeleteTemplateVersionRequest) String() string

type DeleteTemplateVersionResponse added in v0.1.30 

type DeleteTemplateVersionResponse struct {

	// 空响应体
	Body           *string `json:"body,omitempty"`
	HttpStatusCode int     `json:"-"`
}

DeleteTemplateVersionResponse Response Object

func (DeleteTemplateVersionResponse) String added in v0.1.30 

func (o DeleteTemplateVersionResponse) String() string

type DeployStackRequest 

type DeployStackRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	Body *DeployStackRequestBody `json:"body,omitempty"`
}

DeployStackRequest Request Object

func (DeployStackRequest) String 

func (o DeployStackRequest) String() string

type DeployStackRequestBody 

type DeployStackRequestBody struct {

	// HCL模板，描述了资源的目标状态。资源编排服务将比较此模板与当前远程资源的状态之间的区别。  template_body和template_uri 必须有且只有一个存在  **注意：**   * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储对应的template_body
	TemplateBody *string `json:"template_body,omitempty"`

	// HCL模板的OBS地址，该模板描述了资源的目标状态。资源编排服务将比较此模板与当前远程资源的状态之间的区别  OBS地址支持同类型Region之间进行互相访问（Region分为通用Region和专属Region，通用Region指面向公共租户提供通用云服务的Region；专属Region指只承载同一类业务或只面向特定租户提供业务服务的专用Region）  对应的文件应该是纯tf文件或zip压缩包  纯tf文件需要以“.tf”或者“.tf.json”结尾，并遵守HCL语法，且文件的编码格式须为UTF-8  压缩包目前只支持zip格式，文件需要以\".zip\"结尾。解压后的文件不得包含\".tfvars\"文件。解压前最大支持1MB，解压后最大支持1MB。zip压缩包文件数量不能超过100个  template_body和template_uri 必须有且只有一个存在  **注意：**   * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储template_uri对应的模板文件内容。   * template_uri对应的模板文件若为zip类型，则内部的文件或文件夹名称长度不得超过255个字节，最深路径长度不得超过2048字节，zip包大小不得超过1MB
	TemplateUri *string `json:"template_uri,omitempty"`

	// HCL参数结构。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  * var_structure可以允许客户提交最简单的字符串类型的参数  * 资源编排服务支持vars_structure，vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * vars_structure中的值只支持简单的字符串类型，如果需要使用其他类型，需要用户自己在HCL引用时转换， 或者用户可以使用vars_uri、vars_body，vars_uri和vars_body中支持HCL支持的各种类型以及复杂结构  * 如果vars_structure过大，可以使用vars_uri  * 注意：vars_structure中默认不应该含有任何敏感信息，资源编排服务会直接明文使用、log、展示、存储对应的vars。如为敏感信息，建议设置encryption字段开启加密
	VarsStructure *[]VarsStructure `json:"vars_structure,omitempty"`

	// HCL参数文件的内容。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  * vars_body使用HCL的tfvars格式，用户可以将“.tfvars”中的内容提交到vars_body中  * 资源编排服务支持vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * 如果vars_body过大，可以使用vars_uri  * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储对应的vars_body。
	VarsBody *string `json:"vars_body,omitempty"`

	// HCL参数文件的OBS地址。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  OBS地址支持同类型Region之间进行互相访问（Region分为通用Region和专属Region，通用Region指面向公共租户提供通用云服务的Region；专属Region指只承载同一类业务或只面向特定租户提供业务服务的专用Region）  * vars_uri需要指向一个OBS的pre-signed URL地址，其他地址暂不支持  * 资源编排服务支持vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * vars_uri中的内容使用HCL的tfvars格式，用户可以将“.tfvars”中的内容保存到文件并上传到OBS中，并将OBS pre-signed URL传递给vars_uri  * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储vars_uri对应的参数文件内容
	VarsUri *string `json:"vars_uri,omitempty"`

	// 资源栈（stack）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`
}

func (DeployStackRequestBody) String 

func (o DeployStackRequestBody) String() string

type DeployStackResponse 

type DeployStackResponse struct {

	// 部署ID
	DeploymentId   *string `json:"deployment_id,omitempty"`
	HttpStatusCode int     `json:"-"`
}

DeployStackResponse Response Object

func (DeployStackResponse) String 

func (o DeployStackResponse) String() string

type DeployStackSetRequest added in v0.1.61 

type DeployStackSetRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈集的名称。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackSetName string `json:"stack_set_name"`

	Body *DeployStackSetRequestBody `json:"body,omitempty"`
}

DeployStackSetRequest Request Object

func (DeployStackSetRequest) String added in v0.1.61 

func (o DeployStackSetRequest) String() string

type DeployStackSetRequestBody added in v0.1.61 

type DeployStackSetRequestBody struct {

	// 资源栈集（stack_set）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈集名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈集，删除，在重新创建一个同名资源栈集。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈集就是我以为的那个，而不是又其他队友删除后创建的同名资源栈集。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈集所对应的ID都不相同，更新不会影响ID。如果给与的stack_set_id和当前资源栈集的ID不一致，则返回400
	StackSetId *string `json:"stack_set_id,omitempty"`

	DeploymentTargets *DeploymentTargets `json:"deployment_targets"`

	// HCL模板，描述了资源的目标状态。资源编排服务将比较此模板与当前远程资源的状态之间的区别。  template_body和template_uri 必须有且只有一个存在  **注意：**   * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储对应的template_body
	TemplateBody *string `json:"template_body,omitempty"`

	// HCL模板的OBS地址，该模板描述了资源的目标状态。资源编排服务将比较此模板与当前远程资源的状态之间的区别  OBS地址支持同类型Region之间进行互相访问（Region分为通用Region和专属Region，通用Region指面向公共租户提供通用云服务的Region；专属Region指只承载同一类业务或只面向特定租户提供业务服务的专用Region）  对应的文件应该是纯tf文件或zip压缩包  纯tf文件需要以“.tf”或者“.tf.json”结尾，并遵守HCL语法，且文件的编码格式须为UTF-8  压缩包目前只支持zip格式，文件需要以\".zip\"结尾。解压后的文件不得包含\".tfvars\"文件。解压前最大支持1MB，解压后最大支持1MB。zip压缩包文件数量不能超过100个  template_body和template_uri 必须有且只有一个存在  **注意：**   * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储template_uri对应的模板文件内容。   * template_uri对应的模板文件若为zip类型，则内部的文件或文件夹名称长度不得超过255个字节，最深路径长度不得超过2048字节，zip包大小不得超过1MB
	TemplateUri *string `json:"template_uri,omitempty"`

	// HCL参数文件的OBS地址。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  OBS地址支持同类型Region之间进行互相访问（Region分为通用Region和专属Region，通用Region指面向公共租户提供通用云服务的Region；专属Region指只承载同一类业务或只面向特定租户提供业务服务的专用Region）  * vars_uri需要指向一个OBS的pre-signed URL地址，其他地址暂不支持  * 资源编排服务支持vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * vars_uri中的内容使用HCL的tfvars格式，用户可以将“.tfvars”中的内容保存到文件并上传到OBS中，并将OBS pre-signed URL传递给vars_uri  * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储vars_uri对应的参数文件内容
	VarsUri *string `json:"vars_uri,omitempty"`

	// HCL参数文件的内容。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  * vars_body使用HCL的tfvars格式，用户可以将“.tfvars”中的内容提交到vars_body中  * 资源编排服务支持vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * 如果vars_body过大，可以使用vars_uri  * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储对应的vars_body。
	VarsBody *string `json:"vars_body,omitempty"`

	VarOverrides *VarOverridesPrimitiveTypeHolderVarOverrides `json:"var_overrides,omitempty"`
}

func (DeployStackSetRequestBody) String added in v0.1.61 

func (o DeployStackSetRequestBody) String() string

type DeployStackSetResponse added in v0.1.61 

type DeployStackSetResponse struct {

	// 资源栈集操作（operation）的唯一Id。  此Id由资源编排服务在生成资源栈集操作的时候生成，为UUID。
	StackSetOperationId *string `json:"stack_set_operation_id,omitempty"`
	HttpStatusCode      int     `json:"-"`
}

DeployStackSetResponse Response Object

func (DeployStackSetResponse) String added in v0.1.61 

func (o DeployStackSetResponse) String() string

type DeploymentIdPrimitiveTypeHolder added in v0.1.30 

type DeploymentIdPrimitiveTypeHolder struct {

	// 标识部署的唯一Id，此Id由资源编排服务在触发部署、回滚等操作时生成，为UUID。
	DeploymentId *string `json:"deployment_id,omitempty"`
}

func (DeploymentIdPrimitiveTypeHolder) String added in v0.1.30 

func (o DeploymentIdPrimitiveTypeHolder) String() string

type DeploymentTargets added in v0.1.63 

type DeploymentTargets struct {

	// 用户指定资源栈集操作所涉及的区域。  *在DeployStackSet API中，根据用户输入regions和domain_ids列表，以笛卡尔积的形式选择资源栈集中存在的资源栈实例进行部署。如果指定了没有被资源栈集所管理的region，则会报错。*
	Regions []string `json:"regions"`

	// 权限模型是SELF_MANAGED时，用户指定包含本次操作涉及到的租户ID内容。  *在DeployStackSet API中，如果指定该参数，根据用户输入的domain_ids列表和regions列表，以笛卡尔积的形式选择资源栈集中存在的资源栈实例进行部署。如果指定了没有被资源栈集所管理的domain_id，则会报错。*  domain_ids和domain_ids_uri 有且仅有一个存在。
	DomainIds *[]string `json:"domain_ids,omitempty"`

	// 权限模型是SELF_MANAGED时，用户指定包含本次操作涉及到的租户ID内容文件的OBS地址。  内容格式要求每个租户ID以逗号（,）分割，支持换行。当前仅支持csv文件，且文件的编码格式须为UTF-8。文件内容大小不超过100KB。  上传的csv文件应尽量避免Excel操作，以防出现读取内容不一致的问题。推荐使用记事本打开确认内容是否符合预期。  *在DeployStackSet API中，如果指定该参数，根据用户输入的domain_ids_uri文件内容和regions列表，以笛卡尔积的形式选择资源栈集中存在的资源栈实例进行部署。如果内容包含了没有被资源栈集所管理的domain_id，则会报错。*  domain_ids和domain_ids_uri有且仅有一个存在。
	DomainIdsUri *string `json:"domain_ids_uri,omitempty"`
}

DeploymentTargets 部署目标信息。

func (DeploymentTargets) String added in v0.1.63 

func (o DeploymentTargets) String() string

type DeploymentTargetsPrimitiveTypeHolder added in v0.1.61 

type DeploymentTargetsPrimitiveTypeHolder struct {
	DeploymentTargets *DeploymentTargets `json:"deployment_targets"`
}

func (DeploymentTargetsPrimitiveTypeHolder) String added in v0.1.61 

func (o DeploymentTargetsPrimitiveTypeHolder) String() string

type EnableAutoRollbackPrimitiveTypeHolder 

type EnableAutoRollbackPrimitiveTypeHolder struct {

	// 自动回滚的标识位，如果不传默认为false，即默认不开启资源栈自动回滚（自动回滚开启后，如果部署失败，则会自动回滚，并返回上一个稳定状态）  *在UpdateStack API中，若该参数未在RequestBody中给予，则不会对资源栈的自动回滚属性进行更新* *该属性与使用模板导入资源功能互斥，如果堆栈的自动回滚设置为true，则不允许部署包含导入资源的模板*
	EnableAutoRollback *bool `json:"enable_auto_rollback,omitempty"`
}

func (EnableAutoRollbackPrimitiveTypeHolder) String 

func (o EnableAutoRollbackPrimitiveTypeHolder) String() string

type EnableDeletionProtectionPrimitiveTypeHolder 

type EnableDeletionProtectionPrimitiveTypeHolder struct {

	// 删除保护的标识位，如果不传默认为false，即默认不开启资源栈删除保护（删除保护开启后资源栈不允许被删除）  *在UpdateStack API中，若该参数未在RequestBody中给予，则不会对资源栈的删除保护属性进行更新*
	EnableDeletionProtection *bool `json:"enable_deletion_protection,omitempty"`
}

func (EnableDeletionProtectionPrimitiveTypeHolder) String 

func (o EnableDeletionProtectionPrimitiveTypeHolder) String() string

type EncryptionStructure 

type EncryptionStructure struct {
	Kms *KmsStructure `json:"kms"`
}

EncryptionStructure 如果用户传递的var_value是已经加密过的，可以通过声名此项以要求资源编排服务在使用前进行解密，目前暂时只支持KMS加解密

func (EncryptionStructure) String 

func (o EncryptionStructure) String() string

type EstimateExecutionPlanPriceRequest 

type EstimateExecutionPlanPriceRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	// 执行计划的名称。此名字在domain_id+区域+project_id+stack_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	ExecutionPlanName string `json:"execution_plan_name"`

	// 资源栈（stack）的唯一Id。  此Id由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`

	// 执行计划（execution_plan）的唯一Id。  此Id由资源编排服务在生成执行计划的时候生成，为UUID。  由于执行计划名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的执行计划，删除，再重新创建一个同名执行计划。  对于团队并行开发，用户可能希望确保，当前我操作的执行计划就是我认为的那个，而不是其他队友删除后创建的同名执行计划。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的执行计划所对应的ID都不相同，更新不会影响ID。如果给与的execution_plan_id和当前执行计划的ID不一致，则返回400
	ExecutionPlanId *string `json:"execution_plan_id,omitempty"`
}

EstimateExecutionPlanPriceRequest Request Object

func (EstimateExecutionPlanPriceRequest) String 

func (o EstimateExecutionPlanPriceRequest) String() string

type EstimateExecutionPlanPriceResponse 

type EstimateExecutionPlanPriceResponse struct {

	// 币种，枚举值   * `CNY` - 元，中国站返回的币种   * `USD` - 美元，国际站返回的币种
	Currency *EstimateExecutionPlanPriceResponseCurrency `json:"currency,omitempty"`

	// 执行计划中所有资源的询价结果
	Items          *[]ItemsResponse `json:"items,omitempty"`
	HttpStatusCode int              `json:"-"`
}

EstimateExecutionPlanPriceResponse Response Object

func (EstimateExecutionPlanPriceResponse) String 

func (o EstimateExecutionPlanPriceResponse) String() string

type EstimateExecutionPlanPriceResponseCurrency 

type EstimateExecutionPlanPriceResponseCurrency struct {
	// contains filtered or unexported fields
}

func (EstimateExecutionPlanPriceResponseCurrency) MarshalJSON 

func (c EstimateExecutionPlanPriceResponseCurrency) MarshalJSON() ([]byte, error)

func (*EstimateExecutionPlanPriceResponseCurrency) UnmarshalJSON 

func (c *EstimateExecutionPlanPriceResponseCurrency) UnmarshalJSON(b []byte) error

func (EstimateExecutionPlanPriceResponseCurrency) Value 

func (c EstimateExecutionPlanPriceResponseCurrency) Value() string

type EstimateExecutionPlanPriceResponseCurrencyEnum 

type EstimateExecutionPlanPriceResponseCurrencyEnum struct {
	CNY EstimateExecutionPlanPriceResponseCurrency
	USD EstimateExecutionPlanPriceResponseCurrency
}

func GetEstimateExecutionPlanPriceResponseCurrencyEnum 

func GetEstimateExecutionPlanPriceResponseCurrencyEnum() EstimateExecutionPlanPriceResponseCurrencyEnum

type ExecutionPlan 

type ExecutionPlan struct {

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	// 资源栈（stack）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`

	// 执行计划（execution_plan）的唯一Id。  此Id由资源编排服务在生成执行计划的时候生成，为UUID。  由于执行计划名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的执行计划，删除，再重新创建一个同名执行计划。  对于团队并行开发，用户可能希望确保，当前我操作的执行计划就是我认为的那个，而不是其他队友删除后创建的同名执行计划。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的执行计划所对应的ID都不相同，更新不会影响ID。如果给与的execution_plan_id和当前执行计划的ID不一致，则返回400
	ExecutionPlanId *string `json:"execution_plan_id,omitempty"`

	// 执行计划的名称。此名字在domain_id+区域+project_id+stack_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	ExecutionPlanName string `json:"execution_plan_name"`

	// 执行计划的描述。可用于客户识别自己的执行计划。
	Description *string `json:"description,omitempty"`

	// 执行计划的状态    * `CREATION_IN_PROGRESS` - 正在创建，请等待    * `CREATION_FAILED` - 创建失败，请从status_message获取错误信息汇总    * `AVAILABLE` - 创建完成，可以调用ApplyExecutionPlan API进行执行    * `APPLY_IN_PROGRESS` - 执行中，可通过GetStackMetadata查询资源栈状态，通过ListStackEvents获取执行过程中产生的资源栈事件    * `APPLIED` - 已执行
	Status *ExecutionPlanStatus `json:"status,omitempty"`

	// 当执行计划的状态为创建失败状态（即为 `CREATION_FAILED` 时），将会展示简要的错误信息总结以供debug
	StatusMessage *string `json:"status_message,omitempty"`

	// 执行计划的生成时间，格式遵循RFC3339，精确到秒，UTC时区，即yyyy-mm-ddTHH:MM:SSZ，如1970-01-01T00:00:00Z
	CreateTime *string `json:"create_time,omitempty"`

	// 执行计划的执行时间，格式遵循RFC3339，精确到秒，UTC时区，即yyyy-mm-ddTHH:MM:SSZ，如1970-01-01T00:00:00Z
	ApplyTime *string `json:"apply_time,omitempty"`
}

func (ExecutionPlan) String 

func (o ExecutionPlan) String() string

type ExecutionPlanDescriptionPrimitiveTypeHolder added in v0.1.30 

type ExecutionPlanDescriptionPrimitiveTypeHolder struct {

	// 执行计划的描述。可用于客户识别自己的执行计划。
	Description *string `json:"description,omitempty"`
}

func (ExecutionPlanDescriptionPrimitiveTypeHolder) String added in v0.1.30 

func (o ExecutionPlanDescriptionPrimitiveTypeHolder) String() string

type ExecutionPlanDiffAttribute added in v0.1.15 

type ExecutionPlanDiffAttribute struct {

	// 当前资源将要被修改的参数的名字。
	Name *string `json:"name,omitempty"`

	// 当前资源被修改的参数的原始值。  若是资源创建的场景，则previous_value为空  若远端资源产生了偏差，则同一个资源会返回两个ExecutionPlanItem，其中一个的drifted为true，另一个的drifted为false   * drifted为true的previous_value为资源栈中所维持的资源属性和状态   * drifted为false的previous_value为provider请求远端资源后，远端资源所返回的资源属性和状态  若远端资源未产生偏差，则只会返回一个drifted为false的ExecutionPlanItem   * drifted为false的previous_value为资源栈中所维持的资源属性和状态
	PreviousValue *string `json:"previous_value,omitempty"`

	// 当前资源被修改的参数的目的值。  若是资源删除的场景，则target_value为空  若远端资源产生了偏差，则同一个资源会返回两个ExecutionPlanItem，其中一个的drifted为true，另一个的drifted为false   * drifted为true的target_value为provider请求远端资源后，远端资源所返回的资源属性和状态   * drifted为false的target_value为基于用户模板更新的资源属性和状态  若远端资源未产生偏差，则只会返回一个drifted为false的ExecutionPlanItem   * drifted为false的target_value为基于用户模板更新的资源属性和状态
	TargetValue *string `json:"target_value,omitempty"`
}

func (ExecutionPlanDiffAttribute) String added in v0.1.15 

func (o ExecutionPlanDiffAttribute) String() string

type ExecutionPlanIdPrimitiveTypeHolder added in v0.1.30 

type ExecutionPlanIdPrimitiveTypeHolder struct {

	// 执行计划（execution_plan）的唯一Id。  此Id由资源编排服务在生成执行计划的时候生成，为UUID。  由于执行计划名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的执行计划，删除，再重新创建一个同名执行计划。  对于团队并行开发，用户可能希望确保，当前我操作的执行计划就是我认为的那个，而不是其他队友删除后创建的同名执行计划。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的执行计划所对应的ID都不相同，更新不会影响ID。如果给与的execution_plan_id和当前执行计划的ID不一致，则返回400
	ExecutionPlanId *string `json:"execution_plan_id,omitempty"`
}

func (ExecutionPlanIdPrimitiveTypeHolder) String added in v0.1.30 

func (o ExecutionPlanIdPrimitiveTypeHolder) String() string

type ExecutionPlanItem added in v0.1.15 

type ExecutionPlanItem struct {

	// 资源的类型  以HCL格式的模板为例，resource_type 为 huaweicloud_vpc  “`hcl resource \"huaweicloud_vpc\" \"my_hello_world_vpc\" {   name = \"test_vpc\" } “`  以json格式的模板为例，resource_type 为 huaweicloud_vpc  “`json {   \"resource\": {     \"huaweicloud_vpc\": {       \"my_hello_world_vpc\": {         \"name\": \"test_vpc\"       }     }   } } “`
	ResourceType *string `json:"resource_type,omitempty"`

	// 资源的名称，默认为资源的逻辑名称  以HCL格式的模板为例，resource_name 为 my_hello_world_vpc  “`hcl resource \"huaweicloud_vpc\" \"my_hello_world_vpc\" {   name = \"test_vpc\" } “`  以json格式的模板为例，resource_name 为 my_hello_world_vpc  “`json {   \"resource\": {     \"huaweicloud_vpc\": {       \"my_hello_world_vpc\": {         \"name\": \"test_vpc\"       }     }   } } “`
	ResourceName *string `json:"resource_name,omitempty"`

	// 资源的索引，若用户在模板中使用了count或for_each则会返回index。若index出现，则resource_name + index可以作为该资源的一种标识  若用户在模板中使用count，则index为从0开始的数字  以HCL格式的模板为例，用户在模板中可以通过`huaweicloud_vpc.my_hello_world_vpc[0]`和`huaweicloud_vpc.my_hello_world_vpc[1]`标识两个资源  “`hcl resource \"huaweicloud_vpc\" \"my_hello_world_vpc\" {   count = 2   name = \"test_vpc\" } “`  以json格式的模板为例，用户在模板中可以通过`huaweicloud_vpc.my_hello_world_vpc[0]`和`huaweicloud_vpc.my_hello_world_vpc[1]`标识两个资源  “`json {   \"resource\": {     \"huaweicloud_vpc\": {       \"my_hello_world_vpc\": {         \"name\": \"test_vpc\",         \"count\": 2       }     }   } } “`  若用户在模板中使用for_each，则index为用户自定义的字符串  以HCL格式的模板为例，用户在模板中可以通过`huaweicloud_vpc.my_hello_world_vpc[\"vpc1\"]`和`huaweicloud_vpc.my_hello_world_vpc[\"vpc2\"]`标识两个资源  “`hcl resource \"huaweicloud_vpc\" \"my_hello_world_vpc\" {   for_each = {     \"vpc1\" = \"test_vpc\"     \"vpc2\" = \"test_vpc\"   }   name = each.value } “`  以json格式的模板为例，用户在模板中可以通过`huaweicloud_vpc.my_hello_world_vpc[\"vpc1\"]`和`huaweicloud_vpc.my_hello_world_vpc[\"vpc2\"]`标识两个资源  “`json {   \"resource\": {     \"huaweicloud_vpc\": {       \"my_hello_world_vpc\": {         \"for_each\": {           \"vpc1\": \"test_vpc\",           \"vpc2\": \"test_vpc\"         }         \"name\": \"${each.value}\"       }     }   } } “`
	Index *string `json:"index,omitempty"`

	// 资源变更的类型   * `ADD` - 新增资源   * `ADD_THEN_DELETE` - 由不可更新的资源返回，先创建新资源，再删除旧资源   * `DELETE ` - 删除资源   * `DELETE_THEN_ADD` - 由不可更新的资源返回，先删除旧资源，再创建新资源   * `UPDATE` - 更新资源    * `NO_OPERATION` - 仅变更资源的依赖关系，但是对资源本身并无修改的操作
	Action *ExecutionPlanItemAction `json:"action,omitempty"`

	// 触发该项目变更的原因，例如用户更新模板；远端删除资源等等
	ActionReason *string `json:"action_reason,omitempty"`

	// 该项目所属的provider名称。
	ProviderName *string `json:"provider_name,omitempty"`

	// 资源模式   * `DATA` - 指可以在模板解析期间运行和获取服务端数据的资源类型，不会操作基础设施组件   * `RESOURCE` - 指通过模板管理的由服务定义的基础设施组件抽象，可以是物理资源也可以是逻辑资源
	Mode *ExecutionPlanItemMode `json:"mode,omitempty"`

	// 当前资源的变更是否由偏差导致。  偏差，也叫漂移。指的是资源被资源编排服务创建以后，又经历过非资源编排服务触发的修改，如手动修改、调用SDK修改等，使得资源的配置与本服务所记录的资源的配置不一致。这种不一致便称为偏差。  当资源产生偏差以后： * 如果用户试图创建执行计划，则会提示用户产生偏差 * 如果用户直接部署，则偏差有可能被覆盖，资源编排服务只保证资源和模板最终一致。  资源的偏差有两种类型： * 资源定位属性被修改：如果是定位属性被修改，常见于删除后重建，此时资源已经不属于同一个资源。资源编排服务会认为此资源已经被删除，会尝试创建一个新的资源。 * 资源普通属性被修改：如果是普通属性被修改，则资源编排服务依然可以找到资源，但是下次部署会尝试修复偏差，即将资源保持和模板最终一致。  **注：资源编排服务团队极力推荐，如果资源是通过本服务创建的，请一直使用本服务进行维护和更新以确保资源和模板保持一致。建议非紧急事件以外的情况不要手动调整。**
	Drifted *bool `json:"drifted,omitempty"`

	// 资源的物理id，是唯一id，由为该资源提供服务的provider、云服务或其他服务提供方在资源部署的时候生成
	ResourceId *string `json:"resource_id,omitempty"`

	// 执行计划项目中变更的属性，当无属性变更时为空列表。
	Attributes *[]ExecutionPlanDiffAttribute `json:"attributes,omitempty"`
}

func (ExecutionPlanItem) String added in v0.1.15 

func (o ExecutionPlanItem) String() string

type ExecutionPlanItemAction added in v0.1.15 

type ExecutionPlanItemAction struct {
	// contains filtered or unexported fields
}

func (ExecutionPlanItemAction) MarshalJSON added in v0.1.15 

func (c ExecutionPlanItemAction) MarshalJSON() ([]byte, error)

func (*ExecutionPlanItemAction) UnmarshalJSON added in v0.1.15 

func (c *ExecutionPlanItemAction) UnmarshalJSON(b []byte) error

func (ExecutionPlanItemAction) Value added in v0.1.15 

func (c ExecutionPlanItemAction) Value() string

type ExecutionPlanItemActionEnum added in v0.1.15 

type ExecutionPlanItemActionEnum struct {
	ADD             ExecutionPlanItemAction
	ADD_THEN_DELETE ExecutionPlanItemAction
	DELETE          ExecutionPlanItemAction
	DELETE_THEN_ADD ExecutionPlanItemAction
	UPDATE          ExecutionPlanItemAction
	NO_OPERATION    ExecutionPlanItemAction
}

func GetExecutionPlanItemActionEnum added in v0.1.15 

func GetExecutionPlanItemActionEnum() ExecutionPlanItemActionEnum

type ExecutionPlanItemMode added in v0.1.15 

type ExecutionPlanItemMode struct {
	// contains filtered or unexported fields
}

func (ExecutionPlanItemMode) MarshalJSON added in v0.1.15 

func (c ExecutionPlanItemMode) MarshalJSON() ([]byte, error)

func (*ExecutionPlanItemMode) UnmarshalJSON added in v0.1.15 

func (c *ExecutionPlanItemMode) UnmarshalJSON(b []byte) error

func (ExecutionPlanItemMode) Value added in v0.1.15 

func (c ExecutionPlanItemMode) Value() string

type ExecutionPlanItemModeEnum added in v0.1.15 

type ExecutionPlanItemModeEnum struct {
	DATA     ExecutionPlanItemMode
	RESOURCE ExecutionPlanItemMode
}

func GetExecutionPlanItemModeEnum added in v0.1.15 

func GetExecutionPlanItemModeEnum() ExecutionPlanItemModeEnum

type ExecutionPlanNamePrimitiveTypeHolder added in v0.1.30 

type ExecutionPlanNamePrimitiveTypeHolder struct {

	// 执行计划的名称。此名字在domain_id+区域+project_id+stack_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	ExecutionPlanName string `json:"execution_plan_name"`
}

func (ExecutionPlanNamePrimitiveTypeHolder) String added in v0.1.30 

func (o ExecutionPlanNamePrimitiveTypeHolder) String() string

type ExecutionPlanStatus 

type ExecutionPlanStatus struct {
	// contains filtered or unexported fields
}

func (ExecutionPlanStatus) MarshalJSON 

func (c ExecutionPlanStatus) MarshalJSON() ([]byte, error)

func (*ExecutionPlanStatus) UnmarshalJSON 

func (c *ExecutionPlanStatus) UnmarshalJSON(b []byte) error

func (ExecutionPlanStatus) Value 

func (c ExecutionPlanStatus) Value() string

type ExecutionPlanStatusEnum 

type ExecutionPlanStatusEnum struct {
	CREATION_IN_PROGRESS ExecutionPlanStatus
	CREATION_FAILED      ExecutionPlanStatus
	AVAILABLE            ExecutionPlanStatus
	APPLY_IN_PROGRESS    ExecutionPlanStatus
	APPLIED              ExecutionPlanStatus
}

func GetExecutionPlanStatusEnum 

func GetExecutionPlanStatusEnum() ExecutionPlanStatusEnum

type ExecutionPlanStatusMessagePrimitiveTypeHolder added in v0.1.30 

type ExecutionPlanStatusMessagePrimitiveTypeHolder struct {

	// 当执行计划的状态为创建失败状态（即为 `CREATION_FAILED` 时），将会展示简要的错误信息总结以供debug
	StatusMessage *string `json:"status_message,omitempty"`
}

func (ExecutionPlanStatusMessagePrimitiveTypeHolder) String added in v0.1.30 

func (o ExecutionPlanStatusMessagePrimitiveTypeHolder) String() string

type ExecutionPlanStatusPrimitiveTypeHolder added in v0.1.30 

type ExecutionPlanStatusPrimitiveTypeHolder struct {

	// 执行计划的状态    * `CREATION_IN_PROGRESS` - 正在创建，请等待    * `CREATION_FAILED` - 创建失败，请从status_message获取错误信息汇总    * `AVAILABLE` - 创建完成，可以调用ApplyExecutionPlan API进行执行    * `APPLY_IN_PROGRESS` - 执行中，可通过GetStackMetadata查询资源栈状态，通过ListStackEvents获取执行过程中产生的资源栈事件    * `APPLIED` - 已执行
	Status *ExecutionPlanStatusPrimitiveTypeHolderStatus `json:"status,omitempty"`
}

func (ExecutionPlanStatusPrimitiveTypeHolder) String added in v0.1.30 

func (o ExecutionPlanStatusPrimitiveTypeHolder) String() string

type ExecutionPlanStatusPrimitiveTypeHolderStatus added in v0.1.30 

type ExecutionPlanStatusPrimitiveTypeHolderStatus struct {
	// contains filtered or unexported fields
}

func (ExecutionPlanStatusPrimitiveTypeHolderStatus) MarshalJSON added in v0.1.30 

func (c ExecutionPlanStatusPrimitiveTypeHolderStatus) MarshalJSON() ([]byte, error)

func (*ExecutionPlanStatusPrimitiveTypeHolderStatus) UnmarshalJSON added in v0.1.30 

func (c *ExecutionPlanStatusPrimitiveTypeHolderStatus) UnmarshalJSON(b []byte) error

func (ExecutionPlanStatusPrimitiveTypeHolderStatus) Value added in v0.1.30 

func (c ExecutionPlanStatusPrimitiveTypeHolderStatus) Value() string

type ExecutionPlanStatusPrimitiveTypeHolderStatusEnum added in v0.1.30 

type ExecutionPlanStatusPrimitiveTypeHolderStatusEnum struct {
	CREATION_IN_PROGRESS ExecutionPlanStatusPrimitiveTypeHolderStatus
	CREATION_FAILED      ExecutionPlanStatusPrimitiveTypeHolderStatus
	AVAILABLE            ExecutionPlanStatusPrimitiveTypeHolderStatus
	APPLY_IN_PROGRESS    ExecutionPlanStatusPrimitiveTypeHolderStatus
	APPLIED              ExecutionPlanStatusPrimitiveTypeHolderStatus
}

func GetExecutionPlanStatusPrimitiveTypeHolderStatusEnum added in v0.1.30 

func GetExecutionPlanStatusPrimitiveTypeHolderStatusEnum() ExecutionPlanStatusPrimitiveTypeHolderStatusEnum

type ExecutionPlanSummary added in v0.1.15 

type ExecutionPlanSummary struct {

	// 新增资源数
	ResourceAdd *int32 `json:"resource_add,omitempty"`

	// 更新资源数
	ResourceUpdate *int32 `json:"resource_update,omitempty"`

	// 删除资源数
	ResourceDelete *int32 `json:"resource_delete,omitempty"`
}

func (ExecutionPlanSummary) String added in v0.1.15 

func (o ExecutionPlanSummary) String() string

type GetExecutionPlanMetadataRequest added in v0.1.30 

type GetExecutionPlanMetadataRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	// 执行计划的名称。此名字在domain_id+区域+project_id+stack_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	ExecutionPlanName string `json:"execution_plan_name"`

	// 资源栈（stack）的唯一Id。  此Id由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`

	// 执行计划（execution_plan）的唯一Id。  此Id由资源编排服务在生成执行计划的时候生成，为UUID。  由于执行计划名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的执行计划，删除，再重新创建一个同名执行计划。  对于团队并行开发，用户可能希望确保，当前我操作的执行计划就是我认为的那个，而不是其他队友删除后创建的同名执行计划。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的执行计划所对应的ID都不相同，更新不会影响ID。如果给与的execution_plan_id和当前执行计划的ID不一致，则返回400
	ExecutionPlanId *string `json:"execution_plan_id,omitempty"`
}

GetExecutionPlanMetadataRequest Request Object

func (GetExecutionPlanMetadataRequest) String added in v0.1.30 

func (o GetExecutionPlanMetadataRequest) String() string

type GetExecutionPlanMetadataResponse added in v0.1.30 

type GetExecutionPlanMetadataResponse struct {

	// 资源栈（stack）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	// 执行计划（execution_plan）的唯一Id。  此Id由资源编排服务在生成执行计划的时候生成，为UUID。  由于执行计划名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的执行计划，删除，再重新创建一个同名执行计划。  对于团队并行开发，用户可能希望确保，当前我操作的执行计划就是我认为的那个，而不是其他队友删除后创建的同名执行计划。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的执行计划所对应的ID都不相同，更新不会影响ID。如果给与的execution_plan_id和当前执行计划的ID不一致，则返回400
	ExecutionPlanId *string `json:"execution_plan_id,omitempty"`

	// 执行计划的名称。此名字在domain_id+区域+project_id+stack_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	ExecutionPlanName string `json:"execution_plan_name"`

	// 执行计划的描述。可用于客户识别自己的执行计划。
	Description *string `json:"description,omitempty"`

	// HCL参数结构。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  * var_structure可以允许客户提交最简单的字符串类型的参数  * 资源编排服务支持vars_structure，vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * vars_structure中的值只支持简单的字符串类型，如果需要使用其他类型，需要用户自己在HCL引用时转换， 或者用户可以使用vars_uri、vars_body，vars_uri和vars_body中支持HCL支持的各种类型以及复杂结构  * 如果vars_structure过大，可以使用vars_uri  * 注意：vars_structure中默认不应该含有任何敏感信息，资源编排服务会直接明文使用、log、展示、存储对应的vars。如为敏感信息，建议设置encryption字段开启加密
	VarsStructure *[]VarsStructure `json:"vars_structure,omitempty"`

	// vars_uri对应的文件内容
	VarsUriContent *string `json:"vars_uri_content,omitempty"`

	// HCL参数文件的内容。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  * vars_body使用HCL的tfvars格式，用户可以将“.tfvars”中的内容提交到vars_body中  * 资源编排服务支持vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * 如果vars_body过大，可以使用vars_uri  * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储对应的vars_body。
	VarsBody *string `json:"vars_body,omitempty"`

	// 执行计划的状态    * `CREATION_IN_PROGRESS` - 正在创建，请等待    * `CREATION_FAILED` - 创建失败，请从status_message获取错误信息汇总    * `AVAILABLE` - 创建完成，可以调用ApplyExecutionPlan API进行执行    * `APPLY_IN_PROGRESS` - 执行中，可通过GetStackMetadata查询资源栈状态，通过ListStackEvents获取执行过程中产生的资源栈事件    * `APPLIED` - 已执行
	Status *GetExecutionPlanMetadataResponseStatus `json:"status,omitempty"`

	// 当执行计划的状态为创建失败状态（即为 `CREATION_FAILED` 时），将会展示简要的错误信息总结以供debug
	StatusMessage *string `json:"status_message,omitempty"`

	// 执行计划的生成时间 格式遵循RFC3339，即yyyy-mm-ddTHH:MM:SSZ，如1970-01-01T00:00:00Z
	CreateTime *string `json:"create_time,omitempty"`

	// 执行计划的执行时间 格式遵循RFC3339，即yyyy-mm-ddTHH:MM:SSZ，如1970-01-01T00:00:00Z
	ApplyTime *string `json:"apply_time,omitempty"`

	Summary        *ExecutionPlanSummary `json:"summary,omitempty"`
	HttpStatusCode int                   `json:"-"`
}

GetExecutionPlanMetadataResponse Response Object

func (GetExecutionPlanMetadataResponse) String added in v0.1.30 

func (o GetExecutionPlanMetadataResponse) String() string

type GetExecutionPlanMetadataResponseStatus added in v0.1.30 

type GetExecutionPlanMetadataResponseStatus struct {
	// contains filtered or unexported fields
}

func (GetExecutionPlanMetadataResponseStatus) MarshalJSON added in v0.1.30 

func (c GetExecutionPlanMetadataResponseStatus) MarshalJSON() ([]byte, error)

func (*GetExecutionPlanMetadataResponseStatus) UnmarshalJSON added in v0.1.30 

func (c *GetExecutionPlanMetadataResponseStatus) UnmarshalJSON(b []byte) error

func (GetExecutionPlanMetadataResponseStatus) Value added in v0.1.30 

func (c GetExecutionPlanMetadataResponseStatus) Value() string

type GetExecutionPlanMetadataResponseStatusEnum added in v0.1.30 

type GetExecutionPlanMetadataResponseStatusEnum struct {
	CREATION_IN_PROGRESS GetExecutionPlanMetadataResponseStatus
	CREATION_FAILED      GetExecutionPlanMetadataResponseStatus
	AVAILABLE            GetExecutionPlanMetadataResponseStatus
	APPLY_IN_PROGRESS    GetExecutionPlanMetadataResponseStatus
	APPLIED              GetExecutionPlanMetadataResponseStatus
}

func GetGetExecutionPlanMetadataResponseStatusEnum added in v0.1.30 

func GetGetExecutionPlanMetadataResponseStatusEnum() GetExecutionPlanMetadataResponseStatusEnum

type GetExecutionPlanRequest added in v0.1.15 

type GetExecutionPlanRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	// 执行计划的名称。此名字在domain_id+区域+project_id+stack_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	ExecutionPlanName string `json:"execution_plan_name"`

	// 资源栈（stack）的唯一Id。  此Id由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`

	// 执行计划（execution_plan）的唯一Id。  此Id由资源编排服务在生成执行计划的时候生成，为UUID。  由于执行计划名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的执行计划，删除，再重新创建一个同名执行计划。  对于团队并行开发，用户可能希望确保，当前我操作的执行计划就是我认为的那个，而不是其他队友删除后创建的同名执行计划。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的执行计划所对应的ID都不相同，更新不会影响ID。如果给与的execution_plan_id和当前执行计划的ID不一致，则返回400
	ExecutionPlanId *string `json:"execution_plan_id,omitempty"`
}

GetExecutionPlanRequest Request Object

func (GetExecutionPlanRequest) String added in v0.1.15 

func (o GetExecutionPlanRequest) String() string

type GetExecutionPlanResponse added in v0.1.15 

type GetExecutionPlanResponse struct {

	// 执行计划项目的列表
	ExecutionPlanItems *[]ExecutionPlanItem `json:"execution_plan_items,omitempty"`
	HttpStatusCode     int                  `json:"-"`
}

GetExecutionPlanResponse Response Object

func (GetExecutionPlanResponse) String added in v0.1.15 

func (o GetExecutionPlanResponse) String() string

type GetStackMetadataRequest added in v0.1.15 

type GetStackMetadataRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	// 资源栈（stack）的唯一Id。  此Id由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`
}

GetStackMetadataRequest Request Object

func (GetStackMetadataRequest) String added in v0.1.15 

func (o GetStackMetadataRequest) String() string

type GetStackMetadataResponse added in v0.1.15 

type GetStackMetadataResponse struct {

	// 资源栈（stack）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	// 资源栈的描述。可用于客户识别自己的资源栈。
	Description *string `json:"description,omitempty"`

	// HCL参数结构。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  * var_structure可以允许客户提交最简单的字符串类型的参数  * 资源编排服务支持vars_structure，vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * vars_structure中的值只支持简单的字符串类型，如果需要使用其他类型，需要用户自己在HCL引用时转换， 或者用户可以使用vars_uri、vars_body，vars_uri和vars_body中支持HCL支持的各种类型以及复杂结构  * 如果vars_structure过大，可以使用vars_uri  * 注意：vars_structure中默认不应该含有任何敏感信息，资源编排服务会直接明文使用、log、展示、存储对应的vars。如为敏感信息，建议设置encryption字段开启加密
	VarsStructure *[]VarsStructure `json:"vars_structure,omitempty"`

	// HCL参数文件的内容。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  * vars_body使用HCL的tfvars格式，用户可以将“.tfvars”中的内容提交到vars_body中  * 资源编排服务支持vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * 如果vars_body过大，可以使用vars_uri  * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储对应的vars_body。
	VarsBody *string `json:"vars_body,omitempty"`

	// 删除保护的标识位，如果不传默认为false，即默认不开启资源栈删除保护（删除保护开启后资源栈不允许被删除）  *在UpdateStack API中，若该参数未在RequestBody中给予，则不会对资源栈的删除保护属性进行更新*
	EnableDeletionProtection *bool `json:"enable_deletion_protection,omitempty"`

	// 自动回滚的标识位，如果不传默认为false，即默认不开启资源栈自动回滚（自动回滚开启后，如果部署失败，则会自动回滚，并返回上一个稳定状态）  *在UpdateStack API中，若该参数未在RequestBody中给予，则不会对资源栈的自动回滚属性进行更新* *该属性与使用模板导入资源功能互斥，如果堆栈的自动回滚设置为true，则不允许部署包含导入资源的模板*
	EnableAutoRollback *bool `json:"enable_auto_rollback,omitempty"`

	// 资源栈的状态    * `CREATION_COMPLETE` - 生成空资源栈完成，并没有任何部署    * `DEPLOYMENT_IN_PROGRESS` - 正在部署，请等待    * `DEPLOYMENT_FAILED` - 部署失败。请从status_message获取错误信息汇总，或者调用ListStackEvents获得事件详情    * `DEPLOYMENT_COMPLETE` - 部署完成    * `ROLLBACK_IN_PROGRESS` - 部署失败，正在回滚，请等待    * `ROLLBACK_FAILED` - 回滚失败。请从status_message获取错误信息汇总，或者调用ListStackEvents获得事件详情    * `ROLLBACK_COMPLETE` - 回滚完成    * `DELETION_IN_PROGRESS` - 正在删除，请等待    * `DELETION_FAILED` - 删除失败。请从status_message获取错误信息汇总，或者调用ListStackEvents获得事件详情
	Status *GetStackMetadataResponseStatus `json:"status,omitempty"`

	// 委托授权的信息。  RFS仅在创建资源栈（触发部署）、创建执行计划、部署资源栈、删除资源栈等涉及资源操作的请求中使用委托，且该委托仅作用于与之绑定的Provider对资源的操作中。若委托中提供的权限不足，有可能导致相关资源操作失败。  [创建委托及授权方式](https://support.huaweicloud.com/usermanual-iam/iam_06_0002.html)
	Agencies *[]Agency `json:"agencies,omitempty"`

	// 当资源栈的状态为任意失败状态（即以 `FAILED` 结尾时），将会展示简要的错误信息总结以供debug
	StatusMessage *string `json:"status_message,omitempty"`

	// vars_uri对应的文件内容
	VarsUriContent *string `json:"vars_uri_content,omitempty"`

	// 资源栈的生成时间 格式遵循RFC3339，即yyyy-mm-ddTHH:MM:SSZ，如1970-01-01T00:00:00Z
	CreateTime *string `json:"create_time,omitempty"`

	// 资源栈的更新时间（更新场景包括元数据更新场景和部署场景） 格式遵循RFC3339，即yyyy-mm-ddTHH:MM:SSZ，如1970-01-01T00:00:00Z
	UpdateTime     *string `json:"update_time,omitempty"`
	HttpStatusCode int     `json:"-"`
}

GetStackMetadataResponse Response Object

func (GetStackMetadataResponse) String added in v0.1.15 

func (o GetStackMetadataResponse) String() string

type GetStackMetadataResponseStatus added in v0.1.15 

type GetStackMetadataResponseStatus struct {
	// contains filtered or unexported fields
}

func (GetStackMetadataResponseStatus) MarshalJSON added in v0.1.15 

func (c GetStackMetadataResponseStatus) MarshalJSON() ([]byte, error)

func (*GetStackMetadataResponseStatus) UnmarshalJSON added in v0.1.15 

func (c *GetStackMetadataResponseStatus) UnmarshalJSON(b []byte) error

func (GetStackMetadataResponseStatus) Value added in v0.1.15 

func (c GetStackMetadataResponseStatus) Value() string

type GetStackMetadataResponseStatusEnum added in v0.1.15 

type GetStackMetadataResponseStatusEnum struct {
	CREATION_COMPLETE      GetStackMetadataResponseStatus
	DEPLOYMENT_IN_PROGRESS GetStackMetadataResponseStatus
	DEPLOYMENT_FAILED      GetStackMetadataResponseStatus
	DEPLOYMENT_COMPLETE    GetStackMetadataResponseStatus
	ROLLBACK_IN_PROGRESS   GetStackMetadataResponseStatus
	ROLLBACK_FAILED        GetStackMetadataResponseStatus
	ROLLBACK_COMPLETE      GetStackMetadataResponseStatus
	DELETION_IN_PROGRESS   GetStackMetadataResponseStatus
	DELETION_FAILED        GetStackMetadataResponseStatus
}

func GetGetStackMetadataResponseStatusEnum added in v0.1.15 

func GetGetStackMetadataResponseStatusEnum() GetStackMetadataResponseStatusEnum

type GetStackTemplateRequest 

type GetStackTemplateRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	// 资源栈（stack）的唯一Id。  此Id由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`
}

GetStackTemplateRequest Request Object

func (GetStackTemplateRequest) String 

func (o GetStackTemplateRequest) String() string

type GetStackTemplateResponse 

type GetStackTemplateResponse struct {
	Location       *string `json:"Location,omitempty"`
	HttpStatusCode int     `json:"-"`
}

GetStackTemplateResponse Response Object

func (GetStackTemplateResponse) String 

func (o GetStackTemplateResponse) String() string

type IndexPrimitiveTypeHolder added in v0.1.30 

type IndexPrimitiveTypeHolder struct {

	// 资源的索引，若用户在模板中使用了count或for_each则会返回index。若index出现，则resource_name + index可以作为该资源的一种标识  若用户在模板中使用count，则index为从0开始的数字  以HCL格式的模板为例，用户在模板中可以通过`huaweicloud_vpc.my_hello_world_vpc[0]`和`huaweicloud_vpc.my_hello_world_vpc[1]`标识两个资源  “`hcl resource \"huaweicloud_vpc\" \"my_hello_world_vpc\" {   count = 2   name = \"test_vpc\" } “`  以json格式的模板为例，用户在模板中可以通过`huaweicloud_vpc.my_hello_world_vpc[0]`和`huaweicloud_vpc.my_hello_world_vpc[1]`标识两个资源  “`json {   \"resource\": {     \"huaweicloud_vpc\": {       \"my_hello_world_vpc\": {         \"name\": \"test_vpc\",         \"count\": 2       }     }   } } “`  若用户在模板中使用for_each，则index为用户自定义的字符串  以HCL格式的模板为例，用户在模板中可以通过`huaweicloud_vpc.my_hello_world_vpc[\"vpc1\"]`和`huaweicloud_vpc.my_hello_world_vpc[\"vpc2\"]`标识两个资源  “`hcl resource \"huaweicloud_vpc\" \"my_hello_world_vpc\" {   for_each = {     \"vpc1\" = \"test_vpc\"     \"vpc2\" = \"test_vpc\"   }   name = each.value } “`  以json格式的模板为例，用户在模板中可以通过`huaweicloud_vpc.my_hello_world_vpc[\"vpc1\"]`和`huaweicloud_vpc.my_hello_world_vpc[\"vpc2\"]`标识两个资源  “`json {   \"resource\": {     \"huaweicloud_vpc\": {       \"my_hello_world_vpc\": {         \"for_each\": {           \"vpc1\": \"test_vpc\",           \"vpc2\": \"test_vpc\"         }         \"name\": \"${each.value}\"       }     }   } } “`
	Index *string `json:"index,omitempty"`
}

func (IndexPrimitiveTypeHolder) String added in v0.1.30 

func (o IndexPrimitiveTypeHolder) String() string

type InitialStackDescriptionPrimitiveTypeHolder added in v0.1.61 

type InitialStackDescriptionPrimitiveTypeHolder struct {

	// 初始化资源栈描述。可用于客户识别被资源栈集所管理的资源栈。  资源栈集下的资源栈仅在创建时统一使用该描述。客户想要更新初始化资源栈描述，可以通过UpdateStackSet API。  后续更新资源栈集描述将不会同步更新已管理的资源栈描述。
	InitialStackDescription *string `json:"initial_stack_description,omitempty"`
}

func (InitialStackDescriptionPrimitiveTypeHolder) String added in v0.1.61 

func (o InitialStackDescriptionPrimitiveTypeHolder) String() string

type ItemsResponse 

type ItemsResponse struct {

	// 资源的类型  以HCL格式的模板为例，resource_type 为 huaweicloud_vpc  “`hcl resource \"huaweicloud_vpc\" \"my_hello_world_vpc\" {   name = \"test_vpc\" } “`  以json格式的模板为例，resource_type 为 huaweicloud_vpc  “`json {   \"resource\": {     \"huaweicloud_vpc\": {       \"my_hello_world_vpc\": {         \"name\": \"test_vpc\"       }     }   } } “`
	ResourceType *string `json:"resource_type,omitempty"`

	// 资源的名称，默认为资源的逻辑名称  以HCL格式的模板为例，resource_name 为 my_hello_world_vpc  “`hcl resource \"huaweicloud_vpc\" \"my_hello_world_vpc\" {   name = \"test_vpc\" } “`  以json格式的模板为例，resource_name 为 my_hello_world_vpc  “`json {   \"resource\": {     \"huaweicloud_vpc\": {       \"my_hello_world_vpc\": {         \"name\": \"test_vpc\"       }     }   } } “`
	ResourceName *string `json:"resource_name,omitempty"`

	// 资源的索引，若用户在模板中使用了count或for_each则会返回index。若index出现，则resource_name + index可以作为该资源的一种标识  若用户在模板中使用count，则index为从0开始的数字  以HCL格式的模板为例，用户在模板中可以通过`huaweicloud_vpc.my_hello_world_vpc[0]`和`huaweicloud_vpc.my_hello_world_vpc[1]`标识两个资源  “`hcl resource \"huaweicloud_vpc\" \"my_hello_world_vpc\" {   count = 2   name = \"test_vpc\" } “`  以json格式的模板为例，用户在模板中可以通过`huaweicloud_vpc.my_hello_world_vpc[0]`和`huaweicloud_vpc.my_hello_world_vpc[1]`标识两个资源  “`json {   \"resource\": {     \"huaweicloud_vpc\": {       \"my_hello_world_vpc\": {         \"name\": \"test_vpc\",         \"count\": 2       }     }   } } “`  若用户在模板中使用for_each，则index为用户自定义的字符串  以HCL格式的模板为例，用户在模板中可以通过`huaweicloud_vpc.my_hello_world_vpc[\"vpc1\"]`和`huaweicloud_vpc.my_hello_world_vpc[\"vpc2\"]`标识两个资源  “`hcl resource \"huaweicloud_vpc\" \"my_hello_world_vpc\" {   for_each = {     \"vpc1\" = \"test_vpc\"     \"vpc2\" = \"test_vpc\"   }   name = each.value } “`  以json格式的模板为例，用户在模板中可以通过`huaweicloud_vpc.my_hello_world_vpc[\"vpc1\"]`和`huaweicloud_vpc.my_hello_world_vpc[\"vpc2\"]`标识两个资源  “`json {   \"resource\": {     \"huaweicloud_vpc\": {       \"my_hello_world_vpc\": {         \"for_each\": {           \"vpc1\": \"test_vpc\",           \"vpc2\": \"test_vpc\"         }         \"name\": \"${each.value}\"       }     }   } } “`
	Index *string `json:"index,omitempty"`

	// 该资源或该资源当前所给予的参数是否支持进行询价
	Supported *bool `json:"supported,omitempty"`

	// 该资源不支持询价的具体原因
	UnsupportedMessage *string `json:"unsupported_message,omitempty"`

	// 该资源的询价信息  若该资源支持包周期计费或按需计费，或者该资源为免费资源，则返回该字段；若该资源不支持询价，则不返回该字段。
	ResourcePrice *[]ResourcePriceResponse `json:"resource_price,omitempty"`
}

func (ItemsResponse) String 

func (o ItemsResponse) String() string

type KmsStructure 

type KmsStructure struct {

	// 解密时，资源编排服务应该使用的KMS秘钥的ID，通常是加密时所使用的秘钥ID
	Id string `json:"id"`

	// 数据加密秘钥所对应的密文
	CipherText string `json:"cipher_text"`
}

KmsStructure 如果用户给与的var_value是经过KMS加密的，可以通过传递相关加密信息，资源编排服务在使用的时候会帮助用户进行KMS解密 更多关于KMS加密以及KMS加密的样例代码请见：[KMS加密使用场景介绍](https://support.huaweicloud.com/productdesc-dew/dew_01_0006.html) **注意：** * 请确保用户给予资源编排服务的委托中包含对指定秘钥ID的操作权限 * KMS每个月有免费试用的额度，如果超过，则KMS需要收费，此费用不是资源编排服务收取，具体标准见：[https://www.huaweicloud.com/pricing.html?tab=detail#/dew](https://www.huaweicloud.com/pricing.html?tab=detail#/dew) * KMS加密只代表资源编排服务在存储和传输的时候传递的是密文，但是在stack-events中依然是明文，如果希望在log中以密文形式对待，请在模板中声明sensitive，更多关于sensitive的介绍见：[https://learn.hashicorp.com/tutorials/terraform/sensitive-variables](https://learn.hashicorp.com/tutorials/terraform/sensitive-variables)

func (KmsStructure) String 

func (o KmsStructure) String() string

type ListExecutionPlansRequest 

type ListExecutionPlansRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	// 资源栈（stack）的唯一Id。  此Id由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`
}

ListExecutionPlansRequest Request Object

func (ListExecutionPlansRequest) String 

func (o ListExecutionPlansRequest) String() string

type ListExecutionPlansResponse 

type ListExecutionPlansResponse struct {

	// 执行计划列表。默认按照生成时间排序，最早生成的在最前
	ExecutionPlans *[]ExecutionPlan `json:"execution_plans,omitempty"`
	HttpStatusCode int              `json:"-"`
}

ListExecutionPlansResponse Response Object

func (ListExecutionPlansResponse) String 

func (o ListExecutionPlansResponse) String() string

type ListStackEventsRequest added in v0.1.12 

type ListStackEventsRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	// 资源栈（stack）的唯一Id。  此Id由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`

	// 标识部署的唯一Id，此Id由资源编排服务在触发部署、回滚等操作时生成，为UUID。
	DeploymentId *string `json:"deployment_id,omitempty"`

	// 过滤条件  * 与（AND）运算符使用逗号（，）定义 * 或（OR）运算符使用竖线（|）定义，OR运算符优先级高于AND运算符 * 不支持括号 * 过滤运算符仅支持等号（==） * 过滤参数名及其值仅支持包含大小写英文、数字和下划线 * 过滤条件中禁止使用分号，若有分号，则此条过滤会被忽略 * 一个过滤参数仅能与一个与条件相关，一个与条件中的多个或条件仅能与一个过滤参数相关
	Filter *string `json:"filter,omitempty"`

	// 选择的属性名称  * 属性名仅支持包含大小写英文、数字和下划线 * 多个属性名称之间以逗号（，）分隔
	Field *string `json:"field,omitempty"`
}

ListStackEventsRequest Request Object

func (ListStackEventsRequest) String added in v0.1.12 

func (o ListStackEventsRequest) String() string

type ListStackEventsResponse added in v0.1.12 

type ListStackEventsResponse struct {

	// 资源栈事件列表
	StackEvents    *[]StackEvent `json:"stack_events,omitempty"`
	HttpStatusCode int           `json:"-"`
}

ListStackEventsResponse Response Object

func (ListStackEventsResponse) String added in v0.1.12 

func (o ListStackEventsResponse) String() string

type ListStackInstancesRequest added in v0.1.61 

type ListStackInstancesRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈集的名称。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackSetName string `json:"stack_set_name"`

	// 资源栈集（stack-set）的唯一ID。  此ID由资源编排服务在生成资源栈集的时候生成，为UUID。  由于资源栈集名称仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈集，删除，再重新创建一个同名资源栈集。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈集就是我认为的那个，而不是其他队友删除后创建的同名资源栈集。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈集所对应的ID都不相同，更新不会影响ID。如果给与的stack_set_id和当前资源栈集的ID不一致，则返回400
	StackSetId *string `json:"stack_set_id,omitempty"`

	// 过滤条件  * 与（AND）运算符使用逗号（，）定义 * 或（OR）运算符使用竖线（|）定义，OR运算符优先级高于AND运算符 * 不支持括号 * 过滤运算符仅支持双等号（==） * 过滤参数名及其值仅支持包含大小写英文、数字和下划线 * 过滤条件中禁止使用分号，若有分号，则此条过滤会被忽略 * 一个过滤参数仅能与一个与条件相关，一个与条件中的多个或条件仅能与一个过滤参数相关
	Filter *string `json:"filter,omitempty"`

	// 排序字段，仅支持给予create_time
	SortKey *[]ListStackInstancesRequestSortKey `json:"sort_key,omitempty"`

	// 指定升序还是降序   * `asc` - 升序   * `desc` - 降序
	SortDir *[]ListStackInstancesRequestSortDir `json:"sort_dir,omitempty"`
}

ListStackInstancesRequest Request Object

func (ListStackInstancesRequest) String added in v0.1.61 

func (o ListStackInstancesRequest) String() string

type ListStackInstancesRequestSortDir added in v0.1.61 

type ListStackInstancesRequestSortDir struct {
	// contains filtered or unexported fields
}

func (ListStackInstancesRequestSortDir) MarshalJSON added in v0.1.61 

func (c ListStackInstancesRequestSortDir) MarshalJSON() ([]byte, error)

func (*ListStackInstancesRequestSortDir) UnmarshalJSON added in v0.1.61 

func (c *ListStackInstancesRequestSortDir) UnmarshalJSON(b []byte) error

func (ListStackInstancesRequestSortDir) Value added in v0.1.61 

func (c ListStackInstancesRequestSortDir) Value() string

type ListStackInstancesRequestSortDirEnum added in v0.1.61 

type ListStackInstancesRequestSortDirEnum struct {
	ASC  ListStackInstancesRequestSortDir
	DESC ListStackInstancesRequestSortDir
}

func GetListStackInstancesRequestSortDirEnum added in v0.1.61 

func GetListStackInstancesRequestSortDirEnum() ListStackInstancesRequestSortDirEnum

type ListStackInstancesRequestSortKey added in v0.1.61 

type ListStackInstancesRequestSortKey struct {
	// contains filtered or unexported fields
}

func (ListStackInstancesRequestSortKey) MarshalJSON added in v0.1.61 

func (c ListStackInstancesRequestSortKey) MarshalJSON() ([]byte, error)

func (*ListStackInstancesRequestSortKey) UnmarshalJSON added in v0.1.61 

func (c *ListStackInstancesRequestSortKey) UnmarshalJSON(b []byte) error

func (ListStackInstancesRequestSortKey) Value added in v0.1.61 

func (c ListStackInstancesRequestSortKey) Value() string

type ListStackInstancesRequestSortKeyEnum added in v0.1.61 

type ListStackInstancesRequestSortKeyEnum struct {
	CREATE_TIME ListStackInstancesRequestSortKey
}

func GetListStackInstancesRequestSortKeyEnum added in v0.1.61 

func GetListStackInstancesRequestSortKeyEnum() ListStackInstancesRequestSortKeyEnum

type ListStackInstancesResponse added in v0.1.61 

type ListStackInstancesResponse struct {

	// 资源栈实例列表
	StackInstances *[]StackInstance `json:"stack_instances,omitempty"`
	HttpStatusCode int              `json:"-"`
}

ListStackInstancesResponse Response Object

func (ListStackInstancesResponse) String added in v0.1.61 

func (o ListStackInstancesResponse) String() string

type ListStackOutputsRequest 

type ListStackOutputsRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	// 资源栈（stack）的唯一Id。  此Id由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`
}

ListStackOutputsRequest Request Object

func (ListStackOutputsRequest) String 

func (o ListStackOutputsRequest) String() string

type ListStackOutputsResponse 

type ListStackOutputsResponse struct {

	// 资源栈输出列表
	Outputs        *[]StackOutput `json:"outputs,omitempty"`
	HttpStatusCode int            `json:"-"`
}

ListStackOutputsResponse Response Object

func (ListStackOutputsResponse) String 

func (o ListStackOutputsResponse) String() string

type ListStackResourcesRequest added in v0.1.12 

type ListStackResourcesRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	// 资源栈（stack）的唯一Id。  此Id由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`
}

ListStackResourcesRequest Request Object

func (ListStackResourcesRequest) String added in v0.1.12 

func (o ListStackResourcesRequest) String() string

type ListStackResourcesResponse added in v0.1.12 

type ListStackResourcesResponse struct {

	// 资源栈中所管理的资源信息列表
	StackResources *[]StackResource `json:"stack_resources,omitempty"`
	HttpStatusCode int              `json:"-"`
}

ListStackResourcesResponse Response Object

func (ListStackResourcesResponse) String added in v0.1.12 

func (o ListStackResourcesResponse) String() string

type ListStackSetOperationsRequest added in v0.1.61 

type ListStackSetOperationsRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈集的名称。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackSetName string `json:"stack_set_name"`

	// 资源栈集（stack-set）的唯一ID。  此ID由资源编排服务在生成资源栈集的时候生成，为UUID。  由于资源栈集名称仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈集，删除，再重新创建一个同名资源栈集。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈集就是我认为的那个，而不是其他队友删除后创建的同名资源栈集。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈集所对应的ID都不相同，更新不会影响ID。如果给与的stack_set_id和当前资源栈集的ID不一致，则返回400
	StackSetId *string `json:"stack_set_id,omitempty"`

	// 过滤条件  * 与（AND）运算符使用逗号（，）定义 * 或（OR）运算符使用竖线（|）定义，OR运算符优先级高于AND运算符 * 不支持括号 * 过滤运算符仅支持双等号（==） * 过滤参数名及其值仅支持包含大小写英文、数字和下划线 * 过滤条件中禁止使用分号，若有分号，则此条过滤会被忽略 * 一个过滤参数仅能与一个与条件相关，一个与条件中的多个或条件仅能与一个过滤参数相关
	Filter *string `json:"filter,omitempty"`

	// 排序字段，仅支持给予create_time
	SortKey *[]ListStackSetOperationsRequestSortKey `json:"sort_key,omitempty"`

	// 指定升序还是降序   * `asc` - 升序   * `desc` - 降序
	SortDir *[]ListStackSetOperationsRequestSortDir `json:"sort_dir,omitempty"`
}

ListStackSetOperationsRequest Request Object

func (ListStackSetOperationsRequest) String added in v0.1.61 

func (o ListStackSetOperationsRequest) String() string

type ListStackSetOperationsRequestSortDir added in v0.1.61 

type ListStackSetOperationsRequestSortDir struct {
	// contains filtered or unexported fields
}

func (ListStackSetOperationsRequestSortDir) MarshalJSON added in v0.1.61 

func (c ListStackSetOperationsRequestSortDir) MarshalJSON() ([]byte, error)

func (*ListStackSetOperationsRequestSortDir) UnmarshalJSON added in v0.1.61 

func (c *ListStackSetOperationsRequestSortDir) UnmarshalJSON(b []byte) error

func (ListStackSetOperationsRequestSortDir) Value added in v0.1.61 

func (c ListStackSetOperationsRequestSortDir) Value() string

type ListStackSetOperationsRequestSortDirEnum added in v0.1.61 

type ListStackSetOperationsRequestSortDirEnum struct {
	ASC  ListStackSetOperationsRequestSortDir
	DESC ListStackSetOperationsRequestSortDir
}

func GetListStackSetOperationsRequestSortDirEnum added in v0.1.61 

func GetListStackSetOperationsRequestSortDirEnum() ListStackSetOperationsRequestSortDirEnum

type ListStackSetOperationsRequestSortKey added in v0.1.61 

type ListStackSetOperationsRequestSortKey struct {
	// contains filtered or unexported fields
}

func (ListStackSetOperationsRequestSortKey) MarshalJSON added in v0.1.61 

func (c ListStackSetOperationsRequestSortKey) MarshalJSON() ([]byte, error)

func (*ListStackSetOperationsRequestSortKey) UnmarshalJSON added in v0.1.61 

func (c *ListStackSetOperationsRequestSortKey) UnmarshalJSON(b []byte) error

func (ListStackSetOperationsRequestSortKey) Value added in v0.1.61 

func (c ListStackSetOperationsRequestSortKey) Value() string

type ListStackSetOperationsRequestSortKeyEnum added in v0.1.61 

type ListStackSetOperationsRequestSortKeyEnum struct {
	CREATE_TIME ListStackSetOperationsRequestSortKey
}

func GetListStackSetOperationsRequestSortKeyEnum added in v0.1.61 

func GetListStackSetOperationsRequestSortKeyEnum() ListStackSetOperationsRequestSortKeyEnum

type ListStackSetOperationsResponse added in v0.1.61 

type ListStackSetOperationsResponse struct {

	// 资源栈集操作列表
	StackSetOperations *[]StackSetOperation `json:"stack_set_operations,omitempty"`
	HttpStatusCode     int                  `json:"-"`
}

ListStackSetOperationsResponse Response Object

func (ListStackSetOperationsResponse) String added in v0.1.61 

func (o ListStackSetOperationsResponse) String() string

type ListStackSetsRequest added in v0.1.61 

type ListStackSetsRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 过滤条件  * 与（AND）运算符使用逗号（，）定义 * 或（OR）运算符使用竖线（|）定义，OR运算符优先级高于AND运算符 * 不支持括号 * 过滤运算符仅支持双等号（==） * 过滤参数名及其值仅支持包含大小写英文、数字和下划线 * 过滤条件中禁止使用分号，若有分号，则此条过滤会被忽略 * 一个过滤参数仅能与一个与条件相关，一个与条件中的多个或条件仅能与一个过滤参数相关
	Filter *string `json:"filter,omitempty"`

	// 排序字段，仅支持给予create_time
	SortKey *[]ListStackSetsRequestSortKey `json:"sort_key,omitempty"`

	// 指定升序还是降序   * `asc` - 升序   * `desc` - 降序
	SortDir *[]ListStackSetsRequestSortDir `json:"sort_dir,omitempty"`
}

ListStackSetsRequest Request Object

func (ListStackSetsRequest) String added in v0.1.61 

func (o ListStackSetsRequest) String() string

type ListStackSetsRequestSortDir added in v0.1.61 

type ListStackSetsRequestSortDir struct {
	// contains filtered or unexported fields
}

func (ListStackSetsRequestSortDir) MarshalJSON added in v0.1.61 

func (c ListStackSetsRequestSortDir) MarshalJSON() ([]byte, error)

func (*ListStackSetsRequestSortDir) UnmarshalJSON added in v0.1.61 

func (c *ListStackSetsRequestSortDir) UnmarshalJSON(b []byte) error

func (ListStackSetsRequestSortDir) Value added in v0.1.61 

func (c ListStackSetsRequestSortDir) Value() string

type ListStackSetsRequestSortDirEnum added in v0.1.61 

type ListStackSetsRequestSortDirEnum struct {
	ASC  ListStackSetsRequestSortDir
	DESC ListStackSetsRequestSortDir
}

func GetListStackSetsRequestSortDirEnum added in v0.1.61 

func GetListStackSetsRequestSortDirEnum() ListStackSetsRequestSortDirEnum

type ListStackSetsRequestSortKey added in v0.1.61 

type ListStackSetsRequestSortKey struct {
	// contains filtered or unexported fields
}

func (ListStackSetsRequestSortKey) MarshalJSON added in v0.1.61 

func (c ListStackSetsRequestSortKey) MarshalJSON() ([]byte, error)

func (*ListStackSetsRequestSortKey) UnmarshalJSON added in v0.1.61 

func (c *ListStackSetsRequestSortKey) UnmarshalJSON(b []byte) error

func (ListStackSetsRequestSortKey) Value added in v0.1.61 

func (c ListStackSetsRequestSortKey) Value() string

type ListStackSetsRequestSortKeyEnum added in v0.1.61 

type ListStackSetsRequestSortKeyEnum struct {
	CREATE_TIME ListStackSetsRequestSortKey
}

func GetListStackSetsRequestSortKeyEnum added in v0.1.61 

func GetListStackSetsRequestSortKeyEnum() ListStackSetsRequestSortKeyEnum

type ListStackSetsResponse added in v0.1.61 

type ListStackSetsResponse struct {

	// 资源栈集
	StackSets      *[]StackSet `json:"stack_sets,omitempty"`
	HttpStatusCode int         `json:"-"`
}

ListStackSetsResponse Response Object

func (ListStackSetsResponse) String added in v0.1.61 

func (o ListStackSetsResponse) String() string

type ListStacksRequest 

type ListStacksRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`
}

ListStacksRequest Request Object

func (ListStacksRequest) String 

func (o ListStacksRequest) String() string

type ListStacksResponse 

type ListStacksResponse struct {

	// 资源栈列表。默认按照生成时间排序，最早生成的在最前
	Stacks         *[]Stack `json:"stacks,omitempty"`
	HttpStatusCode int      `json:"-"`
}

ListStacksResponse Response Object

func (ListStacksResponse) String 

func (o ListStacksResponse) String() string

type ListTemplateVersionsRequest added in v0.1.46 

type ListTemplateVersionsRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 用户希望创建的模板名称
	TemplateName string `json:"template_name"`

	// 模板的ID。当template_id存在时，模板服务会检查template_id是否和template_name匹配，不匹配会返回400
	TemplateId *string `json:"template_id,omitempty"`
}

ListTemplateVersionsRequest Request Object

func (ListTemplateVersionsRequest) String added in v0.1.46 

func (o ListTemplateVersionsRequest) String() string

type ListTemplateVersionsResponse added in v0.1.46 

type ListTemplateVersionsResponse struct {

	// 模板版本列表
	Versions       *[]TemplateVersion `json:"versions,omitempty"`
	HttpStatusCode int                `json:"-"`
}

ListTemplateVersionsResponse Response Object

func (ListTemplateVersionsResponse) String added in v0.1.46 

func (o ListTemplateVersionsResponse) String() string

type ListTemplatesRequest added in v0.1.30 

type ListTemplatesRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`
}

ListTemplatesRequest Request Object

func (ListTemplatesRequest) String added in v0.1.30 

func (o ListTemplatesRequest) String() string

type ListTemplatesResponse added in v0.1.30 

type ListTemplatesResponse struct {

	// 模板列表
	Templates      *[]Template `json:"templates,omitempty"`
	HttpStatusCode int         `json:"-"`
}

ListTemplatesResponse Response Object

func (ListTemplatesResponse) String added in v0.1.30 

func (o ListTemplatesResponse) String() string

type ManagedAgencyNamePrimitiveTypeHolder added in v0.1.61 

type ManagedAgencyNamePrimitiveTypeHolder struct {

	// 被管理的委托名称。  资源编排服务会使用该委托获取实际部署资源所需要的权限  不同成员账号委托给管理账号的委托名称需要保持一致。暂不支持根据不同provider定义不同委托权限  当用户定义SELF_MANAGED权限类型时，必须指定该参数。当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400  [创建委托及授权方式](https://support.huaweicloud.com/usermanual-iam/iam_06_0002.html)
	ManagedAgencyName *string `json:"managed_agency_name,omitempty"`
}

func (ManagedAgencyNamePrimitiveTypeHolder) String added in v0.1.61 

func (o ManagedAgencyNamePrimitiveTypeHolder) String() string

type OperationIdPrimitiveTypeHolder added in v0.1.61 

type OperationIdPrimitiveTypeHolder struct {

	// 资源栈集操作Id。  此Id由资源编排服务在生成资源栈集操作的时候生成，为UUID。
	OperationId *string `json:"operation_id,omitempty"`
}

func (OperationIdPrimitiveTypeHolder) String added in v0.1.61 

func (o OperationIdPrimitiveTypeHolder) String() string

type ParseTemplateVariablesRequest 

type ParseTemplateVariablesRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	Body *ParseTemplateVariablesRequestBody `json:"body,omitempty"`
}

ParseTemplateVariablesRequest Request Object

func (ParseTemplateVariablesRequest) String 

func (o ParseTemplateVariablesRequest) String() string

type ParseTemplateVariablesRequestBody 

type ParseTemplateVariablesRequestBody struct {

	// HCL模板，描述了资源的目标状态。资源编排服务将比较此模板与当前远程资源的状态之间的区别。  template_body和template_uri 必须有且只有一个存在  **注意：**   * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储对应的template_body
	TemplateBody *string `json:"template_body,omitempty"`

	// HCL模板的OBS地址，该模板描述了资源的目标状态。资源编排服务将比较此模板与当前远程资源的状态之间的区别  OBS地址支持同类型Region之间进行互相访问（Region分为通用Region和专属Region，通用Region指面向公共租户提供通用云服务的Region；专属Region指只承载同一类业务或只面向特定租户提供业务服务的专用Region）  对应的文件应该是纯tf文件或zip压缩包  纯tf文件需要以“.tf”或者“.tf.json”结尾，并遵守HCL语法，且文件的编码格式须为UTF-8  压缩包目前只支持zip格式，文件需要以\".zip\"结尾。解压后的文件不得包含\".tfvars\"文件。解压前最大支持1MB，解压后最大支持1MB。zip压缩包文件数量不能超过100个  template_body和template_uri 必须有且只有一个存在  **注意：**   * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储template_uri对应的模板文件内容。   * template_uri对应的模板文件若为zip类型，则内部的文件或文件夹名称长度不得超过255个字节，最深路径长度不得超过2048字节，zip包大小不得超过1MB
	TemplateUri *string `json:"template_uri,omitempty"`
}

func (ParseTemplateVariablesRequestBody) String 

func (o ParseTemplateVariablesRequestBody) String() string

type ParseTemplateVariablesResponse 

type ParseTemplateVariablesResponse struct {

	// 解析模板得到的参数列表
	Variables      *[]VariableResponse `json:"variables,omitempty"`
	HttpStatusCode int                 `json:"-"`
}

ParseTemplateVariablesResponse Response Object

func (ParseTemplateVariablesResponse) String 

func (o ParseTemplateVariablesResponse) String() string

type PermissionModelPrimitiveTypeHolder added in v0.1.61 

type PermissionModelPrimitiveTypeHolder struct {

	// 权限模型，定义了RFS操作资源栈集时所需委托的创建方式，枚举值    * `SELF_MANAGED` - 基于部署需求，用户需要提前手动创建委托，既包含管理账号给RFS的委托，也包含成员账号创建给管理账号的委托。如果委托不存在或错误，创建资源栈集不会失败，部署资源栈集或部署资源栈实例的时候才会报错。
	PermissionModel *PermissionModelPrimitiveTypeHolderPermissionModel `json:"permission_model,omitempty"`
}

func (PermissionModelPrimitiveTypeHolder) String added in v0.1.61 

func (o PermissionModelPrimitiveTypeHolder) String() string

type PermissionModelPrimitiveTypeHolderPermissionModel added in v0.1.61 

type PermissionModelPrimitiveTypeHolderPermissionModel struct {
	// contains filtered or unexported fields
}

func (PermissionModelPrimitiveTypeHolderPermissionModel) MarshalJSON added in v0.1.61 

func (c PermissionModelPrimitiveTypeHolderPermissionModel) MarshalJSON() ([]byte, error)

func (*PermissionModelPrimitiveTypeHolderPermissionModel) UnmarshalJSON added in v0.1.61 

func (c *PermissionModelPrimitiveTypeHolderPermissionModel) UnmarshalJSON(b []byte) error

func (PermissionModelPrimitiveTypeHolderPermissionModel) Value added in v0.1.61 

func (c PermissionModelPrimitiveTypeHolderPermissionModel) Value() string

type PermissionModelPrimitiveTypeHolderPermissionModelEnum added in v0.1.61 

type PermissionModelPrimitiveTypeHolderPermissionModelEnum struct {
	SELF_MANAGED PermissionModelPrimitiveTypeHolderPermissionModel
}

func GetPermissionModelPrimitiveTypeHolderPermissionModelEnum added in v0.1.61 

func GetPermissionModelPrimitiveTypeHolderPermissionModelEnum() PermissionModelPrimitiveTypeHolderPermissionModelEnum

type ResourceAttribute added in v0.1.30 

type ResourceAttribute struct {

	// 资源属性的键
	Key *string `json:"key,omitempty"`

	// 资源属性的值
	Value *string `json:"value,omitempty"`
}

ResourceAttribute 资源属性 以HCL格式的模板为例，资源属性的key 为 name，value 为 \"test_vpc\" ```hcl resource \"huaweicloud_vpc\" \"my_hello_world_vpc\" { name = \"test_vpc\" } ``` 以json格式的模板为例，资源属性的key 为 name，value 为 \"test_vpc\" ```json { \"resource\": { \"huaweicloud_vpc\": { \"my_hello_world_vpc\": { \"name\": \"test_vpc\" } } } } ```

func (ResourceAttribute) String added in v0.1.30 

func (o ResourceAttribute) String() string

type ResourceNamePrimitiveTypeHolder added in v0.1.30 

type ResourceNamePrimitiveTypeHolder struct {

	// 资源的名称，默认为资源的逻辑名称  以HCL格式的模板为例，resource_name 为 my_hello_world_vpc  “`hcl resource \"huaweicloud_vpc\" \"my_hello_world_vpc\" {   name = \"test_vpc\" } “`  以json格式的模板为例，resource_name 为 my_hello_world_vpc  “`json {   \"resource\": {     \"huaweicloud_vpc\": {       \"my_hello_world_vpc\": {         \"name\": \"test_vpc\"       }     }   } } “`
	ResourceName *string `json:"resource_name,omitempty"`
}

func (ResourceNamePrimitiveTypeHolder) String added in v0.1.30 

func (o ResourceNamePrimitiveTypeHolder) String() string

type ResourcePriceResponse 

type ResourcePriceResponse struct {

	// 计费模式  * `PRE_PAID` - 包周期计费 * `POST_PAID` - 按需计费 * `FREE` - 免费
	ChargeMode *ResourcePriceResponseChargeMode `json:"charge_mode,omitempty"`

	// 该资源最终优惠后的金额（只考虑官网折扣、商务折扣以及伙伴折扣，不包含促销折扣及优惠券），保留小数点后2位，向上取整，默认单位是元。
	SalePrice *float64 `json:"sale_price,omitempty"`

	// 该资源的总优惠额，保留小数点后2位，向上取整，默认单位是元。
	Discount *float64 `json:"discount,omitempty"`

	// 该资源的原价，保留小数点后2位，向上取整，默认单位是元。
	OriginalPrice *float64 `json:"original_price,omitempty"`

	// 计费单位  若该资源支持包周期计费或按需计费，则会返回该字段；若该资源为免费资源，则不返回该字段。  * `HOUR` - 小时，按需计费的单位 * `DAY` - 天，按需计费的单位 * `MONTH` - 月，包周期计费的单位 * `YEAR` - 年，包周期计费的单位 * `BYTE` - 字节，按需计费的单位 * `MB` - 百万字节，包周期计费和按需计费的单位 * `GB` - 千兆字节，包周期计费和按需计费的单位
	PeriodType *ResourcePriceResponsePeriodType `json:"period_type,omitempty"`

	// 该资源的计费数量，需要和period_type搭配使用  若该资源支持包周期计费或按需计费，则会返回该字段；若该资源为免费资源，则不返回该字段。  * 对于按需计费资源，此值默认返回1，代表在1个计费单位下，该资源的价格 * 对于包周期计费资源，此值与模板中该资源的period字段保持一致
	PeriodCount *int32 `json:"period_count,omitempty"`
}

func (ResourcePriceResponse) String 

func (o ResourcePriceResponse) String() string

type ResourcePriceResponseChargeMode 

type ResourcePriceResponseChargeMode struct {
	// contains filtered or unexported fields
}

func (ResourcePriceResponseChargeMode) MarshalJSON 

func (c ResourcePriceResponseChargeMode) MarshalJSON() ([]byte, error)

func (*ResourcePriceResponseChargeMode) UnmarshalJSON 

func (c *ResourcePriceResponseChargeMode) UnmarshalJSON(b []byte) error

func (ResourcePriceResponseChargeMode) Value 

func (c ResourcePriceResponseChargeMode) Value() string

type ResourcePriceResponseChargeModeEnum 

type ResourcePriceResponseChargeModeEnum struct {
	PRE_PAID  ResourcePriceResponseChargeMode
	POST_PAID ResourcePriceResponseChargeMode
	FREE      ResourcePriceResponseChargeMode
}

func GetResourcePriceResponseChargeModeEnum 

func GetResourcePriceResponseChargeModeEnum() ResourcePriceResponseChargeModeEnum

type ResourcePriceResponsePeriodType 

type ResourcePriceResponsePeriodType struct {
	// contains filtered or unexported fields
}

func (ResourcePriceResponsePeriodType) MarshalJSON 

func (c ResourcePriceResponsePeriodType) MarshalJSON() ([]byte, error)

func (*ResourcePriceResponsePeriodType) UnmarshalJSON 

func (c *ResourcePriceResponsePeriodType) UnmarshalJSON(b []byte) error

func (ResourcePriceResponsePeriodType) Value 

func (c ResourcePriceResponsePeriodType) Value() string

type ResourcePriceResponsePeriodTypeEnum 

type ResourcePriceResponsePeriodTypeEnum struct {
	HOUR  ResourcePriceResponsePeriodType
	DAY   ResourcePriceResponsePeriodType
	MONTH ResourcePriceResponsePeriodType
	YEAR  ResourcePriceResponsePeriodType
	BYTE  ResourcePriceResponsePeriodType
	MB    ResourcePriceResponsePeriodType
	GB    ResourcePriceResponsePeriodType
}

func GetResourcePriceResponsePeriodTypeEnum 

func GetResourcePriceResponsePeriodTypeEnum() ResourcePriceResponsePeriodTypeEnum

type ResourceTypePrimitiveTypeHolder added in v0.1.30 

type ResourceTypePrimitiveTypeHolder struct {

	// 资源的类型  以HCL格式的模板为例，resource_type 为 huaweicloud_vpc  “`hcl resource \"huaweicloud_vpc\" \"my_hello_world_vpc\" {   name = \"test_vpc\" } “`  以json格式的模板为例，resource_type 为 huaweicloud_vpc  “`json {   \"resource\": {     \"huaweicloud_vpc\": {       \"my_hello_world_vpc\": {         \"name\": \"test_vpc\"       }     }   } } “`
	ResourceType *string `json:"resource_type,omitempty"`
}

func (ResourceTypePrimitiveTypeHolder) String added in v0.1.30 

func (o ResourceTypePrimitiveTypeHolder) String() string

type RetainAllResourcesTypeHolder added in v0.1.58 

type RetainAllResourcesTypeHolder struct {

	// 删除资源栈是否保留资源的标志位，如果不传默认为false，即默认不保留资源（删除资源栈后会删除资源栈中的资源）  * DeleteStackEnhanced API中，若该参数未在RequestBody中给予，则删除时不会保留资源栈中的资源*
	RetainAllResources *bool `json:"retain_all_resources,omitempty"`
}

func (RetainAllResourcesTypeHolder) String added in v0.1.58 

func (o RetainAllResourcesTypeHolder) String() string

type ShowStackInstanceRequest added in v0.1.63 

type ShowStackInstanceRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈集的名称。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackSetName string `json:"stack_set_name"`

	// 资源栈实例的唯一地址。该地址由region和stack_domain_id通过\"/\"（转义后为%2f或%2F）拼接而成。该地址在domain_id+region+stack_set_name下唯一。
	StackInstanceAddr string `json:"stack_instance_addr"`

	// 资源栈集（stack-set）的唯一ID。  此ID由资源编排服务在生成资源栈集的时候生成，为UUID。  由于资源栈集名称仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈集，删除，再重新创建一个同名资源栈集。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈集就是我认为的那个，而不是其他队友删除后创建的同名资源栈集。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈集所对应的ID都不相同，更新不会影响ID。如果给与的stack_set_id和当前资源栈集的ID不一致，则返回400
	StackSetId *string `json:"stack_set_id,omitempty"`
}

ShowStackInstanceRequest Request Object

func (ShowStackInstanceRequest) String added in v0.1.63 

func (o ShowStackInstanceRequest) String() string

type ShowStackInstanceResponse added in v0.1.63 

type ShowStackInstanceResponse struct {

	// 资源栈集（stack_set）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈集名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈集，删除，在重新创建一个同名资源栈集。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈集就是我以为的那个，而不是又其他队友删除后创建的同名资源栈集。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈集所对应的ID都不相同，更新不会影响ID。如果给与的stack_set_id和当前资源栈集的ID不一致，则返回400
	StackSetId *string `json:"stack_set_id,omitempty"`

	// 资源栈集（stack_set）的名字。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackSetName string `json:"stack_set_name"`

	// 资源栈实例的状态  * `WAIT_IN_PROGRESS` - 资源栈实例等待操作中 * `CANCEL_COMPLETE` - 资源栈实例操作取消完成 * `OPERATION_IN_PROGRESS` - 资源栈实例操作中 * `OPERATION_FAILED` - 资源栈实例操作失败 * `INOPERABLE` - 资源栈实例不可操作 * `OPERATION_COMPLETE` - 资源栈实例操作完成
	Status *ShowStackInstanceResponseStatus `json:"status,omitempty"`

	// 在资源栈实例状态为`INOPERABLE`或`OPERATION_FAILED`时，会显示简要的错误信息总结以供debug
	StatusMessage *string `json:"status_message,omitempty"`

	// 资源栈（stack）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	// 资源栈实例所关联的资源栈所在的租户ID
	StackDomainId *string `json:"stack_domain_id,omitempty"`

	// 最新一次部署该资源栈实例的资源栈集操作ID  此Id由资源编排服务在生成资源栈集操作的时候生成，为UUID
	LatestStackSetOperationId *string `json:"latest_stack_set_operation_id,omitempty"`

	// 资源栈实例所关联的资源栈所在的区域
	Region *string `json:"region,omitempty"`

	// 资源栈实例的创建时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z
	CreateTime *string `json:"create_time,omitempty"`

	// 资源栈实例的更新时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z
	UpdateTime *string `json:"update_time,omitempty"`

	// 该资源栈实例的参数覆盖内容  若用户通过CreateStackInstances或UpdateStackInstances API 对该资源栈实例设置了参数覆盖，该字段会返回资源栈实例记录的最新参数覆盖内容  若该字段未返回，用户使用资源栈集中记录的参数部署该实例
	VarOverrides   *interface{} `json:"var_overrides,omitempty"`
	HttpStatusCode int          `json:"-"`
}

ShowStackInstanceResponse Response Object

func (ShowStackInstanceResponse) String added in v0.1.63 

func (o ShowStackInstanceResponse) String() string

type ShowStackInstanceResponseStatus added in v0.1.63 

type ShowStackInstanceResponseStatus struct {
	// contains filtered or unexported fields
}

func (ShowStackInstanceResponseStatus) MarshalJSON added in v0.1.63 

func (c ShowStackInstanceResponseStatus) MarshalJSON() ([]byte, error)

func (*ShowStackInstanceResponseStatus) UnmarshalJSON added in v0.1.63 

func (c *ShowStackInstanceResponseStatus) UnmarshalJSON(b []byte) error

func (ShowStackInstanceResponseStatus) Value added in v0.1.63 

func (c ShowStackInstanceResponseStatus) Value() string

type ShowStackInstanceResponseStatusEnum added in v0.1.63 

type ShowStackInstanceResponseStatusEnum struct {
	WAIT_IN_PROGRESS      ShowStackInstanceResponseStatus
	CANCEL_COMPLETE       ShowStackInstanceResponseStatus
	OPERATION_IN_PROGRESS ShowStackInstanceResponseStatus
	OPERATION_FAILED      ShowStackInstanceResponseStatus
	INOPERABLE            ShowStackInstanceResponseStatus
	OPERATION_COMPLETE    ShowStackInstanceResponseStatus
}

func GetShowStackInstanceResponseStatusEnum added in v0.1.63 

func GetShowStackInstanceResponseStatusEnum() ShowStackInstanceResponseStatusEnum

type ShowStackSetMetadataRequest added in v0.1.61 

type ShowStackSetMetadataRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈集的名称。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackSetName string `json:"stack_set_name"`

	// 资源栈集（stack-set）的唯一ID。  此ID由资源编排服务在生成资源栈集的时候生成，为UUID。  由于资源栈集名称仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈集，删除，再重新创建一个同名资源栈集。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈集就是我认为的那个，而不是其他队友删除后创建的同名资源栈集。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈集所对应的ID都不相同，更新不会影响ID。如果给与的stack_set_id和当前资源栈集的ID不一致，则返回400
	StackSetId *string `json:"stack_set_id,omitempty"`
}

ShowStackSetMetadataRequest Request Object

func (ShowStackSetMetadataRequest) String added in v0.1.61 

func (o ShowStackSetMetadataRequest) String() string

type ShowStackSetMetadataResponse added in v0.1.61 

type ShowStackSetMetadataResponse struct {

	// 资源栈集（stack_set）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈集名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈集，删除，在重新创建一个同名资源栈集。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈集就是我以为的那个，而不是又其他队友删除后创建的同名资源栈集。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈集所对应的ID都不相同，更新不会影响ID。如果给与的stack_set_id和当前资源栈集的ID不一致，则返回400
	StackSetId *string `json:"stack_set_id,omitempty"`

	// 资源栈集（stack_set）的名字。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackSetName string `json:"stack_set_name"`

	// 资源栈集的描述。可用于客户识别自己的资源栈集。
	StackSetDescription *string `json:"stack_set_description,omitempty"`

	// 初始化资源栈描述。可用于客户识别被资源栈集所管理的资源栈。  资源栈集下的资源栈仅在创建时统一使用该描述。客户想要更新初始化资源栈描述，可以通过UpdateStackSet API。  后续更新资源栈集描述将不会同步更新已管理的资源栈描述。
	InitialStackDescription *string `json:"initial_stack_description,omitempty"`

	// 权限模型，定义了RFS操作资源栈集时所需委托的创建方式，枚举值    * `SELF_MANAGED` - 基于部署需求，用户需要提前手动创建委托，既包含管理账号给RFS的委托，也包含成员账号创建给管理账号的委托。如果委托不存在或错误，创建资源栈集不会失败，部署资源栈集或部署资源栈实例的时候才会报错。
	PermissionModel *ShowStackSetMetadataResponsePermissionModel `json:"permission_model,omitempty"`

	// 管理委托名称  资源编排服务使用该委托获取成员账号委托给管理账号的权限  当用户定义SELF_MANAGED权限类型时，administration_agency_name和administration_agency_urn 必须有且只有一个存在。  推荐用户在使用v5委托时给与administration_agency_urn，administration_agency_name只支持接收v3委托名称，若给与了v5委托名称，则会在部署模板时失败。  当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400。  [创建委托及授权方式](https://support.huaweicloud.com/usermanual-iam/iam_06_0002.html)
	AdministrationAgencyName *string `json:"administration_agency_name,omitempty"`

	// 被管理的委托名称。  资源编排服务会使用该委托获取实际部署资源所需要的权限  不同成员账号委托给管理账号的委托名称需要保持一致。暂不支持根据不同provider定义不同委托权限  当用户定义SELF_MANAGED权限类型时，必须指定该参数。当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400  [创建委托及授权方式](https://support.huaweicloud.com/usermanual-iam/iam_06_0002.html)
	ManagedAgencyName *string `json:"managed_agency_name,omitempty"`

	// 资源栈集的状态     * `IDLE` - 资源栈集空闲 * `OPERATION_IN_PROGRESS` - 资源栈集操作中 * `DEACTIVATED` - 资源栈集禁用
	Status *ShowStackSetMetadataResponseStatus `json:"status,omitempty"`

	// vars_uri对应的文件内容
	VarsUriContent *string `json:"vars_uri_content,omitempty"`

	// HCL参数文件的内容。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  * vars_body使用HCL的tfvars格式，用户可以将“.tfvars”中的内容提交到vars_body中  * 资源编排服务支持vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * 如果vars_body过大，可以使用vars_uri  * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储对应的vars_body。
	VarsBody *string `json:"vars_body,omitempty"`

	// 资源栈集的创建时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z。
	CreateTime *string `json:"create_time,omitempty"`

	// 资源栈集的更新时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z。
	UpdateTime *string `json:"update_time,omitempty"`

	// 管理委托URN  资源编排服务使用该委托获取成员账号委托给管理账号的权限  当用户定义SELF_MANAGED权限类型时，administration_agency_name和administration_agency_urn 必须有且只有一个存在。  推荐用户在使用v5委托时给与administration_agency_urn，administration_agency_name只支持接收普通委托名称，若给与了v5委托名称，则会在部署模板时失败。  当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400。
	AdministrationAgencyUrn *string `json:"administration_agency_urn,omitempty"`
	HttpStatusCode          int     `json:"-"`
}

ShowStackSetMetadataResponse Response Object

func (ShowStackSetMetadataResponse) String added in v0.1.61 

func (o ShowStackSetMetadataResponse) String() string

type ShowStackSetMetadataResponsePermissionModel added in v0.1.61 

type ShowStackSetMetadataResponsePermissionModel struct {
	// contains filtered or unexported fields
}

func (ShowStackSetMetadataResponsePermissionModel) MarshalJSON added in v0.1.61 

func (c ShowStackSetMetadataResponsePermissionModel) MarshalJSON() ([]byte, error)

func (*ShowStackSetMetadataResponsePermissionModel) UnmarshalJSON added in v0.1.61 

func (c *ShowStackSetMetadataResponsePermissionModel) UnmarshalJSON(b []byte) error

func (ShowStackSetMetadataResponsePermissionModel) Value added in v0.1.61 

func (c ShowStackSetMetadataResponsePermissionModel) Value() string

type ShowStackSetMetadataResponsePermissionModelEnum added in v0.1.61 

type ShowStackSetMetadataResponsePermissionModelEnum struct {
	SELF_MANAGED ShowStackSetMetadataResponsePermissionModel
}

func GetShowStackSetMetadataResponsePermissionModelEnum added in v0.1.61 

func GetShowStackSetMetadataResponsePermissionModelEnum() ShowStackSetMetadataResponsePermissionModelEnum

type ShowStackSetMetadataResponseStatus added in v0.1.61 

type ShowStackSetMetadataResponseStatus struct {
	// contains filtered or unexported fields
}

func (ShowStackSetMetadataResponseStatus) MarshalJSON added in v0.1.61 

func (c ShowStackSetMetadataResponseStatus) MarshalJSON() ([]byte, error)

func (*ShowStackSetMetadataResponseStatus) UnmarshalJSON added in v0.1.61 

func (c *ShowStackSetMetadataResponseStatus) UnmarshalJSON(b []byte) error

func (ShowStackSetMetadataResponseStatus) Value added in v0.1.61 

func (c ShowStackSetMetadataResponseStatus) Value() string

type ShowStackSetMetadataResponseStatusEnum added in v0.1.61 

type ShowStackSetMetadataResponseStatusEnum struct {
	IDLE                  ShowStackSetMetadataResponseStatus
	OPERATION_IN_PROGRESS ShowStackSetMetadataResponseStatus
	DEACTIVATED           ShowStackSetMetadataResponseStatus
}

func GetShowStackSetMetadataResponseStatusEnum added in v0.1.61 

func GetShowStackSetMetadataResponseStatusEnum() ShowStackSetMetadataResponseStatusEnum

type ShowStackSetOperationMetadataRequest added in v0.1.61 

type ShowStackSetOperationMetadataRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈集的名称。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackSetName string `json:"stack_set_name"`

	// 资源栈集（stack-set）的唯一ID。  此ID由资源编排服务在生成资源栈集的时候生成，为UUID。  由于资源栈集名称仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈集，删除，再重新创建一个同名资源栈集。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈集就是我认为的那个，而不是其他队友删除后创建的同名资源栈集。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈集所对应的ID都不相同，更新不会影响ID。如果给与的stack_set_id和当前资源栈集的ID不一致，则返回400
	StackSetId *string `json:"stack_set_id,omitempty"`

	// 资源栈集操作（stack_set_operation）的唯一Id。  此Id由资源编排服务在生成资源栈集操作的时候生成，为UUID。
	StackSetOperationId string `json:"stack_set_operation_id"`
}

ShowStackSetOperationMetadataRequest Request Object

func (ShowStackSetOperationMetadataRequest) String added in v0.1.61 

func (o ShowStackSetOperationMetadataRequest) String() string

type ShowStackSetOperationMetadataResponse added in v0.1.61 

type ShowStackSetOperationMetadataResponse struct {

	// 资源栈集操作（operation）的唯一Id。  此Id由资源编排服务在生成资源栈集操作的时候生成，为UUID。
	StackSetOperationId *string `json:"stack_set_operation_id,omitempty"`

	// 资源栈集（stack_set）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈集名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈集，删除，在重新创建一个同名资源栈集。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈集就是我以为的那个，而不是又其他队友删除后创建的同名资源栈集。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈集所对应的ID都不相同，更新不会影响ID。如果给与的stack_set_id和当前资源栈集的ID不一致，则返回400
	StackSetId *string `json:"stack_set_id,omitempty"`

	// 资源栈集（stack_set）的名字。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackSetName string `json:"stack_set_name"`

	// 资源栈集操作状态   * `QUEUE_IN_PROGRESS` - 正在排队   * `OPERATION_IN_PROGRESS` - 正在操作   * `OPERATION_COMPLETE` - 操作完成   * `OPERATION_FAILED` - 操作失败   * `STOP_IN_PROGRESS` - 正在停止   * `STOP_COMPLETE` - 停止完成   * `STOP_FAILED` - 停止失败
	Status *ShowStackSetOperationMetadataResponseStatus `json:"status,omitempty"`

	// 资源栈集操作失败时会展示此次操作失败的原因，例如，资源栈实例部署或删除失败个数超过上限或资源栈集操作超时。  如果需要查看详细失败信息，可通过ListStackInstances API获取查看资源栈实例的status_message。
	StatusMessage *string `json:"status_message,omitempty"`

	// 用户当前的操作   * `CREATE_STACK_INSTANCES` - 创建资源栈实例   * `DELETE_STACK_INSTANCES` - 删除资源栈实例   * `DEPLOY_STACK_SET` - 部署资源栈集   * `DEPLOY_STACK_INSTANCES` - 部署资源栈实例
	Action *ShowStackSetOperationMetadataResponseAction `json:"action,omitempty"`

	// 管理委托名称  资源编排服务使用该委托获取成员账号委托给管理账号的权限  当用户定义SELF_MANAGED权限类型时，administration_agency_name和administration_agency_urn 必须有且只有一个存在。  推荐用户在使用v5委托时给与administration_agency_urn，administration_agency_name只支持接收v3委托名称，若给与了v5委托名称，则会在部署模板时失败。  当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400。  [创建委托及授权方式](https://support.huaweicloud.com/usermanual-iam/iam_06_0002.html)
	AdministrationAgencyName *string `json:"administration_agency_name,omitempty"`

	// 管理委托URN  资源编排服务使用该委托获取成员账号委托给管理账号的权限  当用户定义SELF_MANAGED权限类型时，administration_agency_name和administration_agency_urn 必须有且只有一个存在。  推荐用户在使用v5委托时给与administration_agency_urn，administration_agency_name只支持接收普通委托名称，若给与了v5委托名称，则会在部署模板时失败。  当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400。
	AdministrationAgencyUrn *string `json:"administration_agency_urn,omitempty"`

	// 被管理的委托名称。  资源编排服务会使用该委托获取实际部署资源所需要的权限  不同成员账号委托给管理账号的委托名称需要保持一致。暂不支持根据不同provider定义不同委托权限  当用户定义SELF_MANAGED权限类型时，必须指定该参数。当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400  [创建委托及授权方式](https://support.huaweicloud.com/usermanual-iam/iam_06_0002.html)
	ManagedAgencyName *string `json:"managed_agency_name,omitempty"`

	DeploymentTargets *DeploymentTargets `json:"deployment_targets"`

	// 资源栈集操作的创建时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z。
	CreateTime *string `json:"create_time,omitempty"`

	// 资源栈集操作的更新时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z。
	UpdateTime     *string `json:"update_time,omitempty"`
	HttpStatusCode int     `json:"-"`
}

ShowStackSetOperationMetadataResponse Response Object

func (ShowStackSetOperationMetadataResponse) String added in v0.1.61 

func (o ShowStackSetOperationMetadataResponse) String() string

type ShowStackSetOperationMetadataResponseAction added in v0.1.61 

type ShowStackSetOperationMetadataResponseAction struct {
	// contains filtered or unexported fields
}

func (ShowStackSetOperationMetadataResponseAction) MarshalJSON added in v0.1.61 

func (c ShowStackSetOperationMetadataResponseAction) MarshalJSON() ([]byte, error)

func (*ShowStackSetOperationMetadataResponseAction) UnmarshalJSON added in v0.1.61 

func (c *ShowStackSetOperationMetadataResponseAction) UnmarshalJSON(b []byte) error

func (ShowStackSetOperationMetadataResponseAction) Value added in v0.1.61 

func (c ShowStackSetOperationMetadataResponseAction) Value() string

type ShowStackSetOperationMetadataResponseActionEnum added in v0.1.61 

type ShowStackSetOperationMetadataResponseActionEnum struct {
	CREATE_STACK_INSTANCES ShowStackSetOperationMetadataResponseAction
	DELETE_STACK_INSTANCES ShowStackSetOperationMetadataResponseAction
	DEPLOY_STACK_SET       ShowStackSetOperationMetadataResponseAction
	DEPLOY_STACK_INSTANCES ShowStackSetOperationMetadataResponseAction
}

func GetShowStackSetOperationMetadataResponseActionEnum added in v0.1.61 

func GetShowStackSetOperationMetadataResponseActionEnum() ShowStackSetOperationMetadataResponseActionEnum

type ShowStackSetOperationMetadataResponseStatus added in v0.1.61 

type ShowStackSetOperationMetadataResponseStatus struct {
	// contains filtered or unexported fields
}

func (ShowStackSetOperationMetadataResponseStatus) MarshalJSON added in v0.1.61 

func (c ShowStackSetOperationMetadataResponseStatus) MarshalJSON() ([]byte, error)

func (*ShowStackSetOperationMetadataResponseStatus) UnmarshalJSON added in v0.1.61 

func (c *ShowStackSetOperationMetadataResponseStatus) UnmarshalJSON(b []byte) error

func (ShowStackSetOperationMetadataResponseStatus) Value added in v0.1.61 

func (c ShowStackSetOperationMetadataResponseStatus) Value() string

type ShowStackSetOperationMetadataResponseStatusEnum added in v0.1.61 

type ShowStackSetOperationMetadataResponseStatusEnum struct {
	QUEUE_IN_PROGRESS     ShowStackSetOperationMetadataResponseStatus
	OPERATION_IN_PROGRESS ShowStackSetOperationMetadataResponseStatus
	OPERATION_COMPLETE    ShowStackSetOperationMetadataResponseStatus
	OPERATION_FAILED      ShowStackSetOperationMetadataResponseStatus
	STOP_IN_PROGRESS      ShowStackSetOperationMetadataResponseStatus
	STOP_COMPLETE         ShowStackSetOperationMetadataResponseStatus
	STOP_FAILED           ShowStackSetOperationMetadataResponseStatus
}

func GetShowStackSetOperationMetadataResponseStatusEnum added in v0.1.61 

func GetShowStackSetOperationMetadataResponseStatusEnum() ShowStackSetOperationMetadataResponseStatusEnum

type ShowStackSetTemplateRequest added in v0.1.61 

type ShowStackSetTemplateRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈集的名称。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackSetName string `json:"stack_set_name"`

	// 资源栈集（stack-set）的唯一ID。  此ID由资源编排服务在生成资源栈集的时候生成，为UUID。  由于资源栈集名称仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈集，删除，再重新创建一个同名资源栈集。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈集就是我认为的那个，而不是其他队友删除后创建的同名资源栈集。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈集所对应的ID都不相同，更新不会影响ID。如果给与的stack_set_id和当前资源栈集的ID不一致，则返回400
	StackSetId *string `json:"stack_set_id,omitempty"`
}

ShowStackSetTemplateRequest Request Object

func (ShowStackSetTemplateRequest) String added in v0.1.61 

func (o ShowStackSetTemplateRequest) String() string

type ShowStackSetTemplateResponse added in v0.1.61 

type ShowStackSetTemplateResponse struct {
	Location       *string `json:"Location,omitempty"`
	HttpStatusCode int     `json:"-"`
}

ShowStackSetTemplateResponse Response Object

func (ShowStackSetTemplateResponse) String added in v0.1.61 

func (o ShowStackSetTemplateResponse) String() string

type ShowTemplateMetadataRequest added in v0.1.30 

type ShowTemplateMetadataRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 用户希望创建的模板名称
	TemplateName string `json:"template_name"`

	// 模板的ID。当template_id存在时，模板服务会检查template_id是否和template_name匹配，不匹配会返回400
	TemplateId *string `json:"template_id,omitempty"`
}

ShowTemplateMetadataRequest Request Object

func (ShowTemplateMetadataRequest) String added in v0.1.30 

func (o ShowTemplateMetadataRequest) String() string

type ShowTemplateMetadataResponse added in v0.1.30 

type ShowTemplateMetadataResponse struct {

	// 模板的唯一ID，由模板服务随机生成
	TemplateId string `json:"template_id"`

	// 用户希望创建的模板名称
	TemplateName string `json:"template_name"`

	// 模板的描述。可用于客户识别自己的模板
	TemplateDescription *string `json:"template_description,omitempty"`

	// 模板的生成时间，格式遵循RFC3339，即yyyy-mm-ddTHH:MM:SSZ，如1970-01-01T00:00:00Z
	CreateTime string `json:"create_time"`

	// 模板的更新时间，格式遵循RFC3339，即yyyy-mm-ddTHH:MM:SSZ，如1970-01-01T00:00:00Z
	UpdateTime     string `json:"update_time"`
	HttpStatusCode int    `json:"-"`
}

ShowTemplateMetadataResponse Response Object

func (ShowTemplateMetadataResponse) String added in v0.1.30 

func (o ShowTemplateMetadataResponse) String() string

type ShowTemplateVersionContentRequest added in v0.1.30 

type ShowTemplateVersionContentRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 用户希望创建的模板名称
	TemplateName string `json:"template_name"`

	// 模板版本ID，以大写V开头，每次创建模板版本，模板版本ID数字部分会自增加一
	VersionId string `json:"version_id"`

	// 模板的ID。当template_id存在时，模板服务会检查template_id是否和template_name匹配，不匹配会返回400
	TemplateId *string `json:"template_id,omitempty"`
}

ShowTemplateVersionContentRequest Request Object

func (ShowTemplateVersionContentRequest) String added in v0.1.30 

func (o ShowTemplateVersionContentRequest) String() string

type ShowTemplateVersionContentResponse added in v0.1.30 

type ShowTemplateVersionContentResponse struct {

	// 空响应体
	Body *string `json:"body,omitempty"`

	Location       *string `json:"Location,omitempty"`
	HttpStatusCode int     `json:"-"`
}

ShowTemplateVersionContentResponse Response Object

func (ShowTemplateVersionContentResponse) String added in v0.1.30 

func (o ShowTemplateVersionContentResponse) String() string

type ShowTemplateVersionMetadataRequest added in v0.1.30 

type ShowTemplateVersionMetadataRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 用户希望创建的模板名称
	TemplateName string `json:"template_name"`

	// 模板版本ID，以大写V开头，每次创建模板版本，模板版本ID数字部分会自增加一
	VersionId string `json:"version_id"`

	// 模板的ID。当template_id存在时，模板服务会检查template_id是否和template_name匹配，不匹配会返回400
	TemplateId *string `json:"template_id,omitempty"`
}

ShowTemplateVersionMetadataRequest Request Object

func (ShowTemplateVersionMetadataRequest) String added in v0.1.30 

func (o ShowTemplateVersionMetadataRequest) String() string

type ShowTemplateVersionMetadataResponse added in v0.1.30 

type ShowTemplateVersionMetadataResponse struct {

	// 模板的唯一ID，由模板服务随机生成
	TemplateId string `json:"template_id"`

	// 用户希望创建的模板名称
	TemplateName string `json:"template_name"`

	// 模板版本的描述。可用于客户识别自己的模板版本
	VersionDescription *string `json:"version_description,omitempty"`

	// 版本创建时间，格式遵循RFC3339，即yyyy-mm-ddTHH:MM:SSZ，如1970-01-01T00:00:00Z
	CreateTime     string `json:"create_time"`
	HttpStatusCode int    `json:"-"`
}

ShowTemplateVersionMetadataResponse Response Object

func (ShowTemplateVersionMetadataResponse) String added in v0.1.30 

func (o ShowTemplateVersionMetadataResponse) String() string

type Stack 

type Stack struct {

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	// 资源栈的描述。可用于客户识别自己的资源栈。
	Description *string `json:"description,omitempty"`

	// 资源栈（stack）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`

	// 资源栈的状态    * `CREATION_COMPLETE` - 生成空资源栈完成，并没有任何部署    * `DEPLOYMENT_IN_PROGRESS` - 正在部署，请等待    * `DEPLOYMENT_FAILED` - 部署失败。请从status_message获取错误信息汇总，或者调用ListStackEvents获得事件详情    * `DEPLOYMENT_COMPLETE` - 部署完成    * `ROLLBACK_IN_PROGRESS` - 部署失败，正在回滚，请等待    * `ROLLBACK_FAILED` - 回滚失败。请从status_message获取错误信息汇总，或者调用ListStackEvents获得事件详情    * `ROLLBACK_COMPLETE` - 回滚完成    * `DELETION_IN_PROGRESS` - 正在删除，请等待    * `DELETION_FAILED` - 删除失败。请从status_message获取错误信息汇总，或者调用ListStackEvents获得事件详情
	Status *StackStatus `json:"status,omitempty"`

	// 资源栈的生成时间，格式遵循RFC3339，精确到秒，UTC时区，即yyyy-mm-ddTHH:MM:SSZ，如1970-01-01T00:00:00Z
	CreateTime *string `json:"create_time,omitempty"`

	// 资源栈的更新时间，格式遵循RFC3339，精确到秒，UTC时区，即yyyy-mm-ddTHH:MM:SSZ，如1970-01-01T00:00:00Z
	UpdateTime *string `json:"update_time,omitempty"`

	// 在失败的时候（资源栈状态以FAILED结尾）会显示简要的错误信息总结以供debug
	StatusMessage *string `json:"status_message,omitempty"`
}

func (Stack) String 

func (o Stack) String() string

type StackDescriptionPrimitiveTypeHolder 

type StackDescriptionPrimitiveTypeHolder struct {

	// 资源栈的描述。可用于客户识别自己的资源栈。
	Description *string `json:"description,omitempty"`
}

func (StackDescriptionPrimitiveTypeHolder) String 

func (o StackDescriptionPrimitiveTypeHolder) String() string

type StackEvent added in v0.1.24 

type StackEvent struct {

	// 资源的类型  以HCL格式的模板为例，resource_type 为 huaweicloud_vpc  “`hcl resource \"huaweicloud_vpc\" \"my_hello_world_vpc\" {   name = \"test_vpc\" } “`  以json格式的模板为例，resource_type 为 huaweicloud_vpc  “`json {   \"resource\": {     \"huaweicloud_vpc\": {       \"my_hello_world_vpc\": {         \"name\": \"test_vpc\"       }     }   } } “`
	ResourceType *string `json:"resource_type,omitempty"`

	// 资源的名称，默认为资源的逻辑名称  以HCL格式的模板为例，resource_name 为 my_hello_world_vpc  “`hcl resource \"huaweicloud_vpc\" \"my_hello_world_vpc\" {   name = \"test_vpc\" } “`  以json格式的模板为例，resource_name 为 my_hello_world_vpc  “`json {   \"resource\": {     \"huaweicloud_vpc\": {       \"my_hello_world_vpc\": {         \"name\": \"test_vpc\"       }     }   } } “`
	ResourceName *string `json:"resource_name,omitempty"`

	// 资源id的名称，即对应资源作为id使用的值的名称，当资源未创建的时候，不返回resource_id_key 此id由provider定义，因此不同的provider可能遵循了不同的命名规则，具体的命名规则请与provider开发者确认或阅读provider文档
	ResourceIdKey *string `json:"resource_id_key,omitempty"`

	// 资源id的值，即对应资源作为id使用的值，当资源未创建的时候，不返回resource_id_value
	ResourceIdValue *string `json:"resource_id_value,omitempty"`

	// 资源键，若用户在模板中使用了count或for_each则会返回resource_key  若用户在模板中使用count，则resource_key为从0开始的数字  以HCL格式的模板为例，模板中count为2，意味着将会生成两个资源，对应的resource_key分别为0和1  “`hcl resource \"huaweicloud_vpc\" \"my_hello_world_vpc\" {   count = 2   name = \"test_vpc\" } “`  以json格式的模板为例，模板中count为2，意味着将会生成两个资源，对应的resource_key分别为0和1  “`json {   \"resource\": {     \"huaweicloud_vpc\": {       \"my_hello_world_vpc\": {         \"name\": \"test_vpc\",         \"count\": 2       }     }   } } “`  若用户在模板中使用for_each，则resource_key为用户自定义的字符串  以HCL格式的模板为例，resource_key分别为vpc1和vpc2  “`hcl resource \"huaweicloud_vpc\" \"my_hello_world_vpc\" {   for_each = {     \"vpc1\" = \"test_vpc\"     \"vpc2\" = \"test_vpc\"   }   name = each.value } “`  以json格式的模板为例，resource_key分别为vpc1和vpc2  “`json {   \"resource\": {     \"huaweicloud_vpc\": {       \"my_hello_world_vpc\": {         \"for_each\": {           \"vpc1\": \"test_vpc\",           \"vpc2\": \"test_vpc\"         }         \"name\": \"${each.value}\"       }     }   } } “`
	ResourceKey *string `json:"resource_key,omitempty"`

	// 事件发生的时间 格式遵循RFC3339，即yyyy-mm-ddTHH:MM:SSZ，如1970-01-01T00:00:00Z
	Time *string `json:"time,omitempty"`

	// 此次事件的类型   * `LOG` - 记录状态信息，比如当前状态，目标状态等。   * `ERROR` - 记录失败信息   * `DRIFT` - 记录资源偏移信息   * `SUMMARY` - 记录资源变更结果总结   * `CREATION_IN_PROGRESS` - 正在生成   * `CREATION_FAILED` - 生成失败   * `CREATION_COMPLETE` - 生成完成   * `DELETION_IN_PROGRESS` - 正在删除   * `DELETION_FAILED` - 删除失败   * `DELETION_COMPLETE` - 已经删除   * `UPDATE_IN_PROGRESS` - 正在更新。此处的更新特指非替换式更新，如果是替换式更新，则是DELETION后CREATION，或者CREATION后DELETION，具体以何种行为进行替换式更新由Provider定义。   * `UPDATE_FAILED` - 更新失败。此处的更新特指非替换式更新，如果是替换式更新，则是DELETION后CREATION，或者CREATION后DELETION，具体以何种行为进行替换式更新由Provider定义。   * `UPDATE_COMPLETE` - 更新完成。此处的更新特指非替换式更新，如果是替换式更新，则是DELETION后CREATION，或者CREATION后DELETION，具体以何种行为进行替换式更新由Provider定义。
	EventType *StackEventEventType `json:"event_type,omitempty"`

	// 该资源栈事件对应的详细信息
	EventMessage *string `json:"event_message,omitempty"`

	// 此事件执行所花的时间，以秒为单位
	ElapsedSeconds *int32 `json:"elapsed_seconds,omitempty"`
}

func (StackEvent) String added in v0.1.24 

func (o StackEvent) String() string

type StackEventEventType added in v0.1.24 

type StackEventEventType struct {
	// contains filtered or unexported fields
}

func (StackEventEventType) MarshalJSON added in v0.1.24 

func (c StackEventEventType) MarshalJSON() ([]byte, error)

func (*StackEventEventType) UnmarshalJSON added in v0.1.24 

func (c *StackEventEventType) UnmarshalJSON(b []byte) error

func (StackEventEventType) Value added in v0.1.24 

func (c StackEventEventType) Value() string

type StackEventEventTypeEnum added in v0.1.24 

type StackEventEventTypeEnum struct {
	LOG                  StackEventEventType
	ERROR                StackEventEventType
	DRIFT                StackEventEventType
	SUMMARY              StackEventEventType
	CREATION_IN_PROGRESS StackEventEventType
	CREATION_FAILED      StackEventEventType
	CREATION_COMPLETE    StackEventEventType
	DELETION_IN_PROGRESS StackEventEventType
	DELETION_FAILED      StackEventEventType
	DELETION_COMPLETE    StackEventEventType
	UPDATE_IN_PROGRESS   StackEventEventType
	UPDATE_FAILED        StackEventEventType
	UPDATE_COMPLETE      StackEventEventType
}

func GetStackEventEventTypeEnum added in v0.1.24 

func GetStackEventEventTypeEnum() StackEventEventTypeEnum

type StackIdPrimitiveTypeHolder 

type StackIdPrimitiveTypeHolder struct {

	// 资源栈（stack）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`
}

func (StackIdPrimitiveTypeHolder) String 

func (o StackIdPrimitiveTypeHolder) String() string

type StackInstance added in v0.1.61 

type StackInstance struct {

	// 资源栈集（stack_set）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈集名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈集，删除，在重新创建一个同名资源栈集。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈集就是我以为的那个，而不是又其他队友删除后创建的同名资源栈集。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈集所对应的ID都不相同，更新不会影响ID。如果给与的stack_set_id和当前资源栈集的ID不一致，则返回400
	StackSetId *string `json:"stack_set_id,omitempty"`

	// 资源栈集（stack_set）的名字。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackSetName string `json:"stack_set_name"`

	// 资源栈实例的状态  * `WAIT_IN_PROGRESS` - 资源栈实例等待操作中 * `CANCEL_COMPLETE` - 资源栈实例操作取消完成 * `OPERATION_IN_PROGRESS` - 资源栈实例操作中 * `OPERATION_FAILED` - 资源栈实例操作失败 * `INOPERABLE` - 资源栈实例不可操作 * `OPERATION_COMPLETE` - 资源栈实例操作完成
	Status *StackInstanceStatus `json:"status,omitempty"`

	// 在资源栈实例状态为`INOPERABLE`或`OPERATION_FAILED`时，会显示简要的错误信息总结以供debug
	StatusMessage *string `json:"status_message,omitempty"`

	// 资源栈（stack）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	// 资源栈实例所关联的资源栈所在的租户ID
	StackDomainId *string `json:"stack_domain_id,omitempty"`

	// 最新一次部署该资源栈实例的资源栈集操作ID。  此Id由资源编排服务在生成资源栈集操作的时候生成，为UUID。
	LatestStackSetOperationId *string `json:"latest_stack_set_operation_id,omitempty"`

	// 资源栈实例所关联的资源栈所在的区域
	Region *string `json:"region,omitempty"`

	// 资源栈实例的创建时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z。
	CreateTime *string `json:"create_time,omitempty"`

	// 资源栈实例的更新时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z。
	UpdateTime *string `json:"update_time,omitempty"`
}

func (StackInstance) String added in v0.1.61 

func (o StackInstance) String() string

type StackInstanceStatus added in v0.1.61 

type StackInstanceStatus struct {
	// contains filtered or unexported fields
}

func (StackInstanceStatus) MarshalJSON added in v0.1.61 

func (c StackInstanceStatus) MarshalJSON() ([]byte, error)

func (*StackInstanceStatus) UnmarshalJSON added in v0.1.61 

func (c *StackInstanceStatus) UnmarshalJSON(b []byte) error

func (StackInstanceStatus) Value added in v0.1.61 

func (c StackInstanceStatus) Value() string

type StackInstanceStatusEnum added in v0.1.61 

type StackInstanceStatusEnum struct {
	WAIT_IN_PROGRESS      StackInstanceStatus
	CANCEL_COMPLETE       StackInstanceStatus
	OPERATION_IN_PROGRESS StackInstanceStatus
	OPERATION_FAILED      StackInstanceStatus
	INOPERABLE            StackInstanceStatus
	OPERATION_COMPLETE    StackInstanceStatus
}

func GetStackInstanceStatusEnum added in v0.1.61 

func GetStackInstanceStatusEnum() StackInstanceStatusEnum

type StackInstanceStatusMessagePrimitiveTypeHolder added in v0.1.61 

type StackInstanceStatusMessagePrimitiveTypeHolder struct {

	// 在资源栈实例状态为`INOPERABLE`或`OPERATION_FAILED`时，会显示简要的错误信息总结以供debug
	StatusMessage *string `json:"status_message,omitempty"`
}

func (StackInstanceStatusMessagePrimitiveTypeHolder) String added in v0.1.61 

func (o StackInstanceStatusMessagePrimitiveTypeHolder) String() string

type StackInstanceStatusPrimitiveTypeHolder added in v0.1.61 

type StackInstanceStatusPrimitiveTypeHolder struct {

	// 资源栈实例的状态  * `WAIT_IN_PROGRESS` - 资源栈实例等待操作中 * `CANCEL_COMPLETE` - 资源栈实例操作取消完成 * `OPERATION_IN_PROGRESS` - 资源栈实例操作中 * `OPERATION_FAILED` - 资源栈实例操作失败 * `INOPERABLE` - 资源栈实例不可操作 * `OPERATION_COMPLETE` - 资源栈实例操作完成
	Status *StackInstanceStatusPrimitiveTypeHolderStatus `json:"status,omitempty"`
}

func (StackInstanceStatusPrimitiveTypeHolder) String added in v0.1.61 

func (o StackInstanceStatusPrimitiveTypeHolder) String() string

type StackInstanceStatusPrimitiveTypeHolderStatus added in v0.1.61 

type StackInstanceStatusPrimitiveTypeHolderStatus struct {
	// contains filtered or unexported fields
}

func (StackInstanceStatusPrimitiveTypeHolderStatus) MarshalJSON added in v0.1.61 

func (c StackInstanceStatusPrimitiveTypeHolderStatus) MarshalJSON() ([]byte, error)

func (*StackInstanceStatusPrimitiveTypeHolderStatus) UnmarshalJSON added in v0.1.61 

func (c *StackInstanceStatusPrimitiveTypeHolderStatus) UnmarshalJSON(b []byte) error

func (StackInstanceStatusPrimitiveTypeHolderStatus) Value added in v0.1.61 

func (c StackInstanceStatusPrimitiveTypeHolderStatus) Value() string

type StackInstanceStatusPrimitiveTypeHolderStatusEnum added in v0.1.61 

type StackInstanceStatusPrimitiveTypeHolderStatusEnum struct {
	WAIT_IN_PROGRESS      StackInstanceStatusPrimitiveTypeHolderStatus
	CANCEL_COMPLETE       StackInstanceStatusPrimitiveTypeHolderStatus
	OPERATION_IN_PROGRESS StackInstanceStatusPrimitiveTypeHolderStatus
	OPERATION_FAILED      StackInstanceStatusPrimitiveTypeHolderStatus
	INOPERABLE            StackInstanceStatusPrimitiveTypeHolderStatus
	OPERATION_COMPLETE    StackInstanceStatusPrimitiveTypeHolderStatus
}

func GetStackInstanceStatusPrimitiveTypeHolderStatusEnum added in v0.1.61 

func GetStackInstanceStatusPrimitiveTypeHolderStatusEnum() StackInstanceStatusPrimitiveTypeHolderStatusEnum

type StackNamePrimitiveTypeHolder 

type StackNamePrimitiveTypeHolder struct {

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`
}

func (StackNamePrimitiveTypeHolder) String 

func (o StackNamePrimitiveTypeHolder) String() string

type StackOutput 

type StackOutput struct {

	// 资源栈输出的名称，由用户在模板中定义  以 HCL 模板为例，name 为 vpc_id  “`hcl output \"vpc_id\" {   value = huaweicloud_vpc.my_hello_world_vpc.id } “`  以 json 模板为例，name 为 vpc_id “`json {   \"output\": {     \"vpc_id\": [       {         \"value\": \"${huaweicloud_vpc.my_hello_world_vpc.id}\"       }     ]   } } “`
	Name *string `json:"name,omitempty"`

	// 资源栈输出的描述，由用户在模板中定义
	Description *string `json:"description,omitempty"`

	// 资源栈输出的类型
	Type *string `json:"type,omitempty"`

	// 资源栈输出的值
	Value *string `json:"value,omitempty"`

	// 标识该资源栈输出是否为敏感信息，由用户在模板中定义  若用户在模板中将该输出定义为sensitive，则返回体中该输出的value和type不会返回真实值，而是返回`<sensitive>`
	Sensitive *bool `json:"sensitive,omitempty"`
}

StackOutput 资源栈输出

func (StackOutput) String 

func (o StackOutput) String() string

type StackResource added in v0.1.12 

type StackResource struct {

	// 资源的物理id，由该资源的provider、云服务或其他服务提供方在资源部署的时候生成  注：与physical相关的参数可以在模板以外的地方，作为该资源的一种标识
	PhysicalResourceId *string `json:"physical_resource_id,omitempty"`

	// 资源的物理名称，由该资源的provider、云服务或其他服务提供方在资源部署的时候定义  注：与physical相关的参数可以在模板以外的地方，作为该资源的一种标识
	PhysicalResourceName *string `json:"physical_resource_name,omitempty"`

	// 资源的逻辑名称，由用户在模板中定义  注：与 logical 相关的参数仅仅在模板内部，作为该资源的一种标识  以HCL格式的模板为例，logical_resource_name 为 my_hello_world_vpc  “`hcl resource \"huaweicloud_vpc\" \"my_hello_world_vpc\" {   name = \"test_vpc\" } “`  以json格式的模板为例，logical_resource_name 为 my_hello_world_vpc  “`json {   \"resource\": {     \"huaweicloud_vpc\": {       \"my_hello_world_vpc\": {         \"name\": \"test_vpc\"       }     }   } } “`
	LogicalResourceName *string `json:"logical_resource_name,omitempty"`

	// 资源的类型  注：与 logical 相关的参数仅仅在模板内部，作为该资源的一种标识  以HCL格式的模板为例，logical_resource_type 为 huaweicloud_vpc  “`hcl resource \"huaweicloud_vpc\" \"my_hello_world_vpc\" {   name = \"test_vpc\" } “`  以json格式的模板为例，logical_resource_type 为 huaweicloud_vpc  “`json {   \"resource\": {     \"huaweicloud_vpc\": {       \"my_hello_world_vpc\": {         \"name\": \"test_vpc\"       }     }   } } “`
	LogicalResourceType *string `json:"logical_resource_type,omitempty"`

	// 资源的索引，若用户在模板中使用了count或for_each则会返回index_key。若index_key出现，则logical_resource_name + index_key可以作为该资源的一种标识  若用户在模板中使用count，则index_key为从0开始的数字  以HCL格式的模板为例，用户在模板中可以通过`huaweicloud_vpc.my_hello_world_vpc[0]`和`huaweicloud_vpc.my_hello_world_vpc[1]`标识两个资源  “`hcl resource \"huaweicloud_vpc\" \"my_hello_world_vpc\" {   count = 2   name = \"test_vpc\" } “`  以json格式的模板为例，用户在模板中可以通过`huaweicloud_vpc.my_hello_world_vpc[0]`和`huaweicloud_vpc.my_hello_world_vpc[1]`标识两个资源  “`json {   \"resource\": {     \"huaweicloud_vpc\": {       \"my_hello_world_vpc\": {         \"name\": \"test_vpc\",         \"count\": 2       }     }   } } “`  若用户在模板中使用for_each，则index_key为用户自定义的字符串  以HCL格式的模板为例，用户在模板中可以通过`huaweicloud_vpc.my_hello_world_vpc[\"vpc1\"]`和`huaweicloud_vpc.my_hello_world_vpc[\"vpc2\"]`标识两个资源  “`hcl resource \"huaweicloud_vpc\" \"my_hello_world_vpc\" {   for_each = {     \"vpc1\" = \"test_vpc\"     \"vpc2\" = \"test_vpc\"   }   name = each.value } “`  以json格式的模板为例，用户在模板中可以通过`huaweicloud_vpc.my_hello_world_vpc[\"vpc1\"]`和`huaweicloud_vpc.my_hello_world_vpc[\"vpc2\"]`标识两个资源  “`json {   \"resource\": {     \"huaweicloud_vpc\": {       \"my_hello_world_vpc\": {         \"for_each\": {           \"vpc1\": \"test_vpc\",           \"vpc2\": \"test_vpc\"         }         \"name\": \"${each.value}\"       }     }   } } “`
	IndexKey *string `json:"index_key,omitempty"`

	// 资源的状态 * `CREATION_IN_PROGRESS` - 正在生成 * `CREATION_FAILED`      - 生成失败 * `CREATION_COMPLETE`    - 生成完成 * `DELETION_IN_PROGRESS` - 正在删除 * `DELETION_FAILED`      - 删除失败 * `DELETION_COMPLETE`    - 已经删除 * `UPDATE_IN_PROGRESS`   - 正在更新。此处的更新特指非替换式更新，如果是替换式更新，则使用CREATION后DELETION * `UPDATE_FAILED`        - 更新失败。此处的更新特指非替换式更新，如果是替换式更新，则使用CREATION后DELETION * `UPDATE_COMPLETE`      - 更新完成。此处的更新特指非替换式更新，如果是替换式更新，则使用CREATION后DELETION
	ResourceStatus *StackResourceResourceStatus `json:"resource_status,omitempty"`

	// 当该资源状态为任意失败状态（即以 `FAILED` 结尾时），将会展示简要的错误信息总结以供debug
	StatusMessage *string `json:"status_message,omitempty"`

	// 资源属性列表
	ResourceAttributes *[]ResourceAttribute `json:"resource_attributes,omitempty"`
}

StackResource 资源栈中所管理的资源信息

func (StackResource) String added in v0.1.12 

func (o StackResource) String() string

type StackResourceResourceStatus added in v0.1.12 

type StackResourceResourceStatus struct {
	// contains filtered or unexported fields
}

func (StackResourceResourceStatus) MarshalJSON added in v0.1.12 

func (c StackResourceResourceStatus) MarshalJSON() ([]byte, error)

func (*StackResourceResourceStatus) UnmarshalJSON added in v0.1.12 

func (c *StackResourceResourceStatus) UnmarshalJSON(b []byte) error

func (StackResourceResourceStatus) Value added in v0.1.12 

func (c StackResourceResourceStatus) Value() string

type StackResourceResourceStatusEnum added in v0.1.12 

type StackResourceResourceStatusEnum struct {
	CREATION_IN_PROGRESS StackResourceResourceStatus
	CREATION_FAILED      StackResourceResourceStatus
	CREATION_COMPLETE    StackResourceResourceStatus
	DELETION_IN_PROGRESS StackResourceResourceStatus
	DELETION_FAILED      StackResourceResourceStatus
	DELETION_COMPLETE    StackResourceResourceStatus
	UPDATE_IN_PROGRESS   StackResourceResourceStatus
	UPDATE_FAILED        StackResourceResourceStatus
	UPDATE_COMPLETE      StackResourceResourceStatus
}

func GetStackResourceResourceStatusEnum added in v0.1.12 

func GetStackResourceResourceStatusEnum() StackResourceResourceStatusEnum

type StackSet added in v0.1.61 

type StackSet struct {

	// 资源栈集（stack_set）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈集名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈集，删除，在重新创建一个同名资源栈集。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈集就是我以为的那个，而不是又其他队友删除后创建的同名资源栈集。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈集所对应的ID都不相同，更新不会影响ID。如果给与的stack_set_id和当前资源栈集的ID不一致，则返回400
	StackSetId *string `json:"stack_set_id,omitempty"`

	// 资源栈集（stack_set）的名字。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackSetName string `json:"stack_set_name"`

	// 资源栈集的描述。可用于客户识别自己的资源栈集。
	StackSetDescription *string `json:"stack_set_description,omitempty"`

	// 权限模型，定义了RFS操作资源栈集时所需委托的创建方式，枚举值    * `SELF_MANAGED` - 基于部署需求，用户需要提前手动创建委托，既包含管理账号给RFS的委托，也包含成员账号创建给管理账号的委托。如果委托不存在或错误，创建资源栈集不会失败，部署资源栈集或部署资源栈实例的时候才会报错。
	PermissionModel *StackSetPermissionModel `json:"permission_model,omitempty"`

	// 资源栈集的状态     * `IDLE` - 资源栈集空闲 * `OPERATION_IN_PROGRESS` - 资源栈集操作中 * `DEACTIVATED` - 资源栈集禁用
	Status *StackSetStatus `json:"status,omitempty"`

	// 资源栈集的创建时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z。
	CreateTime *string `json:"create_time,omitempty"`

	// 资源栈集的更新时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z。
	UpdateTime *string `json:"update_time,omitempty"`
}

func (StackSet) String added in v0.1.61 

func (o StackSet) String() string

type StackSetCreateTimePrimitiveTypeHolder added in v0.1.61 

type StackSetCreateTimePrimitiveTypeHolder struct {

	// 资源栈集的创建时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z。
	CreateTime *string `json:"create_time,omitempty"`
}

func (StackSetCreateTimePrimitiveTypeHolder) String added in v0.1.61 

func (o StackSetCreateTimePrimitiveTypeHolder) String() string

type StackSetDescriptionPrimitiveTypeHolder added in v0.1.61 

type StackSetDescriptionPrimitiveTypeHolder struct {

	// 资源栈集的描述。可用于客户识别自己的资源栈集。
	StackSetDescription *string `json:"stack_set_description,omitempty"`
}

func (StackSetDescriptionPrimitiveTypeHolder) String added in v0.1.61 

func (o StackSetDescriptionPrimitiveTypeHolder) String() string

type StackSetIdPrimitiveTypeHolder added in v0.1.61 

type StackSetIdPrimitiveTypeHolder struct {

	// 资源栈集（stack_set）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈集名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈集，删除，在重新创建一个同名资源栈集。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈集就是我以为的那个，而不是又其他队友删除后创建的同名资源栈集。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈集所对应的ID都不相同，更新不会影响ID。如果给与的stack_set_id和当前资源栈集的ID不一致，则返回400
	StackSetId *string `json:"stack_set_id,omitempty"`
}

func (StackSetIdPrimitiveTypeHolder) String added in v0.1.61 

func (o StackSetIdPrimitiveTypeHolder) String() string

type StackSetNamePrimitiveTypeHolder added in v0.1.61 

type StackSetNamePrimitiveTypeHolder struct {

	// 资源栈集（stack_set）的名字。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackSetName string `json:"stack_set_name"`
}

func (StackSetNamePrimitiveTypeHolder) String added in v0.1.61 

func (o StackSetNamePrimitiveTypeHolder) String() string

type StackSetOperation added in v0.1.61 

type StackSetOperation struct {

	// 资源栈集操作Id。  此Id由资源编排服务在生成资源栈集操作的时候生成，为UUID。
	OperationId *string `json:"operation_id,omitempty"`

	// 资源栈集（stack_set）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈集名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈集，删除，在重新创建一个同名资源栈集。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈集就是我以为的那个，而不是又其他队友删除后创建的同名资源栈集。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈集所对应的ID都不相同，更新不会影响ID。如果给与的stack_set_id和当前资源栈集的ID不一致，则返回400
	StackSetId *string `json:"stack_set_id,omitempty"`

	// 资源栈集（stack_set）的名字。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackSetName string `json:"stack_set_name"`

	// 用户当前的操作   * `CREATE_STACK_INSTANCES` - 创建资源栈实例   * `DELETE_STACK_INSTANCES` - 删除资源栈实例   * `DEPLOY_STACK_SET` - 部署资源栈集   * `DEPLOY_STACK_INSTANCES` - 部署资源栈实例
	Action *StackSetOperationAction `json:"action,omitempty"`

	// 资源栈集操作状态   * `QUEUE_IN_PROGRESS` - 正在排队   * `OPERATION_IN_PROGRESS` - 正在操作   * `OPERATION_COMPLETE` - 操作完成   * `OPERATION_FAILED` - 操作失败   * `STOP_IN_PROGRESS` - 正在停止   * `STOP_COMPLETE` - 停止完成   * `STOP_FAILED` - 停止失败
	Status *StackSetOperationStatus `json:"status,omitempty"`

	// 资源栈集操作失败时会展示此次操作失败的原因，例如，资源栈实例部署或删除失败个数超过上限或资源栈集操作超时。  如果需要查看详细失败信息，可通过ListStackInstances API获取查看资源栈实例的status_message。
	StatusMessage *string `json:"status_message,omitempty"`

	// 资源栈集操作的创建时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z。
	CreateTime *string `json:"create_time,omitempty"`

	// 资源栈集操作的更新时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z。
	UpdateTime *string `json:"update_time,omitempty"`
}

func (StackSetOperation) String added in v0.1.61 

func (o StackSetOperation) String() string

type StackSetOperationAction added in v0.1.61 

type StackSetOperationAction struct {
	// contains filtered or unexported fields
}

func (StackSetOperationAction) MarshalJSON added in v0.1.61 

func (c StackSetOperationAction) MarshalJSON() ([]byte, error)

func (*StackSetOperationAction) UnmarshalJSON added in v0.1.61 

func (c *StackSetOperationAction) UnmarshalJSON(b []byte) error

func (StackSetOperationAction) Value added in v0.1.61 

func (c StackSetOperationAction) Value() string

type StackSetOperationActionEnum added in v0.1.61 

type StackSetOperationActionEnum struct {
	CREATE_STACK_INSTANCES StackSetOperationAction
	DELETE_STACK_INSTANCES StackSetOperationAction
	DEPLOY_STACK_SET       StackSetOperationAction
	DEPLOY_STACK_INSTANCES StackSetOperationAction
}

func GetStackSetOperationActionEnum added in v0.1.61 

func GetStackSetOperationActionEnum() StackSetOperationActionEnum

type StackSetOperationActionPrimitiveTypeHolder added in v0.1.61 

type StackSetOperationActionPrimitiveTypeHolder struct {

	// 用户当前的操作   * `CREATE_STACK_INSTANCES` - 创建资源栈实例   * `DELETE_STACK_INSTANCES` - 删除资源栈实例   * `DEPLOY_STACK_SET` - 部署资源栈集   * `DEPLOY_STACK_INSTANCES` - 部署资源栈实例
	Action *StackSetOperationActionPrimitiveTypeHolderAction `json:"action,omitempty"`
}

func (StackSetOperationActionPrimitiveTypeHolder) String added in v0.1.61 

func (o StackSetOperationActionPrimitiveTypeHolder) String() string

type StackSetOperationActionPrimitiveTypeHolderAction added in v0.1.61 

type StackSetOperationActionPrimitiveTypeHolderAction struct {
	// contains filtered or unexported fields
}

func (StackSetOperationActionPrimitiveTypeHolderAction) MarshalJSON added in v0.1.61 

func (c StackSetOperationActionPrimitiveTypeHolderAction) MarshalJSON() ([]byte, error)

func (*StackSetOperationActionPrimitiveTypeHolderAction) UnmarshalJSON added in v0.1.61 

func (c *StackSetOperationActionPrimitiveTypeHolderAction) UnmarshalJSON(b []byte) error

func (StackSetOperationActionPrimitiveTypeHolderAction) Value added in v0.1.61 

func (c StackSetOperationActionPrimitiveTypeHolderAction) Value() string

type StackSetOperationActionPrimitiveTypeHolderActionEnum added in v0.1.61 

type StackSetOperationActionPrimitiveTypeHolderActionEnum struct {
	CREATE_STACK_INSTANCES StackSetOperationActionPrimitiveTypeHolderAction
	DELETE_STACK_INSTANCES StackSetOperationActionPrimitiveTypeHolderAction
	DEPLOY_STACK_SET       StackSetOperationActionPrimitiveTypeHolderAction
	DEPLOY_STACK_INSTANCES StackSetOperationActionPrimitiveTypeHolderAction
}

func GetStackSetOperationActionPrimitiveTypeHolderActionEnum added in v0.1.61 

func GetStackSetOperationActionPrimitiveTypeHolderActionEnum() StackSetOperationActionPrimitiveTypeHolderActionEnum

type StackSetOperationCreateTimePrimitiveTypeHolder added in v0.1.61 

type StackSetOperationCreateTimePrimitiveTypeHolder struct {

	// 资源栈集操作的创建时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z。
	CreateTime *string `json:"create_time,omitempty"`
}

func (StackSetOperationCreateTimePrimitiveTypeHolder) String added in v0.1.61 

func (o StackSetOperationCreateTimePrimitiveTypeHolder) String() string

type StackSetOperationIdPrimitiveTypeHolder added in v0.1.61 

type StackSetOperationIdPrimitiveTypeHolder struct {

	// 资源栈集操作（operation）的唯一Id。  此Id由资源编排服务在生成资源栈集操作的时候生成，为UUID。
	StackSetOperationId *string `json:"stack_set_operation_id,omitempty"`
}

func (StackSetOperationIdPrimitiveTypeHolder) String added in v0.1.61 

func (o StackSetOperationIdPrimitiveTypeHolder) String() string

type StackSetOperationStatus added in v0.1.61 

type StackSetOperationStatus struct {
	// contains filtered or unexported fields
}

func (StackSetOperationStatus) MarshalJSON added in v0.1.61 

func (c StackSetOperationStatus) MarshalJSON() ([]byte, error)

func (*StackSetOperationStatus) UnmarshalJSON added in v0.1.61 

func (c *StackSetOperationStatus) UnmarshalJSON(b []byte) error

func (StackSetOperationStatus) Value added in v0.1.61 

func (c StackSetOperationStatus) Value() string

type StackSetOperationStatusEnum added in v0.1.61 

type StackSetOperationStatusEnum struct {
	QUEUE_IN_PROGRESS     StackSetOperationStatus
	OPERATION_IN_PROGRESS StackSetOperationStatus
	OPERATION_COMPLETE    StackSetOperationStatus
	OPERATION_FAILED      StackSetOperationStatus
	STOP_IN_PROGRESS      StackSetOperationStatus
	STOP_COMPLETE         StackSetOperationStatus
	STOP_FAILED           StackSetOperationStatus
}

func GetStackSetOperationStatusEnum added in v0.1.61 

func GetStackSetOperationStatusEnum() StackSetOperationStatusEnum

type StackSetOperationStatusMessagePrimitiveTypeHolder added in v0.1.61 

type StackSetOperationStatusMessagePrimitiveTypeHolder struct {

	// 资源栈集操作失败时会展示此次操作失败的原因，例如，资源栈实例部署或删除失败个数超过上限或资源栈集操作超时。  如果需要查看详细失败信息，可通过ListStackInstances API获取查看资源栈实例的status_message。
	StatusMessage *string `json:"status_message,omitempty"`
}

func (StackSetOperationStatusMessagePrimitiveTypeHolder) String added in v0.1.61 

func (o StackSetOperationStatusMessagePrimitiveTypeHolder) String() string

type StackSetOperationStatusPrimitiveTypeHolder added in v0.1.61 

type StackSetOperationStatusPrimitiveTypeHolder struct {

	// 资源栈集操作状态   * `QUEUE_IN_PROGRESS` - 正在排队   * `OPERATION_IN_PROGRESS` - 正在操作   * `OPERATION_COMPLETE` - 操作完成   * `OPERATION_FAILED` - 操作失败   * `STOP_IN_PROGRESS` - 正在停止   * `STOP_COMPLETE` - 停止完成   * `STOP_FAILED` - 停止失败
	Status *StackSetOperationStatusPrimitiveTypeHolderStatus `json:"status,omitempty"`
}

func (StackSetOperationStatusPrimitiveTypeHolder) String added in v0.1.61 

func (o StackSetOperationStatusPrimitiveTypeHolder) String() string

type StackSetOperationStatusPrimitiveTypeHolderStatus added in v0.1.61 

type StackSetOperationStatusPrimitiveTypeHolderStatus struct {
	// contains filtered or unexported fields
}

func (StackSetOperationStatusPrimitiveTypeHolderStatus) MarshalJSON added in v0.1.61 

func (c StackSetOperationStatusPrimitiveTypeHolderStatus) MarshalJSON() ([]byte, error)

func (*StackSetOperationStatusPrimitiveTypeHolderStatus) UnmarshalJSON added in v0.1.61 

func (c *StackSetOperationStatusPrimitiveTypeHolderStatus) UnmarshalJSON(b []byte) error

func (StackSetOperationStatusPrimitiveTypeHolderStatus) Value added in v0.1.61 

func (c StackSetOperationStatusPrimitiveTypeHolderStatus) Value() string

type StackSetOperationStatusPrimitiveTypeHolderStatusEnum added in v0.1.61 

type StackSetOperationStatusPrimitiveTypeHolderStatusEnum struct {
	QUEUE_IN_PROGRESS     StackSetOperationStatusPrimitiveTypeHolderStatus
	OPERATION_IN_PROGRESS StackSetOperationStatusPrimitiveTypeHolderStatus
	OPERATION_COMPLETE    StackSetOperationStatusPrimitiveTypeHolderStatus
	OPERATION_FAILED      StackSetOperationStatusPrimitiveTypeHolderStatus
	STOP_IN_PROGRESS      StackSetOperationStatusPrimitiveTypeHolderStatus
	STOP_COMPLETE         StackSetOperationStatusPrimitiveTypeHolderStatus
	STOP_FAILED           StackSetOperationStatusPrimitiveTypeHolderStatus
}

func GetStackSetOperationStatusPrimitiveTypeHolderStatusEnum added in v0.1.61 

func GetStackSetOperationStatusPrimitiveTypeHolderStatusEnum() StackSetOperationStatusPrimitiveTypeHolderStatusEnum

type StackSetOperationUpdateTimePrimitiveTypeHolder added in v0.1.61 

type StackSetOperationUpdateTimePrimitiveTypeHolder struct {

	// 资源栈集操作的更新时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z。
	UpdateTime *string `json:"update_time,omitempty"`
}

func (StackSetOperationUpdateTimePrimitiveTypeHolder) String added in v0.1.61 

func (o StackSetOperationUpdateTimePrimitiveTypeHolder) String() string

type StackSetPermissionModel added in v0.1.61 

type StackSetPermissionModel struct {
	// contains filtered or unexported fields
}

func (StackSetPermissionModel) MarshalJSON added in v0.1.61 

func (c StackSetPermissionModel) MarshalJSON() ([]byte, error)

func (*StackSetPermissionModel) UnmarshalJSON added in v0.1.61 

func (c *StackSetPermissionModel) UnmarshalJSON(b []byte) error

func (StackSetPermissionModel) Value added in v0.1.61 

func (c StackSetPermissionModel) Value() string

type StackSetPermissionModelEnum added in v0.1.61 

type StackSetPermissionModelEnum struct {
	SELF_MANAGED StackSetPermissionModel
}

func GetStackSetPermissionModelEnum added in v0.1.61 

func GetStackSetPermissionModelEnum() StackSetPermissionModelEnum

type StackSetStatus added in v0.1.61 

type StackSetStatus struct {
	// contains filtered or unexported fields
}

func (StackSetStatus) MarshalJSON added in v0.1.61 

func (c StackSetStatus) MarshalJSON() ([]byte, error)

func (*StackSetStatus) UnmarshalJSON added in v0.1.61 

func (c *StackSetStatus) UnmarshalJSON(b []byte) error

func (StackSetStatus) Value added in v0.1.61 

func (c StackSetStatus) Value() string

type StackSetStatusEnum added in v0.1.61 

type StackSetStatusEnum struct {
	IDLE                  StackSetStatus
	OPERATION_IN_PROGRESS StackSetStatus
	DEACTIVATED           StackSetStatus
}

func GetStackSetStatusEnum added in v0.1.61 

func GetStackSetStatusEnum() StackSetStatusEnum

type StackSetStatusPrimitiveTypeHolder added in v0.1.61 

type StackSetStatusPrimitiveTypeHolder struct {

	// 资源栈集的状态     * `IDLE` - 资源栈集空闲 * `OPERATION_IN_PROGRESS` - 资源栈集操作中 * `DEACTIVATED` - 资源栈集禁用
	Status *StackSetStatusPrimitiveTypeHolderStatus `json:"status,omitempty"`
}

func (StackSetStatusPrimitiveTypeHolder) String added in v0.1.61 

func (o StackSetStatusPrimitiveTypeHolder) String() string

type StackSetStatusPrimitiveTypeHolderStatus added in v0.1.61 

type StackSetStatusPrimitiveTypeHolderStatus struct {
	// contains filtered or unexported fields
}

func (StackSetStatusPrimitiveTypeHolderStatus) MarshalJSON added in v0.1.61 

func (c StackSetStatusPrimitiveTypeHolderStatus) MarshalJSON() ([]byte, error)

func (*StackSetStatusPrimitiveTypeHolderStatus) UnmarshalJSON added in v0.1.61 

func (c *StackSetStatusPrimitiveTypeHolderStatus) UnmarshalJSON(b []byte) error

func (StackSetStatusPrimitiveTypeHolderStatus) Value added in v0.1.61 

func (c StackSetStatusPrimitiveTypeHolderStatus) Value() string

type StackSetStatusPrimitiveTypeHolderStatusEnum added in v0.1.61 

type StackSetStatusPrimitiveTypeHolderStatusEnum struct {
	IDLE                  StackSetStatusPrimitiveTypeHolderStatus
	OPERATION_IN_PROGRESS StackSetStatusPrimitiveTypeHolderStatus
	DEACTIVATED           StackSetStatusPrimitiveTypeHolderStatus
}

func GetStackSetStatusPrimitiveTypeHolderStatusEnum added in v0.1.61 

func GetStackSetStatusPrimitiveTypeHolderStatusEnum() StackSetStatusPrimitiveTypeHolderStatusEnum

type StackSetUpdateTimePrimitiveTypeHolder added in v0.1.61 

type StackSetUpdateTimePrimitiveTypeHolder struct {

	// 资源栈集的更新时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z。
	UpdateTime *string `json:"update_time,omitempty"`
}

func (StackSetUpdateTimePrimitiveTypeHolder) String added in v0.1.61 

func (o StackSetUpdateTimePrimitiveTypeHolder) String() string

type StackSetVarsUriContentPrimitiveTypeHolder added in v0.1.61 

type StackSetVarsUriContentPrimitiveTypeHolder struct {

	// vars_uri对应的文件内容
	VarsUriContent *string `json:"vars_uri_content,omitempty"`
}

func (StackSetVarsUriContentPrimitiveTypeHolder) String added in v0.1.61 

func (o StackSetVarsUriContentPrimitiveTypeHolder) String() string

type StackStatus 

type StackStatus struct {
	// contains filtered or unexported fields
}

func (StackStatus) MarshalJSON 

func (c StackStatus) MarshalJSON() ([]byte, error)

func (*StackStatus) UnmarshalJSON 

func (c *StackStatus) UnmarshalJSON(b []byte) error

func (StackStatus) Value 

func (c StackStatus) Value() string

type StackStatusEnum 

type StackStatusEnum struct {
	CREATION_COMPLETE      StackStatus
	DEPLOYMENT_IN_PROGRESS StackStatus
	DEPLOYMENT_FAILED      StackStatus
	DEPLOYMENT_COMPLETE    StackStatus
	ROLLBACK_IN_PROGRESS   StackStatus
	ROLLBACK_FAILED        StackStatus
	ROLLBACK_COMPLETE      StackStatus
	DELETION_IN_PROGRESS   StackStatus
	DELETION_FAILED        StackStatus
}

func GetStackStatusEnum 

func GetStackStatusEnum() StackStatusEnum

type StackStatusMessagePrimitiveTypeHolder added in v0.1.24 

type StackStatusMessagePrimitiveTypeHolder struct {

	// 当资源栈的状态为任意失败状态（即以 `FAILED` 结尾时），将会展示简要的错误信息总结以供debug
	StatusMessage *string `json:"status_message,omitempty"`
}

func (StackStatusMessagePrimitiveTypeHolder) String added in v0.1.24 

func (o StackStatusMessagePrimitiveTypeHolder) String() string

type StackStatusPrimitiveTypeHolder 

type StackStatusPrimitiveTypeHolder struct {

	// 资源栈的状态    * `CREATION_COMPLETE` - 生成空资源栈完成，并没有任何部署    * `DEPLOYMENT_IN_PROGRESS` - 正在部署，请等待    * `DEPLOYMENT_FAILED` - 部署失败。请从status_message获取错误信息汇总，或者调用ListStackEvents获得事件详情    * `DEPLOYMENT_COMPLETE` - 部署完成    * `ROLLBACK_IN_PROGRESS` - 部署失败，正在回滚，请等待    * `ROLLBACK_FAILED` - 回滚失败。请从status_message获取错误信息汇总，或者调用ListStackEvents获得事件详情    * `ROLLBACK_COMPLETE` - 回滚完成    * `DELETION_IN_PROGRESS` - 正在删除，请等待    * `DELETION_FAILED` - 删除失败。请从status_message获取错误信息汇总，或者调用ListStackEvents获得事件详情
	Status *StackStatusPrimitiveTypeHolderStatus `json:"status,omitempty"`
}

func (StackStatusPrimitiveTypeHolder) String 

func (o StackStatusPrimitiveTypeHolder) String() string

type StackStatusPrimitiveTypeHolderStatus 

type StackStatusPrimitiveTypeHolderStatus struct {
	// contains filtered or unexported fields
}

func (StackStatusPrimitiveTypeHolderStatus) MarshalJSON 

func (c StackStatusPrimitiveTypeHolderStatus) MarshalJSON() ([]byte, error)

func (*StackStatusPrimitiveTypeHolderStatus) UnmarshalJSON 

func (c *StackStatusPrimitiveTypeHolderStatus) UnmarshalJSON(b []byte) error

func (StackStatusPrimitiveTypeHolderStatus) Value 

func (c StackStatusPrimitiveTypeHolderStatus) Value() string

type StackStatusPrimitiveTypeHolderStatusEnum 

type StackStatusPrimitiveTypeHolderStatusEnum struct {
	CREATION_COMPLETE      StackStatusPrimitiveTypeHolderStatus
	DEPLOYMENT_IN_PROGRESS StackStatusPrimitiveTypeHolderStatus
	DEPLOYMENT_FAILED      StackStatusPrimitiveTypeHolderStatus
	DEPLOYMENT_COMPLETE    StackStatusPrimitiveTypeHolderStatus
	ROLLBACK_IN_PROGRESS   StackStatusPrimitiveTypeHolderStatus
	ROLLBACK_FAILED        StackStatusPrimitiveTypeHolderStatus
	ROLLBACK_COMPLETE      StackStatusPrimitiveTypeHolderStatus
	DELETION_IN_PROGRESS   StackStatusPrimitiveTypeHolderStatus
	DELETION_FAILED        StackStatusPrimitiveTypeHolderStatus
}

func GetStackStatusPrimitiveTypeHolderStatusEnum 

func GetStackStatusPrimitiveTypeHolderStatusEnum() StackStatusPrimitiveTypeHolderStatusEnum

type Template added in v0.1.30 

type Template struct {

	// 模板的唯一ID，由模板服务随机生成
	TemplateId string `json:"template_id"`

	// 用户希望创建的模板名称
	TemplateName string `json:"template_name"`

	// 模板的描述。可用于客户识别自己的模板
	TemplateDescription *string `json:"template_description,omitempty"`

	// 模板的生成时间，格式遵循RFC3339，即yyyy-mm-ddTHH:MM:SSZ，如1970-01-01T00:00:00Z
	CreateTime string `json:"create_time"`

	// 模板的更新时间，格式遵循RFC3339，即yyyy-mm-ddTHH:MM:SSZ，如1970-01-01T00:00:00Z
	UpdateTime string `json:"update_time"`

	// 模板中最新的模板版本ID
	LatestVersionId string `json:"latest_version_id"`

	// 模板中最新模板版本的版本描述
	LatestVersionDescription string `json:"latest_version_description"`
}

func (Template) String added in v0.1.30 

func (o Template) String() string

type TemplateBodyPrimitiveTypeHolder 

type TemplateBodyPrimitiveTypeHolder struct {

	// HCL模板，描述了资源的目标状态。资源编排服务将比较此模板与当前远程资源的状态之间的区别。  template_body和template_uri 必须有且只有一个存在  **注意：**   * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储对应的template_body
	TemplateBody *string `json:"template_body,omitempty"`
}

func (TemplateBodyPrimitiveTypeHolder) String 

func (o TemplateBodyPrimitiveTypeHolder) String() string

type TemplateUriPrimitiveTypeHolder 

type TemplateUriPrimitiveTypeHolder struct {

	// HCL模板的OBS地址，该模板描述了资源的目标状态。资源编排服务将比较此模板与当前远程资源的状态之间的区别  OBS地址支持同类型Region之间进行互相访问（Region分为通用Region和专属Region，通用Region指面向公共租户提供通用云服务的Region；专属Region指只承载同一类业务或只面向特定租户提供业务服务的专用Region）  对应的文件应该是纯tf文件或zip压缩包  纯tf文件需要以“.tf”或者“.tf.json”结尾，并遵守HCL语法，且文件的编码格式须为UTF-8  压缩包目前只支持zip格式，文件需要以\".zip\"结尾。解压后的文件不得包含\".tfvars\"文件。解压前最大支持1MB，解压后最大支持1MB。zip压缩包文件数量不能超过100个  template_body和template_uri 必须有且只有一个存在  **注意：**   * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储template_uri对应的模板文件内容。   * template_uri对应的模板文件若为zip类型，则内部的文件或文件夹名称长度不得超过255个字节，最深路径长度不得超过2048字节，zip包大小不得超过1MB
	TemplateUri *string `json:"template_uri,omitempty"`
}

func (TemplateUriPrimitiveTypeHolder) String 

func (o TemplateUriPrimitiveTypeHolder) String() string

type TemplateVersion added in v0.1.46 

type TemplateVersion struct {

	// 模板的唯一ID，由模板服务随机生成
	TemplateId string `json:"template_id"`

	// 用户希望创建的模板名称
	TemplateName string `json:"template_name"`

	// 模板版本的描述。可用于客户识别自己的模板版本
	VersionDescription *string `json:"version_description,omitempty"`

	// 版本创建时间，格式遵循RFC3339，即yyyy-mm-ddTHH:MM:SSZ，如1970-01-01T00:00:00Z
	CreateTime string `json:"create_time"`

	// 模板模板版本ID
	VersionId string `json:"version_id"`
}

func (TemplateVersion) String added in v0.1.46 

func (o TemplateVersion) String() string

type UpdateStackInstancesRequest added in v0.1.63 

type UpdateStackInstancesRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈集的名称。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackSetName string `json:"stack_set_name"`

	Body *UpdateStackInstancesRequestBody `json:"body,omitempty"`
}

UpdateStackInstancesRequest Request Object

func (UpdateStackInstancesRequest) String added in v0.1.63 

func (o UpdateStackInstancesRequest) String() string

type UpdateStackInstancesRequestBody added in v0.1.63 

type UpdateStackInstancesRequestBody struct {

	// 资源栈集（stack_set）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈集名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈集，删除，在重新创建一个同名资源栈集。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈集就是我以为的那个，而不是又其他队友删除后创建的同名资源栈集。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈集所对应的ID都不相同，更新不会影响ID。如果给与的stack_set_id和当前资源栈集的ID不一致，则返回400
	StackSetId *string `json:"stack_set_id,omitempty"`

	DeploymentTargets *DeploymentTargets `json:"deployment_targets"`

	VarOverrides *VarOverridesPrimitiveTypeHolderVarOverrides `json:"var_overrides,omitempty"`
}

func (UpdateStackInstancesRequestBody) String added in v0.1.63 

func (o UpdateStackInstancesRequestBody) String() string

type UpdateStackInstancesResponse added in v0.1.63 

type UpdateStackInstancesResponse struct {

	// 资源栈集操作（operation）的唯一Id。  此Id由资源编排服务在生成资源栈集操作的时候生成，为UUID。
	StackSetOperationId *string `json:"stack_set_operation_id,omitempty"`
	HttpStatusCode      int     `json:"-"`
}

UpdateStackInstancesResponse Response Object

func (UpdateStackInstancesResponse) String added in v0.1.63 

func (o UpdateStackInstancesResponse) String() string

type UpdateStackRequest added in v0.1.24 

type UpdateStackRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈的名称。此名字在domain_id+区域+project_id下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackName string `json:"stack_name"`

	Body *UpdateStackRequestBody `json:"body,omitempty"`
}

UpdateStackRequest Request Object

func (UpdateStackRequest) String added in v0.1.24 

func (o UpdateStackRequest) String() string

type UpdateStackRequestBody added in v0.1.24 

type UpdateStackRequestBody struct {

	// 资源栈的描述。可用于客户识别自己的资源栈。
	Description *string `json:"description,omitempty"`

	// 资源栈（stack）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈，删除，再重新创建一个同名资源栈。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈就是我认为的那个，而不是其他队友删除后创建的同名资源栈。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈所对应的ID都不相同，更新不会影响ID。如果给与的stack_id和当前资源栈的ID不一致，则返回400
	StackId *string `json:"stack_id,omitempty"`

	// 删除保护的标识位，如果不传默认为false，即默认不开启资源栈删除保护（删除保护开启后资源栈不允许被删除）  *在UpdateStack API中，若该参数未在RequestBody中给予，则不会对资源栈的删除保护属性进行更新*
	EnableDeletionProtection *bool `json:"enable_deletion_protection,omitempty"`

	// 自动回滚的标识位，如果不传默认为false，即默认不开启资源栈自动回滚（自动回滚开启后，如果部署失败，则会自动回滚，并返回上一个稳定状态）  *在UpdateStack API中，若该参数未在RequestBody中给予，则不会对资源栈的自动回滚属性进行更新* *该属性与使用模板导入资源功能互斥，如果堆栈的自动回滚设置为true，则不允许部署包含导入资源的模板*
	EnableAutoRollback *bool `json:"enable_auto_rollback,omitempty"`

	// 委托授权的信息。  RFS仅在创建资源栈（触发部署）、创建执行计划、部署资源栈、删除资源栈等涉及资源操作的请求中使用委托，且该委托仅作用于与之绑定的Provider对资源的操作中。若委托中提供的权限不足，有可能导致相关资源操作失败。  [创建委托及授权方式](https://support.huaweicloud.com/usermanual-iam/iam_06_0002.html)
	Agencies *[]Agency `json:"agencies,omitempty"`
}

func (UpdateStackRequestBody) String added in v0.1.24 

func (o UpdateStackRequestBody) String() string

type UpdateStackResponse added in v0.1.24 

type UpdateStackResponse struct {
	HttpStatusCode int `json:"-"`
}

UpdateStackResponse Response Object

func (UpdateStackResponse) String added in v0.1.24 

func (o UpdateStackResponse) String() string

type UpdateStackSetRequest added in v0.1.61 

type UpdateStackSetRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 资源栈集的名称。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。
	StackSetName string `json:"stack_set_name"`

	Body *UpdateStackSetRequestBody `json:"body,omitempty"`
}

UpdateStackSetRequest Request Object

func (UpdateStackSetRequest) String added in v0.1.61 

func (o UpdateStackSetRequest) String() string

type UpdateStackSetRequestBody added in v0.1.61 

type UpdateStackSetRequestBody struct {

	// 资源栈集（stack_set）的唯一ID。  此ID由资源编排服务在生成资源栈的时候生成，为UUID。  由于资源栈集名仅仅在同一时间下唯一，即用户允许先生成一个叫HelloWorld的资源栈集，删除，在重新创建一个同名资源栈集。  对于团队并行开发，用户可能希望确保，当前我操作的资源栈集就是我以为的那个，而不是又其他队友删除后创建的同名资源栈集。因此，使用ID就可以做到强匹配。  资源编排服务保证每次创建的资源栈集所对应的ID都不相同，更新不会影响ID。如果给与的stack_set_id和当前资源栈集的ID不一致，则返回400
	StackSetId *string `json:"stack_set_id,omitempty"`

	// 资源栈集的描述。可用于客户识别自己的资源栈集。
	StackSetDescription *string `json:"stack_set_description,omitempty"`

	// 初始化资源栈描述。可用于客户识别被资源栈集所管理的资源栈。  资源栈集下的资源栈仅在创建时统一使用该描述。客户想要更新初始化资源栈描述，可以通过UpdateStackSet API。  后续更新资源栈集描述将不会同步更新已管理的资源栈描述。
	InitialStackDescription *string `json:"initial_stack_description,omitempty"`

	// 权限模型，定义了RFS操作资源栈集时所需委托的创建方式，枚举值    * `SELF_MANAGED` - 基于部署需求，用户需要提前手动创建委托，既包含管理账号给RFS的委托，也包含成员账号创建给管理账号的委托。如果委托不存在或错误，创建资源栈集不会失败，部署资源栈集或部署资源栈实例的时候才会报错。
	PermissionModel *UpdateStackSetRequestBodyPermissionModel `json:"permission_model,omitempty"`

	// 管理委托名称  资源编排服务使用该委托获取成员账号委托给管理账号的权限  当用户定义SELF_MANAGED权限类型时，administration_agency_name和administration_agency_urn 必须有且只有一个存在。  推荐用户在使用v5委托时给与administration_agency_urn，administration_agency_name只支持接收v3委托名称，若给与了v5委托名称，则会在部署模板时失败。  当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400。  [创建委托及授权方式](https://support.huaweicloud.com/usermanual-iam/iam_06_0002.html)
	AdministrationAgencyName *string `json:"administration_agency_name,omitempty"`

	// 被管理的委托名称。  资源编排服务会使用该委托获取实际部署资源所需要的权限  不同成员账号委托给管理账号的委托名称需要保持一致。暂不支持根据不同provider定义不同委托权限  当用户定义SELF_MANAGED权限类型时，必须指定该参数。当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400  [创建委托及授权方式](https://support.huaweicloud.com/usermanual-iam/iam_06_0002.html)
	ManagedAgencyName *string `json:"managed_agency_name,omitempty"`

	// 管理委托URN  资源编排服务使用该委托获取成员账号委托给管理账号的权限  当用户定义SELF_MANAGED权限类型时，administration_agency_name和administration_agency_urn 必须有且只有一个存在。  推荐用户在使用v5委托时给与administration_agency_urn，administration_agency_name只支持接收普通委托名称，若给与了v5委托名称，则会在部署模板时失败。  当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400。
	AdministrationAgencyUrn *string `json:"administration_agency_urn,omitempty"`
}

func (UpdateStackSetRequestBody) String added in v0.1.61 

func (o UpdateStackSetRequestBody) String() string

type UpdateStackSetRequestBodyPermissionModel added in v0.1.61 

type UpdateStackSetRequestBodyPermissionModel struct {
	// contains filtered or unexported fields
}

func (UpdateStackSetRequestBodyPermissionModel) MarshalJSON added in v0.1.61 

func (c UpdateStackSetRequestBodyPermissionModel) MarshalJSON() ([]byte, error)

func (*UpdateStackSetRequestBodyPermissionModel) UnmarshalJSON added in v0.1.61 

func (c *UpdateStackSetRequestBodyPermissionModel) UnmarshalJSON(b []byte) error

func (UpdateStackSetRequestBodyPermissionModel) Value added in v0.1.61 

func (c UpdateStackSetRequestBodyPermissionModel) Value() string

type UpdateStackSetRequestBodyPermissionModelEnum added in v0.1.61 

type UpdateStackSetRequestBodyPermissionModelEnum struct {
	SELF_MANAGED UpdateStackSetRequestBodyPermissionModel
}

func GetUpdateStackSetRequestBodyPermissionModelEnum added in v0.1.61 

func GetUpdateStackSetRequestBodyPermissionModelEnum() UpdateStackSetRequestBodyPermissionModelEnum

type UpdateStackSetResponse added in v0.1.61 

type UpdateStackSetResponse struct {
	HttpStatusCode int `json:"-"`
}

UpdateStackSetResponse Response Object

func (UpdateStackSetResponse) String added in v0.1.61 

func (o UpdateStackSetResponse) String() string

type UpdateTemplateMetadataRequest added in v0.1.30 

type UpdateTemplateMetadataRequest struct {

	// 用户指定的，对于此请求的唯一ID，用于定位某个请求，推荐使用UUID
	ClientRequestId string `json:"Client-Request-Id"`

	// 用户希望创建的模板名称
	TemplateName string `json:"template_name"`

	Body *UpdateTemplateMetadataRequestBody `json:"body,omitempty"`
}

UpdateTemplateMetadataRequest Request Object

func (UpdateTemplateMetadataRequest) String added in v0.1.30 

func (o UpdateTemplateMetadataRequest) String() string

type UpdateTemplateMetadataRequestBody added in v0.1.30 

type UpdateTemplateMetadataRequestBody struct {

	// 模板的唯一ID，由模板服务随机生成
	TemplateId *string `json:"template_id,omitempty"`

	// 模板的描述。可用于客户识别自己的模板
	TemplateDescription *string `json:"template_description,omitempty"`
}

UpdateTemplateMetadataRequestBody 更新模板元数据请求体

func (UpdateTemplateMetadataRequestBody) String added in v0.1.30 

func (o UpdateTemplateMetadataRequestBody) String() string

type UpdateTemplateMetadataResponse added in v0.1.30 

type UpdateTemplateMetadataResponse struct {

	// 空响应体
	Body           *string `json:"body,omitempty"`
	HttpStatusCode int     `json:"-"`
}

UpdateTemplateMetadataResponse Response Object

func (UpdateTemplateMetadataResponse) String added in v0.1.30 

func (o UpdateTemplateMetadataResponse) String() string

type VarOverridesPrimitiveTypeHolder added in v0.1.61 

type VarOverridesPrimitiveTypeHolder struct {
	VarOverrides *VarOverridesPrimitiveTypeHolderVarOverrides `json:"var_overrides,omitempty"`
}

func (VarOverridesPrimitiveTypeHolder) String added in v0.1.61 

func (o VarOverridesPrimitiveTypeHolder) String() string

type VarOverridesPrimitiveTypeHolderVarOverrides added in v0.1.61 

type VarOverridesPrimitiveTypeHolderVarOverrides struct {

	// HCL参数文件的OBS地址。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  OBS地址支持同类型Region之间进行互相访问（Region分为通用Region和专属Region，通用Region指面向公共租户提供通用云服务的Region；专属Region指只承载同一类业务或只面向特定租户提供业务服务的专用Region）  * vars_uri需要指向一个OBS的pre-signed URL地址，其他地址暂不支持  * 资源编排服务支持vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * vars_uri中的内容使用HCL的tfvars格式，用户可以将“.tfvars”中的内容保存到文件并上传到OBS中，并将OBS pre-signed URL传递给vars_uri  * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储vars_uri对应的参数文件内容
	VarsUri *string `json:"vars_uri,omitempty"`

	// HCL参数文件的内容。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  * vars_body使用HCL的tfvars格式，用户可以将“.tfvars”中的内容提交到vars_body中  * 资源编排服务支持vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * 如果vars_body过大，可以使用vars_uri  * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储对应的vars_body。
	VarsBody *string `json:"vars_body,omitempty"`

	// 用户期望使用资源栈集中记录的参数值进行部署的参数名称列表。  用户只能选择已经在资源栈集中被记录的参数，如果指定了未被记录的参数会报错400。  如果use_stack_set_vars中包含资源栈实例中已经被覆盖的参数名称，则会将该参数回退至资源栈集中记录的参数值。
	UseStackSetVars *[]string `json:"use_stack_set_vars,omitempty"`
}

VarOverridesPrimitiveTypeHolderVarOverrides 用户期望在资源栈实例中更新的参数内容，参数将覆盖到本次请求中指定的所有资源栈实例中，并根据更新后的参数部署资源栈实例。覆盖后的参数将永久被记录在资源栈实例中，并在之后的部署中继续使用被覆盖参数，直到下一次被更新覆盖。 用户只能覆盖在资源栈集中记录的参数集合vars，如果指定了vars中不存在的参数会报错400。如果用户想要增加可以覆盖的参数，需要先通过DeployStackSet API 更新资源栈集记录的参数集合vars。通过DeployStackSet API更新vars后，资源栈实例中已经被覆盖的参数不会被更新，仍然保留覆盖值。 参数覆盖只针对用户在资源栈集中通过vars指定的参数，不包括在模板中定义使用默认值的参数。如果用户期望对使用默认值的参数进行覆盖，则需要按上述要求先通过DeployStackSet API 更新资源栈集记录的vars，显式地向vars中增加相关参数定义。 用户每次通过DeployStackSet API 更新资源栈集vars时，如果缺少了任一部署目标的资源栈实例中所记录的被覆盖参数时（即当前被覆盖参数已不是更新后资源栈集参数vars的子集)，会报错400 当前用户在更新参数覆盖时不能指定保留已有的参数覆盖，必须在更新的时候给予全部的覆盖信息。 参数覆盖后的资源栈实例应用的vars_body总长不超过51200。参数覆盖后的资源栈实例应用的vars_uri文件内容不超过1M。 例如：资源栈集中记录的vars_body内容为”key1=value1,key2=value2,....“，资源栈实例参数覆盖的vars_body为“key1=another_value1”，则要求应用参数覆盖后的vars_body“key1=another_value1,key2=value2,....”总长不超过51200。 例如：资源栈集中记录的vars_uri文件内容为”key1=value1,key2=value2,....“，资源栈实例参数覆盖的vars_body为“key1=another_value1”，则要求应用参数覆盖后的vars_uri文件内容“key1=another_value1,key2=value2,....”总长不超过1M。 若var_overrides未给予，则不会更新覆盖资源栈实例中记录的参数。若vars_uri或vars_body或use_stack_set_vars至少给予了一个，则会对参数覆盖进行替换式更新，即所给予的参数将被完全覆盖至指定资源栈实例中。 vars_body、vars_uri和use_stack_set_vars中声明的全部参数集合必须和资源栈集中记录的参数集合保持一致，如果声明了资源栈集中不存在的参数会报错400，如果没有声明已经在资源栈集中记录的参数会报错400，如果声名了同一个参数会报错400。 注： *期望覆盖指定参数值，需要在vars_uri或者vars_body中指定期望覆盖的参数名称及参数值 *期望将某个已覆盖参数回退至资源栈集中记录的参数值，需要在use_stack_set_vars中指定期望回退的参数名称 *期望将所有已覆盖参数回退至资源栈集中记录的参数值，需要在use_stack_set_vars中指定资源栈集中记录的全部参数名称 *期望使用当前资源栈实例中记录的参数值进行部署，则不需要指定var_overrides

func (VarOverridesPrimitiveTypeHolderVarOverrides) String added in v0.1.61 

func (o VarOverridesPrimitiveTypeHolderVarOverrides) String() string

type VariableResponse 

type VariableResponse struct {

	// 参数的名字  以HCL格式的模板为例，name 为 `my_hello_world_variable`  “`hcl variable \"my_hello_world_variable\" {   type = string   description = \"this is a variable\"   default = \"hello world\"   sensitive = false   nullable = false   validation {     condition     = length(var.my_hello_world_variable) > 0 && substr(var.my_hello_world_variable, 0, 5) == \"hello\"     error_message = \"my_hello_world_variable should start with 'hello'.\"   } } “`  以json格式的模板为例，name 为 `my_hello_world_variable`  “`json {   \"variable\": {     \"my_hello_world_variable\": [       {         \"default\": \"hello world\",         \"description\": \"this is a variable\",         \"nullable\": false,         \"sensitive\": false,         \"type\": \"string\",         \"validation\": [           {             \"condition\": \"${length(var.my_hello_world_variable) > 0 && substr(var.my_hello_world_variable, 0, 5) == \\\"hello\\\"}\",             \"error_message\": \"my_hello_world_variable should start with 'hello'.\"           }         ]       }     ]   } } “`
	Name *string `json:"name,omitempty"`

	// 参数的类型  以HCL格式的模板为例，type 为 `string`  “`hcl variable \"my_hello_world_variable\" {   type = string   description = \"this is a variable\"   default = \"hello world\"   sensitive = false   nullable = false   validation {     condition     = length(var.my_hello_world_variable) > 0 && substr(var.my_hello_world_variable, 0, 5) == \"hello\"     error_message = \"my_hello_world_variable should start with 'hello'.\"   } } “`  以json格式的模板为例，type 为 `string`  “`json {   \"variable\": {     \"my_hello_world_variable\": [       {         \"default\": \"hello world\",         \"description\": \"this is a variable\",         \"nullable\": false,         \"sensitive\": false,         \"type\": \"string\",         \"validation\": [           {             \"condition\": \"${length(var.my_hello_world_variable) > 0 && substr(var.my_hello_world_variable, 0, 5) == \\\"hello\\\"}\",             \"error_message\": \"my_hello_world_variable should start with 'hello'.\"           }         ]       }     ]   } } “`
	Type *string `json:"type,omitempty"`

	// 参数的描述  以HCL格式的模板为例，description 为 `this is a variable`  “`hcl variable \"my_hello_world_variable\" {   type = string   description = \"this is a variable\"   default = \"hello world\"   sensitive = false   nullable = false   validation {     condition     = length(var.my_hello_world_variable) > 0 && substr(var.my_hello_world_variable, 0, 5) == \"hello\"     error_message = \"my_hello_world_variable should start with 'hello'.\"   } } “`  以json格式的模板为例，description 为 `this is a variable`  “`json {   \"variable\": {     \"my_hello_world_variable\": [       {         \"default\": \"hello world\",         \"description\": \"this is a variable\",         \"nullable\": false,         \"sensitive\": false,         \"type\": \"string\",         \"validation\": [           {             \"condition\": \"${length(var.my_hello_world_variable) > 0 && substr(var.my_hello_world_variable, 0, 5) == \\\"hello\\\"}\",             \"error_message\": \"my_hello_world_variable should start with 'hello'.\"           }         ]       }     ]   } } “`
	Description *string `json:"description,omitempty"`

	// 参数默认值。此返回值的类型将与type保持一致  例如，对于type为string的变量，此值的返回类型为string；对于type为number的变量，此值的返回类型为number  以HCL格式的模板为例，default 为 `hello world`  “`hcl variable \"my_hello_world_variable\" {   type = string   description = \"this is a variable\"   default = \"hello world\"   sensitive = false   nullable = false   validation {     condition     = length(var.my_hello_world_variable) > 0 && substr(var.my_hello_world_variable, 0, 5) == \"hello\"     error_message = \"my_hello_world_variable should start with 'hello'.\"   } } “`  以json格式的模板为例，default 为 `hello world`  “`json {   \"variable\": {     \"my_hello_world_variable\": [       {         \"default\": \"hello world\",         \"description\": \"this is a variable\",         \"nullable\": false,         \"sensitive\": false,         \"type\": \"string\",         \"validation\": [           {             \"condition\": \"${length(var.my_hello_world_variable) > 0 && substr(var.my_hello_world_variable, 0, 5) == \\\"hello\\\"}\",             \"error_message\": \"my_hello_world_variable should start with 'hello'.\"           }         ]       }     ]   } } “`
	Default *interface{} `json:"default,omitempty"`

	// 参数是否为敏感字段  若variable中没有定义sensitive，默认返回false。  以HCL格式的模板为例，sensitive 为 `false`  “`hcl variable \"my_hello_world_variable\" {   type = string   description = \"this is a variable\"   default = \"hello world\"   sensitive = false   nullable = false   validation {     condition     = length(var.my_hello_world_variable) > 0 && substr(var.my_hello_world_variable, 0, 5) == \"hello\"     error_message = \"my_hello_world_variable should start with 'hello'.\"   } } “`  以json格式的模板为例，sensitive 为 `false`  “`json {   \"variable\": {     \"my_hello_world_variable\": [       {         \"default\": \"hello world\",         \"description\": \"this is a variable\",         \"nullable\": false,         \"sensitive\": false,         \"type\": \"string\",         \"validation\": [           {             \"condition\": \"${length(var.my_hello_world_variable) > 0 && substr(var.my_hello_world_variable, 0, 5) == \\\"hello\\\"}\",             \"error_message\": \"my_hello_world_variable should start with 'hello'.\"           }         ]       }     ]   } } “`
	Sensitive *bool `json:"sensitive,omitempty"`

	// 参数是否可设置为null。  若variable中没有定义nullable，默认返回true。  以HCL格式的模板为例，nullable 为 `false`  “`hcl variable \"my_hello_world_variable\" {   type = string   description = \"this is a variable\"   default = \"hello world\"   sensitive = false   nullable = false   validation {     condition     = length(var.my_hello_world_variable) > 0 && substr(var.my_hello_world_variable, 0, 5) == \"hello\"     error_message = \"my_hello_world_variable should start with 'hello'.\"   } } “`  以json格式的模板为例，nullable 为 `false`  “`json {   \"variable\": {     \"my_hello_world_variable\": [       {         \"default\": \"hello world\",         \"description\": \"this is a variable\",         \"nullable\": false,         \"sensitive\": false,         \"type\": \"string\",         \"validation\": [           {             \"condition\": \"${length(var.my_hello_world_variable) > 0 && substr(var.my_hello_world_variable, 0, 5) == \\\"hello\\\"}\",             \"error_message\": \"my_hello_world_variable should start with 'hello'.\"           }         ]       }     ]   } } “`
	Nullable *bool `json:"nullable,omitempty"`

	// 参数的校验模块
	Validations *[]VariableValidationResponse `json:"validations,omitempty"`
}

func (VariableResponse) String 

func (o VariableResponse) String() string

type VariableValidationResponse 

type VariableValidationResponse struct {

	// 校验表达式
	Condition *string `json:"condition,omitempty"`

	// 校验失败后的错误信息
	ErrorMessage *string `json:"error_message,omitempty"`
}

func (VariableValidationResponse) String 

func (o VariableValidationResponse) String() string

type VarsBodyPrimitiveTypeHolder 

type VarsBodyPrimitiveTypeHolder struct {

	// HCL参数文件的内容。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  * vars_body使用HCL的tfvars格式，用户可以将“.tfvars”中的内容提交到vars_body中  * 资源编排服务支持vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * 如果vars_body过大，可以使用vars_uri  * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储对应的vars_body。
	VarsBody *string `json:"vars_body,omitempty"`
}

func (VarsBodyPrimitiveTypeHolder) String 

func (o VarsBodyPrimitiveTypeHolder) String() string

type VarsStructure 

type VarsStructure struct {

	// 参数的名字
	VarKey string `json:"var_key"`

	// 参数的值。  注意，参数需要以字符串形式存在，如果是数字，也需要以字符串形式存在，如'10'。  如果需要支持不同类型，或者复杂结构，请使用vars_uri或vars_body
	VarValue string `json:"var_value"`

	Encryption *EncryptionStructure `json:"encryption,omitempty"`
}

VarsStructure HCL支持参数，即，同一个模板可以给予不同的参数而达到不同的效果。 var_structure可以允许客户提交最简单的字符串类型的参数 资源编排服务支持vars_structure，vars_body和vars_uri，如果他们中声名了同一个变量，将报错400 vars_structure中的值只支持简单的字符串类型，如果需要使用其他类型，需要用户自己在HCL引用时转换， 或者用户可以使用vars_uri、vars_body，vars_uri和vars_body中支持HCL支持的各种类型以及复杂结构 如果vars_structure过大，可以使用vars_uri 注意：vars中不应该传递任何敏感信息，资源编排服务会直接明文使用、log、展示、存储对应的vars

func (VarsStructure) String 

func (o VarsStructure) String() string

type VarsStructurePrimitiveTypeHolder 

type VarsStructurePrimitiveTypeHolder struct {

	// HCL参数结构。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  * var_structure可以允许客户提交最简单的字符串类型的参数  * 资源编排服务支持vars_structure，vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * vars_structure中的值只支持简单的字符串类型，如果需要使用其他类型，需要用户自己在HCL引用时转换， 或者用户可以使用vars_uri、vars_body，vars_uri和vars_body中支持HCL支持的各种类型以及复杂结构  * 如果vars_structure过大，可以使用vars_uri  * 注意：vars_structure中默认不应该含有任何敏感信息，资源编排服务会直接明文使用、log、展示、存储对应的vars。如为敏感信息，建议设置encryption字段开启加密
	VarsStructure *[]VarsStructure `json:"vars_structure,omitempty"`
}

func (VarsStructurePrimitiveTypeHolder) String 

func (o VarsStructurePrimitiveTypeHolder) String() string

type VarsUriContentPrimitiveTypeHolder added in v0.1.30 

type VarsUriContentPrimitiveTypeHolder struct {

	// vars_uri对应的文件内容
	VarsUriContent *string `json:"vars_uri_content,omitempty"`
}

func (VarsUriContentPrimitiveTypeHolder) String added in v0.1.30 

func (o VarsUriContentPrimitiveTypeHolder) String() string

type VarsUriPrimitiveTypeHolder 

type VarsUriPrimitiveTypeHolder struct {

	// HCL参数文件的OBS地址。HCL模板支持参数传入，即，同一个模板可以给予不同的参数而达到不同的效果。  OBS地址支持同类型Region之间进行互相访问（Region分为通用Region和专属Region，通用Region指面向公共租户提供通用云服务的Region；专属Region指只承载同一类业务或只面向特定租户提供业务服务的专用Region）  * vars_uri需要指向一个OBS的pre-signed URL地址，其他地址暂不支持  * 资源编排服务支持vars_body和vars_uri，如果他们中声名了同一个变量，将报错400  * vars_uri中的内容使用HCL的tfvars格式，用户可以将“.tfvars”中的内容保存到文件并上传到OBS中，并将OBS pre-signed URL传递给vars_uri  * 资源栈集不支持敏感数据加密，资源编排服务会直接明文使用、log、展示、存储vars_uri对应的参数文件内容
	VarsUri *string `json:"vars_uri,omitempty"`
}

func (VarsUriPrimitiveTypeHolder) String 

func (o VarsUriPrimitiveTypeHolder) String() string

type VoidBody added in v0.1.63 

type VoidBody struct {
}

VoidBody 空响应体

func (VoidBody) String added in v0.1.63 

func (o VoidBody) String() string

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.