model

package
v0.1.126 Latest Latest
Warning

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

 Go to latest Published: Dec 10, 2024 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 {

	// 管理委托名称  资源编排服务使用该委托获取成员账号委托给管理账号的权限。该委托中必须含有iam:tokens:assume权限，用以后续获取被管理委托凭证。如果不包含，则会在新增或者部署实例时报错。  当用户定义SELF_MANAGED权限类型时，administration_agency_name和administration_agency_urn 必须有且只有一个存在。  推荐用户在使用信任委托时给予administration_agency_urn，administration_agency_name只支持接收委托名称，如果给予了信任委托名称，则会在部署模板时失败。  当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400。  [[创建委托及授权方式](https://support.huaweicloud.com/usermanual-iam/iam_06_0002.html)](tag:hws) [[创建委托及授权方式](https://support.huaweicloud.com/intl/zh-cn/usermanual-iam/iam_06_0002.html)](tag:hws_hk) [[创建委托及授权方式](https://support.huaweicloud.com/eu/usermanual-iam/iam_06_0002.html)](tag:hws_eu)
	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  资源编排服务使用该委托获取成员账号委托给管理账号的权限。该委托中必须含有sts:tokens:assume权限，用以后续获取被管理委托凭证。如果不包含，则会在新增或者部署实例时报错。  当用户定义SELF_MANAGED权限类型时，administration_agency_name和administration_agency_urn 必须有且只有一个存在。  推荐用户在使用信任委托时给予administration_agency_urn，administration_agency_name只支持接收委托名称，如果给予了信任委托名称，则会在部署模板时失败。  当用户使用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)](tag:hws) [[创建委托及授权方式](https://support.huaweicloud.com/intl/zh-cn/usermanual-iam/iam_06_0002.html)](tag:hws_hk) [[创建委托及授权方式](https://support.huaweicloud.com/eu/usermanual-iam/iam_06_0002.html)](tag:hws_eu)
	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 必须有且只有一个存在。  推荐用户在使用信任委托时给予agency_urn，agency_name只支持接收普通委托名称，如果给予了信任委托名称，则会在部署模板时失败。
	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  **注意：** * 创建执行计划后，资源编排服务持久化请求并立即返回，客户端不等待请求最终处理完成，用户无法实时感知请求处理结果 * 资源编排服务最终会将异步部署请求排队，在服务端空闲的情况下逐个处理。用户最大等待时长为1小时
	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。  接受请求，进行异步处理。可以调用GetStackMetadata来获取异步请求的部署状态  **注意：** * 部署资源栈后，资源编排服务持久化请求并立即返回，客户端不等待请求最终处理完成，用户无法实时感知请求处理结果 * 资源编排服务最终会将异步部署请求排队，在服务端空闲的情况下逐个处理。用户最大等待时长为6小时
	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 CallIdentityPrimitiveTypeHolder added in v0.1.103 

type CallIdentityPrimitiveTypeHolder struct {

	// 仅支持资源栈集权限模式为SERVICE_MANAGED时指定该参数。用于指定用户是以组织管理账号还是成员账号中的服务委托管理员身份调用资源栈集。默认为SELF。 当资源栈集权限模式为SELF_MANAGED时，默认为SELF。 * 无论指定何种用户身份，涉及操作的资源栈集始终在组织管理账号名下。*   * `SELF` - 以组织管理账号身份调用。   * `DELEGATED_ADMIN` - 以服务委托管理员身份调用。用户的华为云账号必须在组织中已经被注册为”资源编排资源栈集服务“的委托管理员。
	CallIdentity *CallIdentityPrimitiveTypeHolderCallIdentity `json:"call_identity,omitempty"`
}

func (CallIdentityPrimitiveTypeHolder) String added in v0.1.103 

func (o CallIdentityPrimitiveTypeHolder) String() string

type CallIdentityPrimitiveTypeHolderCallIdentity added in v0.1.103 

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

func (CallIdentityPrimitiveTypeHolderCallIdentity) MarshalJSON added in v0.1.103 

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

func (*CallIdentityPrimitiveTypeHolderCallIdentity) UnmarshalJSON added in v0.1.103 

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

func (CallIdentityPrimitiveTypeHolderCallIdentity) Value added in v0.1.103 

func (c CallIdentityPrimitiveTypeHolderCallIdentity) Value() string

type CallIdentityPrimitiveTypeHolderCallIdentityEnum added in v0.1.103 

type CallIdentityPrimitiveTypeHolderCallIdentityEnum struct {
	SELF            CallIdentityPrimitiveTypeHolderCallIdentity
	DELEGATED_ADMIN CallIdentityPrimitiveTypeHolderCallIdentity
}

func GetCallIdentityPrimitiveTypeHolderCallIdentityEnum added in v0.1.103 

func GetCallIdentityPrimitiveTypeHolderCallIdentityEnum() CallIdentityPrimitiveTypeHolderCallIdentityEnum

type ConfigurationPrimitiveTypeHolder added in v0.1.109 

type ConfigurationPrimitiveTypeHolder struct {
	Configuration *ConfigurationPrimitiveTypeHolderConfiguration `json:"configuration,omitempty"`
}

func (ConfigurationPrimitiveTypeHolder) String added in v0.1.109 

func (o ConfigurationPrimitiveTypeHolder) String() string

type ConfigurationPrimitiveTypeHolderConfiguration added in v0.1.109 

type ConfigurationPrimitiveTypeHolderConfiguration struct {

	// 指定私有hook生效的目标资源栈，有效值为NONE或ALL。  NONE：指定此私有hook不会作用于任何资源栈 ALL：指定此私有hook将会应用于账号下的所有资源栈
	TargetStacks *ConfigurationPrimitiveTypeHolderConfigurationTargetStacks `json:"target_stacks,omitempty"`

	// 指定私有hook校验失败后的行为，有效值为FAIL或WARN。  FAIL：指定此私有hook校验失败后资源栈将停止部署，资源栈状态将更新为DEPLOYMENT_FAILED。 WARN：指定此私有hook校验失败后仅通过资源栈事件展示警告消息，但不影响资源栈部署。
	FailureMode *ConfigurationPrimitiveTypeHolderConfigurationFailureMode `json:"failure_mode,omitempty"`
}

ConfigurationPrimitiveTypeHolderConfiguration 私有hook配置项，可以指定私有hook生效的目标资源栈以及私有hook校验失败后资源栈的行为。可通过UpdatePrivateHook API更新私有hook配置项。

func (ConfigurationPrimitiveTypeHolderConfiguration) String added in v0.1.109 

func (o ConfigurationPrimitiveTypeHolderConfiguration) String() string

type ConfigurationPrimitiveTypeHolderConfigurationFailureMode added in v0.1.109 

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

func (ConfigurationPrimitiveTypeHolderConfigurationFailureMode) MarshalJSON added in v0.1.109 

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

func (*ConfigurationPrimitiveTypeHolderConfigurationFailureMode) UnmarshalJSON added in v0.1.109 

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

func (ConfigurationPrimitiveTypeHolderConfigurationFailureMode) Value added in v0.1.109 

func (c ConfigurationPrimitiveTypeHolderConfigurationFailureMode) Value() string

type ConfigurationPrimitiveTypeHolderConfigurationFailureModeEnum added in v0.1.109 

type ConfigurationPrimitiveTypeHolderConfigurationFailureModeEnum struct {
	WARN ConfigurationPrimitiveTypeHolderConfigurationFailureMode
	FAIL ConfigurationPrimitiveTypeHolderConfigurationFailureMode
}

func GetConfigurationPrimitiveTypeHolderConfigurationFailureModeEnum added in v0.1.109 

func GetConfigurationPrimitiveTypeHolderConfigurationFailureModeEnum() ConfigurationPrimitiveTypeHolderConfigurationFailureModeEnum

type ConfigurationPrimitiveTypeHolderConfigurationTargetStacks added in v0.1.109 

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

func (ConfigurationPrimitiveTypeHolderConfigurationTargetStacks) MarshalJSON added in v0.1.109 

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

func (*ConfigurationPrimitiveTypeHolderConfigurationTargetStacks) UnmarshalJSON added in v0.1.109 

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

func (ConfigurationPrimitiveTypeHolderConfigurationTargetStacks) Value added in v0.1.109 

func (c ConfigurationPrimitiveTypeHolderConfigurationTargetStacks) Value() string

type ConfigurationPrimitiveTypeHolderConfigurationTargetStacksEnum added in v0.1.109 

type ConfigurationPrimitiveTypeHolderConfigurationTargetStacksEnum struct {
	NONE ConfigurationPrimitiveTypeHolderConfigurationTargetStacks
	ALL  ConfigurationPrimitiveTypeHolderConfigurationTargetStacks
}

func GetConfigurationPrimitiveTypeHolderConfigurationTargetStacksEnum added in v0.1.109 

func GetConfigurationPrimitiveTypeHolderConfigurationTargetStacksEnum() ConfigurationPrimitiveTypeHolderConfigurationTargetStacksEnum

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 接受请求，进行异步处理。可以调用GetStackMetadata来获取异步请求的部署状态  **注意：** * 部署资源栈后，资源编排服务持久化请求并立即返回，客户端不等待请求最终处理完成，用户无法实时感知请求处理结果 * 资源编排服务最终会将异步部署请求排队，在服务端空闲的情况下逐个处理。用户最大等待时长为6小时
	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  接受请求，进行异步处理。可以调用GetStackMetadata来获取异步请求的部署状态  **注意：** * 资源编排服务最终会将异步部署请求排队，在服务端空闲的情况下逐个处理。用户最大等待时长为6小时
	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地址所在局点与使用RFS服务局点一致。  对应的文件应该是纯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地址所在局点与使用RFS服务局点一致。  * 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  **注意：** * 创建执行计划后，资源编排服务持久化请求并立即返回，客户端不等待请求最终处理完成，用户无法实时感知请求处理结果 * 资源编排服务最终会将异步部署请求排队，在服务端空闲的情况下逐个处理。用户最大等待时长为1小时
	ExecutionPlanId *string `json:"execution_plan_id,omitempty"`
	HttpStatusCode  int     `json:"-"`
}

CreateExecutionPlanResponse Response Object

func (CreateExecutionPlanResponse) String 

func (o CreateExecutionPlanResponse) String() string

type CreatePrivateHookRequest added in v0.1.109 

type CreatePrivateHookRequest struct {

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

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

CreatePrivateHookRequest Request Object

func (CreatePrivateHookRequest) String added in v0.1.109 

func (o CreatePrivateHookRequest) String() string

type CreatePrivateHookRequestBody added in v0.1.109 

type CreatePrivateHookRequestBody struct {

	// 私有hook的名字。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。  推荐用户使用三段命名空间：{自定义hook名称}-{hook应用场景}-hook。
	HookName string `json:"hook_name"`

	// 私有hook的版本号。版本号必须遵循语义化版本号（Semantic Version），为用户自定义。
	HookVersion string `json:"hook_version"`

	// 私有hook的描述。可用于客户识别创建的私有hook。可通过UpdatePrivateHook API更新私有hook的描述。
	HookDescription *string `json:"hook_description,omitempty"`

	// 私有hook版本的描述。可用于客户识别创建私有hook的版本。注意：hook版本为不可更新（immutable），所以该字段不可更新，如果需要更新，请删除后重建。
	HookVersionDescription *string `json:"hook_version_description,omitempty"`

	Configuration *ConfigurationPrimitiveTypeHolderConfiguration `json:"configuration,omitempty"`

	// 策略文件的OBS地址。内容仅支持OPA开源引擎识别的，以Rego（https://www.openpolicyagent.org/docs/latest/policy-language/）语言编写的策略模板。  请确保OBS地址所在局点与使用RFS服务局点一致。  策略文件当前支持单文件或zip压缩包，单文件需要以\".rego\"结尾，压缩包当前只支持zip格式，文件需要以`.zip`结尾。  关于策略文件的校验要求如下：   * 文件必须是UTF8编码   * 创建时会对大小、格式、语法等进行校验   * 策略文件必须是UTF-8编码   * 单文件或压缩包解压前后的大小应控制在1MB以内   * 压缩包内的文件数量不能超过100个   * 压缩包内的文件路径最长为2048   * 压缩包内的文件名最长为255个字节  policy_uri和policy_body必须有且只有一个存在
	PolicyUri *string `json:"policy_uri,omitempty"`

	// 策略内容。仅支持OPA开源引擎识别的，以Rego（https://www.openpolicyagent.org/docs/latest/policy-language/）语言编写的策略模板。  policy_body和policy_uri 必须有且只有一个存在
	PolicyBody *string `json:"policy_body,omitempty"`
}

func (CreatePrivateHookRequestBody) String added in v0.1.109 

func (o CreatePrivateHookRequestBody) String() string

type CreatePrivateHookResponse added in v0.1.109 

type CreatePrivateHookResponse struct {

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

CreatePrivateHookResponse Response Object

func (CreatePrivateHookResponse) String added in v0.1.109 

func (o CreatePrivateHookResponse) String() string

type CreatePrivateHookVersionRequest added in v0.1.109 

type CreatePrivateHookVersionRequest struct {

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

	// 私有hook的名字。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。  推荐用户使用三段命名空间：{自定义hook名称}-{hook应用场景}-hook。
	HookName string `json:"hook_name"`

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

CreatePrivateHookVersionRequest Request Object

func (CreatePrivateHookVersionRequest) String added in v0.1.109 

func (o CreatePrivateHookVersionRequest) String() string

type CreatePrivateHookVersionRequestBody added in v0.1.109 

type CreatePrivateHookVersionRequestBody struct {

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

	// 私有hook的版本号。版本号必须遵循语义化版本号（Semantic Version），为用户自定义。
	HookVersion string `json:"hook_version"`

	// 私有hook版本的描述。可用于客户识别创建私有hook的版本。注意：hook版本为不可更新（immutable），所以该字段不可更新，如果需要更新，请删除后重建。
	HookVersionDescription *string `json:"hook_version_description,omitempty"`

	// 策略文件的OBS地址。内容仅支持OPA开源引擎识别的，以Rego（https://www.openpolicyagent.org/docs/latest/policy-language/）语言编写的策略模板。  请确保OBS地址所在局点与使用RFS服务局点一致。  策略文件当前支持单文件或zip压缩包，单文件需要以\".rego\"结尾，压缩包当前只支持zip格式，文件需要以`.zip`结尾。  关于策略文件的校验要求如下：   * 文件必须是UTF8编码   * 创建时会对大小、格式、语法等进行校验   * 策略文件必须是UTF-8编码   * 单文件或压缩包解压前后的大小应控制在1MB以内   * 压缩包内的文件数量不能超过100个   * 压缩包内的文件路径最长为2048   * 压缩包内的文件名最长为255个字节  policy_uri和policy_body必须有且只有一个存在
	PolicyUri *string `json:"policy_uri,omitempty"`

	// 策略内容。仅支持OPA开源引擎识别的，以Rego（https://www.openpolicyagent.org/docs/latest/policy-language/）语言编写的策略模板。  policy_body和policy_uri 必须有且只有一个存在
	PolicyBody *string `json:"policy_body,omitempty"`
}

func (CreatePrivateHookVersionRequestBody) String added in v0.1.109 

func (o CreatePrivateHookVersionRequestBody) String() string

type CreatePrivateHookVersionResponse added in v0.1.109 

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

CreatePrivateHookVersionResponse Response Object

func (CreatePrivateHookVersionResponse) String added in v0.1.109 

func (o CreatePrivateHookVersionResponse) String() string

type CreatePrivateProviderRequest added in v0.1.80 

type CreatePrivateProviderRequest struct {

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

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

CreatePrivateProviderRequest Request Object

func (CreatePrivateProviderRequest) String added in v0.1.80 

func (o CreatePrivateProviderRequest) String() string

type CreatePrivateProviderRequestBody added in v0.1.80 

type CreatePrivateProviderRequestBody struct {

	// 私有provider（private-provider）的名称。此名字在domain_id+region下应唯一，可以使用小写英文、数字、中划线。仅支持以小写英文、数字开头结尾。  按照HCL最佳实践，该名称推荐为在模板中定义的provider的本地名称（local_name）。  创建私有Provider（CreatePrivateProvider）API 还会以 “huawei.com/private-provider”为固定前缀，并以“huawei.com/private-provider/{provider_name}”的形式返回provider_source字段。关于provider_name和provider_source字段在模板中的使用细节，详见创建私有Provider的API描述。
	ProviderName string `json:"provider_name"`

	// 私有provider（private-provider）的描述。可用于客户识别被管理的私有provider。
	ProviderDescription *string `json:"provider_description,omitempty"`

	// provider的版本号。版本号必须遵循语义化版本号（Semantic Version），为用户自定义
	ProviderVersion *string `json:"provider_version,omitempty"`

	// 私有provider版本（provider version）的描述。可用于客户识别并管理私有provider的版本。注意：provider版本为不可更新（immutable），所以该字段不可更新，如果需要更新，请删除后重建
	VersionDescription *string `json:"version_description,omitempty"`

	// FunctionGraph方法的统一资源标识，用于唯一标识的FunctionGraph方法。当前只支持和RFS同region的function_graph_urn，如果给予了关于其他region的，会报错400。  关于该参数的详细解释，请参考官方文档：https://support.huaweicloud.com/api-functiongraph/functiongraph_06_0102.html
	FunctionGraphUrn *string `json:"function_graph_urn,omitempty"`
}

func (CreatePrivateProviderRequestBody) String added in v0.1.80 

func (o CreatePrivateProviderRequestBody) String() string

type CreatePrivateProviderResponse added in v0.1.80 

type CreatePrivateProviderResponse struct {

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

	// 用户使用私有provider，在Terraform模板中定义required_providers信息时，需要指明的source参数。  该参数按照“huawei.com/private-provider/{provider_name}”的形式拼接。关于provider_name和provider_source字段在模板中的使用细节，详见创建私有Provider的API描述。
	ProviderSource *string `json:"provider_source,omitempty"`
	HttpStatusCode int     `json:"-"`
}

CreatePrivateProviderResponse Response Object

func (CreatePrivateProviderResponse) String added in v0.1.80 

func (o CreatePrivateProviderResponse) String() string

type CreatePrivateProviderVersionRequest added in v0.1.80 

type CreatePrivateProviderVersionRequest struct {

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

	// 私有provider（private-provider）的名称。此名字在domain_id+region下应唯一，可以使用小写英文、数字、中划线。仅支持以小写英文、数字开头结尾。
	ProviderName string `json:"provider_name"`

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

CreatePrivateProviderVersionRequest Request Object

func (CreatePrivateProviderVersionRequest) String added in v0.1.80 

func (o CreatePrivateProviderVersionRequest) String() string

type CreatePrivateProviderVersionRequestBody added in v0.1.80 

type CreatePrivateProviderVersionRequestBody struct {

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

	// provider的版本号。版本号必须遵循语义化版本号（Semantic Version），为用户自定义
	ProviderVersion string `json:"provider_version"`

	// 私有provider版本（provider version）的描述。可用于客户识别并管理私有provider的版本。注意：provider版本为不可更新（immutable），所以该字段不可更新，如果需要更新，请删除后重建
	VersionDescription *string `json:"version_description,omitempty"`

	// FunctionGraph方法的统一资源标识，用于标识唯一的FunctionGraph方法。当前只支持和RFS同region的function_graph_urn，如果给予了关于其他region的，会报错400。  关于该参数的详细解释，请参考官方文档：https://support.huaweicloud.com/api-functiongraph/functiongraph_06_0102.html
	FunctionGraphUrn string `json:"function_graph_urn"`
}

func (CreatePrivateProviderVersionRequestBody) String added in v0.1.80 

func (o CreatePrivateProviderVersionRequestBody) String() string

type CreatePrivateProviderVersionResponse added in v0.1.80 

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

CreatePrivateProviderVersionResponse Response Object

func (CreatePrivateProviderVersionResponse) String added in v0.1.80 

func (o CreatePrivateProviderVersionResponse) 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"`

	OperationPreferences *OperationPreferences `json:"operation_preferences,omitempty"`

	// 仅支持资源栈集权限模式为SERVICE_MANAGED时指定该参数。用于指定用户是以组织管理账号还是成员账号中的服务委托管理员身份调用资源栈集。默认为SELF。 当资源栈集权限模式为SELF_MANAGED时，默认为SELF。 * 无论指定何种用户身份，涉及操作的资源栈集始终在组织管理账号名下。*   * `SELF` - 以组织管理账号身份调用。   * `DELEGATED_ADMIN` - 以服务委托管理员身份调用。用户的华为云账号必须在组织中已经被注册为”资源编排资源栈集服务“的委托管理员。
	CallIdentity *CreateStackInstanceRequestBodyCallIdentity `json:"call_identity,omitempty"`
}

func (CreateStackInstanceRequestBody) String added in v0.1.61 

func (o CreateStackInstanceRequestBody) String() string

type CreateStackInstanceRequestBodyCallIdentity added in v0.1.103 

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

func (CreateStackInstanceRequestBodyCallIdentity) MarshalJSON added in v0.1.103 

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

func (*CreateStackInstanceRequestBodyCallIdentity) UnmarshalJSON added in v0.1.103 

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

func (CreateStackInstanceRequestBodyCallIdentity) Value added in v0.1.103 

func (c CreateStackInstanceRequestBodyCallIdentity) Value() string

type CreateStackInstanceRequestBodyCallIdentityEnum added in v0.1.103 

type CreateStackInstanceRequestBodyCallIdentityEnum struct {
	SELF            CreateStackInstanceRequestBodyCallIdentity
	DELEGATED_ADMIN CreateStackInstanceRequestBodyCallIdentity
}

func GetCreateStackInstanceRequestBodyCallIdentityEnum added in v0.1.103 

func GetCreateStackInstanceRequestBodyCallIdentityEnum() CreateStackInstanceRequestBodyCallIdentityEnum

type CreateStackInstanceResponse added in v0.1.61 

type CreateStackInstanceResponse struct {

	// 资源栈集操作（stack_set_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)](tag:hws) [[创建委托及授权方式](https://support.huaweicloud.com/intl/zh-cn/usermanual-iam/iam_06_0002.html)](tag:hws_hk) [[创建委托及授权方式](https://support.huaweicloud.com/eu/usermanual-iam/iam_06_0002.html)](tag:hws_eu)
	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地址所在局点与使用RFS服务局点一致。  对应的文件应该是纯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地址所在局点与使用RFS服务局点一致。  * 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 接受请求，进行异步处理。可以调用GetStackMetadata来获取异步请求的部署状态  **注意：** * 部署资源栈后，资源编排服务持久化请求并立即返回，客户端不等待请求最终处理完成，用户无法实时感知请求处理结果 * 资源编排服务最终会将异步部署请求排队，在服务端空闲的情况下逐个处理。用户最大等待时长为6小时
	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。用户可以使用创建资源栈集（CreateStackSet）API 指定该参数。该参数暂不支持更新。用户如果想要更新权限模型，可以通过先删除再创建同名资源栈集实现。   * `SELF_MANAGED` - 自我管理，基于部署需求，用户需要提前手动创建委托，既包含管理账号授权给RFS的委托，也包含成员账号授权给管理账号的委托。如果委托不存在或权限不足，创建资源栈集不会失败，创建资源栈实例时才会报错。   * `SERVICE_MANAGED` - 服务管理，基于Organization服务，RFS会自动创建部署Organization 成员账号时所需的全部 IAM 委托。用户需要提前在Organization可信服务列表中将”资源编排资源栈集服务“启用，且只有Organization的管理账号或”资源编排资源栈集服务“的委托管理员，才允许指定SERVICE_MANAGED创建资源栈集，否则会报错。
	PermissionModel *CreateStackSetRequestBodyPermissionModel `json:"permission_model,omitempty"`

	// 管理委托名称  资源编排服务使用该委托获取成员账号委托给管理账号的权限。该委托中必须含有iam:tokens:assume权限，用以后续获取被管理委托凭证。如果不包含，则会在新增或者部署实例时报错。  当用户定义SELF_MANAGED权限类型时，administration_agency_name和administration_agency_urn 必须有且只有一个存在。  推荐用户在使用信任委托时给予administration_agency_urn，administration_agency_name只支持接收委托名称，如果给予了信任委托名称，则会在部署模板时失败。  当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400。  [[创建委托及授权方式](https://support.huaweicloud.com/usermanual-iam/iam_06_0002.html)](tag:hws) [[创建委托及授权方式](https://support.huaweicloud.com/intl/zh-cn/usermanual-iam/iam_06_0002.html)](tag:hws_hk) [[创建委托及授权方式](https://support.huaweicloud.com/eu/usermanual-iam/iam_06_0002.html)](tag:hws_eu)
	AdministrationAgencyName *string `json:"administration_agency_name,omitempty"`

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

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

	// HCL模板的OBS地址，该模板描述了资源的目标状态。资源编排服务将比较此模板与当前远程资源的状态之间的区别  请确保OBS地址所在局点与使用RFS服务局点一致。  对应的文件应该是纯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地址所在局点与使用RFS服务局点一致。  * 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  资源编排服务使用该委托获取成员账号委托给管理账号的权限。该委托中必须含有sts:tokens:assume权限，用以后续获取被管理委托凭证。如果不包含，则会在新增或者部署实例时报错。  当用户定义SELF_MANAGED权限类型时，administration_agency_name和administration_agency_urn 必须有且只有一个存在。  推荐用户在使用信任委托时给予administration_agency_urn，administration_agency_name只支持接收委托名称，如果给予了信任委托名称，则会在部署模板时失败。  当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400。
	AdministrationAgencyUrn *string `json:"administration_agency_urn,omitempty"`

	ManagedOperation *ManagedOperation `json:"managed_operation,omitempty"`

	// 仅支持资源栈集权限模式为SERVICE_MANAGED时指定该参数。用于指定用户是以组织管理账号还是成员账号中的服务委托管理员身份调用资源栈集。默认为SELF。 当资源栈集权限模式为SELF_MANAGED时，默认为SELF。 * 无论指定何种用户身份，涉及操作的资源栈集始终在组织管理账号名下。*   * `SELF` - 以组织管理账号身份调用。   * `DELEGATED_ADMIN` - 以服务委托管理员身份调用。用户的华为云账号必须在组织中已经被注册为”资源编排资源栈集服务“的委托管理员。
	CallIdentity *CreateStackSetRequestBodyCallIdentity `json:"call_identity,omitempty"`
}

func (CreateStackSetRequestBody) String added in v0.1.61 

func (o CreateStackSetRequestBody) String() string

type CreateStackSetRequestBodyCallIdentity added in v0.1.103 

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

func (CreateStackSetRequestBodyCallIdentity) MarshalJSON added in v0.1.103 

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

func (*CreateStackSetRequestBodyCallIdentity) UnmarshalJSON added in v0.1.103 

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

func (CreateStackSetRequestBodyCallIdentity) Value added in v0.1.103 

func (c CreateStackSetRequestBodyCallIdentity) Value() string

type CreateStackSetRequestBodyCallIdentityEnum added in v0.1.103 

type CreateStackSetRequestBodyCallIdentityEnum struct {
	SELF            CreateStackSetRequestBodyCallIdentity
	DELEGATED_ADMIN CreateStackSetRequestBodyCallIdentity
}

func GetCreateStackSetRequestBodyCallIdentityEnum added in v0.1.103 

func GetCreateStackSetRequestBodyCallIdentityEnum() CreateStackSetRequestBodyCallIdentityEnum

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
	SERVICE_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 DeletePrivateHookRequest added in v0.1.109 

type DeletePrivateHookRequest struct {

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

	// 私有hook的名字。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。  推荐用户使用三段命名空间：{自定义hook名称}-{hook应用场景}-hook。
	HookName string `json:"hook_name"`

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

DeletePrivateHookRequest Request Object

func (DeletePrivateHookRequest) String added in v0.1.109 

func (o DeletePrivateHookRequest) String() string

type DeletePrivateHookResponse added in v0.1.109 

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

DeletePrivateHookResponse Response Object

func (DeletePrivateHookResponse) String added in v0.1.109 

func (o DeletePrivateHookResponse) String() string

type DeletePrivateHookVersionRequest added in v0.1.109 

type DeletePrivateHookVersionRequest struct {

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

	// 私有hook的名字。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。  推荐用户使用三段命名空间：{自定义hook名称}-{hook应用场景}-hook。
	HookName string `json:"hook_name"`

	// 私有hook的版本号。版本号必须遵循语义化版本号（Semantic Version），为用户自定义。
	HookVersion string `json:"hook_version"`

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

DeletePrivateHookVersionRequest Request Object

func (DeletePrivateHookVersionRequest) String added in v0.1.109 

func (o DeletePrivateHookVersionRequest) String() string

type DeletePrivateHookVersionResponse added in v0.1.109 

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

DeletePrivateHookVersionResponse Response Object

func (DeletePrivateHookVersionResponse) String added in v0.1.109 

func (o DeletePrivateHookVersionResponse) 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 DeleteStackInstanceDeprecatedRequest added in v0.1.71 

type DeleteStackInstanceDeprecatedRequest struct {

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

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

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

DeleteStackInstanceDeprecatedRequest Request Object

func (DeleteStackInstanceDeprecatedRequest) String added in v0.1.71 

func (o DeleteStackInstanceDeprecatedRequest) String() string

type DeleteStackInstanceDeprecatedResponse added in v0.1.71 

type DeleteStackInstanceDeprecatedResponse struct {

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

DeleteStackInstanceDeprecatedResponse Response Object

func (DeleteStackInstanceDeprecatedResponse) String added in v0.1.71 

func (o DeleteStackInstanceDeprecatedResponse) 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"`

	OperationPreferences *OperationPreferences `json:"operation_preferences,omitempty"`

	// 仅支持资源栈集权限模式为SERVICE_MANAGED时指定该参数。用于指定用户是以组织管理账号还是成员账号中的服务委托管理员身份调用资源栈集。默认为SELF。 当资源栈集权限模式为SELF_MANAGED时，默认为SELF。 * 无论指定何种用户身份，涉及操作的资源栈集始终在组织管理账号名下。*   * `SELF` - 以组织管理账号身份调用。   * `DELEGATED_ADMIN` - 以服务委托管理员身份调用。用户的华为云账号必须在组织中已经被注册为”资源编排资源栈集服务“的委托管理员。
	CallIdentity *DeleteStackInstanceRequestBodyCallIdentity `json:"call_identity,omitempty"`
}

func (DeleteStackInstanceRequestBody) String added in v0.1.61 

func (o DeleteStackInstanceRequestBody) String() string

type DeleteStackInstanceRequestBodyCallIdentity added in v0.1.103 

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

func (DeleteStackInstanceRequestBodyCallIdentity) MarshalJSON added in v0.1.103 

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

func (*DeleteStackInstanceRequestBodyCallIdentity) UnmarshalJSON added in v0.1.103 

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

func (DeleteStackInstanceRequestBodyCallIdentity) Value added in v0.1.103 

func (c DeleteStackInstanceRequestBodyCallIdentity) Value() string

type DeleteStackInstanceRequestBodyCallIdentityEnum added in v0.1.103 

type DeleteStackInstanceRequestBodyCallIdentityEnum struct {
	SELF            DeleteStackInstanceRequestBodyCallIdentity
	DELEGATED_ADMIN DeleteStackInstanceRequestBodyCallIdentity
}

func GetDeleteStackInstanceRequestBodyCallIdentityEnum added in v0.1.103 

func GetDeleteStackInstanceRequestBodyCallIdentityEnum() DeleteStackInstanceRequestBodyCallIdentityEnum

type DeleteStackInstanceResponse added in v0.1.61 

type DeleteStackInstanceResponse struct {

	// 资源栈集操作（stack_set_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"`

	// 仅支持资源栈集权限模式为SERVICE_MANAGED时指定该参数。用于指定用户是以组织管理账号还是成员账号中的服务委托管理员身份调用资源栈集。默认为SELF。 * 无论指定何种用户身份，创建或部署的资源栈集始终在组织管理账号名下。*   * `SELF` - 以组织管理账号身份调用。   * `DELEGATED_ADMIN` - 以服务委托管理员身份调用。用户的华为云账号必须在组织中已经被注册为”资源编排资源栈集服务“的委托管理员。
	CallIdentity *DeleteStackSetRequestCallIdentity `json:"call_identity,omitempty"`
}

DeleteStackSetRequest Request Object

func (DeleteStackSetRequest) String added in v0.1.61 

func (o DeleteStackSetRequest) String() string

type DeleteStackSetRequestCallIdentity added in v0.1.103 

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

func (DeleteStackSetRequestCallIdentity) MarshalJSON added in v0.1.103 

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

func (*DeleteStackSetRequestCallIdentity) UnmarshalJSON added in v0.1.103 

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

func (DeleteStackSetRequestCallIdentity) Value added in v0.1.103 

func (c DeleteStackSetRequestCallIdentity) Value() string

type DeleteStackSetRequestCallIdentityEnum added in v0.1.103 

type DeleteStackSetRequestCallIdentityEnum struct {
	SELF            DeleteStackSetRequestCallIdentity
	DELEGATED_ADMIN DeleteStackSetRequestCallIdentity
}

func GetDeleteStackSetRequestCallIdentityEnum added in v0.1.103 

func GetDeleteStackSetRequestCallIdentityEnum() DeleteStackSetRequestCallIdentityEnum

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 {
	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 {
	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地址所在局点与使用RFS服务局点一致。  对应的文件应该是纯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地址所在局点与使用RFS服务局点一致。  * 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 接受请求，进行异步处理。可以调用GetStackMetadata来获取异步请求的部署状态  **注意：** * 部署资源栈后，资源编排服务持久化请求并立即返回，客户端不等待请求最终处理完成，用户无法实时感知请求处理结果 * 资源编排服务最终会将异步部署请求排队，在服务端空闲的情况下逐个处理。用户最大等待时长为6小时
	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地址所在局点与使用RFS服务局点一致。  对应的文件应该是纯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地址所在局点与使用RFS服务局点一致。  * 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"`

	OperationPreferences *OperationPreferences `json:"operation_preferences,omitempty"`

	// 仅支持资源栈集权限模式为SERVICE_MANAGED时指定该参数。用于指定用户是以组织管理账号还是成员账号中的服务委托管理员身份调用资源栈集。默认为SELF。 当资源栈集权限模式为SELF_MANAGED时，默认为SELF。 * 无论指定何种用户身份，涉及操作的资源栈集始终在组织管理账号名下。*   * `SELF` - 以组织管理账号身份调用。   * `DELEGATED_ADMIN` - 以服务委托管理员身份调用。用户的华为云账号必须在组织中已经被注册为”资源编排资源栈集服务“的委托管理员。
	CallIdentity *DeployStackSetRequestBodyCallIdentity `json:"call_identity,omitempty"`
}

func (DeployStackSetRequestBody) String added in v0.1.61 

func (o DeployStackSetRequestBody) String() string

type DeployStackSetRequestBodyCallIdentity added in v0.1.103 

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

func (DeployStackSetRequestBodyCallIdentity) MarshalJSON added in v0.1.103 

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

func (*DeployStackSetRequestBodyCallIdentity) UnmarshalJSON added in v0.1.103 

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

func (DeployStackSetRequestBodyCallIdentity) Value added in v0.1.103 

func (c DeployStackSetRequestBodyCallIdentity) Value() string

type DeployStackSetRequestBodyCallIdentityEnum added in v0.1.103 

type DeployStackSetRequestBodyCallIdentityEnum struct {
	SELF            DeployStackSetRequestBodyCallIdentity
	DELEGATED_ADMIN DeployStackSetRequestBodyCallIdentity
}

func GetDeployStackSetRequestBodyCallIdentityEnum added in v0.1.103 

func GetDeployStackSetRequestBodyCallIdentityEnum() DeployStackSetRequestBodyCallIdentityEnum

type DeployStackSetResponse added in v0.1.61 

type DeployStackSetResponse struct {

	// 资源栈集操作（stack_set_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。  接受请求，进行异步处理。可以调用GetStackMetadata来获取异步请求的部署状态  **注意：** * 部署资源栈后，资源编排服务持久化请求并立即返回，客户端不等待请求最终处理完成，用户无法实时感知请求处理结果 * 资源编排服务最终会将异步部署请求排队，在服务端空闲的情况下逐个处理。用户最大等待时长为6小时
	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，则会报错。*  当资源栈集权限模型是SERVICE_MANAGED时，该参数需结合domain_id_filter_type使用。用于指定资源栈集操作涉及到的，从所提供的OU中指定或排除部署的租户ID信息，或除提供的OU外，还进行额外部署的租户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，则会报错。*  当资源栈集权限模型是SERVICE_MANAGED时，该参数需结合domain_id_filter_type使用。链接文件内容用于指定资源栈集操作涉及到的，从所提供的OU中指定或排除部署的租户ID信息，或除提供的OU外，还进行额外部署的租户ID信息。  domain_ids和domain_ids_uri有且仅有一个存在。
	DomainIdsUri *string `json:"domain_ids_uri,omitempty"`

	// 组织单元（Organizational Unit，缩写OU）ID列表，仅在资源栈集权限模型是SERVICE_MANAGED时，才允许指定该参数。  用户指定的Organization组织部署的ID列表，可以是根组织（Root）ID，也可以是某些组织单元的ID。  创建资源栈实例 （CreateStackInstances）API 必须指定该参数，该API 会异步校验OU IDs 的合法性，校验有效的OU IDs 及其所有非空子OU ID 都会被资源栈集记录管理。该API允许指定没有或者已经被资源栈集管理的OU IDs。   * 若资源栈集不自动部署，空子OU不会被资源栈集记录管理（特指子OU下无成员账号或部署排除其下所有成员账号）。*   * 【暂不支持】若资源栈集开启自动部署，空子OU也会被资源栈集记录管理（特指子OU下无成员账号或部署排除其下所有成员账号），自动部署仅针对成员账号变动，不针对其他组织结构变化，例如新增OU等，新增OU不会自动被资源栈集管理。*  部署或删除资源栈实例（DeployStackSet、UpdateStackInstances、DeleteStackInstances） API，只允许指定已经被资源栈集管理的OU IDs。若指定了没有被资源栈集记录管理的OU IDs，则会报错。  删除资源栈实例 （DeleteStackInstances）API 必须指定该参数。  用户可以通过获取资源栈集元数据（ShowStackSetMetadata）API ，获取通过创建资源栈实例（CreateStackInstances）API 请求指定过的OU IDs。  资源栈集不仅会部署到目标 OU 中的用户，同时还会部署所有子 OU 下的用户。指定该参数后，资源栈集会根据用户输入的 OU 列表下所有的用户信息（包含子 OU 下的用户）和region列表，以笛卡尔积的形式，选择资源栈实例进行创建或部署。  *资源栈集不会选择组织管理员作为部署目标，进行资源栈实例的创建或部署，即使组织管理员位于给与的组织或组织的 OU 中。*
	OrganizationalUnitIds *[]string `json:"organizational_unit_ids,omitempty"`

	// 租户ID筛选类型，仅支持资源栈集权限模型是SERVICE_MANAGED时指定该参数。默认为NONE  用户可以指定不同的筛选类型，通过domain_ids或domain_ids_uri 指定或排除部署的用户信息，以增加或限制部署目标用户范围，实现不同的部署策略。     * `INTERSECTION` - 从所提供的 OUs 中选择指定用户进行部署。指定该类型时，domain_ids和domain_ids_uri 有且仅能有一个存在。    * `DIFFERENCE` - 从所提供的 OUs 中排除指定用户部署。指定该类型时，domain_ids和domain_ids_uri 有且仅能有一个存在。    * `UNION` - 除了部署到提供的 OUs 外，还将部署到指定的账号中。用户可以通过同时指定organizational_unit_ids 和 domain_ids/domain_ids_uri 以实现在同一请求中部署整个OU和来自不同OU的特定个人账号。指定该类型时，domain_ids和domain_ids_uri 有且仅能有一个存在。创建资源栈实例（CreateStackInstances）除外，该API 不允许指定使用该类型。    * `NONE` - 只部署在指定 OUs 中的所有账号。该类型下domain_ids和domain_ids_uri字段必须为空。
	DomainIdFilterType *DeploymentTargetsDomainIdFilterType `json:"domain_id_filter_type,omitempty"`
}

DeploymentTargets 部署目标信息。

func (DeploymentTargets) String added in v0.1.63 

func (o DeploymentTargets) String() string

type DeploymentTargetsDomainIdFilterType added in v0.1.103 

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

func (DeploymentTargetsDomainIdFilterType) MarshalJSON added in v0.1.103 

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

func (*DeploymentTargetsDomainIdFilterType) UnmarshalJSON added in v0.1.103 

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

func (DeploymentTargetsDomainIdFilterType) Value added in v0.1.103 

func (c DeploymentTargetsDomainIdFilterType) Value() string

type DeploymentTargetsDomainIdFilterTypeEnum added in v0.1.103 

type DeploymentTargetsDomainIdFilterTypeEnum struct {
	INTERSECTION DeploymentTargetsDomainIdFilterType
	DIFFERENCE   DeploymentTargetsDomainIdFilterType
	UNION        DeploymentTargetsDomainIdFilterType
	NONE         DeploymentTargetsDomainIdFilterType
}

func GetDeploymentTargetsDomainIdFilterTypeEnum added in v0.1.103 

func GetDeploymentTargetsDomainIdFilterTypeEnum() DeploymentTargetsDomainIdFilterTypeEnum

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 DomainIdFilterTypePrimitiveTypeHolder added in v0.1.103 

type DomainIdFilterTypePrimitiveTypeHolder struct {

	// 租户ID筛选类型，仅支持资源栈集权限模型是SERVICE_MANAGED时指定该参数。默认为NONE  用户可以指定不同的筛选类型，通过domain_ids或domain_ids_uri 指定或排除部署的用户信息，以增加或限制部署目标用户范围，实现不同的部署策略。     * `INTERSECTION` - 从所提供的 OUs 中选择指定用户进行部署。指定该类型时，domain_ids和domain_ids_uri 有且仅能有一个存在。    * `DIFFERENCE` - 从所提供的 OUs 中排除指定用户部署。指定该类型时，domain_ids和domain_ids_uri 有且仅能有一个存在。    * `UNION` - 除了部署到提供的 OUs 外，还将部署到指定的账号中。用户可以通过同时指定organizational_unit_ids 和 domain_ids/domain_ids_uri 以实现在同一请求中部署整个OU和来自不同OU的特定个人账号。指定该类型时，domain_ids和domain_ids_uri 有且仅能有一个存在。创建资源栈实例（CreateStackInstances）除外，该API 不允许指定使用该类型。    * `NONE` - 只部署在指定 OUs 中的所有账号。该类型下domain_ids和domain_ids_uri字段必须为空。
	DomainIdFilterType *DomainIdFilterTypePrimitiveTypeHolderDomainIdFilterType `json:"domain_id_filter_type,omitempty"`
}

func (DomainIdFilterTypePrimitiveTypeHolder) String added in v0.1.103 

func (o DomainIdFilterTypePrimitiveTypeHolder) String() string

type DomainIdFilterTypePrimitiveTypeHolderDomainIdFilterType added in v0.1.103 

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

func (DomainIdFilterTypePrimitiveTypeHolderDomainIdFilterType) MarshalJSON added in v0.1.103 

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

func (*DomainIdFilterTypePrimitiveTypeHolderDomainIdFilterType) UnmarshalJSON added in v0.1.103 

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

func (DomainIdFilterTypePrimitiveTypeHolderDomainIdFilterType) Value added in v0.1.103 

func (c DomainIdFilterTypePrimitiveTypeHolderDomainIdFilterType) Value() string

type DomainIdFilterTypePrimitiveTypeHolderDomainIdFilterTypeEnum added in v0.1.103 

type DomainIdFilterTypePrimitiveTypeHolderDomainIdFilterTypeEnum struct {
	INTERSECTION DomainIdFilterTypePrimitiveTypeHolderDomainIdFilterType
	DIFFERENCE   DomainIdFilterTypePrimitiveTypeHolderDomainIdFilterType
	UNION        DomainIdFilterTypePrimitiveTypeHolderDomainIdFilterType
	NONE         DomainIdFilterTypePrimitiveTypeHolderDomainIdFilterType
}

func GetDomainIdFilterTypePrimitiveTypeHolderDomainIdFilterTypeEnum added in v0.1.103 

func GetDomainIdFilterTypePrimitiveTypeHolderDomainIdFilterTypeEnum() DomainIdFilterTypePrimitiveTypeHolderDomainIdFilterTypeEnum

type DomainIdsPrimitiveTypeHolder added in v0.1.103 

type DomainIdsPrimitiveTypeHolder struct {

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

func (DomainIdsPrimitiveTypeHolder) String added in v0.1.103 

func (o DomainIdsPrimitiveTypeHolder) String() string

type DomainIdsUriPrimitiveTypeHolder added in v0.1.103 

type DomainIdsUriPrimitiveTypeHolder struct {

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

func (DomainIdsUriPrimitiveTypeHolder) String added in v0.1.103 

func (o DomainIdsUriPrimitiveTypeHolder) 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` - 元，中国站返回的币种](tag:hws)[`USD` - 美元，国际站返回的币种](tag:hws_hk)[`USD` - 美元，欧洲站返回的币种](tag:hws_eu)
	Currency *string `json:"currency,omitempty"`

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

EstimateExecutionPlanPriceResponse Response Object

func (EstimateExecutionPlanPriceResponse) String 

func (o EstimateExecutionPlanPriceResponse) String() string

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  **注意：** * 创建执行计划后，资源编排服务持久化请求并立即返回，客户端不等待请求最终处理完成，用户无法实时感知请求处理结果 * 资源编排服务最终会将异步部署请求排队，在服务端空闲的情况下逐个处理。用户最大等待时长为1小时
	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  **注意：** * 创建执行计划后，资源编排服务持久化请求并立即返回，客户端不等待请求最终处理完成，用户无法实时感知请求处理结果 * 资源编排服务最终会将异步部署请求排队，在服务端空闲的情况下逐个处理。用户最大等待时长为1小时
	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"`

	// 当前资源的变更是否是导入的。
	Imported *bool `json:"imported,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"`

	// 导入资源数
	ResourceImport *int32 `json:"resource_import,omitempty"`
}

func (ExecutionPlanSummary) String added in v0.1.15 

func (o ExecutionPlanSummary) String() string

type FunctionGraphUrnPrimitiveTypeHolder added in v0.1.80 

type FunctionGraphUrnPrimitiveTypeHolder struct {

	// FunctionGraph方法的统一资源标识，用于唯一标识的FunctionGraph方法。当前只支持和RFS同region的function_graph_urn，如果给予了关于其他region的，会报错400。  关于该参数的详细解释，请参考官方文档：https://support.huaweicloud.com/api-functiongraph/functiongraph_06_0102.html
	FunctionGraphUrn *string `json:"function_graph_urn,omitempty"`
}

func (FunctionGraphUrnPrimitiveTypeHolder) String added in v0.1.80 

func (o FunctionGraphUrnPrimitiveTypeHolder) String() string

type FunctionGraphUrnRequiredPrimitiveTypeHolder added in v0.1.80 

type FunctionGraphUrnRequiredPrimitiveTypeHolder struct {

	// FunctionGraph方法的统一资源标识，用于标识唯一的FunctionGraph方法。当前只支持和RFS同region的function_graph_urn，如果给予了关于其他region的，会报错400。  关于该参数的详细解释，请参考官方文档：https://support.huaweicloud.com/api-functiongraph/functiongraph_06_0102.html
	FunctionGraphUrn string `json:"function_graph_urn"`
}

func (FunctionGraphUrnRequiredPrimitiveTypeHolder) String added in v0.1.80 

func (o FunctionGraphUrnRequiredPrimitiveTypeHolder) 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  **注意：** * 创建执行计划后，资源编排服务持久化请求并立即返回，客户端不等待请求最终处理完成，用户无法实时感知请求处理结果 * 资源编排服务最终会将异步部署请求排队，在服务端空闲的情况下逐个处理。用户最大等待时长为1小时
	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)](tag:hws) [[创建委托及授权方式](https://support.huaweicloud.com/intl/zh-cn/usermanual-iam/iam_06_0002.html)](tag:hws_hk) [[创建委托及授权方式](https://support.huaweicloud.com/eu/usermanual-iam/iam_06_0002.html)](tag:hws_eu)
	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"`

	// 允许访问资源栈模板的source ip列表，source ip应是具有CIDR表示法且带有子网掩码的IPv4地址。
	AccessControlSourceIps *[]string `json:"access_control_source_ips,omitempty"`

	// 允许访问资源栈模板的source vpc id列表， source vpc id应仅包含小写字母、数字或中划线。
	AccessControlSourceVpcIds *[]string `json:"access_control_source_vpc_ids,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"`

	// 该资源的模块地址
	ModuleAddress *string `json:"module_address,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)](tag:hws)[[KMS加密使用场景介绍](https://support.huaweicloud.com/intl/zh-cn/productdesc-dew/dew_01_0006.html)](tag:hws_hk)[[KMS加密使用场景介绍](https://support.huaweicloud.com/eu/productdesc-dew/dew_01_0006.html)](tag:hws_eu) **注意：** * 请确保用户给予资源编排服务的委托中包含对指定密钥ID的操作权限 * KMS每个月有免费试用的额度，如果超过，则KMS需要收费，此费用不是资源编排服务收取，具体标准见：[[https://www.huaweicloud.com/pricing.html?tab=detail#/dew](https://www.huaweicloud.com/pricing.html?tab=detail#/dew)](tag:hws)[[https://www.huaweicloud.com/intl/zh-cn/pricing/index.html#/kms](https://www.huaweicloud.com/intl/zh-cn/pricing/index.html#/kms)](tag:hws_hk)[[https://www.huaweicloud.com/eu/pricing/index.html#/dew](https://www.huaweicloud.com/eu/pricing/index.html#/dew)](tag:hws_eu) * 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 ListPrivateHooksRequest added in v0.1.123 

type ListPrivateHooksRequest struct {

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

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

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

ListPrivateHooksRequest Request Object

func (ListPrivateHooksRequest) String added in v0.1.123 

func (o ListPrivateHooksRequest) String() string

type ListPrivateHooksRequestSortDir added in v0.1.123 

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

func (ListPrivateHooksRequestSortDir) MarshalJSON added in v0.1.123 

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

func (*ListPrivateHooksRequestSortDir) UnmarshalJSON added in v0.1.123 

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

func (ListPrivateHooksRequestSortDir) Value added in v0.1.123 

func (c ListPrivateHooksRequestSortDir) Value() string

type ListPrivateHooksRequestSortDirEnum added in v0.1.123 

type ListPrivateHooksRequestSortDirEnum struct {
	ASC  ListPrivateHooksRequestSortDir
	DESC ListPrivateHooksRequestSortDir
}

func GetListPrivateHooksRequestSortDirEnum added in v0.1.123 

func GetListPrivateHooksRequestSortDirEnum() ListPrivateHooksRequestSortDirEnum

type ListPrivateHooksRequestSortKey added in v0.1.123 

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

func (ListPrivateHooksRequestSortKey) MarshalJSON added in v0.1.123 

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

func (*ListPrivateHooksRequestSortKey) UnmarshalJSON added in v0.1.123 

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

func (ListPrivateHooksRequestSortKey) Value added in v0.1.123 

func (c ListPrivateHooksRequestSortKey) Value() string

type ListPrivateHooksRequestSortKeyEnum added in v0.1.123 

type ListPrivateHooksRequestSortKeyEnum struct {
	CREATE_TIME ListPrivateHooksRequestSortKey
}

func GetListPrivateHooksRequestSortKeyEnum added in v0.1.123 

func GetListPrivateHooksRequestSortKeyEnum() ListPrivateHooksRequestSortKeyEnum

type ListPrivateHooksResponse added in v0.1.123 

type ListPrivateHooksResponse struct {

	// 私有hook的列表。默认以创建时间降序排序。
	Hooks          *[]PrivateHookSummary `json:"hooks,omitempty"`
	HttpStatusCode int                   `json:"-"`
}

ListPrivateHooksResponse Response Object

func (ListPrivateHooksResponse) String added in v0.1.123 

func (o ListPrivateHooksResponse) 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"`

	// 仅支持资源栈集权限模式为SERVICE_MANAGED时指定该参数。用于指定用户是以组织管理账号还是成员账号中的服务委托管理员身份调用资源栈集。默认为SELF。 * 无论指定何种用户身份，创建或部署的资源栈集始终在组织管理账号名下。*   * `SELF` - 以组织管理账号身份调用。   * `DELEGATED_ADMIN` - 以服务委托管理员身份调用。用户的华为云账号必须在组织中已经被注册为”资源编排资源栈集服务“的委托管理员。
	CallIdentity *ListStackInstancesRequestCallIdentity `json:"call_identity,omitempty"`
}

ListStackInstancesRequest Request Object

func (ListStackInstancesRequest) String added in v0.1.61 

func (o ListStackInstancesRequest) String() string

type ListStackInstancesRequestCallIdentity added in v0.1.103 

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

func (ListStackInstancesRequestCallIdentity) MarshalJSON added in v0.1.103 

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

func (*ListStackInstancesRequestCallIdentity) UnmarshalJSON added in v0.1.103 

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

func (ListStackInstancesRequestCallIdentity) Value added in v0.1.103 

func (c ListStackInstancesRequestCallIdentity) Value() string

type ListStackInstancesRequestCallIdentityEnum added in v0.1.103 

type ListStackInstancesRequestCallIdentityEnum struct {
	SELF            ListStackInstancesRequestCallIdentity
	DELEGATED_ADMIN ListStackInstancesRequestCallIdentity
}

func GetListStackInstancesRequestCallIdentityEnum added in v0.1.103 

func GetListStackInstancesRequestCallIdentityEnum() ListStackInstancesRequestCallIdentityEnum

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

	// 仅支持资源栈集权限模式为SERVICE_MANAGED时指定该参数。用于指定用户是以组织管理账号还是成员账号中的服务委托管理员身份调用资源栈集。默认为SELF。 * 无论指定何种用户身份，创建或部署的资源栈集始终在组织管理账号名下。*   * `SELF` - 以组织管理账号身份调用。   * `DELEGATED_ADMIN` - 以服务委托管理员身份调用。用户的华为云账号必须在组织中已经被注册为”资源编排资源栈集服务“的委托管理员。
	CallIdentity *ListStackSetOperationsRequestCallIdentity `json:"call_identity,omitempty"`
}

ListStackSetOperationsRequest Request Object

func (ListStackSetOperationsRequest) String added in v0.1.61 

func (o ListStackSetOperationsRequest) String() string

type ListStackSetOperationsRequestCallIdentity added in v0.1.103 

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

func (ListStackSetOperationsRequestCallIdentity) MarshalJSON added in v0.1.103 

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

func (*ListStackSetOperationsRequestCallIdentity) UnmarshalJSON added in v0.1.103 

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

func (ListStackSetOperationsRequestCallIdentity) Value added in v0.1.103 

func (c ListStackSetOperationsRequestCallIdentity) Value() string

type ListStackSetOperationsRequestCallIdentityEnum added in v0.1.103 

type ListStackSetOperationsRequestCallIdentityEnum struct {
	SELF            ListStackSetOperationsRequestCallIdentity
	DELEGATED_ADMIN ListStackSetOperationsRequestCallIdentity
}

func GetListStackSetOperationsRequestCallIdentityEnum added in v0.1.103 

func GetListStackSetOperationsRequestCallIdentityEnum() ListStackSetOperationsRequestCallIdentityEnum

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

	// 仅支持资源栈集权限模式为SERVICE_MANAGED时指定该参数。用于指定用户是以组织管理账号还是成员账号中的服务委托管理员身份调用资源栈集。默认为SELF。 * 无论指定何种用户身份，创建或部署的资源栈集始终在组织管理账号名下。*   * `SELF` - 以组织管理账号身份调用。   * `DELEGATED_ADMIN` - 以服务委托管理员身份调用。用户的华为云账号必须在组织中已经被注册为”资源编排资源栈集服务“的委托管理员。
	CallIdentity *ListStackSetsRequestCallIdentity `json:"call_identity,omitempty"`
}

ListStackSetsRequest Request Object

func (ListStackSetsRequest) String added in v0.1.61 

func (o ListStackSetsRequest) String() string

type ListStackSetsRequestCallIdentity added in v0.1.103 

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

func (ListStackSetsRequestCallIdentity) MarshalJSON added in v0.1.103 

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

func (*ListStackSetsRequestCallIdentity) UnmarshalJSON added in v0.1.103 

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

func (ListStackSetsRequestCallIdentity) Value added in v0.1.103 

func (c ListStackSetsRequestCallIdentity) Value() string

type ListStackSetsRequestCallIdentityEnum added in v0.1.103 

type ListStackSetsRequestCallIdentityEnum struct {
	SELF            ListStackSetsRequestCallIdentity
	DELEGATED_ADMIN ListStackSetsRequestCallIdentity
}

func GetListStackSetsRequestCallIdentityEnum added in v0.1.103 

func GetListStackSetsRequestCallIdentityEnum() ListStackSetsRequestCallIdentityEnum

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)](tag:hws) [[创建委托及授权方式](https://support.huaweicloud.com/intl/zh-cn/usermanual-iam/iam_06_0002.html)](tag:hws_hk) [[创建委托及授权方式](https://support.huaweicloud.com/eu/usermanual-iam/iam_06_0002.html)](tag:hws_eu)
	ManagedAgencyName *string `json:"managed_agency_name,omitempty"`
}

func (ManagedAgencyNamePrimitiveTypeHolder) String added in v0.1.61 

func (o ManagedAgencyNamePrimitiveTypeHolder) String() string

type ManagedOperation added in v0.1.91 

type ManagedOperation struct {

	// 资源栈集（stack_set）是否可以并发地创建多个资源栈集操作。该参数作为资源栈集属性，可以通过创建资源栈集API（CreateStackSet）指定，通过更新资源栈集API（UpdateStackSet）更新该参数。  该参数默认为false，资源栈集只允许以串行的方式生成并执行资源栈集操作。同一时刻，资源栈集中只会存在一个处于运行态，即QUEUE_IN_PROGRESS或OPERATION_IN_PROGRESS状态的资源栈集操作，该操作执行完成后，下一个资源栈集操作才允许被创建。  该参数如果设定为true，资源栈集允许并发地生成多个资源栈集操作，执行非冲突操作，并将冲突操作进行排队处理。当冲突操作执行完毕，资源栈集按请求顺序继续执行排队操作。当前同一资源栈集下最多允许创建10个并发的资源栈集操作。  注：冲突操作指资源栈集允许多个操作同时执行的条件下，如果超过一个以上的操作包含了同一资源栈实例，此时在该资源栈实例上的多个操作被称为冲突操作。  当资源栈集状态为OPERATION_IN_PROGRESS时，不允许用户通过更新资源栈集（UpdateStackSet）来更新该参数。  * 当前，一个资源栈集下仅允许同时最多存在10个处于运行态的资源栈集操作*
	EnableParallelOperation *bool `json:"enable_parallel_operation,omitempty"`
}

ManagedOperation 用于定义管理资源栈集操作的一系列属性。

func (ManagedOperation) String added in v0.1.91 

func (o ManagedOperation) String() string

type ManagedOperationTypeHolder added in v0.1.91 

type ManagedOperationTypeHolder struct {
	ManagedOperation *ManagedOperation `json:"managed_operation,omitempty"`
}

func (ManagedOperationTypeHolder) String added in v0.1.91 

func (o ManagedOperationTypeHolder) 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 OperationPreferences added in v0.1.91 

type OperationPreferences struct {

	// 部署资源栈实例时区域（region）的执行策略，分为两种，SEQUENTIAL和PARALLEL，区分大小写，默认值为SEQUENTIAL  详细介绍：  * `SEQUENTIAL`：顺序执行，执行完一个region下的全部资源栈实例后再去执行另一个region。默认顺序执行。  * `PARALLEL`：并发执行，并发部署所有指定区域的资源栈实例。
	RegionConcurrencyType *OperationPreferencesRegionConcurrencyType `json:"region_concurrency_type,omitempty"`

	// 区域（region）部署顺序。只有当用户指定region_concurrency_type为SEQUENTIAL时才会允许指定该参数。用户指定部署region的顺序，不允许出现资源栈集管理之外的region。  如果不指定，实际部署region顺序随机。部署顺序仅在当次部署时生效，应该包含且仅包含本次部署的所有region。
	RegionOrder *[]string `json:"region_order,omitempty"`

	// 容错次数。用户定义在每个区域（region）下，允许部署失败的资源栈实例数量。该参数取值默认为0，限定0和正整数。  如果定义region顺序执行（region_concurrency_type值为SEQUENTIAL），在某个region超过容错次数时，资源栈集会取消所有状态仍处于WAIT_IN_PROGRESS状态的实例。被取消的实例状态最终变为CANCEL_COMPLETE；  如果是region并行执行（region_concurrency_type值为PARALLEL），在某个region超过容错次数时，资源栈集只会取消该region下所有处于WAIT_IN_PROGRESS状态的实例。被取消的实例状态最终变为CANCEL_COMPLETE。  对处于OPERATION_IN_PROGRESS，或已经部署完成，即处于OPERATION_COMPLETE或者OPERATION_FAILED状态的资源栈实例，不受影响，状态不变。  failure_tolerance_count  和 failure_tolerance_percentage 仅能有一个存在。
	FailureToleranceCount *int64 `json:"failure_tolerance_count,omitempty"`

	// 容错百分比。定义每个区域（region）下，允许部署失败的资源栈实例数占该region下所有资源栈实例数的百分比。该参数取值默认为0，限定0和正整数。  通过容错百分比*资源栈实例数，并向下取整，得到实际容错次数。  failure_tolerance_count  和 failure_tolerance_percentage 仅能有一个存在。
	FailureTolerancePercentage *int64 `json:"failure_tolerance_percentage,omitempty"`

	// 每个区域（region）下可同时部署资源栈实例的最大账号数。该参数取值默认为1，限定为正整数。  最大并发账号数最多比容错次数多1。如果用户指定failure_tolerance_percentage，最大并发账号数最多比 failure_tolerance_percentage * 资源栈实例数多1。保证部署在所需的容错级别停止。  max_concurrent_count 和 max_concurrent_percentage 仅能有一个存在。
	MaxConcurrentCount *int64 `json:"max_concurrent_count,omitempty"`

	// 最大并发账号百分比，每个区域（region）中可同时部署的资源栈实例的最大账号百分比。该参数取值默认为1，限定正整数。  RFS根据百分比 *（每个region下资源栈实例数）得到的值，再向下取整，得到实际最大并发账号数。如果实际最大并发账号数向下取整值为0时，则默认选择最大并发账号数为1。  通过百分比计算得到的实际最大并发账号数最多比容错次数多1。如果用户指定failure_tolerance_percentage，实际最大并发账号数最多比 failure_tolerance_percentage * 资源栈实例数多1。保证部署在所需的容错级别停止。  max_concurrent_count 和 max_concurrent_percentage 仅能有一个存在。
	MaxConcurrentPercentage *int64 `json:"max_concurrent_percentage,omitempty"`

	// 资源栈集操作部署的失败容忍模式，分为两种，STRICT_FAILURE_TOLERANCE和SOFT_FAILURE_TOLERANCE，区分大小写，默认值为STRICT_FAILURE_TOLERANCE。  详细介绍：  * `STRICT_FAILURE_TOLERANCE`：此选项会动态降低并发级别，以确保同region下部署失败的账号数量永远不超过 failure_tolerance_count + 1。当用户指定failure_tolerance_percentage时，确保同region下部署失败的账号数量不超过 failure_tolerance_percentage * 资源栈实例数 + 1。  * 初始实际最大并发数为max_concurrent_count，如果用户指定的是max_concurrent_percentage，则初始实际最大并发数为 max_concurrent_percentage * 资源栈实例数，随后，实际最大并发数会根据失败次数增加而减少。  * `SOFT_FAILURE_TOLERANCE`：此选项将failure_tolerance_count (failure_tolerance_percentage) 与实际并发数分离开。该参数允许资源栈集操作始终以指定的 max_concurrent_count 或 max_concurrent_percentage 操作资源栈实例。  * 此时不保证资源栈实例失败总数小于 failure_tolerance_count + 1，如果用户指定的是failure_tolerance_percentage的值，则不保证资源栈实例失败总数小于 failure_tolerance_percentage * 资源栈实例数 + 1。
	FailureToleranceMode *OperationPreferencesFailureToleranceMode `json:"failure_tolerance_mode,omitempty"`
}

OperationPreferences 资源栈集操作（stack_set_operation）的部署策略。该参数只在指定的单次操作中生效。 当用户不指定该参数时，默认的操作部署策略为区域（region）内资源栈实例串行部署，即每次只执行一个资源栈实例，区域（region）间随机且串行部署，执行完一个region下的全部资源栈实例后，才会选择另一个region部署，容错次数默认为0。 该参数可以在生成资源栈集操作的四个API中指定： 创建资源栈实例（CreateStackInstance），部署资源栈集（DeployStackSet），更新资源栈实例（UpdateStackInstance），删除资源栈实例（DeleteStackInstance）

func (OperationPreferences) String added in v0.1.91 

func (o OperationPreferences) String() string

type OperationPreferencesFailureToleranceMode added in v0.1.91 

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

func (OperationPreferencesFailureToleranceMode) MarshalJSON added in v0.1.91 

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

func (*OperationPreferencesFailureToleranceMode) UnmarshalJSON added in v0.1.91 

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

func (OperationPreferencesFailureToleranceMode) Value added in v0.1.91 

func (c OperationPreferencesFailureToleranceMode) Value() string

type OperationPreferencesFailureToleranceModeEnum added in v0.1.91 

type OperationPreferencesFailureToleranceModeEnum struct {
	STRICT_FAILURE_TOLERANCE OperationPreferencesFailureToleranceMode
	SOFT_FAILURE_TOLERANCE   OperationPreferencesFailureToleranceMode
}

func GetOperationPreferencesFailureToleranceModeEnum added in v0.1.91 

func GetOperationPreferencesFailureToleranceModeEnum() OperationPreferencesFailureToleranceModeEnum

type OperationPreferencesRegionConcurrencyType added in v0.1.91 

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

func (OperationPreferencesRegionConcurrencyType) MarshalJSON added in v0.1.91 

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

func (*OperationPreferencesRegionConcurrencyType) UnmarshalJSON added in v0.1.91 

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

func (OperationPreferencesRegionConcurrencyType) Value added in v0.1.91 

func (c OperationPreferencesRegionConcurrencyType) Value() string

type OperationPreferencesRegionConcurrencyTypeEnum added in v0.1.91 

type OperationPreferencesRegionConcurrencyTypeEnum struct {
	SEQUENTIAL OperationPreferencesRegionConcurrencyType
	PARALLEL   OperationPreferencesRegionConcurrencyType
}

func GetOperationPreferencesRegionConcurrencyTypeEnum added in v0.1.91 

func GetOperationPreferencesRegionConcurrencyTypeEnum() OperationPreferencesRegionConcurrencyTypeEnum

type OperationPreferencesTypeHolder added in v0.1.91 

type OperationPreferencesTypeHolder struct {
	OperationPreferences *OperationPreferences `json:"operation_preferences,omitempty"`
}

func (OperationPreferencesTypeHolder) String added in v0.1.91 

func (o OperationPreferencesTypeHolder) String() string

type OrganizationalUnitIdsPrimitiveTypeHolder added in v0.1.103 

type OrganizationalUnitIdsPrimitiveTypeHolder struct {

	// 组织单元（Organizational Unit，缩写OU）ID列表，仅在资源栈集权限模型是SERVICE_MANAGED时，才允许指定该参数。  用户指定的Organization组织部署的ID列表，可以是根组织（Root）ID，也可以是某些组织单元的ID。  创建资源栈实例 （CreateStackInstances）API 必须指定该参数，该API 会异步校验OU IDs 的合法性，校验有效的OU IDs 及其所有非空子OU ID 都会被资源栈集记录管理。该API允许指定没有或者已经被资源栈集管理的OU IDs。   * 若资源栈集不自动部署，空子OU不会被资源栈集记录管理（特指子OU下无成员账号或部署排除其下所有成员账号）。*   * 【暂不支持】若资源栈集开启自动部署，空子OU也会被资源栈集记录管理（特指子OU下无成员账号或部署排除其下所有成员账号），自动部署仅针对成员账号变动，不针对其他组织结构变化，例如新增OU等，新增OU不会自动被资源栈集管理。*  部署或删除资源栈实例（DeployStackSet、UpdateStackInstances、DeleteStackInstances） API，只允许指定已经被资源栈集管理的OU IDs。若指定了没有被资源栈集记录管理的OU IDs，则会报错。  删除资源栈实例 （DeleteStackInstances）API 必须指定该参数。  用户可以通过获取资源栈集元数据（ShowStackSetMetadata）API ，获取通过创建资源栈实例（CreateStackInstances）API 请求指定过的OU IDs。  资源栈集不仅会部署到目标 OU 中的用户，同时还会部署所有子 OU 下的用户。指定该参数后，资源栈集会根据用户输入的 OU 列表下所有的用户信息（包含子 OU 下的用户）和region列表，以笛卡尔积的形式，选择资源栈实例进行创建或部署。  *资源栈集不会选择组织管理员作为部署目标，进行资源栈实例的创建或部署，即使组织管理员位于给与的组织或组织的 OU 中。*
	OrganizationalUnitIds *[]string `json:"organizational_unit_ids,omitempty"`
}

func (OrganizationalUnitIdsPrimitiveTypeHolder) String added in v0.1.103 

func (o OrganizationalUnitIdsPrimitiveTypeHolder) 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地址所在局点与使用RFS服务局点一致。  对应的文件应该是纯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。用户可以使用创建资源栈集（CreateStackSet）API 指定该参数。该参数暂不支持更新。用户如果想要更新权限模型，可以通过先删除再创建同名资源栈集实现。   * `SELF_MANAGED` - 自我管理，基于部署需求，用户需要提前手动创建委托，既包含管理账号授权给RFS的委托，也包含成员账号授权给管理账号的委托。如果委托不存在或权限不足，创建资源栈集不会失败，创建资源栈实例时才会报错。   * `SERVICE_MANAGED` - 服务管理，基于Organization服务，RFS会自动创建部署Organization 成员账号时所需的全部 IAM 委托。用户需要提前在Organization可信服务列表中将”资源编排资源栈集服务“启用，且只有Organization的管理账号或”资源编排资源栈集服务“的委托管理员，才允许指定SERVICE_MANAGED创建资源栈集，否则会报错。
	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
	SERVICE_MANAGED PermissionModelPrimitiveTypeHolderPermissionModel
}

func GetPermissionModelPrimitiveTypeHolderPermissionModelEnum added in v0.1.61 

func GetPermissionModelPrimitiveTypeHolderPermissionModelEnum() PermissionModelPrimitiveTypeHolderPermissionModelEnum

type PrivateHookCreateTimePrimitiveTypeHolder added in v0.1.109 

type PrivateHookCreateTimePrimitiveTypeHolder struct {

	// 私有Hook（private-hook）的生成时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z。
	CreateTime *string `json:"create_time,omitempty"`
}

func (PrivateHookCreateTimePrimitiveTypeHolder) String added in v0.1.109 

func (o PrivateHookCreateTimePrimitiveTypeHolder) String() string

type PrivateHookDefaultVersionPrimitiveTypeHolder added in v0.1.109 

type PrivateHookDefaultVersionPrimitiveTypeHolder struct {

	// 私有hook的默认版本号。版本号必须遵循语义化版本号（Semantic Version），为用户自定义。
	DefaultVersion *string `json:"default_version,omitempty"`
}

func (PrivateHookDefaultVersionPrimitiveTypeHolder) String added in v0.1.109 

func (o PrivateHookDefaultVersionPrimitiveTypeHolder) String() string

type PrivateHookDescriptionPrimitiveTypeHolder added in v0.1.109 

type PrivateHookDescriptionPrimitiveTypeHolder struct {

	// 私有hook的描述。可用于客户识别创建的私有hook。可通过UpdatePrivateHook API更新私有hook的描述。
	HookDescription *string `json:"hook_description,omitempty"`
}

func (PrivateHookDescriptionPrimitiveTypeHolder) String added in v0.1.109 

func (o PrivateHookDescriptionPrimitiveTypeHolder) String() string

type PrivateHookIdPrimitiveTypeHolder added in v0.1.109 

type PrivateHookIdPrimitiveTypeHolder struct {

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

func (PrivateHookIdPrimitiveTypeHolder) String added in v0.1.109 

func (o PrivateHookIdPrimitiveTypeHolder) String() string

type PrivateHookNamePrimitiveTypeHolder added in v0.1.109 

type PrivateHookNamePrimitiveTypeHolder struct {

	// 私有hook的名字。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。  推荐用户使用三段命名空间：{自定义hook名称}-{hook应用场景}-hook。
	HookName string `json:"hook_name"`
}

func (PrivateHookNamePrimitiveTypeHolder) String added in v0.1.109 

func (o PrivateHookNamePrimitiveTypeHolder) String() string

type PrivateHookSummary added in v0.1.109 

type PrivateHookSummary struct {

	// 私有hook的名字。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。  推荐用户使用三段命名空间：{自定义hook名称}-{hook应用场景}-hook。
	HookName string `json:"hook_name"`

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

	// 私有hook的描述。可用于客户识别创建的私有hook。可通过UpdatePrivateHook API更新私有hook的描述。
	HookDescription *string `json:"hook_description,omitempty"`

	// 私有hook的默认版本号。版本号必须遵循语义化版本号（Semantic Version），为用户自定义。
	DefaultVersion *string `json:"default_version,omitempty"`

	Configuration *ConfigurationPrimitiveTypeHolderConfiguration `json:"configuration,omitempty"`

	// 私有Hook（private-hook）的生成时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z。
	CreateTime *string `json:"create_time,omitempty"`

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

func (PrivateHookSummary) String added in v0.1.109 

func (o PrivateHookSummary) String() string

type PrivateHookUpdateTimePrimitiveTypeHolder added in v0.1.109 

type PrivateHookUpdateTimePrimitiveTypeHolder struct {

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

func (PrivateHookUpdateTimePrimitiveTypeHolder) String added in v0.1.109 

func (o PrivateHookUpdateTimePrimitiveTypeHolder) String() string

type PrivateHookVersionCreateTimePrimitiveTypeHolder added in v0.1.109 

type PrivateHookVersionCreateTimePrimitiveTypeHolder struct {

	// 私有Hook Version（private-hook-version）的生成时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z。
	CreateTime *string `json:"create_time,omitempty"`
}

func (PrivateHookVersionCreateTimePrimitiveTypeHolder) String added in v0.1.109 

func (o PrivateHookVersionCreateTimePrimitiveTypeHolder) String() string

type PrivateHookVersionDescriptionPrimitiveTypeHolder added in v0.1.109 

type PrivateHookVersionDescriptionPrimitiveTypeHolder struct {

	// 私有hook版本的描述。可用于客户识别创建私有hook的版本。注意：hook版本为不可更新（immutable），所以该字段不可更新，如果需要更新，请删除后重建。
	HookVersionDescription *string `json:"hook_version_description,omitempty"`
}

func (PrivateHookVersionDescriptionPrimitiveTypeHolder) String added in v0.1.109 

func (o PrivateHookVersionDescriptionPrimitiveTypeHolder) String() string

type PrivateHookVersionPrimitiveTypeHolder added in v0.1.109 

type PrivateHookVersionPrimitiveTypeHolder struct {

	// 私有hook的版本号。版本号必须遵循语义化版本号（Semantic Version），为用户自定义。
	HookVersion string `json:"hook_version"`
}

func (PrivateHookVersionPrimitiveTypeHolder) String added in v0.1.109 

func (o PrivateHookVersionPrimitiveTypeHolder) String() string

type PrivateHookVersionSummary added in v0.1.109 

type PrivateHookVersionSummary struct {

	// 私有hook的名字。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。  推荐用户使用三段命名空间：{自定义hook名称}-{hook应用场景}-hook。
	HookName string `json:"hook_name"`

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

	// 私有hook的版本号。版本号必须遵循语义化版本号（Semantic Version），为用户自定义。
	HookVersion string `json:"hook_version"`

	// 私有hook版本的描述。可用于客户识别创建私有hook的版本。注意：hook版本为不可更新（immutable），所以该字段不可更新，如果需要更新，请删除后重建。
	HookVersionDescription *string `json:"hook_version_description,omitempty"`

	// 私有Hook Version（private-hook-version）的生成时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z。
	CreateTime *string `json:"create_time,omitempty"`
}

func (PrivateHookVersionSummary) String added in v0.1.109 

func (o PrivateHookVersionSummary) String() string

type PrivatePolicyBodyPrimitiveTypeHolder added in v0.1.109 

type PrivatePolicyBodyPrimitiveTypeHolder struct {

	// 策略内容。仅支持OPA开源引擎识别的，以Rego（https://www.openpolicyagent.org/docs/latest/policy-language/）语言编写的策略模板。  policy_body和policy_uri 必须有且只有一个存在
	PolicyBody *string `json:"policy_body,omitempty"`
}

func (PrivatePolicyBodyPrimitiveTypeHolder) String added in v0.1.109 

func (o PrivatePolicyBodyPrimitiveTypeHolder) String() string

type PrivatePolicyUriPrimitiveTypeHolder added in v0.1.109 

type PrivatePolicyUriPrimitiveTypeHolder struct {

	// 策略文件的OBS地址。内容仅支持OPA开源引擎识别的，以Rego（https://www.openpolicyagent.org/docs/latest/policy-language/）语言编写的策略模板。  请确保OBS地址所在局点与使用RFS服务局点一致。  策略文件当前支持单文件或zip压缩包，单文件需要以\".rego\"结尾，压缩包当前只支持zip格式，文件需要以`.zip`结尾。  关于策略文件的校验要求如下：   * 文件必须是UTF8编码   * 创建时会对大小、格式、语法等进行校验   * 策略文件必须是UTF-8编码   * 单文件或压缩包解压前后的大小应控制在1MB以内   * 压缩包内的文件数量不能超过100个   * 压缩包内的文件路径最长为2048   * 压缩包内的文件名最长为255个字节  policy_uri和policy_body必须有且只有一个存在
	PolicyUri *string `json:"policy_uri,omitempty"`
}

func (PrivatePolicyUriPrimitiveTypeHolder) String added in v0.1.109 

func (o PrivatePolicyUriPrimitiveTypeHolder) String() string

type PrivateProviderDescriptionPrimitiveTypeHolder added in v0.1.80 

type PrivateProviderDescriptionPrimitiveTypeHolder struct {

	// 私有provider（private-provider）的描述。可用于客户识别被管理的私有provider。
	ProviderDescription *string `json:"provider_description,omitempty"`
}

func (PrivateProviderDescriptionPrimitiveTypeHolder) String added in v0.1.80 

func (o PrivateProviderDescriptionPrimitiveTypeHolder) String() string

type PrivateProviderIdPrimitiveTypeHolder added in v0.1.80 

type PrivateProviderIdPrimitiveTypeHolder struct {

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

func (PrivateProviderIdPrimitiveTypeHolder) String added in v0.1.80 

func (o PrivateProviderIdPrimitiveTypeHolder) String() string

type PrivateProviderNamePrimitiveTypeHolder added in v0.1.80 

type PrivateProviderNamePrimitiveTypeHolder struct {

	// 私有provider（private-provider）的名称。此名字在domain_id+region下应唯一，可以使用小写英文、数字、中划线。仅支持以小写英文、数字开头结尾。  按照HCL最佳实践，该名称推荐为在模板中定义的provider的本地名称（local_name）。  创建私有Provider（CreatePrivateProvider）API 还会以 “huawei.com/private-provider”为固定前缀，并以“huawei.com/private-provider/{provider_name}”的形式返回provider_source字段。关于provider_name和provider_source字段在模板中的使用细节，详见创建私有Provider的API描述。
	ProviderName string `json:"provider_name"`
}

func (PrivateProviderNamePrimitiveTypeHolder) String added in v0.1.80 

func (o PrivateProviderNamePrimitiveTypeHolder) String() string

type PrivateProviderSourcePrimitiveTypeHolder added in v0.1.80 

type PrivateProviderSourcePrimitiveTypeHolder struct {

	// 用户使用私有provider，在Terraform模板中定义required_providers信息时，需要指明的source参数。  该参数按照“huawei.com/private-provider/{provider_name}”的形式拼接。关于provider_name和provider_source字段在模板中的使用细节，详见创建私有Provider的API描述。
	ProviderSource *string `json:"provider_source,omitempty"`
}

func (PrivateProviderSourcePrimitiveTypeHolder) String added in v0.1.80 

func (o PrivateProviderSourcePrimitiveTypeHolder) String() string

type PrivateProviderVersionDescriptionPrimitiveTypeHolder added in v0.1.80 

type PrivateProviderVersionDescriptionPrimitiveTypeHolder struct {

	// 私有provider版本（provider version）的描述。可用于客户识别并管理私有provider的版本。注意：provider版本为不可更新（immutable），所以该字段不可更新，如果需要更新，请删除后重建
	VersionDescription *string `json:"version_description,omitempty"`
}

func (PrivateProviderVersionDescriptionPrimitiveTypeHolder) String added in v0.1.80 

func (o PrivateProviderVersionDescriptionPrimitiveTypeHolder) String() string

type PrivateProviderVersionPrimitiveTypeHolder added in v0.1.80 

type PrivateProviderVersionPrimitiveTypeHolder struct {

	// provider的版本号。版本号必须遵循语义化版本号（Semantic Version），为用户自定义
	ProviderVersion *string `json:"provider_version,omitempty"`
}

func (PrivateProviderVersionPrimitiveTypeHolder) String added in v0.1.80 

func (o PrivateProviderVersionPrimitiveTypeHolder) String() string

type PrivateProviderVersionRequiredPrimitiveTypeHolder added in v0.1.80 

type PrivateProviderVersionRequiredPrimitiveTypeHolder struct {

	// provider的版本号。版本号必须遵循语义化版本号（Semantic Version），为用户自定义
	ProviderVersion string `json:"provider_version"`
}

func (PrivateProviderVersionRequiredPrimitiveTypeHolder) String added in v0.1.80 

func (o PrivateProviderVersionRequiredPrimitiveTypeHolder) String() string

type RegionsPrimitiveTypeHolder added in v0.1.103 

type RegionsPrimitiveTypeHolder struct {

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

func (RegionsPrimitiveTypeHolder) String added in v0.1.103 

func (o RegionsPrimitiveTypeHolder) String() string

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

	// 该资源的最优折扣类型  对于按需计费资源的折扣类型 合同商务优惠类型：605 （华为云商务-折扣率，一口价，华为云用户）、606 （渠道商务-折扣率，一口价，BP用户） 伙伴折扣优惠类型：607 (合作伙伴授予折扣-折扣率)  对于包周期计费资源的折扣类型 合同商务折扣：605（华为云BE场景下的合同商务折扣）、606（分销商BE场景下的合同商务折扣） 伙伴授予折扣：607 促销折扣：700  如果该资源存在折扣，则返回该字段；如果该资源不存在折扣，则不返回该字段。
	BestDiscountType *int32 `json:"best_discount_type,omitempty"`

	// 最优折扣优惠额，保留小数点后2位，向上取整，默认单位是元。  如果该资源存在折扣，则返回该字段；如果该资源不存在折扣，则不返回该字段。
	BestDiscountPrice *float64 `json:"best_discount_price,omitempty"`

	// 官网价优惠额，保留小数点后2位，向上取整，默认单位是元。  如果该资源存在官网价优惠额，则返回该字段；如果该资源不存在官网价优惠额，则不返回该字段。
	OfficialWebsiteDiscountPrice *float64 `json:"official_website_discount_price,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 ShowPrivateHookMetadataRequest added in v0.1.109 

type ShowPrivateHookMetadataRequest struct {

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

	// 私有hook的名字。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。  推荐用户使用三段命名空间：{自定义hook名称}-{hook应用场景}-hook。
	HookName string `json:"hook_name"`

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

ShowPrivateHookMetadataRequest Request Object

func (ShowPrivateHookMetadataRequest) String added in v0.1.109 

func (o ShowPrivateHookMetadataRequest) String() string

type ShowPrivateHookMetadataResponse added in v0.1.109 

type ShowPrivateHookMetadataResponse struct {

	// 私有hook的名字。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。  推荐用户使用三段命名空间：{自定义hook名称}-{hook应用场景}-hook。
	HookName string `json:"hook_name"`

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

	// 私有hook的描述。可用于客户识别创建的私有hook。可通过UpdatePrivateHook API更新私有hook的描述。
	HookDescription *string `json:"hook_description,omitempty"`

	// 私有hook的默认版本号。版本号必须遵循语义化版本号（Semantic Version），为用户自定义。
	DefaultVersion *string `json:"default_version,omitempty"`

	Configuration *ConfigurationPrimitiveTypeHolderConfiguration `json:"configuration,omitempty"`

	// 私有Hook（private-hook）的生成时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z。
	CreateTime *string `json:"create_time,omitempty"`

	// 私有Hook（private-hook）的更新时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z。
	UpdateTime     *string `json:"update_time,omitempty"`
	HttpStatusCode int     `json:"-"`
}

ShowPrivateHookMetadataResponse Response Object

func (ShowPrivateHookMetadataResponse) String added in v0.1.109 

func (o ShowPrivateHookMetadataResponse) String() string

type ShowPrivateHookVersionMetadataRequest added in v0.1.109 

type ShowPrivateHookVersionMetadataRequest struct {

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

	// 私有hook的名字。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。  推荐用户使用三段命名空间：{自定义hook名称}-{hook应用场景}-hook。
	HookName string `json:"hook_name"`

	// 私有hook的版本号。版本号必须遵循语义化版本号（Semantic Version），为用户自定义。
	HookVersion string `json:"hook_version"`

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

ShowPrivateHookVersionMetadataRequest Request Object

func (ShowPrivateHookVersionMetadataRequest) String added in v0.1.109 

func (o ShowPrivateHookVersionMetadataRequest) String() string

type ShowPrivateHookVersionMetadataResponse added in v0.1.109 

type ShowPrivateHookVersionMetadataResponse struct {

	// 私有hook的名字。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。  推荐用户使用三段命名空间：{自定义hook名称}-{hook应用场景}-hook。
	HookName string `json:"hook_name"`

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

	// 私有hook的版本号。版本号必须遵循语义化版本号（Semantic Version），为用户自定义。
	HookVersion string `json:"hook_version"`

	// 私有hook版本的描述。可用于客户识别创建私有hook的版本。注意：hook版本为不可更新（immutable），所以该字段不可更新，如果需要更新，请删除后重建。
	HookVersionDescription *string `json:"hook_version_description,omitempty"`

	// 私有Hook Version（private-hook-version）的生成时间，格式为YYYY-MM-DDTHH:mm:ss.SSSZ，精确到毫秒，UTC时区，即，如1970-01-01T00:00:00.000Z。
	CreateTime     *string `json:"create_time,omitempty"`
	HttpStatusCode int     `json:"-"`
}

ShowPrivateHookVersionMetadataResponse Response Object

func (ShowPrivateHookVersionMetadataResponse) String added in v0.1.109 

func (o ShowPrivateHookVersionMetadataResponse) String() string

type ShowPrivateHookVersionPolicyRequest added in v0.1.123 

type ShowPrivateHookVersionPolicyRequest struct {

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

	// 私有hook的名字。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。  推荐用户使用三段命名空间：{自定义hook名称}-{hook应用场景}-hook。
	HookName string `json:"hook_name"`

	// 私有hook的版本号。版本号必须遵循语义化版本号（Semantic Version），为用户自定义。
	HookVersion string `json:"hook_version"`

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

ShowPrivateHookVersionPolicyRequest Request Object

func (ShowPrivateHookVersionPolicyRequest) String added in v0.1.123 

func (o ShowPrivateHookVersionPolicyRequest) String() string

type ShowPrivateHookVersionPolicyResponse added in v0.1.123 

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

ShowPrivateHookVersionPolicyResponse Response Object

func (ShowPrivateHookVersionPolicyResponse) String added in v0.1.123 

func (o ShowPrivateHookVersionPolicyResponse) 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"`

	// 仅支持资源栈集权限模式为SERVICE_MANAGED时指定该参数。用于指定用户是以组织管理账号还是成员账号中的服务委托管理员身份调用资源栈集。默认为SELF。 * 无论指定何种用户身份，创建或部署的资源栈集始终在组织管理账号名下。*   * `SELF` - 以组织管理账号身份调用。   * `DELEGATED_ADMIN` - 以服务委托管理员身份调用。用户的华为云账号必须在组织中已经被注册为”资源编排资源栈集服务“的委托管理员。
	CallIdentity *ShowStackInstanceRequestCallIdentity `json:"call_identity,omitempty"`
}

ShowStackInstanceRequest Request Object

func (ShowStackInstanceRequest) String added in v0.1.63 

func (o ShowStackInstanceRequest) String() string

type ShowStackInstanceRequestCallIdentity added in v0.1.103 

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

func (ShowStackInstanceRequestCallIdentity) MarshalJSON added in v0.1.103 

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

func (*ShowStackInstanceRequestCallIdentity) UnmarshalJSON added in v0.1.103 

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

func (ShowStackInstanceRequestCallIdentity) Value added in v0.1.103 

func (c ShowStackInstanceRequestCallIdentity) Value() string

type ShowStackInstanceRequestCallIdentityEnum added in v0.1.103 

type ShowStackInstanceRequestCallIdentityEnum struct {
	SELF            ShowStackInstanceRequestCallIdentity
	DELEGATED_ADMIN ShowStackInstanceRequestCallIdentity
}

func GetShowStackInstanceRequestCallIdentityEnum added in v0.1.103 

func GetShowStackInstanceRequestCallIdentityEnum() ShowStackInstanceRequestCallIdentityEnum

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,omitempty"`

	// 资源栈实例所关联的资源栈所在的租户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"`

	// 仅支持资源栈集权限模式为SERVICE_MANAGED时指定该参数。用于指定用户是以组织管理账号还是成员账号中的服务委托管理员身份调用资源栈集。默认为SELF。 * 无论指定何种用户身份，创建或部署的资源栈集始终在组织管理账号名下。*   * `SELF` - 以组织管理账号身份调用。   * `DELEGATED_ADMIN` - 以服务委托管理员身份调用。用户的华为云账号必须在组织中已经被注册为”资源编排资源栈集服务“的委托管理员。
	CallIdentity *ShowStackSetMetadataRequestCallIdentity `json:"call_identity,omitempty"`
}

ShowStackSetMetadataRequest Request Object

func (ShowStackSetMetadataRequest) String added in v0.1.61 

func (o ShowStackSetMetadataRequest) String() string

type ShowStackSetMetadataRequestCallIdentity added in v0.1.103 

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

func (ShowStackSetMetadataRequestCallIdentity) MarshalJSON added in v0.1.103 

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

func (*ShowStackSetMetadataRequestCallIdentity) UnmarshalJSON added in v0.1.103 

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

func (ShowStackSetMetadataRequestCallIdentity) Value added in v0.1.103 

func (c ShowStackSetMetadataRequestCallIdentity) Value() string

type ShowStackSetMetadataRequestCallIdentityEnum added in v0.1.103 

type ShowStackSetMetadataRequestCallIdentityEnum struct {
	SELF            ShowStackSetMetadataRequestCallIdentity
	DELEGATED_ADMIN ShowStackSetMetadataRequestCallIdentity
}

func GetShowStackSetMetadataRequestCallIdentityEnum added in v0.1.103 

func GetShowStackSetMetadataRequestCallIdentityEnum() ShowStackSetMetadataRequestCallIdentityEnum

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。用户可以使用创建资源栈集（CreateStackSet）API 指定该参数。该参数暂不支持更新。用户如果想要更新权限模型，可以通过先删除再创建同名资源栈集实现。   * `SELF_MANAGED` - 自我管理，基于部署需求，用户需要提前手动创建委托，既包含管理账号授权给RFS的委托，也包含成员账号授权给管理账号的委托。如果委托不存在或权限不足，创建资源栈集不会失败，创建资源栈实例时才会报错。   * `SERVICE_MANAGED` - 服务管理，基于Organization服务，RFS会自动创建部署Organization 成员账号时所需的全部 IAM 委托。用户需要提前在Organization可信服务列表中将”资源编排资源栈集服务“启用，且只有Organization的管理账号或”资源编排资源栈集服务“的委托管理员，才允许指定SERVICE_MANAGED创建资源栈集，否则会报错。
	PermissionModel *ShowStackSetMetadataResponsePermissionModel `json:"permission_model,omitempty"`

	// 管理委托名称  资源编排服务使用该委托获取成员账号委托给管理账号的权限。该委托中必须含有iam:tokens:assume权限，用以后续获取被管理委托凭证。如果不包含，则会在新增或者部署实例时报错。  当用户定义SELF_MANAGED权限类型时，administration_agency_name和administration_agency_urn 必须有且只有一个存在。  推荐用户在使用信任委托时给予administration_agency_urn，administration_agency_name只支持接收委托名称，如果给予了信任委托名称，则会在部署模板时失败。  当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400。  [[创建委托及授权方式](https://support.huaweicloud.com/usermanual-iam/iam_06_0002.html)](tag:hws) [[创建委托及授权方式](https://support.huaweicloud.com/intl/zh-cn/usermanual-iam/iam_06_0002.html)](tag:hws_hk) [[创建委托及授权方式](https://support.huaweicloud.com/eu/usermanual-iam/iam_06_0002.html)](tag:hws_eu)
	AdministrationAgencyName *string `json:"administration_agency_name,omitempty"`

	// 被管理的委托名称。  资源编排服务会使用该委托获取实际部署资源所需要的权限  不同成员账号委托给管理账号的委托名称需要保持一致。暂不支持根据不同provider定义不同委托权限  当用户定义SELF_MANAGED权限类型时，必须指定该参数。当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400  [[创建委托及授权方式](https://support.huaweicloud.com/usermanual-iam/iam_06_0002.html)](tag:hws) [[创建委托及授权方式](https://support.huaweicloud.com/intl/zh-cn/usermanual-iam/iam_06_0002.html)](tag:hws_hk) [[创建委托及授权方式](https://support.huaweicloud.com/eu/usermanual-iam/iam_06_0002.html)](tag:hws_eu)
	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  资源编排服务使用该委托获取成员账号委托给管理账号的权限。该委托中必须含有sts:tokens:assume权限，用以后续获取被管理委托凭证。如果不包含，则会在新增或者部署实例时报错。  当用户定义SELF_MANAGED权限类型时，administration_agency_name和administration_agency_urn 必须有且只有一个存在。  推荐用户在使用信任委托时给予administration_agency_urn，administration_agency_name只支持接收委托名称，如果给予了信任委托名称，则会在部署模板时失败。  当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400。
	AdministrationAgencyUrn *string `json:"administration_agency_urn,omitempty"`

	ManagedOperation *ManagedOperation `json:"managed_operation,omitempty"`

	// 组织单元（Organizational Unit，缩写OU）ID列表，仅在资源栈集权限模型是SERVICE_MANAGED时，才允许指定该参数。  用户指定的Organization组织部署的ID列表，可以是根组织（Root）ID，也可以是某些组织单元的ID。  创建资源栈实例 （CreateStackInstances）API 必须指定该参数，该API 会异步校验OU IDs 的合法性，校验有效的OU IDs 及其所有非空子OU ID 都会被资源栈集记录管理。该API允许指定没有或者已经被资源栈集管理的OU IDs。   * 若资源栈集不自动部署，空子OU不会被资源栈集记录管理（特指子OU下无成员账号或部署排除其下所有成员账号）。*   * 【暂不支持】若资源栈集开启自动部署，空子OU也会被资源栈集记录管理（特指子OU下无成员账号或部署排除其下所有成员账号），自动部署仅针对成员账号变动，不针对其他组织结构变化，例如新增OU等，新增OU不会自动被资源栈集管理。*  部署或删除资源栈实例（DeployStackSet、UpdateStackInstances、DeleteStackInstances） API，只允许指定已经被资源栈集管理的OU IDs。若指定了没有被资源栈集记录管理的OU IDs，则会报错。  删除资源栈实例 （DeleteStackInstances）API 必须指定该参数。  用户可以通过获取资源栈集元数据（ShowStackSetMetadata）API ，获取通过创建资源栈实例（CreateStackInstances）API 请求指定过的OU IDs。  资源栈集不仅会部署到目标 OU 中的用户，同时还会部署所有子 OU 下的用户。指定该参数后，资源栈集会根据用户输入的 OU 列表下所有的用户信息（包含子 OU 下的用户）和region列表，以笛卡尔积的形式，选择资源栈实例进行创建或部署。  *资源栈集不会选择组织管理员作为部署目标，进行资源栈实例的创建或部署，即使组织管理员位于给与的组织或组织的 OU 中。*
	OrganizationalUnitIds *[]string `json:"organizational_unit_ids,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
	SERVICE_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"`

	// 仅支持资源栈集权限模式为SERVICE_MANAGED时指定该参数。用于指定用户是以组织管理账号还是成员账号中的服务委托管理员身份调用资源栈集。默认为SELF。 * 无论指定何种用户身份，创建或部署的资源栈集始终在组织管理账号名下。*   * `SELF` - 以组织管理账号身份调用。   * `DELEGATED_ADMIN` - 以服务委托管理员身份调用。用户的华为云账号必须在组织中已经被注册为”资源编排资源栈集服务“的委托管理员。
	CallIdentity *ShowStackSetOperationMetadataRequestCallIdentity `json:"call_identity,omitempty"`
}

ShowStackSetOperationMetadataRequest Request Object

func (ShowStackSetOperationMetadataRequest) String added in v0.1.61 

func (o ShowStackSetOperationMetadataRequest) String() string

type ShowStackSetOperationMetadataRequestCallIdentity added in v0.1.103 

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

func (ShowStackSetOperationMetadataRequestCallIdentity) MarshalJSON added in v0.1.103 

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

func (*ShowStackSetOperationMetadataRequestCallIdentity) UnmarshalJSON added in v0.1.103 

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

func (ShowStackSetOperationMetadataRequestCallIdentity) Value added in v0.1.103 

func (c ShowStackSetOperationMetadataRequestCallIdentity) Value() string

type ShowStackSetOperationMetadataRequestCallIdentityEnum added in v0.1.103 

type ShowStackSetOperationMetadataRequestCallIdentityEnum struct {
	SELF            ShowStackSetOperationMetadataRequestCallIdentity
	DELEGATED_ADMIN ShowStackSetOperationMetadataRequestCallIdentity
}

func GetShowStackSetOperationMetadataRequestCallIdentityEnum added in v0.1.103 

func GetShowStackSetOperationMetadataRequestCallIdentityEnum() ShowStackSetOperationMetadataRequestCallIdentityEnum

type ShowStackSetOperationMetadataResponse added in v0.1.61 

type ShowStackSetOperationMetadataResponse struct {

	// 资源栈集操作（stack_set_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` - 部署资源栈实例   * `UPDATE_STACK_INSTANCES` - 更新资源栈实例
	Action *ShowStackSetOperationMetadataResponseAction `json:"action,omitempty"`

	// 管理委托名称  资源编排服务使用该委托获取成员账号委托给管理账号的权限。该委托中必须含有iam:tokens:assume权限，用以后续获取被管理委托凭证。如果不包含，则会在新增或者部署实例时报错。  当用户定义SELF_MANAGED权限类型时，administration_agency_name和administration_agency_urn 必须有且只有一个存在。  推荐用户在使用信任委托时给予administration_agency_urn，administration_agency_name只支持接收委托名称，如果给予了信任委托名称，则会在部署模板时失败。  当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400。  [[创建委托及授权方式](https://support.huaweicloud.com/usermanual-iam/iam_06_0002.html)](tag:hws) [[创建委托及授权方式](https://support.huaweicloud.com/intl/zh-cn/usermanual-iam/iam_06_0002.html)](tag:hws_hk) [[创建委托及授权方式](https://support.huaweicloud.com/eu/usermanual-iam/iam_06_0002.html)](tag:hws_eu)
	AdministrationAgencyName *string `json:"administration_agency_name,omitempty"`

	// 管理委托URN  资源编排服务使用该委托获取成员账号委托给管理账号的权限。该委托中必须含有sts:tokens:assume权限，用以后续获取被管理委托凭证。如果不包含，则会在新增或者部署实例时报错。  当用户定义SELF_MANAGED权限类型时，administration_agency_name和administration_agency_urn 必须有且只有一个存在。  推荐用户在使用信任委托时给予administration_agency_urn，administration_agency_name只支持接收委托名称，如果给予了信任委托名称，则会在部署模板时失败。  当用户使用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)](tag:hws) [[创建委托及授权方式](https://support.huaweicloud.com/intl/zh-cn/usermanual-iam/iam_06_0002.html)](tag:hws_hk) [[创建委托及授权方式](https://support.huaweicloud.com/eu/usermanual-iam/iam_06_0002.html)](tag:hws_eu)
	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"`

	OperationPreferences *OperationPreferences `json:"operation_preferences,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
	UPDATE_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"`

	// 允许访问资源栈集模板的source ip列表，source ip应是具有CIDR表示法且带有子网掩码的IPv4地址。
	AccessControlSourceIps *[]string `json:"access_control_source_ips,omitempty"`

	// 允许访问资源栈集模板的source vpc id列表， source vpc id应仅包含小写字母、数字或中划线。
	AccessControlSourceVpcIds *[]string `json:"access_control_source_vpc_ids,omitempty"`

	// 仅支持资源栈集权限模式为SERVICE_MANAGED时指定该参数。用于指定用户是以组织管理账号还是成员账号中的服务委托管理员身份调用资源栈集。默认为SELF。 * 无论指定何种用户身份，创建或部署的资源栈集始终在组织管理账号名下。*   * `SELF` - 以组织管理账号身份调用。   * `DELEGATED_ADMIN` - 以服务委托管理员身份调用。用户的华为云账号必须在组织中已经被注册为”资源编排资源栈集服务“的委托管理员。
	CallIdentity *ShowStackSetTemplateRequestCallIdentity `json:"call_identity,omitempty"`
}

ShowStackSetTemplateRequest Request Object

func (ShowStackSetTemplateRequest) String added in v0.1.61 

func (o ShowStackSetTemplateRequest) String() string

type ShowStackSetTemplateRequestCallIdentity added in v0.1.103 

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

func (ShowStackSetTemplateRequestCallIdentity) MarshalJSON added in v0.1.103 

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

func (*ShowStackSetTemplateRequestCallIdentity) UnmarshalJSON added in v0.1.103 

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

func (ShowStackSetTemplateRequestCallIdentity) Value added in v0.1.103 

func (c ShowStackSetTemplateRequestCallIdentity) Value() string

type ShowStackSetTemplateRequestCallIdentityEnum added in v0.1.103 

type ShowStackSetTemplateRequestCallIdentityEnum struct {
	SELF            ShowStackSetTemplateRequestCallIdentity
	DELEGATED_ADMIN ShowStackSetTemplateRequestCallIdentity
}

func GetShowStackSetTemplateRequestCallIdentityEnum added in v0.1.103 

func GetShowStackSetTemplateRequestCallIdentityEnum() ShowStackSetTemplateRequestCallIdentityEnum

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

	// 允许访问资源栈模板的source vpc id列表， source vpc id应仅包含小写字母、数字或中划线。
	AccessControlSourceVpcIds *[]string `json:"access_control_source_vpc_ids,omitempty"`

	// 允许访问资源栈模板的source ip列表，source ip应是具有CIDR表示法且带有子网掩码的IPv4地址。
	AccessControlSourceIps *[]string `json:"access_control_source_ips,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,omitempty"`

	// 资源栈实例所关联的资源栈所在的租户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。用户可以使用创建资源栈集（CreateStackSet）API 指定该参数。该参数暂不支持更新。用户如果想要更新权限模型，可以通过先删除再创建同名资源栈集实现。   * `SELF_MANAGED` - 自我管理，基于部署需求，用户需要提前手动创建委托，既包含管理账号授权给RFS的委托，也包含成员账号授权给管理账号的委托。如果委托不存在或权限不足，创建资源栈集不会失败，创建资源栈实例时才会报错。   * `SERVICE_MANAGED` - 服务管理，基于Organization服务，RFS会自动创建部署Organization 成员账号时所需的全部 IAM 委托。用户需要提前在Organization可信服务列表中将”资源编排资源栈集服务“启用，且只有Organization的管理账号或”资源编排资源栈集服务“的委托管理员，才允许指定SERVICE_MANAGED创建资源栈集，否则会报错。
	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` - 部署资源栈实例   * `UPDATE_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
	UPDATE_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` - 部署资源栈实例   * `UPDATE_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
	UPDATE_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 {

	// 资源栈集操作（stack_set_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
	SERVICE_MANAGED StackSetPermissionModel
}

func GetStackSetPermissionModelEnum added in v0.1.61 

func GetStackSetPermissionModelEnum() StackSetPermissionModelEnum

type StackSetStackNamePrimitiveTypeHolder added in v0.1.71 

type StackSetStackNamePrimitiveTypeHolder struct {

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

func (StackSetStackNamePrimitiveTypeHolder) String added in v0.1.71 

func (o StackSetStackNamePrimitiveTypeHolder) String() string

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地址所在局点与使用RFS服务局点一致。  对应的文件应该是纯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 UpdatePrivateHookMetadataRequest added in v0.1.109 

type UpdatePrivateHookMetadataRequest struct {

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

	// 私有hook的名字。此名字在domain_id+region下应唯一，可以使用中文、大小写英文、数字、下划线、中划线。首字符需为中文或者英文，区分大小写。  推荐用户使用三段命名空间：{自定义hook名称}-{hook应用场景}-hook。
	HookName string `json:"hook_name"`

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

UpdatePrivateHookMetadataRequest Request Object

func (UpdatePrivateHookMetadataRequest) String added in v0.1.109 

func (o UpdatePrivateHookMetadataRequest) String() string

type UpdatePrivateHookMetadataRequestBody added in v0.1.109 

type UpdatePrivateHookMetadataRequestBody struct {

	// 私有hook的描述。可用于客户识别创建的私有hook。可通过UpdatePrivateHook API更新私有hook的描述。
	HookDescription *string `json:"hook_description,omitempty"`

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

	// 私有hook的默认版本号。版本号必须遵循语义化版本号（Semantic Version），为用户自定义。
	DefaultVersion *string `json:"default_version,omitempty"`

	Configuration *ConfigurationPrimitiveTypeHolderConfiguration `json:"configuration,omitempty"`
}

func (UpdatePrivateHookMetadataRequestBody) String added in v0.1.109 

func (o UpdatePrivateHookMetadataRequestBody) String() string

type UpdatePrivateHookMetadataResponse added in v0.1.109 

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

UpdatePrivateHookMetadataResponse Response Object

func (UpdatePrivateHookMetadataResponse) String added in v0.1.109 

func (o UpdatePrivateHookMetadataResponse) 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"`

	OperationPreferences *OperationPreferences `json:"operation_preferences,omitempty"`

	// 仅支持资源栈集权限模式为SERVICE_MANAGED时指定该参数。用于指定用户是以组织管理账号还是成员账号中的服务委托管理员身份调用资源栈集。默认为SELF。 当资源栈集权限模式为SELF_MANAGED时，默认为SELF。 * 无论指定何种用户身份，涉及操作的资源栈集始终在组织管理账号名下。*   * `SELF` - 以组织管理账号身份调用。   * `DELEGATED_ADMIN` - 以服务委托管理员身份调用。用户的华为云账号必须在组织中已经被注册为”资源编排资源栈集服务“的委托管理员。
	CallIdentity *UpdateStackInstancesRequestBodyCallIdentity `json:"call_identity,omitempty"`
}

func (UpdateStackInstancesRequestBody) String added in v0.1.63 

func (o UpdateStackInstancesRequestBody) String() string

type UpdateStackInstancesRequestBodyCallIdentity added in v0.1.103 

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

func (UpdateStackInstancesRequestBodyCallIdentity) MarshalJSON added in v0.1.103 

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

func (*UpdateStackInstancesRequestBodyCallIdentity) UnmarshalJSON added in v0.1.103 

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

func (UpdateStackInstancesRequestBodyCallIdentity) Value added in v0.1.103 

func (c UpdateStackInstancesRequestBodyCallIdentity) Value() string

type UpdateStackInstancesRequestBodyCallIdentityEnum added in v0.1.103 

type UpdateStackInstancesRequestBodyCallIdentityEnum struct {
	SELF            UpdateStackInstancesRequestBodyCallIdentity
	DELEGATED_ADMIN UpdateStackInstancesRequestBodyCallIdentity
}

func GetUpdateStackInstancesRequestBodyCallIdentityEnum added in v0.1.103 

func GetUpdateStackInstancesRequestBodyCallIdentityEnum() UpdateStackInstancesRequestBodyCallIdentityEnum

type UpdateStackInstancesResponse added in v0.1.63 

type UpdateStackInstancesResponse struct {

	// 资源栈集操作（stack_set_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)](tag:hws) [[创建委托及授权方式](https://support.huaweicloud.com/intl/zh-cn/usermanual-iam/iam_06_0002.html)](tag:hws_hk) [[创建委托及授权方式](https://support.huaweicloud.com/eu/usermanual-iam/iam_06_0002.html)](tag:hws_eu)
	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"`

	// 管理委托名称  资源编排服务使用该委托获取成员账号委托给管理账号的权限。该委托中必须含有iam:tokens:assume权限，用以后续获取被管理委托凭证。如果不包含，则会在新增或者部署实例时报错。  当用户定义SELF_MANAGED权限类型时，administration_agency_name和administration_agency_urn 必须有且只有一个存在。  推荐用户在使用信任委托时给予administration_agency_urn，administration_agency_name只支持接收委托名称，如果给予了信任委托名称，则会在部署模板时失败。  当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400。  [[创建委托及授权方式](https://support.huaweicloud.com/usermanual-iam/iam_06_0002.html)](tag:hws) [[创建委托及授权方式](https://support.huaweicloud.com/intl/zh-cn/usermanual-iam/iam_06_0002.html)](tag:hws_hk) [[创建委托及授权方式](https://support.huaweicloud.com/eu/usermanual-iam/iam_06_0002.html)](tag:hws_eu)
	AdministrationAgencyName *string `json:"administration_agency_name,omitempty"`

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

	// 管理委托URN  资源编排服务使用该委托获取成员账号委托给管理账号的权限。该委托中必须含有sts:tokens:assume权限，用以后续获取被管理委托凭证。如果不包含，则会在新增或者部署实例时报错。  当用户定义SELF_MANAGED权限类型时，administration_agency_name和administration_agency_urn 必须有且只有一个存在。  推荐用户在使用信任委托时给予administration_agency_urn，administration_agency_name只支持接收委托名称，如果给予了信任委托名称，则会在部署模板时失败。  当用户使用SERVICE_MANAGED权限类型时，指定该参数将报错400。
	AdministrationAgencyUrn *string `json:"administration_agency_urn,omitempty"`

	ManagedOperation *ManagedOperation `json:"managed_operation,omitempty"`

	// 仅支持资源栈集权限模式为SERVICE_MANAGED时指定该参数。用于指定用户是以组织管理账号还是成员账号中的服务委托管理员身份调用资源栈集。默认为SELF。 当资源栈集权限模式为SELF_MANAGED时，默认为SELF。 * 无论指定何种用户身份，涉及操作的资源栈集始终在组织管理账号名下。*   * `SELF` - 以组织管理账号身份调用。   * `DELEGATED_ADMIN` - 以服务委托管理员身份调用。用户的华为云账号必须在组织中已经被注册为”资源编排资源栈集服务“的委托管理员。
	CallIdentity *UpdateStackSetRequestBodyCallIdentity `json:"call_identity,omitempty"`
}

func (UpdateStackSetRequestBody) String added in v0.1.61 

func (o UpdateStackSetRequestBody) String() string

type UpdateStackSetRequestBodyCallIdentity added in v0.1.103 

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

func (UpdateStackSetRequestBodyCallIdentity) MarshalJSON added in v0.1.103 

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

func (*UpdateStackSetRequestBodyCallIdentity) UnmarshalJSON added in v0.1.103 

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

func (UpdateStackSetRequestBodyCallIdentity) Value added in v0.1.103 

func (c UpdateStackSetRequestBodyCallIdentity) Value() string

type UpdateStackSetRequestBodyCallIdentityEnum added in v0.1.103 

type UpdateStackSetRequestBodyCallIdentityEnum struct {
	SELF            UpdateStackSetRequestBodyCallIdentity
	DELEGATED_ADMIN UpdateStackSetRequestBodyCallIdentity
}

func GetUpdateStackSetRequestBodyCallIdentityEnum added in v0.1.103 

func GetUpdateStackSetRequestBodyCallIdentityEnum() UpdateStackSetRequestBodyCallIdentityEnum

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 {
	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地址所在局点与使用RFS服务局点一致。  * 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地址所在局点与使用RFS服务局点一致。  * 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.