model

package
v0.0.32-rc.1 Latest Latest
Warning

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

 Go to latest Published: Feb 4, 2021 License: Apache-2.0, BSD-2-Clause, BSD-3-Clause Imports: 5 Imported by: 1

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ApiBackendVpcReq 

type ApiBackendVpcReq struct {
	// 代理主机
	VpcChannelProxyHost *string `json:"vpc_channel_proxy_host,omitempty"`
	// VPC通道编号
	VpcChannelId string `json:"vpc_channel_id"`
}

VPC通道详情。vpc_channel_status = 1，则这个object类型为必填信息

func (ApiBackendVpcReq) String 

func (o ApiBackendVpcReq) String() string

type ApiBaseInfo 

type ApiBaseInfo struct {
	// API名称长度。  为3 ~ 64位的字符串，字符串由中文、英文字母、数字、下划线组成，且只能以英文或中文开头。 > 中文字符必须为UTF-8或者unicode编码。
	Name string `json:"name"`
	// API类型 - 1：公有API - 2：私有API
	Type ApiBaseInfoType `json:"type"`
	// API的版本
	Version *string `json:"version,omitempty"`
	// API的请求协议 - HTTP - HTTPS - BOTH：同时支持HTTP和HTTPS
	ReqProtocol ApiBaseInfoReqProtocol `json:"req_protocol"`
	// API的请求方式
	ReqMethod ApiBaseInfoReqMethod `json:"req_method"`
	// 请求地址。可以包含请求参数，用{}标识，比如/getUserInfo/{userId}，支持 * % - _ . 等特殊字符，总长度不超过512，且满足URI规范。  支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、中划线、下划线组成，且只能以英文开头。 > 需要服从URI规范。
	ReqUri string `json:"req_uri"`
	// API的认证方式 - NONE：无认证 - APP：APP认证 - IAM：IAM认证 - AUTHORIZER：自定义认证
	AuthType ApiBaseInfoAuthType `json:"auth_type"`
	AuthOpt  *AuthOpt            `json:"auth_opt,omitempty"`
	// 是否支持跨域 - TRUE：支持 - FALSE：不支持
	Cors *bool `json:"cors,omitempty"`
	// API的匹配方式 - SWA：前缀匹配 - NORMAL：正常匹配（绝对匹配） 默认：NORMAL
	MatchMode *ApiBaseInfoMatchMode `json:"match_mode,omitempty"`
	// 后端类型 - HTTP：web后端 - FUNCTION：函数工作流 - MOCK：模拟的后端
	BackendType ApiBaseInfoBackendType `json:"backend_type"`
	// API描述。字符长度不超过255 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// API所属的分组编号
	GroupId string `json:"group_id"`
	// API请求体描述，可以是请求体示例、媒体类型、参数等信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	BodyRemark *string `json:"body_remark,omitempty"`
	// 正常响应示例，描述API的正常返回信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	ResultNormalSample *string `json:"result_normal_sample,omitempty"`
	// 失败返回示例，描述API的异常返回信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	ResultFailureSample *string `json:"result_failure_sample,omitempty"`
	// 前端自定义认证对象的ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
	// 标签。  支持英文，数字，下划线，且只能以英文开头。支持输入多个标签，不同标签以英文逗号分割。
	Tags *[]string `json:"tags,omitempty"`
	// 分组自定义响应ID
	ResponseId *string `json:"response_id,omitempty"`
	// 集成应用ID  暂不支持
	RomaAppId *string `json:"roma_app_id,omitempty"`
	// API绑定的自定义域名  暂不支持
	DomainName *string `json:"domain_name,omitempty"`
	// 标签  待废弃，优先使用tags字段
	Tag *string `json:"tag,omitempty"`
}

func (ApiBaseInfo) String 

func (o ApiBaseInfo) String() string

type ApiBaseInfoAuthType 

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

func (ApiBaseInfoAuthType) MarshalJSON 

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

func (*ApiBaseInfoAuthType) UnmarshalJSON 

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

type ApiBaseInfoAuthTypeEnum 

type ApiBaseInfoAuthTypeEnum struct {
	NONE       ApiBaseInfoAuthType
	APP        ApiBaseInfoAuthType
	IAM        ApiBaseInfoAuthType
	AUTHORIZER ApiBaseInfoAuthType
}

func GetApiBaseInfoAuthTypeEnum 

func GetApiBaseInfoAuthTypeEnum() ApiBaseInfoAuthTypeEnum

type ApiBaseInfoBackendType 

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

func (ApiBaseInfoBackendType) MarshalJSON 

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

func (*ApiBaseInfoBackendType) UnmarshalJSON 

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

type ApiBaseInfoBackendTypeEnum 

type ApiBaseInfoBackendTypeEnum struct {
	HTTP     ApiBaseInfoBackendType
	FUNCTION ApiBaseInfoBackendType
	MOCK     ApiBaseInfoBackendType
}

func GetApiBaseInfoBackendTypeEnum 

func GetApiBaseInfoBackendTypeEnum() ApiBaseInfoBackendTypeEnum

type ApiBaseInfoMatchMode 

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

func (ApiBaseInfoMatchMode) MarshalJSON 

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

func (*ApiBaseInfoMatchMode) UnmarshalJSON 

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

type ApiBaseInfoMatchModeEnum 

type ApiBaseInfoMatchModeEnum struct {
	SWA    ApiBaseInfoMatchMode
	NORMAL ApiBaseInfoMatchMode
}

func GetApiBaseInfoMatchModeEnum 

func GetApiBaseInfoMatchModeEnum() ApiBaseInfoMatchModeEnum

type ApiBaseInfoReqMethod 

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

func (ApiBaseInfoReqMethod) MarshalJSON 

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

func (*ApiBaseInfoReqMethod) UnmarshalJSON 

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

type ApiBaseInfoReqMethodEnum 

type ApiBaseInfoReqMethodEnum struct {
	GET     ApiBaseInfoReqMethod
	POST    ApiBaseInfoReqMethod
	PUT     ApiBaseInfoReqMethod
	DELETE  ApiBaseInfoReqMethod
	HEAD    ApiBaseInfoReqMethod
	PATCH   ApiBaseInfoReqMethod
	OPTIONS ApiBaseInfoReqMethod
	ANY     ApiBaseInfoReqMethod
}

func GetApiBaseInfoReqMethodEnum 

func GetApiBaseInfoReqMethodEnum() ApiBaseInfoReqMethodEnum

type ApiBaseInfoReqProtocol 

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

func (ApiBaseInfoReqProtocol) MarshalJSON 

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

func (*ApiBaseInfoReqProtocol) UnmarshalJSON 

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

type ApiBaseInfoReqProtocolEnum 

type ApiBaseInfoReqProtocolEnum struct {
	HTTP  ApiBaseInfoReqProtocol
	HTTPS ApiBaseInfoReqProtocol
	BOTH  ApiBaseInfoReqProtocol
}

func GetApiBaseInfoReqProtocolEnum 

func GetApiBaseInfoReqProtocolEnum() ApiBaseInfoReqProtocolEnum

type ApiBaseInfoType 

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

func (ApiBaseInfoType) MarshalJSON 

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

func (*ApiBaseInfoType) UnmarshalJSON 

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

type ApiBaseInfoTypeEnum 

type ApiBaseInfoTypeEnum struct {
	E_1 ApiBaseInfoType
	E_2 ApiBaseInfoType
}

func GetApiBaseInfoTypeEnum 

func GetApiBaseInfoTypeEnum() ApiBaseInfoTypeEnum

type ApiCommon 

type ApiCommon struct {
	// API名称长度。  为3 ~ 64位的字符串，字符串由中文、英文字母、数字、下划线组成，且只能以英文或中文开头。 > 中文字符必须为UTF-8或者unicode编码。
	Name string `json:"name"`
	// API类型 - 1：公有API - 2：私有API
	Type ApiCommonType `json:"type"`
	// API的版本
	Version *string `json:"version,omitempty"`
	// API的请求协议 - HTTP - HTTPS - BOTH：同时支持HTTP和HTTPS
	ReqProtocol ApiCommonReqProtocol `json:"req_protocol"`
	// API的请求方式
	ReqMethod ApiCommonReqMethod `json:"req_method"`
	// 请求地址。可以包含请求参数，用{}标识，比如/getUserInfo/{userId}，支持 * % - _ . 等特殊字符，总长度不超过512，且满足URI规范。  支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、中划线、下划线组成，且只能以英文开头。 > 需要服从URI规范。
	ReqUri string `json:"req_uri"`
	// API的认证方式 - NONE：无认证 - APP：APP认证 - IAM：IAM认证 - AUTHORIZER：自定义认证
	AuthType ApiCommonAuthType `json:"auth_type"`
	AuthOpt  *AuthOpt          `json:"auth_opt,omitempty"`
	// 是否支持跨域 - TRUE：支持 - FALSE：不支持
	Cors *bool `json:"cors,omitempty"`
	// API的匹配方式 - SWA：前缀匹配 - NORMAL：正常匹配（绝对匹配） 默认：NORMAL
	MatchMode *ApiCommonMatchMode `json:"match_mode,omitempty"`
	// 后端类型 - HTTP：web后端 - FUNCTION：函数工作流 - MOCK：模拟的后端
	BackendType ApiCommonBackendType `json:"backend_type"`
	// API描述。字符长度不超过255 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// API所属的分组编号
	GroupId string `json:"group_id"`
	// API请求体描述，可以是请求体示例、媒体类型、参数等信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	BodyRemark *string `json:"body_remark,omitempty"`
	// 正常响应示例，描述API的正常返回信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	ResultNormalSample *string `json:"result_normal_sample,omitempty"`
	// 失败返回示例，描述API的异常返回信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	ResultFailureSample *string `json:"result_failure_sample,omitempty"`
	// 前端自定义认证对象的ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
	// 标签。  支持英文，数字，下划线，且只能以英文开头。支持输入多个标签，不同标签以英文逗号分割。
	Tags *[]string `json:"tags,omitempty"`
	// 分组自定义响应ID
	ResponseId *string `json:"response_id,omitempty"`
	// 集成应用ID  暂不支持
	RomaAppId *string `json:"roma_app_id,omitempty"`
	// API绑定的自定义域名  暂不支持
	DomainName *string `json:"domain_name,omitempty"`
	// 标签  待废弃，优先使用tags字段
	Tag *string `json:"tag,omitempty"`
	// API编号
	Id *string `json:"id,omitempty"`
	// API的状态
	Status *int32 `json:"status,omitempty"`
	// 是否需要编排
	ArrangeNecessary *int32 `json:"arrange_necessary,omitempty"`
	// API注册时间
	RegisterTime *sdktime.SdkTime `json:"register_time,omitempty"`
	// API修改时间
	UpdateTime *sdktime.SdkTime `json:"update_time,omitempty"`
	// API所属分组的名称
	GroupName *string `json:"group_name,omitempty"`
	// API所属分组的版本  默认V1，其他版本暂不支持
	GroupVersion *string `json:"group_version,omitempty"`
	// 发布的环境id
	RunEnvId *string `json:"run_env_id,omitempty"`
	// 发布的环境名称
	RunEnvName *string `json:"run_env_name,omitempty"`
	// 发布记录编号  存在多个发布记录时，编号之间用|隔开
	PublishId *string  `json:"publish_id,omitempty"`
	FuncInfo  *ApiFunc `json:"func_info,omitempty"`
	MockInfo  *ApiMock `json:"mock_info,omitempty"`
	// API的请求参数列表
	ReqParams *[]ReqParam `json:"req_params,omitempty"`
	// API的后端参数列表
	BackendParams *[]BackendParam `json:"backend_params,omitempty"`
	// 函数工作流策略后端列表
	PolicyFunctions *[]ApiPolicyFunctionResp `json:"policy_functions,omitempty"`
	// mock策略后端列表
	PolicyMocks *[]ApiPolicyMockResp `json:"policy_mocks,omitempty"`
}

func (ApiCommon) String 

func (o ApiCommon) String() string

type ApiCommonAuthType 

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

func (ApiCommonAuthType) MarshalJSON 

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

func (*ApiCommonAuthType) UnmarshalJSON 

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

type ApiCommonAuthTypeEnum 

type ApiCommonAuthTypeEnum struct {
	NONE       ApiCommonAuthType
	APP        ApiCommonAuthType
	IAM        ApiCommonAuthType
	AUTHORIZER ApiCommonAuthType
}

func GetApiCommonAuthTypeEnum 

func GetApiCommonAuthTypeEnum() ApiCommonAuthTypeEnum

type ApiCommonBackendType 

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

func (ApiCommonBackendType) MarshalJSON 

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

func (*ApiCommonBackendType) UnmarshalJSON 

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

type ApiCommonBackendTypeEnum 

type ApiCommonBackendTypeEnum struct {
	HTTP     ApiCommonBackendType
	FUNCTION ApiCommonBackendType
	MOCK     ApiCommonBackendType
}

func GetApiCommonBackendTypeEnum 

func GetApiCommonBackendTypeEnum() ApiCommonBackendTypeEnum

type ApiCommonMatchMode 

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

func (ApiCommonMatchMode) MarshalJSON 

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

func (*ApiCommonMatchMode) UnmarshalJSON 

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

type ApiCommonMatchModeEnum 

type ApiCommonMatchModeEnum struct {
	SWA    ApiCommonMatchMode
	NORMAL ApiCommonMatchMode
}

func GetApiCommonMatchModeEnum 

func GetApiCommonMatchModeEnum() ApiCommonMatchModeEnum

type ApiCommonReqMethod 

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

func (ApiCommonReqMethod) MarshalJSON 

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

func (*ApiCommonReqMethod) UnmarshalJSON 

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

type ApiCommonReqMethodEnum 

type ApiCommonReqMethodEnum struct {
	GET     ApiCommonReqMethod
	POST    ApiCommonReqMethod
	PUT     ApiCommonReqMethod
	DELETE  ApiCommonReqMethod
	HEAD    ApiCommonReqMethod
	PATCH   ApiCommonReqMethod
	OPTIONS ApiCommonReqMethod
	ANY     ApiCommonReqMethod
}

func GetApiCommonReqMethodEnum 

func GetApiCommonReqMethodEnum() ApiCommonReqMethodEnum

type ApiCommonReqProtocol 

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

func (ApiCommonReqProtocol) MarshalJSON 

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

func (*ApiCommonReqProtocol) UnmarshalJSON 

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

type ApiCommonReqProtocolEnum 

type ApiCommonReqProtocolEnum struct {
	HTTP  ApiCommonReqProtocol
	HTTPS ApiCommonReqProtocol
	BOTH  ApiCommonReqProtocol
}

func GetApiCommonReqProtocolEnum 

func GetApiCommonReqProtocolEnum() ApiCommonReqProtocolEnum

type ApiCommonType 

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

func (ApiCommonType) MarshalJSON 

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

func (*ApiCommonType) UnmarshalJSON 

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

type ApiCommonTypeEnum 

type ApiCommonTypeEnum struct {
	E_1 ApiCommonType
	E_2 ApiCommonType
}

func GetApiCommonTypeEnum 

func GetApiCommonTypeEnum() ApiCommonTypeEnum

type ApiConditionBase 

type ApiConditionBase struct {
	// 关联的请求参数对象名称。策略类型为param时必选
	ReqParamName *string `json:"req_param_name,omitempty"`
	// 策略条件 - exact：绝对匹配 - enum：枚举 - pattern：正则  策略类型为param时必选
	ConditionType *ApiConditionBaseConditionType `json:"condition_type,omitempty"`
	// 策略类型 - param：参数 - source：源IP
	ConditionOrigin ApiConditionBaseConditionOrigin `json:"condition_origin"`
	// 策略值
	ConditionValue string `json:"condition_value"`
}

func (ApiConditionBase) String 

func (o ApiConditionBase) String() string

type ApiConditionBaseConditionOrigin 

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

func (ApiConditionBaseConditionOrigin) MarshalJSON 

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

func (*ApiConditionBaseConditionOrigin) UnmarshalJSON 

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

type ApiConditionBaseConditionOriginEnum 

type ApiConditionBaseConditionOriginEnum struct {
	PARAM  ApiConditionBaseConditionOrigin
	SOURCE ApiConditionBaseConditionOrigin
}

func GetApiConditionBaseConditionOriginEnum 

func GetApiConditionBaseConditionOriginEnum() ApiConditionBaseConditionOriginEnum

type ApiConditionBaseConditionType 

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

func (ApiConditionBaseConditionType) MarshalJSON 

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

func (*ApiConditionBaseConditionType) UnmarshalJSON 

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

type ApiConditionBaseConditionTypeEnum 

type ApiConditionBaseConditionTypeEnum struct {
	EXACT   ApiConditionBaseConditionType
	ENUM    ApiConditionBaseConditionType
	PATTERN ApiConditionBaseConditionType
}

func GetApiConditionBaseConditionTypeEnum 

func GetApiConditionBaseConditionTypeEnum() ApiConditionBaseConditionTypeEnum

type ApiCreate 

type ApiCreate struct {
	// API名称长度。  为3 ~ 64位的字符串，字符串由中文、英文字母、数字、下划线组成，且只能以英文或中文开头。 > 中文字符必须为UTF-8或者unicode编码。
	Name string `json:"name"`
	// API类型 - 1：公有API - 2：私有API
	Type ApiCreateType `json:"type"`
	// API的版本
	Version *string `json:"version,omitempty"`
	// API的请求协议 - HTTP - HTTPS - BOTH：同时支持HTTP和HTTPS
	ReqProtocol ApiCreateReqProtocol `json:"req_protocol"`
	// API的请求方式
	ReqMethod ApiCreateReqMethod `json:"req_method"`
	// 请求地址。可以包含请求参数，用{}标识，比如/getUserInfo/{userId}，支持 * % - _ . 等特殊字符，总长度不超过512，且满足URI规范。  支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、中划线、下划线组成，且只能以英文开头。 > 需要服从URI规范。
	ReqUri string `json:"req_uri"`
	// API的认证方式 - NONE：无认证 - APP：APP认证 - IAM：IAM认证 - AUTHORIZER：自定义认证
	AuthType ApiCreateAuthType `json:"auth_type"`
	AuthOpt  *AuthOpt          `json:"auth_opt,omitempty"`
	// 是否支持跨域 - TRUE：支持 - FALSE：不支持
	Cors *bool `json:"cors,omitempty"`
	// API的匹配方式 - SWA：前缀匹配 - NORMAL：正常匹配（绝对匹配） 默认：NORMAL
	MatchMode *ApiCreateMatchMode `json:"match_mode,omitempty"`
	// 后端类型 - HTTP：web后端 - FUNCTION：函数工作流 - MOCK：模拟的后端
	BackendType ApiCreateBackendType `json:"backend_type"`
	// API描述。字符长度不超过255 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// API所属的分组编号
	GroupId string `json:"group_id"`
	// API请求体描述，可以是请求体示例、媒体类型、参数等信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	BodyRemark *string `json:"body_remark,omitempty"`
	// 正常响应示例，描述API的正常返回信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	ResultNormalSample *string `json:"result_normal_sample,omitempty"`
	// 失败返回示例，描述API的异常返回信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	ResultFailureSample *string `json:"result_failure_sample,omitempty"`
	// 前端自定义认证对象的ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
	// 标签。  支持英文，数字，下划线，且只能以英文开头。支持输入多个标签，不同标签以英文逗号分割。
	Tags *[]string `json:"tags,omitempty"`
	// 分组自定义响应ID
	ResponseId *string `json:"response_id,omitempty"`
	// 集成应用ID  暂不支持
	RomaAppId *string `json:"roma_app_id,omitempty"`
	// API绑定的自定义域名  暂不支持
	DomainName *string `json:"domain_name,omitempty"`
	// 标签  待废弃，优先使用tags字段
	Tag      *string        `json:"tag,omitempty"`
	MockInfo *ApiMockCreate `json:"mock_info,omitempty"`
	FuncInfo *ApiFuncCreate `json:"func_info,omitempty"`
	// API的请求参数列表
	ReqParams *[]ReqParamBase `json:"req_params,omitempty"`
	// API的后端参数列表
	BackendParams *[]BackendParamBase `json:"backend_params,omitempty"`
	// mock策略后端列表
	PolicyMocks *[]ApiPolicyMockCreate `json:"policy_mocks,omitempty"`
	// 函数工作流策略后端列表
	PolicyFunctions *[]ApiPolicyFunctionCreate `json:"policy_functions,omitempty"`
	BackendApi      *BackendApiCreate          `json:"backend_api,omitempty"`
	// web策略后端列表
	PolicyHttps *[]ApiPolicyHttpCreate `json:"policy_https,omitempty"`
}

func (ApiCreate) String 

func (o ApiCreate) String() string

type ApiCreateAuthType 

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

func (ApiCreateAuthType) MarshalJSON 

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

func (*ApiCreateAuthType) UnmarshalJSON 

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

type ApiCreateAuthTypeEnum 

type ApiCreateAuthTypeEnum struct {
	NONE       ApiCreateAuthType
	APP        ApiCreateAuthType
	IAM        ApiCreateAuthType
	AUTHORIZER ApiCreateAuthType
}

func GetApiCreateAuthTypeEnum 

func GetApiCreateAuthTypeEnum() ApiCreateAuthTypeEnum

type ApiCreateBackendType 

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

func (ApiCreateBackendType) MarshalJSON 

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

func (*ApiCreateBackendType) UnmarshalJSON 

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

type ApiCreateBackendTypeEnum 

type ApiCreateBackendTypeEnum struct {
	HTTP     ApiCreateBackendType
	FUNCTION ApiCreateBackendType
	MOCK     ApiCreateBackendType
}

func GetApiCreateBackendTypeEnum 

func GetApiCreateBackendTypeEnum() ApiCreateBackendTypeEnum

type ApiCreateBase 

type ApiCreateBase struct {
	// API名称长度。  为3 ~ 64位的字符串，字符串由中文、英文字母、数字、下划线组成，且只能以英文或中文开头。 > 中文字符必须为UTF-8或者unicode编码。
	Name string `json:"name"`
	// API类型 - 1：公有API - 2：私有API
	Type ApiCreateBaseType `json:"type"`
	// API的版本
	Version *string `json:"version,omitempty"`
	// API的请求协议 - HTTP - HTTPS - BOTH：同时支持HTTP和HTTPS
	ReqProtocol ApiCreateBaseReqProtocol `json:"req_protocol"`
	// API的请求方式
	ReqMethod ApiCreateBaseReqMethod `json:"req_method"`
	// 请求地址。可以包含请求参数，用{}标识，比如/getUserInfo/{userId}，支持 * % - _ . 等特殊字符，总长度不超过512，且满足URI规范。  支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、中划线、下划线组成，且只能以英文开头。 > 需要服从URI规范。
	ReqUri string `json:"req_uri"`
	// API的认证方式 - NONE：无认证 - APP：APP认证 - IAM：IAM认证 - AUTHORIZER：自定义认证
	AuthType ApiCreateBaseAuthType `json:"auth_type"`
	AuthOpt  *AuthOpt              `json:"auth_opt,omitempty"`
	// 是否支持跨域 - TRUE：支持 - FALSE：不支持
	Cors *bool `json:"cors,omitempty"`
	// API的匹配方式 - SWA：前缀匹配 - NORMAL：正常匹配（绝对匹配） 默认：NORMAL
	MatchMode *ApiCreateBaseMatchMode `json:"match_mode,omitempty"`
	// 后端类型 - HTTP：web后端 - FUNCTION：函数工作流 - MOCK：模拟的后端
	BackendType ApiCreateBaseBackendType `json:"backend_type"`
	// API描述。字符长度不超过255 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// API所属的分组编号
	GroupId string `json:"group_id"`
	// API请求体描述，可以是请求体示例、媒体类型、参数等信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	BodyRemark *string `json:"body_remark,omitempty"`
	// 正常响应示例，描述API的正常返回信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	ResultNormalSample *string `json:"result_normal_sample,omitempty"`
	// 失败返回示例，描述API的异常返回信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	ResultFailureSample *string `json:"result_failure_sample,omitempty"`
	// 前端自定义认证对象的ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
	// 标签。  支持英文，数字，下划线，且只能以英文开头。支持输入多个标签，不同标签以英文逗号分割。
	Tags *[]string `json:"tags,omitempty"`
	// 分组自定义响应ID
	ResponseId *string `json:"response_id,omitempty"`
	// 集成应用ID  暂不支持
	RomaAppId *string `json:"roma_app_id,omitempty"`
	// API绑定的自定义域名  暂不支持
	DomainName *string `json:"domain_name,omitempty"`
	// 标签  待废弃，优先使用tags字段
	Tag      *string        `json:"tag,omitempty"`
	MockInfo *ApiMockCreate `json:"mock_info,omitempty"`
	FuncInfo *ApiFuncCreate `json:"func_info,omitempty"`
	// API的请求参数列表
	ReqParams *[]ReqParamBase `json:"req_params,omitempty"`
	// API的后端参数列表
	BackendParams *[]BackendParamBase `json:"backend_params,omitempty"`
	// mock策略后端列表
	PolicyMocks *[]ApiPolicyMockCreate `json:"policy_mocks,omitempty"`
	// 函数工作流策略后端列表
	PolicyFunctions *[]ApiPolicyFunctionCreate `json:"policy_functions,omitempty"`
}

func (ApiCreateBase) String 

func (o ApiCreateBase) String() string

type ApiCreateBaseAuthType 

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

func (ApiCreateBaseAuthType) MarshalJSON 

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

func (*ApiCreateBaseAuthType) UnmarshalJSON 

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

type ApiCreateBaseAuthTypeEnum 

type ApiCreateBaseAuthTypeEnum struct {
	NONE       ApiCreateBaseAuthType
	APP        ApiCreateBaseAuthType
	IAM        ApiCreateBaseAuthType
	AUTHORIZER ApiCreateBaseAuthType
}

func GetApiCreateBaseAuthTypeEnum 

func GetApiCreateBaseAuthTypeEnum() ApiCreateBaseAuthTypeEnum

type ApiCreateBaseBackendType 

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

func (ApiCreateBaseBackendType) MarshalJSON 

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

func (*ApiCreateBaseBackendType) UnmarshalJSON 

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

type ApiCreateBaseBackendTypeEnum 

type ApiCreateBaseBackendTypeEnum struct {
	HTTP     ApiCreateBaseBackendType
	FUNCTION ApiCreateBaseBackendType
	MOCK     ApiCreateBaseBackendType
}

func GetApiCreateBaseBackendTypeEnum 

func GetApiCreateBaseBackendTypeEnum() ApiCreateBaseBackendTypeEnum

type ApiCreateBaseMatchMode 

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

func (ApiCreateBaseMatchMode) MarshalJSON 

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

func (*ApiCreateBaseMatchMode) UnmarshalJSON 

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

type ApiCreateBaseMatchModeEnum 

type ApiCreateBaseMatchModeEnum struct {
	SWA    ApiCreateBaseMatchMode
	NORMAL ApiCreateBaseMatchMode
}

func GetApiCreateBaseMatchModeEnum 

func GetApiCreateBaseMatchModeEnum() ApiCreateBaseMatchModeEnum

type ApiCreateBaseReqMethod 

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

func (ApiCreateBaseReqMethod) MarshalJSON 

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

func (*ApiCreateBaseReqMethod) UnmarshalJSON 

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

type ApiCreateBaseReqMethodEnum 

type ApiCreateBaseReqMethodEnum struct {
	GET     ApiCreateBaseReqMethod
	POST    ApiCreateBaseReqMethod
	PUT     ApiCreateBaseReqMethod
	DELETE  ApiCreateBaseReqMethod
	HEAD    ApiCreateBaseReqMethod
	PATCH   ApiCreateBaseReqMethod
	OPTIONS ApiCreateBaseReqMethod
	ANY     ApiCreateBaseReqMethod
}

func GetApiCreateBaseReqMethodEnum 

func GetApiCreateBaseReqMethodEnum() ApiCreateBaseReqMethodEnum

type ApiCreateBaseReqProtocol 

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

func (ApiCreateBaseReqProtocol) MarshalJSON 

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

func (*ApiCreateBaseReqProtocol) UnmarshalJSON 

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

type ApiCreateBaseReqProtocolEnum 

type ApiCreateBaseReqProtocolEnum struct {
	HTTP  ApiCreateBaseReqProtocol
	HTTPS ApiCreateBaseReqProtocol
	BOTH  ApiCreateBaseReqProtocol
}

func GetApiCreateBaseReqProtocolEnum 

func GetApiCreateBaseReqProtocolEnum() ApiCreateBaseReqProtocolEnum

type ApiCreateBaseType 

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

func (ApiCreateBaseType) MarshalJSON 

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

func (*ApiCreateBaseType) UnmarshalJSON 

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

type ApiCreateBaseTypeEnum 

type ApiCreateBaseTypeEnum struct {
	E_1 ApiCreateBaseType
	E_2 ApiCreateBaseType
}

func GetApiCreateBaseTypeEnum 

func GetApiCreateBaseTypeEnum() ApiCreateBaseTypeEnum

type ApiCreateMatchMode 

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

func (ApiCreateMatchMode) MarshalJSON 

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

func (*ApiCreateMatchMode) UnmarshalJSON 

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

type ApiCreateMatchModeEnum 

type ApiCreateMatchModeEnum struct {
	SWA    ApiCreateMatchMode
	NORMAL ApiCreateMatchMode
}

func GetApiCreateMatchModeEnum 

func GetApiCreateMatchModeEnum() ApiCreateMatchModeEnum

type ApiCreateReqMethod 

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

func (ApiCreateReqMethod) MarshalJSON 

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

func (*ApiCreateReqMethod) UnmarshalJSON 

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

type ApiCreateReqMethodEnum 

type ApiCreateReqMethodEnum struct {
	GET     ApiCreateReqMethod
	POST    ApiCreateReqMethod
	PUT     ApiCreateReqMethod
	DELETE  ApiCreateReqMethod
	HEAD    ApiCreateReqMethod
	PATCH   ApiCreateReqMethod
	OPTIONS ApiCreateReqMethod
	ANY     ApiCreateReqMethod
}

func GetApiCreateReqMethodEnum 

func GetApiCreateReqMethodEnum() ApiCreateReqMethodEnum

type ApiCreateReqProtocol 

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

func (ApiCreateReqProtocol) MarshalJSON 

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

func (*ApiCreateReqProtocol) UnmarshalJSON 

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

type ApiCreateReqProtocolEnum 

type ApiCreateReqProtocolEnum struct {
	HTTP  ApiCreateReqProtocol
	HTTPS ApiCreateReqProtocol
	BOTH  ApiCreateReqProtocol
}

func GetApiCreateReqProtocolEnum 

func GetApiCreateReqProtocolEnum() ApiCreateReqProtocolEnum

type ApiCreateType 

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

func (ApiCreateType) MarshalJSON 

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

func (*ApiCreateType) UnmarshalJSON 

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

type ApiCreateTypeEnum 

type ApiCreateTypeEnum struct {
	E_1 ApiCreateType
	E_2 ApiCreateType
}

func GetApiCreateTypeEnum 

func GetApiCreateTypeEnum() ApiCreateTypeEnum

type ApiFunc 

type ApiFunc struct {
	// 函数URN
	FunctionUrn string `json:"function_urn"`
	// 描述信息。长度不超过255个字符 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// 调用类型 - async： 异步 - sync：同步
	InvocationType ApiFuncInvocationType `json:"invocation_type"`
	// 版本。
	Version *string `json:"version,omitempty"`
	// API网关请求函数服务的超时时间。  单位：毫秒。请求参数值不在合法范围内时将使用缺省值
	Timeout int32 `json:"timeout"`
	// 后端自定义认证ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
	// 编号
	Id *string `json:"id,omitempty"`
	// 注册时间
	RegisterTime *sdktime.SdkTime `json:"register_time,omitempty"`
	// 状态
	Status *int32 `json:"status,omitempty"`
	// 修改时间
	UpdateTime *sdktime.SdkTime `json:"update_time,omitempty"`
}

函数工作流后端详情

func (ApiFunc) String 

func (o ApiFunc) String() string

type ApiFuncCreate 

type ApiFuncCreate struct {
	// 函数URN
	FunctionUrn string `json:"function_urn"`
	// 描述信息。长度不超过255个字符 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// 调用类型 - async： 异步 - sync：同步
	InvocationType ApiFuncCreateInvocationType `json:"invocation_type"`
	// 版本。
	Version *string `json:"version,omitempty"`
	// API网关请求函数服务的超时时间。  单位：毫秒。请求参数值不在合法范围内时将使用缺省值
	Timeout int32 `json:"timeout"`
	// 后端自定义认证ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
}

函数后端详情

func (ApiFuncCreate) String 

func (o ApiFuncCreate) String() string

type ApiFuncCreateInvocationType 

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

func (ApiFuncCreateInvocationType) MarshalJSON 

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

func (*ApiFuncCreateInvocationType) UnmarshalJSON 

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

type ApiFuncCreateInvocationTypeEnum 

type ApiFuncCreateInvocationTypeEnum struct {
	ASYNC ApiFuncCreateInvocationType
	SYNC  ApiFuncCreateInvocationType
}

func GetApiFuncCreateInvocationTypeEnum 

func GetApiFuncCreateInvocationTypeEnum() ApiFuncCreateInvocationTypeEnum

type ApiFuncInvocationType 

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

func (ApiFuncInvocationType) MarshalJSON 

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

func (*ApiFuncInvocationType) UnmarshalJSON 

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

type ApiFuncInvocationTypeEnum 

type ApiFuncInvocationTypeEnum struct {
	ASYNC ApiFuncInvocationType
	SYNC  ApiFuncInvocationType
}

func GetApiFuncInvocationTypeEnum 

func GetApiFuncInvocationTypeEnum() ApiFuncInvocationTypeEnum

type ApiGroupDetailResp 

type ApiGroupDetailResp struct {
	// 分组上绑定的独立域名列表
	UrlDomains *[]UrlDomainsResp `json:"url_domains,omitempty"`
	// 流控时长内分组下的API的总访问次数限制，默认不限，请根据服务的负载能力自行设置  暂不支持
	CallLimits *int32 `json:"call_limits,omitempty"`
	// 最近修改时间
	UpdateTime *sdktime.SdkTime `json:"update_time"`
	// API分组名称
	Name string `json:"name"`
	// 流控的时间单位  暂不支持
	TimeUnit *string `json:"time_unit,omitempty"`
	// 是否已上架云市场： - 1：已上架 - 2：未上架 - 3：审核中
	OnSellStatus int32 `json:"on_sell_status"`
	// 描述
	Remark *string `json:"remark,omitempty"`
	// 系统默认分配的子域名
	SlDomain string `json:"sl_domain"`
	// 系统默认分配的子域名列表
	SlDomains *[]string `json:"sl_domains,omitempty"`
	// 编号
	Id string `json:"id"`
	// 流控时长  暂不支持
	TimeInterval *int32 `json:"time_interval,omitempty"`
	// 创建时间
	RegisterTime *sdktime.SdkTime `json:"register_time"`
	// 状态
	Status int32 `json:"status"`
	// 是否为默认分组
	IsDefault *int32 `json:"is_default,omitempty"`
}

func (ApiGroupDetailResp) String 

func (o ApiGroupDetailResp) String() string

type ApiGroupReq 

type ApiGroupReq struct {
	// API分组的名称。 由中文、英文字母、数字、“_”组成，且只能以英文或中文开头。 > 中文字符必须为UTF-8或者unicode编码。
	Name string `json:"name"`
	// API分组描述。 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
}

func (ApiGroupReq) String 

func (o ApiGroupReq) String() string

type ApiInfoPerPage 

type ApiInfoPerPage struct {
	// API名称长度。  为3 ~ 64位的字符串，字符串由中文、英文字母、数字、下划线组成，且只能以英文或中文开头。 > 中文字符必须为UTF-8或者unicode编码。
	Name string `json:"name"`
	// API类型 - 1：公有API - 2：私有API
	Type ApiInfoPerPageType `json:"type"`
	// API的版本
	Version *string `json:"version,omitempty"`
	// API的请求协议 - HTTP - HTTPS - BOTH：同时支持HTTP和HTTPS
	ReqProtocol ApiInfoPerPageReqProtocol `json:"req_protocol"`
	// API的请求方式
	ReqMethod ApiInfoPerPageReqMethod `json:"req_method"`
	// 请求地址。可以包含请求参数，用{}标识，比如/getUserInfo/{userId}，支持 * % - _ . 等特殊字符，总长度不超过512，且满足URI规范。  支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、中划线、下划线组成，且只能以英文开头。 > 需要服从URI规范。
	ReqUri string `json:"req_uri"`
	// API的认证方式 - NONE：无认证 - APP：APP认证 - IAM：IAM认证 - AUTHORIZER：自定义认证
	AuthType ApiInfoPerPageAuthType `json:"auth_type"`
	AuthOpt  *AuthOpt               `json:"auth_opt,omitempty"`
	// 是否支持跨域 - TRUE：支持 - FALSE：不支持
	Cors *bool `json:"cors,omitempty"`
	// API的匹配方式 - SWA：前缀匹配 - NORMAL：正常匹配（绝对匹配） 默认：NORMAL
	MatchMode *ApiInfoPerPageMatchMode `json:"match_mode,omitempty"`
	// 后端类型 - HTTP：web后端 - FUNCTION：函数工作流 - MOCK：模拟的后端
	BackendType ApiInfoPerPageBackendType `json:"backend_type"`
	// API描述。字符长度不超过255 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// API所属的分组编号
	GroupId string `json:"group_id"`
	// API请求体描述，可以是请求体示例、媒体类型、参数等信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	BodyRemark *string `json:"body_remark,omitempty"`
	// 正常响应示例，描述API的正常返回信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	ResultNormalSample *string `json:"result_normal_sample,omitempty"`
	// 失败返回示例，描述API的异常返回信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	ResultFailureSample *string `json:"result_failure_sample,omitempty"`
	// 前端自定义认证对象的ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
	// 标签。  支持英文，数字，下划线，且只能以英文开头。支持输入多个标签，不同标签以英文逗号分割。
	Tags *[]string `json:"tags,omitempty"`
	// 分组自定义响应ID
	ResponseId *string `json:"response_id,omitempty"`
	// 集成应用ID  暂不支持
	RomaAppId *string `json:"roma_app_id,omitempty"`
	// API绑定的自定义域名  暂不支持
	DomainName *string `json:"domain_name,omitempty"`
	// 标签  待废弃，优先使用tags字段
	Tag *string `json:"tag,omitempty"`
	// API编号
	Id *string `json:"id,omitempty"`
	// API的状态
	Status *int32 `json:"status,omitempty"`
	// 是否需要编排
	ArrangeNecessary *int32 `json:"arrange_necessary,omitempty"`
	// API注册时间
	RegisterTime *sdktime.SdkTime `json:"register_time,omitempty"`
	// API修改时间
	UpdateTime *sdktime.SdkTime `json:"update_time,omitempty"`
	// API所属分组的名称
	GroupName *string `json:"group_name,omitempty"`
	// API所属分组的版本  默认V1，其他版本暂不支持
	GroupVersion *string `json:"group_version,omitempty"`
	// 发布的环境id
	RunEnvId *string `json:"run_env_id,omitempty"`
	// 发布的环境名称
	RunEnvName *string `json:"run_env_name,omitempty"`
	// 发布记录编号  存在多个发布记录时，编号之间用|隔开
	PublishId *string `json:"publish_id,omitempty"`
	// API的请求参数列表
	ReqParams *[]ReqParam `json:"req_params,omitempty"`
}

func (ApiInfoPerPage) String 

func (o ApiInfoPerPage) String() string

type ApiInfoPerPageAuthType 

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

func (ApiInfoPerPageAuthType) MarshalJSON 

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

func (*ApiInfoPerPageAuthType) UnmarshalJSON 

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

type ApiInfoPerPageAuthTypeEnum 

type ApiInfoPerPageAuthTypeEnum struct {
	NONE       ApiInfoPerPageAuthType
	APP        ApiInfoPerPageAuthType
	IAM        ApiInfoPerPageAuthType
	AUTHORIZER ApiInfoPerPageAuthType
}

func GetApiInfoPerPageAuthTypeEnum 

func GetApiInfoPerPageAuthTypeEnum() ApiInfoPerPageAuthTypeEnum

type ApiInfoPerPageBackendType 

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

func (ApiInfoPerPageBackendType) MarshalJSON 

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

func (*ApiInfoPerPageBackendType) UnmarshalJSON 

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

type ApiInfoPerPageBackendTypeEnum 

type ApiInfoPerPageBackendTypeEnum struct {
	HTTP     ApiInfoPerPageBackendType
	FUNCTION ApiInfoPerPageBackendType
	MOCK     ApiInfoPerPageBackendType
}

func GetApiInfoPerPageBackendTypeEnum 

func GetApiInfoPerPageBackendTypeEnum() ApiInfoPerPageBackendTypeEnum

type ApiInfoPerPageMatchMode 

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

func (ApiInfoPerPageMatchMode) MarshalJSON 

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

func (*ApiInfoPerPageMatchMode) UnmarshalJSON 

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

type ApiInfoPerPageMatchModeEnum 

type ApiInfoPerPageMatchModeEnum struct {
	SWA    ApiInfoPerPageMatchMode
	NORMAL ApiInfoPerPageMatchMode
}

func GetApiInfoPerPageMatchModeEnum 

func GetApiInfoPerPageMatchModeEnum() ApiInfoPerPageMatchModeEnum

type ApiInfoPerPageReqMethod 

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

func (ApiInfoPerPageReqMethod) MarshalJSON 

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

func (*ApiInfoPerPageReqMethod) UnmarshalJSON 

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

type ApiInfoPerPageReqMethodEnum 

type ApiInfoPerPageReqMethodEnum struct {
	GET     ApiInfoPerPageReqMethod
	POST    ApiInfoPerPageReqMethod
	PUT     ApiInfoPerPageReqMethod
	DELETE  ApiInfoPerPageReqMethod
	HEAD    ApiInfoPerPageReqMethod
	PATCH   ApiInfoPerPageReqMethod
	OPTIONS ApiInfoPerPageReqMethod
	ANY     ApiInfoPerPageReqMethod
}

func GetApiInfoPerPageReqMethodEnum 

func GetApiInfoPerPageReqMethodEnum() ApiInfoPerPageReqMethodEnum

type ApiInfoPerPageReqProtocol 

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

func (ApiInfoPerPageReqProtocol) MarshalJSON 

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

func (*ApiInfoPerPageReqProtocol) UnmarshalJSON 

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

type ApiInfoPerPageReqProtocolEnum 

type ApiInfoPerPageReqProtocolEnum struct {
	HTTP  ApiInfoPerPageReqProtocol
	HTTPS ApiInfoPerPageReqProtocol
	BOTH  ApiInfoPerPageReqProtocol
}

func GetApiInfoPerPageReqProtocolEnum 

func GetApiInfoPerPageReqProtocolEnum() ApiInfoPerPageReqProtocolEnum

type ApiInfoPerPageType 

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

func (ApiInfoPerPageType) MarshalJSON 

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

func (*ApiInfoPerPageType) UnmarshalJSON 

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

type ApiInfoPerPageTypeEnum 

type ApiInfoPerPageTypeEnum struct {
	E_1 ApiInfoPerPageType
	E_2 ApiInfoPerPageType
}

func GetApiInfoPerPageTypeEnum 

func GetApiInfoPerPageTypeEnum() ApiInfoPerPageTypeEnum

type ApiMock 

type ApiMock struct {
	// 描述信息。长度不超过255个字符 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// 返回结果
	ResultContent *string `json:"result_content,omitempty"`
	// 版本。字符长度不超过64
	Version *string `json:"version,omitempty"`
	// 后端自定义认证ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
}

mock后端详情

func (ApiMock) String 

func (o ApiMock) String() string

type ApiMockCreate 

type ApiMockCreate struct {
	// 描述信息。长度不超过255个字符 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// 返回结果
	ResultContent *string `json:"result_content,omitempty"`
	// 版本。字符长度不超过64
	Version *string `json:"version,omitempty"`
	// 后端自定义认证ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
}

mock后端详情

func (ApiMockCreate) String 

func (o ApiMockCreate) String() string

type ApiPolicyFunctionBase 

type ApiPolicyFunctionBase struct {
	// 函数URN
	FunctionUrn string `json:"function_urn"`
	// 调用类型 - async： 异步 - sync：同步
	InvocationType ApiPolicyFunctionBaseInvocationType `json:"invocation_type"`
	// 版本。字符长度不超过64
	Version *string `json:"version,omitempty"`
	// API网关请求后端服务的超时时间。  单位：毫秒。请求参数值不在合法范围内时将使用默认值
	Timeout *int32 `json:"timeout,omitempty"`
}

func (ApiPolicyFunctionBase) String 

func (o ApiPolicyFunctionBase) String() string

type ApiPolicyFunctionBaseInvocationType 

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

func (ApiPolicyFunctionBaseInvocationType) MarshalJSON 

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

func (*ApiPolicyFunctionBaseInvocationType) UnmarshalJSON 

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

type ApiPolicyFunctionBaseInvocationTypeEnum 

type ApiPolicyFunctionBaseInvocationTypeEnum struct {
	ASYNC ApiPolicyFunctionBaseInvocationType
	SYNC  ApiPolicyFunctionBaseInvocationType
}

func GetApiPolicyFunctionBaseInvocationTypeEnum 

func GetApiPolicyFunctionBaseInvocationTypeEnum() ApiPolicyFunctionBaseInvocationTypeEnum

type ApiPolicyFunctionCreate 

type ApiPolicyFunctionCreate struct {
	// 函数URN
	FunctionUrn string `json:"function_urn"`
	// 调用类型 - async： 异步 - sync：同步
	InvocationType ApiPolicyFunctionCreateInvocationType `json:"invocation_type"`
	// 版本。字符长度不超过64
	Version *string `json:"version,omitempty"`
	// API网关请求后端服务的超时时间。  单位：毫秒。请求参数值不在合法范围内时将使用默认值
	Timeout *int32 `json:"timeout,omitempty"`
	// 关联的策略组合模式： - ALL：满足全部条件 - ANY：满足任一条件
	EffectMode ApiPolicyFunctionCreateEffectMode `json:"effect_mode"`
	// 策略后端名称。字符串由中文、英文字母、数字、下划线组成，且只能以中文或英文开头。
	Name string `json:"name"`
	// 后端参数列表
	BackendParams *[]BackendParamBase `json:"backend_params,omitempty"`
	// 策略条件列表
	Conditions []ApiConditionBase `json:"conditions"`
	// 后端自定义认证对象的ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
}

func (ApiPolicyFunctionCreate) String 

func (o ApiPolicyFunctionCreate) String() string

type ApiPolicyFunctionCreateEffectMode 

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

func (ApiPolicyFunctionCreateEffectMode) MarshalJSON 

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

func (*ApiPolicyFunctionCreateEffectMode) UnmarshalJSON 

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

type ApiPolicyFunctionCreateEffectModeEnum 

type ApiPolicyFunctionCreateEffectModeEnum struct {
	ALL ApiPolicyFunctionCreateEffectMode
	ANY ApiPolicyFunctionCreateEffectMode
}

func GetApiPolicyFunctionCreateEffectModeEnum 

func GetApiPolicyFunctionCreateEffectModeEnum() ApiPolicyFunctionCreateEffectModeEnum

type ApiPolicyFunctionCreateInvocationType 

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

func (ApiPolicyFunctionCreateInvocationType) MarshalJSON 

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

func (*ApiPolicyFunctionCreateInvocationType) UnmarshalJSON 

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

type ApiPolicyFunctionCreateInvocationTypeEnum 

type ApiPolicyFunctionCreateInvocationTypeEnum struct {
	ASYNC ApiPolicyFunctionCreateInvocationType
	SYNC  ApiPolicyFunctionCreateInvocationType
}

func GetApiPolicyFunctionCreateInvocationTypeEnum 

func GetApiPolicyFunctionCreateInvocationTypeEnum() ApiPolicyFunctionCreateInvocationTypeEnum

type ApiPolicyFunctionResp 

type ApiPolicyFunctionResp struct {
	// 函数URN
	FunctionUrn string `json:"function_urn"`
	// 调用类型 - async： 异步 - sync：同步
	InvocationType ApiPolicyFunctionRespInvocationType `json:"invocation_type"`
	// 版本。字符长度不超过64
	Version *string `json:"version,omitempty"`
	// API网关请求后端服务的超时时间。  单位：毫秒。请求参数值不在合法范围内时将使用默认值
	Timeout *int32 `json:"timeout,omitempty"`
	// 编号
	Id *string `json:"id,omitempty"`
	// 关联的策略组合模式： - ALL：满足全部条件 - ANY：满足任一条件
	EffectMode ApiPolicyFunctionRespEffectMode `json:"effect_mode"`
	// 策略后端名称。字符串由中文、英文字母、数字、下划线组成，且只能以中文或英文开头。
	Name string `json:"name"`
	// 后端参数列表
	BackendParams *[]BackendParam `json:"backend_params,omitempty"`
	// 策略条件列表
	Conditions []CoditionResp `json:"conditions"`
	// 后端自定义认证对象的ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
}

func (ApiPolicyFunctionResp) String 

func (o ApiPolicyFunctionResp) String() string

type ApiPolicyFunctionRespEffectMode 

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

func (ApiPolicyFunctionRespEffectMode) MarshalJSON 

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

func (*ApiPolicyFunctionRespEffectMode) UnmarshalJSON 

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

type ApiPolicyFunctionRespEffectModeEnum 

type ApiPolicyFunctionRespEffectModeEnum struct {
	ALL ApiPolicyFunctionRespEffectMode
	ANY ApiPolicyFunctionRespEffectMode
}

func GetApiPolicyFunctionRespEffectModeEnum 

func GetApiPolicyFunctionRespEffectModeEnum() ApiPolicyFunctionRespEffectModeEnum

type ApiPolicyFunctionRespInvocationType 

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

func (ApiPolicyFunctionRespInvocationType) MarshalJSON 

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

func (*ApiPolicyFunctionRespInvocationType) UnmarshalJSON 

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

type ApiPolicyFunctionRespInvocationTypeEnum 

type ApiPolicyFunctionRespInvocationTypeEnum struct {
	ASYNC ApiPolicyFunctionRespInvocationType
	SYNC  ApiPolicyFunctionRespInvocationType
}

func GetApiPolicyFunctionRespInvocationTypeEnum 

func GetApiPolicyFunctionRespInvocationTypeEnum() ApiPolicyFunctionRespInvocationTypeEnum

type ApiPolicyHttpBase 

type ApiPolicyHttpBase struct {
	// 策略后端的Endpoint。 由域名（或IP地址）和端口号组成，总长度不超过255。格式为域名:端口（如：apig.example.com:7443）。如果不写端口，则HTTPS默认端口号为443， HTTP默认端口号为80。 支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、“_”、“-”组成，且只能以英文开头。
	UrlDomain *string `json:"url_domain,omitempty"`
	// 请求协议：HTTP、HTTPS
	ReqProtocol ApiPolicyHttpBaseReqProtocol `json:"req_protocol"`
	// 请求方式：GET、POST、PUT、DELETE、HEAD、PATCH、OPTIONS、ANY
	ReqMethod ApiPolicyHttpBaseReqMethod `json:"req_method"`
	// 请求地址。可以包含请求参数，用{}标识，比如/getUserInfo/{userId}，支持 * % - _ . 等特殊字符，总长度不超过512，且满足URI规范。  支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、中划线、下划线组成，且只能以英文开头。 > 需要服从URI规范。
	ReqUri string `json:"req_uri"`
	// API网关请求后端服务的超时时间。  单位：毫秒。
	Timeout *int32 `json:"timeout,omitempty"`
}

func (ApiPolicyHttpBase) String 

func (o ApiPolicyHttpBase) String() string

type ApiPolicyHttpBaseReqMethod 

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

func (ApiPolicyHttpBaseReqMethod) MarshalJSON 

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

func (*ApiPolicyHttpBaseReqMethod) UnmarshalJSON 

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

type ApiPolicyHttpBaseReqMethodEnum 

type ApiPolicyHttpBaseReqMethodEnum struct {
	GET     ApiPolicyHttpBaseReqMethod
	POST    ApiPolicyHttpBaseReqMethod
	PUT     ApiPolicyHttpBaseReqMethod
	DELETE  ApiPolicyHttpBaseReqMethod
	HEAD    ApiPolicyHttpBaseReqMethod
	PATCH   ApiPolicyHttpBaseReqMethod
	OPTIONS ApiPolicyHttpBaseReqMethod
	ANY     ApiPolicyHttpBaseReqMethod
}

func GetApiPolicyHttpBaseReqMethodEnum 

func GetApiPolicyHttpBaseReqMethodEnum() ApiPolicyHttpBaseReqMethodEnum

type ApiPolicyHttpBaseReqProtocol 

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

func (ApiPolicyHttpBaseReqProtocol) MarshalJSON 

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

func (*ApiPolicyHttpBaseReqProtocol) UnmarshalJSON 

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

type ApiPolicyHttpBaseReqProtocolEnum 

type ApiPolicyHttpBaseReqProtocolEnum struct {
	HTTP  ApiPolicyHttpBaseReqProtocol
	HTTPS ApiPolicyHttpBaseReqProtocol
}

func GetApiPolicyHttpBaseReqProtocolEnum 

func GetApiPolicyHttpBaseReqProtocolEnum() ApiPolicyHttpBaseReqProtocolEnum

type ApiPolicyHttpCreate 

type ApiPolicyHttpCreate struct {
	// 策略后端的Endpoint。 由域名（或IP地址）和端口号组成，总长度不超过255。格式为域名:端口（如：apig.example.com:7443）。如果不写端口，则HTTPS默认端口号为443， HTTP默认端口号为80。 支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、“_”、“-”组成，且只能以英文开头。
	UrlDomain *string `json:"url_domain,omitempty"`
	// 请求协议：HTTP、HTTPS
	ReqProtocol ApiPolicyHttpCreateReqProtocol `json:"req_protocol"`
	// 请求方式：GET、POST、PUT、DELETE、HEAD、PATCH、OPTIONS、ANY
	ReqMethod ApiPolicyHttpCreateReqMethod `json:"req_method"`
	// 请求地址。可以包含请求参数，用{}标识，比如/getUserInfo/{userId}，支持 * % - _ . 等特殊字符，总长度不超过512，且满足URI规范。  支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、中划线、下划线组成，且只能以英文开头。 > 需要服从URI规范。
	ReqUri string `json:"req_uri"`
	// API网关请求后端服务的超时时间。  单位：毫秒。
	Timeout *int32 `json:"timeout,omitempty"`
	// 关联的策略组合模式： - ALL：满足全部条件 - ANY：满足任一条件
	EffectMode ApiPolicyHttpCreateEffectMode `json:"effect_mode"`
	// 策略后端名称。字符串由中文、英文字母、数字、下划线组成，且只能以中文或英文开头。
	Name string `json:"name"`
	// 后端参数列表
	BackendParams *[]BackendParamBase `json:"backend_params,omitempty"`
	// 策略条件列表
	Conditions []ApiConditionBase `json:"conditions"`
	// 后端自定义认证对象的ID
	AuthorizerId   *string           `json:"authorizer_id,omitempty"`
	VpcChannelInfo *ApiBackendVpcReq `json:"vpc_channel_info,omitempty"`
	// 是否使用VPC通道 - 1 : 使用VPC通道 - 2 : 不使用VPC通道
	VpcChannelStatus *ApiPolicyHttpCreateVpcChannelStatus `json:"vpc_channel_status,omitempty"`
}

func (ApiPolicyHttpCreate) String 

func (o ApiPolicyHttpCreate) String() string

type ApiPolicyHttpCreateEffectMode 

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

func (ApiPolicyHttpCreateEffectMode) MarshalJSON 

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

func (*ApiPolicyHttpCreateEffectMode) UnmarshalJSON 

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

type ApiPolicyHttpCreateEffectModeEnum 

type ApiPolicyHttpCreateEffectModeEnum struct {
	ALL ApiPolicyHttpCreateEffectMode
	ANY ApiPolicyHttpCreateEffectMode
}

func GetApiPolicyHttpCreateEffectModeEnum 

func GetApiPolicyHttpCreateEffectModeEnum() ApiPolicyHttpCreateEffectModeEnum

type ApiPolicyHttpCreateReqMethod 

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

func (ApiPolicyHttpCreateReqMethod) MarshalJSON 

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

func (*ApiPolicyHttpCreateReqMethod) UnmarshalJSON 

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

type ApiPolicyHttpCreateReqMethodEnum 

type ApiPolicyHttpCreateReqMethodEnum struct {
	GET     ApiPolicyHttpCreateReqMethod
	POST    ApiPolicyHttpCreateReqMethod
	PUT     ApiPolicyHttpCreateReqMethod
	DELETE  ApiPolicyHttpCreateReqMethod
	HEAD    ApiPolicyHttpCreateReqMethod
	PATCH   ApiPolicyHttpCreateReqMethod
	OPTIONS ApiPolicyHttpCreateReqMethod
	ANY     ApiPolicyHttpCreateReqMethod
}

func GetApiPolicyHttpCreateReqMethodEnum 

func GetApiPolicyHttpCreateReqMethodEnum() ApiPolicyHttpCreateReqMethodEnum

type ApiPolicyHttpCreateReqProtocol 

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

func (ApiPolicyHttpCreateReqProtocol) MarshalJSON 

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

func (*ApiPolicyHttpCreateReqProtocol) UnmarshalJSON 

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

type ApiPolicyHttpCreateReqProtocolEnum 

type ApiPolicyHttpCreateReqProtocolEnum struct {
	HTTP  ApiPolicyHttpCreateReqProtocol
	HTTPS ApiPolicyHttpCreateReqProtocol
}

func GetApiPolicyHttpCreateReqProtocolEnum 

func GetApiPolicyHttpCreateReqProtocolEnum() ApiPolicyHttpCreateReqProtocolEnum

type ApiPolicyHttpCreateVpcChannelStatus 

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

func (ApiPolicyHttpCreateVpcChannelStatus) MarshalJSON 

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

func (*ApiPolicyHttpCreateVpcChannelStatus) UnmarshalJSON 

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

type ApiPolicyHttpCreateVpcChannelStatusEnum 

type ApiPolicyHttpCreateVpcChannelStatusEnum struct {
	E_1 ApiPolicyHttpCreateVpcChannelStatus
	E_2 ApiPolicyHttpCreateVpcChannelStatus
}

func GetApiPolicyHttpCreateVpcChannelStatusEnum 

func GetApiPolicyHttpCreateVpcChannelStatusEnum() ApiPolicyHttpCreateVpcChannelStatusEnum

type ApiPolicyHttpResp 

type ApiPolicyHttpResp struct {
	// 编号
	Id *string `json:"id,omitempty"`
	// 关联的策略组合模式： - ALL：满足全部条件 - ANY：满足任一条件
	EffectMode ApiPolicyHttpRespEffectMode `json:"effect_mode"`
	// 策略后端名称。字符串由中文、英文字母、数字、下划线组成，且只能以中文或英文开头。
	Name string `json:"name"`
	// 后端参数列表
	BackendParams *[]BackendParam `json:"backend_params,omitempty"`
	// 策略条件列表
	Conditions []CoditionResp `json:"conditions"`
	// 后端自定义认证对象的ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
	// 策略后端的Endpoint。 由域名（或IP地址）和端口号组成，总长度不超过255。格式为域名:端口（如：apig.example.com:7443）。如果不写端口，则HTTPS默认端口号为443， HTTP默认端口号为80。 支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、“_”、“-”组成，且只能以英文开头。
	UrlDomain *string `json:"url_domain,omitempty"`
	// 请求协议：HTTP、HTTPS
	ReqProtocol ApiPolicyHttpRespReqProtocol `json:"req_protocol"`
	// 请求方式：GET、POST、PUT、DELETE、HEAD、PATCH、OPTIONS、ANY
	ReqMethod ApiPolicyHttpRespReqMethod `json:"req_method"`
	// 请求地址。可以包含请求参数，用{}标识，比如/getUserInfo/{userId}，支持 * % - _ . 等特殊字符，总长度不超过512，且满足URI规范。  支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、中划线、下划线组成，且只能以英文开头。 > 需要服从URI规范。
	ReqUri string `json:"req_uri"`
	// API网关请求后端服务的超时时间。  单位：毫秒。
	Timeout *int32 `json:"timeout,omitempty"`
	// VPC通道信息
	VpcChannelInfo *string `json:"vpc_channel_info,omitempty"`
	// 是否使用VPC通道： - 1： 使用VPC通道 - 2：不使用VPC通道
	VpcChannelStatus *int32 `json:"vpc_channel_status,omitempty"`
}

func (ApiPolicyHttpResp) String 

func (o ApiPolicyHttpResp) String() string

type ApiPolicyHttpRespEffectMode 

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

func (ApiPolicyHttpRespEffectMode) MarshalJSON 

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

func (*ApiPolicyHttpRespEffectMode) UnmarshalJSON 

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

type ApiPolicyHttpRespEffectModeEnum 

type ApiPolicyHttpRespEffectModeEnum struct {
	ALL ApiPolicyHttpRespEffectMode
	ANY ApiPolicyHttpRespEffectMode
}

func GetApiPolicyHttpRespEffectModeEnum 

func GetApiPolicyHttpRespEffectModeEnum() ApiPolicyHttpRespEffectModeEnum

type ApiPolicyHttpRespReqMethod 

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

func (ApiPolicyHttpRespReqMethod) MarshalJSON 

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

func (*ApiPolicyHttpRespReqMethod) UnmarshalJSON 

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

type ApiPolicyHttpRespReqMethodEnum 

type ApiPolicyHttpRespReqMethodEnum struct {
	GET     ApiPolicyHttpRespReqMethod
	POST    ApiPolicyHttpRespReqMethod
	PUT     ApiPolicyHttpRespReqMethod
	DELETE  ApiPolicyHttpRespReqMethod
	HEAD    ApiPolicyHttpRespReqMethod
	PATCH   ApiPolicyHttpRespReqMethod
	OPTIONS ApiPolicyHttpRespReqMethod
	ANY     ApiPolicyHttpRespReqMethod
}

func GetApiPolicyHttpRespReqMethodEnum 

func GetApiPolicyHttpRespReqMethodEnum() ApiPolicyHttpRespReqMethodEnum

type ApiPolicyHttpRespReqProtocol 

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

func (ApiPolicyHttpRespReqProtocol) MarshalJSON 

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

func (*ApiPolicyHttpRespReqProtocol) UnmarshalJSON 

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

type ApiPolicyHttpRespReqProtocolEnum 

type ApiPolicyHttpRespReqProtocolEnum struct {
	HTTP  ApiPolicyHttpRespReqProtocol
	HTTPS ApiPolicyHttpRespReqProtocol
}

func GetApiPolicyHttpRespReqProtocolEnum 

func GetApiPolicyHttpRespReqProtocolEnum() ApiPolicyHttpRespReqProtocolEnum

type ApiPolicyMockBase 

type ApiPolicyMockBase struct {
	// 返回结果
	ResultContent *string `json:"result_content,omitempty"`
}

func (ApiPolicyMockBase) String 

func (o ApiPolicyMockBase) String() string

type ApiPolicyMockCreate 

type ApiPolicyMockCreate struct {
	// 返回结果
	ResultContent *string `json:"result_content,omitempty"`
	// 关联的策略组合模式： - ALL：满足全部条件 - ANY：满足任一条件
	EffectMode ApiPolicyMockCreateEffectMode `json:"effect_mode"`
	// 策略后端名称。字符串由中文、英文字母、数字、下划线组成，且只能以中文或英文开头。
	Name string `json:"name"`
	// 后端参数列表
	BackendParams *[]BackendParamBase `json:"backend_params,omitempty"`
	// 策略条件列表
	Conditions []ApiConditionBase `json:"conditions"`
	// 后端自定义认证对象的ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
}

func (ApiPolicyMockCreate) String 

func (o ApiPolicyMockCreate) String() string

type ApiPolicyMockCreateEffectMode 

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

func (ApiPolicyMockCreateEffectMode) MarshalJSON 

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

func (*ApiPolicyMockCreateEffectMode) UnmarshalJSON 

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

type ApiPolicyMockCreateEffectModeEnum 

type ApiPolicyMockCreateEffectModeEnum struct {
	ALL ApiPolicyMockCreateEffectMode
	ANY ApiPolicyMockCreateEffectMode
}

func GetApiPolicyMockCreateEffectModeEnum 

func GetApiPolicyMockCreateEffectModeEnum() ApiPolicyMockCreateEffectModeEnum

type ApiPolicyMockResp 

type ApiPolicyMockResp struct {
	// 编号
	Id *string `json:"id,omitempty"`
	// 关联的策略组合模式： - ALL：满足全部条件 - ANY：满足任一条件
	EffectMode ApiPolicyMockRespEffectMode `json:"effect_mode"`
	// 策略后端名称。字符串由中文、英文字母、数字、下划线组成，且只能以中文或英文开头。
	Name string `json:"name"`
	// 后端参数列表
	BackendParams *[]BackendParam `json:"backend_params,omitempty"`
	// 策略条件列表
	Conditions []CoditionResp `json:"conditions"`
	// 后端自定义认证对象的ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
	// 返回结果
	ResultContent *string `json:"result_content,omitempty"`
}

func (ApiPolicyMockResp) String 

func (o ApiPolicyMockResp) String() string

type ApiPolicyMockRespEffectMode 

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

func (ApiPolicyMockRespEffectMode) MarshalJSON 

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

func (*ApiPolicyMockRespEffectMode) UnmarshalJSON 

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

type ApiPolicyMockRespEffectModeEnum 

type ApiPolicyMockRespEffectModeEnum struct {
	ALL ApiPolicyMockRespEffectMode
	ANY ApiPolicyMockRespEffectMode
}

func GetApiPolicyMockRespEffectModeEnum 

func GetApiPolicyMockRespEffectModeEnum() ApiPolicyMockRespEffectModeEnum

type ApiPolicyReqBase 

type ApiPolicyReqBase struct {
	// 关联的策略组合模式： - ALL：满足全部条件 - ANY：满足任一条件
	EffectMode ApiPolicyReqBaseEffectMode `json:"effect_mode"`
	// 策略后端名称。字符串由中文、英文字母、数字、下划线组成，且只能以中文或英文开头。
	Name string `json:"name"`
	// 后端参数列表
	BackendParams *[]BackendParamBase `json:"backend_params,omitempty"`
	// 策略条件列表
	Conditions []ApiConditionBase `json:"conditions"`
	// 后端自定义认证对象的ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
}

func (ApiPolicyReqBase) String 

func (o ApiPolicyReqBase) String() string

type ApiPolicyReqBaseEffectMode 

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

func (ApiPolicyReqBaseEffectMode) MarshalJSON 

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

func (*ApiPolicyReqBaseEffectMode) UnmarshalJSON 

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

type ApiPolicyReqBaseEffectModeEnum 

type ApiPolicyReqBaseEffectModeEnum struct {
	ALL ApiPolicyReqBaseEffectMode
	ANY ApiPolicyReqBaseEffectMode
}

func GetApiPolicyReqBaseEffectModeEnum 

func GetApiPolicyReqBaseEffectModeEnum() ApiPolicyReqBaseEffectModeEnum

type ApiPolicyRespBase 

type ApiPolicyRespBase struct {
	// 编号
	Id *string `json:"id,omitempty"`
	// 关联的策略组合模式： - ALL：满足全部条件 - ANY：满足任一条件
	EffectMode ApiPolicyRespBaseEffectMode `json:"effect_mode"`
	// 策略后端名称。字符串由中文、英文字母、数字、下划线组成，且只能以中文或英文开头。
	Name string `json:"name"`
	// 后端参数列表
	BackendParams *[]BackendParam `json:"backend_params,omitempty"`
	// 策略条件列表
	Conditions []CoditionResp `json:"conditions"`
	// 后端自定义认证对象的ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
}

func (ApiPolicyRespBase) String 

func (o ApiPolicyRespBase) String() string

type ApiPolicyRespBaseEffectMode 

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

func (ApiPolicyRespBaseEffectMode) MarshalJSON 

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

func (*ApiPolicyRespBaseEffectMode) UnmarshalJSON 

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

type ApiPolicyRespBaseEffectModeEnum 

type ApiPolicyRespBaseEffectModeEnum struct {
	ALL ApiPolicyRespBaseEffectMode
	ANY ApiPolicyRespBaseEffectMode
}

func GetApiPolicyRespBaseEffectModeEnum 

func GetApiPolicyRespBaseEffectModeEnum() ApiPolicyRespBaseEffectModeEnum

type ApiPublishReq 

type ApiPublishReq struct {
	// 需要进行的操作。 - online：发布 - offline：下线
	Action ApiPublishReqAction `json:"action"`
	// 环境的编号，即：API需要发布到哪个环境
	EnvId string `json:"env_id"`
	// API的编号，即：需要进行发布或下线的API的编号
	ApiId string `json:"api_id"`
	// 对发布动作的简述。字符长度不超过255 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
}

func (ApiPublishReq) String 

func (o ApiPublishReq) String() string

type ApiPublishReqAction 

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

func (ApiPublishReqAction) MarshalJSON 

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

func (*ApiPublishReqAction) UnmarshalJSON 

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

type ApiPublishReqActionEnum 

type ApiPublishReqActionEnum struct {
	ONLINE  ApiPublishReqAction
	OFFLINE ApiPublishReqAction
}

func GetApiPublishReqActionEnum 

func GetApiPublishReqActionEnum() ApiPublishReqActionEnum

type ApiRespBaseInfo 

type ApiRespBaseInfo struct {
	// API名称长度。  为3 ~ 64位的字符串，字符串由中文、英文字母、数字、下划线组成，且只能以英文或中文开头。 > 中文字符必须为UTF-8或者unicode编码。
	Name string `json:"name"`
	// API类型 - 1：公有API - 2：私有API
	Type ApiRespBaseInfoType `json:"type"`
	// API的版本
	Version *string `json:"version,omitempty"`
	// API的请求协议 - HTTP - HTTPS - BOTH：同时支持HTTP和HTTPS
	ReqProtocol ApiRespBaseInfoReqProtocol `json:"req_protocol"`
	// API的请求方式
	ReqMethod ApiRespBaseInfoReqMethod `json:"req_method"`
	// 请求地址。可以包含请求参数，用{}标识，比如/getUserInfo/{userId}，支持 * % - _ . 等特殊字符，总长度不超过512，且满足URI规范。  支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、中划线、下划线组成，且只能以英文开头。 > 需要服从URI规范。
	ReqUri string `json:"req_uri"`
	// API的认证方式 - NONE：无认证 - APP：APP认证 - IAM：IAM认证 - AUTHORIZER：自定义认证
	AuthType ApiRespBaseInfoAuthType `json:"auth_type"`
	AuthOpt  *AuthOpt                `json:"auth_opt,omitempty"`
	// 是否支持跨域 - TRUE：支持 - FALSE：不支持
	Cors *bool `json:"cors,omitempty"`
	// API的匹配方式 - SWA：前缀匹配 - NORMAL：正常匹配（绝对匹配） 默认：NORMAL
	MatchMode *ApiRespBaseInfoMatchMode `json:"match_mode,omitempty"`
	// 后端类型 - HTTP：web后端 - FUNCTION：函数工作流 - MOCK：模拟的后端
	BackendType ApiRespBaseInfoBackendType `json:"backend_type"`
	// API描述。字符长度不超过255 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// API所属的分组编号
	GroupId string `json:"group_id"`
	// API请求体描述，可以是请求体示例、媒体类型、参数等信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	BodyRemark *string `json:"body_remark,omitempty"`
	// 正常响应示例，描述API的正常返回信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	ResultNormalSample *string `json:"result_normal_sample,omitempty"`
	// 失败返回示例，描述API的异常返回信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	ResultFailureSample *string `json:"result_failure_sample,omitempty"`
	// 前端自定义认证对象的ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
	// 标签。  支持英文，数字，下划线，且只能以英文开头。支持输入多个标签，不同标签以英文逗号分割。
	Tags *[]string `json:"tags,omitempty"`
	// 分组自定义响应ID
	ResponseId *string `json:"response_id,omitempty"`
	// 集成应用ID  暂不支持
	RomaAppId *string `json:"roma_app_id,omitempty"`
	// API绑定的自定义域名  暂不支持
	DomainName *string `json:"domain_name,omitempty"`
	// 标签  待废弃，优先使用tags字段
	Tag *string `json:"tag,omitempty"`
	// API编号
	Id *string `json:"id,omitempty"`
	// API的状态
	Status *int32 `json:"status,omitempty"`
	// 是否需要编排
	ArrangeNecessary *int32 `json:"arrange_necessary,omitempty"`
	// API注册时间
	RegisterTime *sdktime.SdkTime `json:"register_time,omitempty"`
	// API修改时间
	UpdateTime *sdktime.SdkTime `json:"update_time,omitempty"`
	// API所属分组的名称
	GroupName *string `json:"group_name,omitempty"`
	// API所属分组的版本  默认V1，其他版本暂不支持
	GroupVersion *string `json:"group_version,omitempty"`
	// 发布的环境id
	RunEnvId *string `json:"run_env_id,omitempty"`
	// 发布的环境名称
	RunEnvName *string `json:"run_env_name,omitempty"`
	// 发布记录编号  存在多个发布记录时，编号之间用|隔开
	PublishId *string `json:"publish_id,omitempty"`
}

func (ApiRespBaseInfo) String 

func (o ApiRespBaseInfo) String() string

type ApiRespBaseInfoAuthType 

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

func (ApiRespBaseInfoAuthType) MarshalJSON 

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

func (*ApiRespBaseInfoAuthType) UnmarshalJSON 

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

type ApiRespBaseInfoAuthTypeEnum 

type ApiRespBaseInfoAuthTypeEnum struct {
	NONE       ApiRespBaseInfoAuthType
	APP        ApiRespBaseInfoAuthType
	IAM        ApiRespBaseInfoAuthType
	AUTHORIZER ApiRespBaseInfoAuthType
}

func GetApiRespBaseInfoAuthTypeEnum 

func GetApiRespBaseInfoAuthTypeEnum() ApiRespBaseInfoAuthTypeEnum

type ApiRespBaseInfoBackendType 

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

func (ApiRespBaseInfoBackendType) MarshalJSON 

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

func (*ApiRespBaseInfoBackendType) UnmarshalJSON 

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

type ApiRespBaseInfoBackendTypeEnum 

type ApiRespBaseInfoBackendTypeEnum struct {
	HTTP     ApiRespBaseInfoBackendType
	FUNCTION ApiRespBaseInfoBackendType
	MOCK     ApiRespBaseInfoBackendType
}

func GetApiRespBaseInfoBackendTypeEnum 

func GetApiRespBaseInfoBackendTypeEnum() ApiRespBaseInfoBackendTypeEnum

type ApiRespBaseInfoMatchMode 

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

func (ApiRespBaseInfoMatchMode) MarshalJSON 

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

func (*ApiRespBaseInfoMatchMode) UnmarshalJSON 

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

type ApiRespBaseInfoMatchModeEnum 

type ApiRespBaseInfoMatchModeEnum struct {
	SWA    ApiRespBaseInfoMatchMode
	NORMAL ApiRespBaseInfoMatchMode
}

func GetApiRespBaseInfoMatchModeEnum 

func GetApiRespBaseInfoMatchModeEnum() ApiRespBaseInfoMatchModeEnum

type ApiRespBaseInfoReqMethod 

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

func (ApiRespBaseInfoReqMethod) MarshalJSON 

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

func (*ApiRespBaseInfoReqMethod) UnmarshalJSON 

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

type ApiRespBaseInfoReqMethodEnum 

type ApiRespBaseInfoReqMethodEnum struct {
	GET     ApiRespBaseInfoReqMethod
	POST    ApiRespBaseInfoReqMethod
	PUT     ApiRespBaseInfoReqMethod
	DELETE  ApiRespBaseInfoReqMethod
	HEAD    ApiRespBaseInfoReqMethod
	PATCH   ApiRespBaseInfoReqMethod
	OPTIONS ApiRespBaseInfoReqMethod
	ANY     ApiRespBaseInfoReqMethod
}

func GetApiRespBaseInfoReqMethodEnum 

func GetApiRespBaseInfoReqMethodEnum() ApiRespBaseInfoReqMethodEnum

type ApiRespBaseInfoReqProtocol 

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

func (ApiRespBaseInfoReqProtocol) MarshalJSON 

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

func (*ApiRespBaseInfoReqProtocol) UnmarshalJSON 

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

type ApiRespBaseInfoReqProtocolEnum 

type ApiRespBaseInfoReqProtocolEnum struct {
	HTTP  ApiRespBaseInfoReqProtocol
	HTTPS ApiRespBaseInfoReqProtocol
	BOTH  ApiRespBaseInfoReqProtocol
}

func GetApiRespBaseInfoReqProtocolEnum 

func GetApiRespBaseInfoReqProtocolEnum() ApiRespBaseInfoReqProtocolEnum

type ApiRespBaseInfoType 

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

func (ApiRespBaseInfoType) MarshalJSON 

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

func (*ApiRespBaseInfoType) UnmarshalJSON 

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

type ApiRespBaseInfoTypeEnum 

type ApiRespBaseInfoTypeEnum struct {
	E_1 ApiRespBaseInfoType
	E_2 ApiRespBaseInfoType
}

func GetApiRespBaseInfoTypeEnum 

func GetApiRespBaseInfoTypeEnum() ApiRespBaseInfoTypeEnum

type AppAuthBindedApiResp 

type AppAuthBindedApiResp struct {
	// API的编号
	ApiId *string `json:"api_id,omitempty"`
	// APP的名称
	AppName *string `json:"app_name,omitempty"`
	// api授权绑定的环境ID
	EnvId *string `json:"env_id,omitempty"`
	// api授权绑定的环境名称
	EnvName *string `json:"env_name,omitempty"`
	// API绑定的分组ID
	GroupId *string `json:"group_id,omitempty"`
	// API绑定的分组名称
	GroupName *string `json:"group_name,omitempty"`
	// API类型
	ApiType *int32 `json:"api_type,omitempty"`
	// API的名称
	ApiName *string `json:"api_name,omitempty"`
	// APP的编号
	AppId *string `json:"app_id,omitempty"`
	// 授权创建的时间
	AuthTime *sdktime.SdkTime `json:"auth_time,omitempty"`
	// APP的创建者，取值如下： - USER：租户自己创建 - MARKET：API市场分配
	AppCreator *string `json:"app_creator,omitempty"`
	// APP的类型  默认为apig，暂不支持其他类型
	AppType *AppAuthBindedApiRespAppType `json:"app_type,omitempty"`
	// 授权关系编号
	Id *string `json:"id,omitempty"`
	// API的描述信息
	ApiRemark *string `json:"api_remark,omitempty"`
	// 授权者
	AuthRole *string `json:"auth_role,omitempty"`
	// 授权通道类型 - NORMAL：普通通道 - GREEN：绿色通道  暂不支持，默认NORMAL
	AuthTunnel *AppAuthBindedApiRespAuthTunnel `json:"auth_tunnel,omitempty"`
	// 绿色通道的白名单配置
	AuthWhitelist *[]string `json:"auth_whitelist,omitempty"`
	// 绿色通道的黑名单配置
	AuthBlacklist *[]string `json:"auth_blacklist,omitempty"`
}

func (AppAuthBindedApiResp) String 

func (o AppAuthBindedApiResp) String() string

type AppAuthBindedApiRespAppType 

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

func (AppAuthBindedApiRespAppType) MarshalJSON 

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

func (*AppAuthBindedApiRespAppType) UnmarshalJSON 

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

type AppAuthBindedApiRespAppTypeEnum 

type AppAuthBindedApiRespAppTypeEnum struct {
	APIG AppAuthBindedApiRespAppType
	ROMA AppAuthBindedApiRespAppType
}

func GetAppAuthBindedApiRespAppTypeEnum 

func GetAppAuthBindedApiRespAppTypeEnum() AppAuthBindedApiRespAppTypeEnum

type AppAuthBindedApiRespAuthTunnel 

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

func (AppAuthBindedApiRespAuthTunnel) MarshalJSON 

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

func (*AppAuthBindedApiRespAuthTunnel) UnmarshalJSON 

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

type AppAuthBindedApiRespAuthTunnelEnum 

type AppAuthBindedApiRespAuthTunnelEnum struct {
	NORMAL AppAuthBindedApiRespAuthTunnel
	GREEN  AppAuthBindedApiRespAuthTunnel
}

func GetAppAuthBindedApiRespAuthTunnelEnum 

func GetAppAuthBindedApiRespAuthTunnelEnum() AppAuthBindedApiRespAuthTunnelEnum

type AppAuthReq 

type AppAuthReq struct {
	// 需要授权的环境编号
	EnvId string `json:"env_id"`
	// APP的编号列表
	AppIds []string `json:"app_ids"`
	// API的编号列表，可以选择租户自己的API，也可以选择从云市场上购买的API。
	ApiIds []string `json:"api_ids"`
}

func (AppAuthReq) String 

func (o AppAuthReq) String() string

type AppAuthResp 

type AppAuthResp struct {
	// API编号
	ApiId      *string         `json:"api_id,omitempty"`
	AuthResult *AuthResultResp `json:"auth_result,omitempty"`
	// 授权时间
	AuthTime *sdktime.SdkTime `json:"auth_time,omitempty"`
	// 授权关系编号
	Id *string `json:"id,omitempty"`
	// APP编号
	AppId *string `json:"app_id,omitempty"`
	// 授权者 - PROVIDER：API提供者授权 - CONSUMER：API消费者授权
	AuthRole *AppAuthRespAuthRole `json:"auth_role,omitempty"`
	// 授权通道类型 - NORMAL：普通通道 - GREEN：绿色通道  暂不支持，默认NORMAL
	AuthTunnel *AppAuthRespAuthTunnel `json:"auth_tunnel,omitempty"`
	// 绿色通道的白名单配置
	AuthWhitelist *[]string `json:"auth_whitelist,omitempty"`
	// 绿色通道的黑名单配置
	AuthBlacklist *[]string `json:"auth_blacklist,omitempty"`
}

func (AppAuthResp) String 

func (o AppAuthResp) String() string

type AppAuthRespAuthRole 

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

func (AppAuthRespAuthRole) MarshalJSON 

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

func (*AppAuthRespAuthRole) UnmarshalJSON 

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

type AppAuthRespAuthRoleEnum 

type AppAuthRespAuthRoleEnum struct {
	PROVIDER AppAuthRespAuthRole
	CONSUMER AppAuthRespAuthRole
}

func GetAppAuthRespAuthRoleEnum 

func GetAppAuthRespAuthRoleEnum() AppAuthRespAuthRoleEnum

type AppAuthRespAuthTunnel 

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

func (AppAuthRespAuthTunnel) MarshalJSON 

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

func (*AppAuthRespAuthTunnel) UnmarshalJSON 

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

type AppAuthRespAuthTunnelEnum 

type AppAuthRespAuthTunnelEnum struct {
	NORMAL AppAuthRespAuthTunnel
	GREEN  AppAuthRespAuthTunnel
}

func GetAppAuthRespAuthTunnelEnum 

func GetAppAuthRespAuthTunnelEnum() AppAuthRespAuthTunnelEnum

type AppAuthUnBindedApiResp 

type AppAuthUnBindedApiResp struct {
	// API的认证方式
	AuthType *string `json:"auth_type,omitempty"`
	// 发布的环境名
	RunEnvName *string `json:"run_env_name,omitempty"`
	// API所属分组的名称
	GroupName *string `json:"group_name,omitempty"`
	// 发布记录的编号
	PublishId *string `json:"publish_id,omitempty"`
	// API所属分组的编号
	GroupId *string `json:"group_id,omitempty"`
	// API名称
	Name *string `json:"name,omitempty"`
	// API描述
	Remark *string `json:"remark,omitempty"`
	// 发布的环境id
	RunEnvId *string `json:"run_env_id,omitempty"`
	// API编号
	Id *string `json:"id,omitempty"`
	// API的访问地址
	ReqUri *string `json:"req_uri,omitempty"`
}

func (AppAuthUnBindedApiResp) String 

func (o AppAuthUnBindedApiResp) String() string

type AppInfoWithBindNumResp 

type AppInfoWithBindNumResp struct {
	// APP的创建者 - USER：用户自行创建 - MARKET：云市场分配
	Creator *string `json:"creator,omitempty"`
	// 更新时间
	UpdateTime *sdktime.SdkTime `json:"update_time,omitempty"`
	// APP的key
	AppKey *string `json:"app_key,omitempty"`
	// 名称
	Name *string `json:"name,omitempty"`
	// 描述
	Remark *string `json:"remark,omitempty"`
	// 编号
	Id *string `json:"id,omitempty"`
	// 密钥
	AppSecret *string `json:"app_secret,omitempty"`
	// 注册时间
	RegisterTime *sdktime.SdkTime `json:"register_time,omitempty"`
	// 状态
	Status *int32 `json:"status,omitempty"`
	// 绑定的API数量
	BindNum *int32 `json:"bind_num,omitempty"`
}

func (AppInfoWithBindNumResp) String 

func (o AppInfoWithBindNumResp) String() string

type AppReq 

type AppReq struct {
	// APP的名称。支持汉字，英文，数字，下划线，且只能以英文和汉字开头，3 ~ 64个字符。 > 中文字符必须为UTF-8或者unicode编码。
	Name string `json:"name"`
	// APP描述。字符长度不能大于255。 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// APP的key。支持英文，数字，“_”,“-”,且只能以英文或数字开头，8 ~ 64个字符。 > 只支持部分region。
	AppKey *string `json:"app_key,omitempty"`
	// 密钥。支持英文，数字，“_”,“-”,“_”,“!”,“@”,“#”,“$”,“%”且只能以英文或数字开头，8 ~ 64个字符。 > 只支持部分region。
	AppSecret *string `json:"app_secret,omitempty"`
}

func (AppReq) String 

func (o AppReq) String() string

type AppSecretReq 

type AppSecretReq struct {
	// 密钥支持英文，数字，“_”,“-”,“_”,“!”,“@”,“#”,“$”,“%”,且只能以英文或数字开头，8 ~ 64个字符。用户自定义APP的密钥需要开启配额开关
	AppSecret *string `json:"app_secret,omitempty"`
}

func (AppSecretReq) String 

func (o AppSecretReq) String() string

type AssociateCertificateV2Request 

type AssociateCertificateV2Request struct {
	ProjectId  string         `json:"project_id"`
	InstanceId string         `json:"instance_id"`
	GroupId    string         `json:"group_id"`
	Body       *DomainCertReq `json:"body,omitempty"`
}

Request Object

func (AssociateCertificateV2Request) String 

func (o AssociateCertificateV2Request) String() string

type AssociateCertificateV2Response 

type AssociateCertificateV2Response struct {
	// 证书的名称
	SslName *string `json:"ssl_name,omitempty"`
	// 自定义域名
	UrlDomain *string `json:"url_domain,omitempty"`
	// 证书的编号
	SslId *string `json:"ssl_id,omitempty"`
	// 自定义域名的编号
	Id *string `json:"id,omitempty"`
	// 解析状态值
	Status         *int32 `json:"status,omitempty"`
	HttpStatusCode int    `json:"-"`
}

Response Object

func (AssociateCertificateV2Response) String 

func (o AssociateCertificateV2Response) String() string

type AssociateDomainV2Request 

type AssociateDomainV2Request struct {
	ProjectId  string     `json:"project_id"`
	InstanceId string     `json:"instance_id"`
	GroupId    string     `json:"group_id"`
	Body       *DomainReq `json:"body,omitempty"`
}

Request Object

func (AssociateDomainV2Request) String 

func (o AssociateDomainV2Request) String() string

type AssociateDomainV2Response 

type AssociateDomainV2Response struct {
	// 自定义域名
	UrlDomain *string `json:"url_domain,omitempty"`
	// 域名的编号
	Id *string `json:"id,omitempty"`
	// CNAME解析状态 - 1: 未解析 - 2: 解析中 - 3: 解析成功 - 4: 解析失败
	Status         *AssociateDomainV2ResponseStatus `json:"status,omitempty"`
	HttpStatusCode int                              `json:"-"`
}

Response Object

func (AssociateDomainV2Response) String 

func (o AssociateDomainV2Response) String() string

type AssociateDomainV2ResponseStatus 

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

func (AssociateDomainV2ResponseStatus) MarshalJSON 

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

func (*AssociateDomainV2ResponseStatus) UnmarshalJSON 

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

type AssociateDomainV2ResponseStatusEnum 

type AssociateDomainV2ResponseStatusEnum struct {
	E_1 AssociateDomainV2ResponseStatus
	E_2 AssociateDomainV2ResponseStatus
	E_3 AssociateDomainV2ResponseStatus
	E_4 AssociateDomainV2ResponseStatus
}

func GetAssociateDomainV2ResponseStatusEnum 

func GetAssociateDomainV2ResponseStatusEnum() AssociateDomainV2ResponseStatusEnum

type AssociateRequestThrottlingPolicyV2Request 

type AssociateRequestThrottlingPolicyV2Request struct {
	ProjectId  string              `json:"project_id"`
	InstanceId string              `json:"instance_id"`
	Body       *ThrottleBindingReq `json:"body,omitempty"`
}

Request Object

func (AssociateRequestThrottlingPolicyV2Request) String 

func (o AssociateRequestThrottlingPolicyV2Request) String() string

type AssociateRequestThrottlingPolicyV2Response 

type AssociateRequestThrottlingPolicyV2Response struct {
	// API与流控策略的绑定关系列表
	ThrottleApplys *[]ThrottleBindingResp `json:"throttle_applys,omitempty"`
	HttpStatusCode int                    `json:"-"`
}

Response Object

func (AssociateRequestThrottlingPolicyV2Response) String 

func (o AssociateRequestThrottlingPolicyV2Response) String() string

type AssociateSignatureKeyV2Request 

type AssociateSignatureKeyV2Request struct {
	ProjectId  string          `json:"project_id"`
	InstanceId string          `json:"instance_id"`
	Body       *SignBindingReq `json:"body,omitempty"`
}

Request Object

func (AssociateSignatureKeyV2Request) String 

func (o AssociateSignatureKeyV2Request) String() string

type AssociateSignatureKeyV2Response 

type AssociateSignatureKeyV2Response struct {
	// API与签名密钥的绑定关系列表
	Bindings       *[]SignBindingApiResp `json:"bindings,omitempty"`
	HttpStatusCode int                   `json:"-"`
}

Response Object

func (AssociateSignatureKeyV2Response) String 

func (o AssociateSignatureKeyV2Response) String() string

type AuthOpt 

type AuthOpt struct {
	// AppCode简易认证类型，仅在auth_type为APP时生效，默认为DISABLE： - DISABLE：不开启简易认证 - HEADER：开启简易认证且AppCode位置在HEADER
	AppCodeAuthType *AuthOptAppCodeAuthType `json:"app_code_auth_type,omitempty"`
}

认证方式参数

func (AuthOpt) String 

func (o AuthOpt) String() string

type AuthOptAppCodeAuthType 

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

func (AuthOptAppCodeAuthType) MarshalJSON 

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

func (*AuthOptAppCodeAuthType) UnmarshalJSON 

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

type AuthOptAppCodeAuthTypeEnum 

type AuthOptAppCodeAuthTypeEnum struct {
	DISABLE AuthOptAppCodeAuthType
	HEADER  AuthOptAppCodeAuthType
}

func GetAuthOptAppCodeAuthTypeEnum 

func GetAuthOptAppCodeAuthTypeEnum() AuthOptAppCodeAuthTypeEnum

type AuthResultResp 

type AuthResultResp struct {
	// API名称
	ApiName *string `json:"api_name,omitempty"`
	// APP名称
	AppName *string `json:"app_name,omitempty"`
	// 授权结果 - SUCCESS：授权成功 - SKIPPED：跳过 - FILAED：授权失败
	Status *AuthResultRespStatus `json:"status,omitempty"`
	// 授权失败错误信息
	ErrorMsg *string `json:"error_msg,omitempty"`
	// 授权失败错误码
	ErrorCode *string `json:"error_code,omitempty"`
}

授权结果

func (AuthResultResp) String 

func (o AuthResultResp) String() string

type AuthResultRespStatus 

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

func (AuthResultRespStatus) MarshalJSON 

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

func (*AuthResultRespStatus) UnmarshalJSON 

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

type AuthResultRespStatusEnum 

type AuthResultRespStatusEnum struct {
	SUCCESS AuthResultRespStatus
	SKIPPED AuthResultRespStatus
	FAILED  AuthResultRespStatus
}

func GetAuthResultRespStatusEnum 

func GetAuthResultRespStatusEnum() AuthResultRespStatusEnum

type BackendApi 

type BackendApi struct {
	// 后端自定义认证对象的ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
	// 后端服务的地址。  由主机（IP或域名）和端口号组成，总长度不超过255。格式为主机:端口（如：apig.example.com:7443）。如果不写端口，则HTTPS默认端口号为443，HTTP默认端口号为80。  支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、下划线、中划线组成，且只能以英文开头
	UrlDomain *string `json:"url_domain,omitempty"`
	// 请求协议
	ReqProtocol BackendApiReqProtocol `json:"req_protocol"`
	// 描述。字符长度不超过255 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// 请求方式
	ReqMethod BackendApiReqMethod `json:"req_method"`
	// web后端版本，字符长度不超过16
	Version *string `json:"version,omitempty"`
	// 请求地址。可以包含请求参数，用{}标识，比如/getUserInfo/{userId}，支持 * % - _ . 等特殊字符，总长度不超过512，且满足URI规范。  支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、中划线、下划线组成，且只能以英文开头。 > 需要服从URI规范。
	ReqUri string `json:"req_uri"`
	// API网关请求后端服务的超时时间。  单位：毫秒。请求参数值不在合法范围内时将使用默认值
	Timeout int32 `json:"timeout"`
	// 编号
	Id *string `json:"id,omitempty"`
	// 状态
	Status *int32 `json:"status,omitempty"`
	// 注册时间
	RegisterTime *sdktime.SdkTime `json:"register_time,omitempty"`
	// 修改时间
	UpdateTime     *sdktime.SdkTime `json:"update_time,omitempty"`
	VpcChannelInfo *VpcInfo         `json:"vpc_channel_info,omitempty"`
	// 是否使用VPC通道 - 1：使用VPC通道 - 2：不使用VPC通道
	VpcChannelStatus *int32 `json:"vpc_channel_status,omitempty"`
}

web后端详情

func (BackendApi) String 

func (o BackendApi) String() string

type BackendApiBase 

type BackendApiBase struct {
	// 后端自定义认证对象的ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
	// 后端服务的地址。  由主机（IP或域名）和端口号组成，总长度不超过255。格式为主机:端口（如：apig.example.com:7443）。如果不写端口，则HTTPS默认端口号为443，HTTP默认端口号为80。  支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、下划线、中划线组成，且只能以英文开头
	UrlDomain *string `json:"url_domain,omitempty"`
	// 请求协议
	ReqProtocol BackendApiBaseReqProtocol `json:"req_protocol"`
	// 描述。字符长度不超过255 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// 请求方式
	ReqMethod BackendApiBaseReqMethod `json:"req_method"`
	// web后端版本，字符长度不超过16
	Version *string `json:"version,omitempty"`
	// 请求地址。可以包含请求参数，用{}标识，比如/getUserInfo/{userId}，支持 * % - _ . 等特殊字符，总长度不超过512，且满足URI规范。  支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、中划线、下划线组成，且只能以英文开头。 > 需要服从URI规范。
	ReqUri string `json:"req_uri"`
	// API网关请求后端服务的超时时间。  单位：毫秒。请求参数值不在合法范围内时将使用默认值
	Timeout int32 `json:"timeout"`
	// 编号
	Id *string `json:"id,omitempty"`
	// 状态
	Status *int32 `json:"status,omitempty"`
	// 注册时间
	RegisterTime *sdktime.SdkTime `json:"register_time,omitempty"`
	// 修改时间
	UpdateTime *sdktime.SdkTime `json:"update_time,omitempty"`
}

func (BackendApiBase) String 

func (o BackendApiBase) String() string

type BackendApiBaseInfo 

type BackendApiBaseInfo struct {
	// 后端自定义认证对象的ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
	// 后端服务的地址。  由主机（IP或域名）和端口号组成，总长度不超过255。格式为主机:端口（如：apig.example.com:7443）。如果不写端口，则HTTPS默认端口号为443，HTTP默认端口号为80。  支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、下划线、中划线组成，且只能以英文开头
	UrlDomain *string `json:"url_domain,omitempty"`
	// 请求协议
	ReqProtocol BackendApiBaseInfoReqProtocol `json:"req_protocol"`
	// 描述。字符长度不超过255 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// 请求方式
	ReqMethod BackendApiBaseInfoReqMethod `json:"req_method"`
	// web后端版本，字符长度不超过16
	Version *string `json:"version,omitempty"`
	// 请求地址。可以包含请求参数，用{}标识，比如/getUserInfo/{userId}，支持 * % - _ . 等特殊字符，总长度不超过512，且满足URI规范。  支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、中划线、下划线组成，且只能以英文开头。 > 需要服从URI规范。
	ReqUri string `json:"req_uri"`
	// API网关请求后端服务的超时时间。  单位：毫秒。请求参数值不在合法范围内时将使用默认值
	Timeout int32 `json:"timeout"`
}

func (BackendApiBaseInfo) String 

func (o BackendApiBaseInfo) String() string

type BackendApiBaseInfoReqMethod 

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

func (BackendApiBaseInfoReqMethod) MarshalJSON 

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

func (*BackendApiBaseInfoReqMethod) UnmarshalJSON 

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

type BackendApiBaseInfoReqMethodEnum 

type BackendApiBaseInfoReqMethodEnum struct {
	GET     BackendApiBaseInfoReqMethod
	POST    BackendApiBaseInfoReqMethod
	PUT     BackendApiBaseInfoReqMethod
	DELETE  BackendApiBaseInfoReqMethod
	HEAD    BackendApiBaseInfoReqMethod
	PATCH   BackendApiBaseInfoReqMethod
	OPTIONS BackendApiBaseInfoReqMethod
	ANY     BackendApiBaseInfoReqMethod
}

func GetBackendApiBaseInfoReqMethodEnum 

func GetBackendApiBaseInfoReqMethodEnum() BackendApiBaseInfoReqMethodEnum

type BackendApiBaseInfoReqProtocol 

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

func (BackendApiBaseInfoReqProtocol) MarshalJSON 

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

func (*BackendApiBaseInfoReqProtocol) UnmarshalJSON 

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

type BackendApiBaseInfoReqProtocolEnum 

type BackendApiBaseInfoReqProtocolEnum struct {
	HTTP  BackendApiBaseInfoReqProtocol
	HTTPS BackendApiBaseInfoReqProtocol
}

func GetBackendApiBaseInfoReqProtocolEnum 

func GetBackendApiBaseInfoReqProtocolEnum() BackendApiBaseInfoReqProtocolEnum

type BackendApiBaseReqMethod 

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

func (BackendApiBaseReqMethod) MarshalJSON 

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

func (*BackendApiBaseReqMethod) UnmarshalJSON 

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

type BackendApiBaseReqMethodEnum 

type BackendApiBaseReqMethodEnum struct {
	GET     BackendApiBaseReqMethod
	POST    BackendApiBaseReqMethod
	PUT     BackendApiBaseReqMethod
	DELETE  BackendApiBaseReqMethod
	HEAD    BackendApiBaseReqMethod
	PATCH   BackendApiBaseReqMethod
	OPTIONS BackendApiBaseReqMethod
	ANY     BackendApiBaseReqMethod
}

func GetBackendApiBaseReqMethodEnum 

func GetBackendApiBaseReqMethodEnum() BackendApiBaseReqMethodEnum

type BackendApiBaseReqProtocol 

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

func (BackendApiBaseReqProtocol) MarshalJSON 

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

func (*BackendApiBaseReqProtocol) UnmarshalJSON 

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

type BackendApiBaseReqProtocolEnum 

type BackendApiBaseReqProtocolEnum struct {
	HTTP  BackendApiBaseReqProtocol
	HTTPS BackendApiBaseReqProtocol
}

func GetBackendApiBaseReqProtocolEnum 

func GetBackendApiBaseReqProtocolEnum() BackendApiBaseReqProtocolEnum

type BackendApiCreate 

type BackendApiCreate struct {
	// 后端自定义认证对象的ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
	// 后端服务的地址。  由主机（IP或域名）和端口号组成，总长度不超过255。格式为主机:端口（如：apig.example.com:7443）。如果不写端口，则HTTPS默认端口号为443，HTTP默认端口号为80。  支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、下划线、中划线组成，且只能以英文开头
	UrlDomain *string `json:"url_domain,omitempty"`
	// 请求协议
	ReqProtocol BackendApiCreateReqProtocol `json:"req_protocol"`
	// 描述。字符长度不超过255 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// 请求方式
	ReqMethod BackendApiCreateReqMethod `json:"req_method"`
	// web后端版本，字符长度不超过16
	Version *string `json:"version,omitempty"`
	// 请求地址。可以包含请求参数，用{}标识，比如/getUserInfo/{userId}，支持 * % - _ . 等特殊字符，总长度不超过512，且满足URI规范。  支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、中划线、下划线组成，且只能以英文开头。 > 需要服从URI规范。
	ReqUri string `json:"req_uri"`
	// API网关请求后端服务的超时时间。  单位：毫秒。请求参数值不在合法范围内时将使用默认值
	Timeout        int32             `json:"timeout"`
	VpcChannelInfo *ApiBackendVpcReq `json:"vpc_channel_info,omitempty"`
	// 是否使用VPC通道 - 1 : 使用VPC通道 - 2 : 不使用VPC通道
	VpcChannelStatus *BackendApiCreateVpcChannelStatus `json:"vpc_channel_status,omitempty"`
}

web后端详情

func (BackendApiCreate) String 

func (o BackendApiCreate) String() string

type BackendApiCreateReqMethod 

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

func (BackendApiCreateReqMethod) MarshalJSON 

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

func (*BackendApiCreateReqMethod) UnmarshalJSON 

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

type BackendApiCreateReqMethodEnum 

type BackendApiCreateReqMethodEnum struct {
	GET     BackendApiCreateReqMethod
	POST    BackendApiCreateReqMethod
	PUT     BackendApiCreateReqMethod
	DELETE  BackendApiCreateReqMethod
	HEAD    BackendApiCreateReqMethod
	PATCH   BackendApiCreateReqMethod
	OPTIONS BackendApiCreateReqMethod
	ANY     BackendApiCreateReqMethod
}

func GetBackendApiCreateReqMethodEnum 

func GetBackendApiCreateReqMethodEnum() BackendApiCreateReqMethodEnum

type BackendApiCreateReqProtocol 

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

func (BackendApiCreateReqProtocol) MarshalJSON 

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

func (*BackendApiCreateReqProtocol) UnmarshalJSON 

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

type BackendApiCreateReqProtocolEnum 

type BackendApiCreateReqProtocolEnum struct {
	HTTP  BackendApiCreateReqProtocol
	HTTPS BackendApiCreateReqProtocol
}

func GetBackendApiCreateReqProtocolEnum 

func GetBackendApiCreateReqProtocolEnum() BackendApiCreateReqProtocolEnum

type BackendApiCreateVpcChannelStatus 

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

func (BackendApiCreateVpcChannelStatus) MarshalJSON 

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

func (*BackendApiCreateVpcChannelStatus) UnmarshalJSON 

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

type BackendApiCreateVpcChannelStatusEnum 

type BackendApiCreateVpcChannelStatusEnum struct {
	E_1 BackendApiCreateVpcChannelStatus
	E_2 BackendApiCreateVpcChannelStatus
}

func GetBackendApiCreateVpcChannelStatusEnum 

func GetBackendApiCreateVpcChannelStatusEnum() BackendApiCreateVpcChannelStatusEnum

type BackendApiReqMethod 

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

func (BackendApiReqMethod) MarshalJSON 

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

func (*BackendApiReqMethod) UnmarshalJSON 

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

type BackendApiReqMethodEnum 

type BackendApiReqMethodEnum struct {
	GET     BackendApiReqMethod
	POST    BackendApiReqMethod
	PUT     BackendApiReqMethod
	DELETE  BackendApiReqMethod
	HEAD    BackendApiReqMethod
	PATCH   BackendApiReqMethod
	OPTIONS BackendApiReqMethod
	ANY     BackendApiReqMethod
}

func GetBackendApiReqMethodEnum 

func GetBackendApiReqMethodEnum() BackendApiReqMethodEnum

type BackendApiReqProtocol 

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

func (BackendApiReqProtocol) MarshalJSON 

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

func (*BackendApiReqProtocol) UnmarshalJSON 

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

type BackendApiReqProtocolEnum 

type BackendApiReqProtocolEnum struct {
	HTTP  BackendApiReqProtocol
	HTTPS BackendApiReqProtocol
}

func GetBackendApiReqProtocolEnum 

func GetBackendApiReqProtocolEnum() BackendApiReqProtocolEnum

type BackendParam 

type BackendParam struct {
	// 参数类别：REQUEST、CONSTANT、SYSTEM
	Origin BackendParamOrigin `json:"origin"`
	// 参数名称。 字符串由英文字母、数字、中划线、下划线、英文句号组成，且只能以英文开头。
	Name string `json:"name"`
	// 描述。字符长度不超过255 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// 参数位置：PATH、QUERY、HEADER
	Location BackendParamLocation `json:"location"`
	// 参数值。字符长度不超过255，类别为REQUEST时，值为req_params中的参数名称；类别为CONSTANT时，值为参数真正的值；类别为SYSTEM时，值为网关参数名称
	Value string `json:"value"`
	// 参数编号
	Id *string `json:"id,omitempty"`
	// 对应的请求参数编号
	ReqParamId *string `json:"req_param_id,omitempty"`
}

func (BackendParam) String 

func (o BackendParam) String() string

type BackendParamBase 

type BackendParamBase struct {
	// 参数类别：REQUEST、CONSTANT、SYSTEM
	Origin BackendParamBaseOrigin `json:"origin"`
	// 参数名称。 字符串由英文字母、数字、中划线、下划线、英文句号组成，且只能以英文开头。
	Name string `json:"name"`
	// 描述。字符长度不超过255 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// 参数位置：PATH、QUERY、HEADER
	Location BackendParamBaseLocation `json:"location"`
	// 参数值。字符长度不超过255，类别为REQUEST时，值为req_params中的参数名称；类别为CONSTANT时，值为参数真正的值；类别为SYSTEM时，值为网关参数名称
	Value string `json:"value"`
}

func (BackendParamBase) String 

func (o BackendParamBase) String() string

type BackendParamBaseLocation 

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

func (BackendParamBaseLocation) MarshalJSON 

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

func (*BackendParamBaseLocation) UnmarshalJSON 

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

type BackendParamBaseLocationEnum 

type BackendParamBaseLocationEnum struct {
	PATH   BackendParamBaseLocation
	QUERY  BackendParamBaseLocation
	HEADER BackendParamBaseLocation
}

func GetBackendParamBaseLocationEnum 

func GetBackendParamBaseLocationEnum() BackendParamBaseLocationEnum

type BackendParamBaseOrigin 

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

func (BackendParamBaseOrigin) MarshalJSON 

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

func (*BackendParamBaseOrigin) UnmarshalJSON 

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

type BackendParamBaseOriginEnum 

type BackendParamBaseOriginEnum struct {
	REQUEST  BackendParamBaseOrigin
	CONSTANT BackendParamBaseOrigin
	SYSTEM   BackendParamBaseOrigin
}

func GetBackendParamBaseOriginEnum 

func GetBackendParamBaseOriginEnum() BackendParamBaseOriginEnum

type BackendParamLocation 

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

func (BackendParamLocation) MarshalJSON 

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

func (*BackendParamLocation) UnmarshalJSON 

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

type BackendParamLocationEnum 

type BackendParamLocationEnum struct {
	PATH   BackendParamLocation
	QUERY  BackendParamLocation
	HEADER BackendParamLocation
}

func GetBackendParamLocationEnum 

func GetBackendParamLocationEnum() BackendParamLocationEnum

type BackendParamOrigin 

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

func (BackendParamOrigin) MarshalJSON 

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

func (*BackendParamOrigin) UnmarshalJSON 

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

type BackendParamOriginEnum 

type BackendParamOriginEnum struct {
	REQUEST  BackendParamOrigin
	CONSTANT BackendParamOrigin
	SYSTEM   BackendParamOrigin
}

func GetBackendParamOriginEnum 

func GetBackendParamOriginEnum() BackendParamOriginEnum

type BatchDisassociateThrottlingPolicyV2Request 

type BatchDisassociateThrottlingPolicyV2Request struct {
	ProjectId  string                      `json:"project_id"`
	InstanceId string                      `json:"instance_id"`
	Action     string                      `json:"action"`
	Body       *ThrottleBindingBatchDelete `json:"body,omitempty"`
}

Request Object

func (BatchDisassociateThrottlingPolicyV2Request) String 

func (o BatchDisassociateThrottlingPolicyV2Request) String() string

type BatchDisassociateThrottlingPolicyV2Response 

type BatchDisassociateThrottlingPolicyV2Response struct {
	// 成功解除绑定的API和流控策略绑定关系的数量
	SuccessCount *int32 `json:"success_count,omitempty"`
	// 解除绑定失败的API和流控绑定关系及错误信息
	Failure        *[]ThrottleBindingBatchResultFailureResp `json:"failure,omitempty"`
	HttpStatusCode int                                      `json:"-"`
}

Response Object

func (BatchDisassociateThrottlingPolicyV2Response) String 

func (o BatchDisassociateThrottlingPolicyV2Response) String() string

type CancelingAuthorizationV2Request 

type CancelingAuthorizationV2Request struct {
	ProjectId  string `json:"project_id"`
	InstanceId string `json:"instance_id"`
	AppAuthId  string `json:"app_auth_id"`
}

Request Object

func (CancelingAuthorizationV2Request) String 

func (o CancelingAuthorizationV2Request) String() string

type CancelingAuthorizationV2Response 

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

Response Object

func (CancelingAuthorizationV2Response) String 

func (o CancelingAuthorizationV2Response) String() string

type CheckAppV2Request 

type CheckAppV2Request struct {
	ProjectId  string `json:"project_id"`
	InstanceId string `json:"instance_id"`
	AppId      string `json:"app_id"`
}

Request Object

func (CheckAppV2Request) String 

func (o CheckAppV2Request) String() string

type CheckAppV2Response 

type CheckAppV2Response struct {
	// 名称
	Name *string `json:"name,omitempty"`
	// 描述
	Remark *string `json:"remark,omitempty"`
	// 编号
	Id             *string `json:"id,omitempty"`
	HttpStatusCode int     `json:"-"`
}

Response Object

func (CheckAppV2Response) String 

func (o CheckAppV2Response) String() string

type CoditionResp 

type CoditionResp struct {
	// 关联的请求参数对象名称。策略类型为param时必选
	ReqParamName *string `json:"req_param_name,omitempty"`
	// 策略条件 - exact：绝对匹配 - enum：枚举 - pattern：正则  策略类型为param时必选
	ConditionType *CoditionRespConditionType `json:"condition_type,omitempty"`
	// 策略类型 - param：参数 - source：源IP
	ConditionOrigin CoditionRespConditionOrigin `json:"condition_origin"`
	// 策略值
	ConditionValue string `json:"condition_value"`
	// 编号
	Id *string `json:"id,omitempty"`
	// 关联的请求参数对象编号
	ReqParamId *string `json:"req_param_id,omitempty"`
	// 关联的请求参数对象位置
	ReqParamLocation *string `json:"req_param_location,omitempty"`
}

func (CoditionResp) String 

func (o CoditionResp) String() string

type CoditionRespConditionOrigin 

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

func (CoditionRespConditionOrigin) MarshalJSON 

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

func (*CoditionRespConditionOrigin) UnmarshalJSON 

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

type CoditionRespConditionOriginEnum 

type CoditionRespConditionOriginEnum struct {
	PARAM  CoditionRespConditionOrigin
	SOURCE CoditionRespConditionOrigin
}

func GetCoditionRespConditionOriginEnum 

func GetCoditionRespConditionOriginEnum() CoditionRespConditionOriginEnum

type CoditionRespConditionType 

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

func (CoditionRespConditionType) MarshalJSON 

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

func (*CoditionRespConditionType) UnmarshalJSON 

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

type CoditionRespConditionTypeEnum 

type CoditionRespConditionTypeEnum struct {
	EXACT   CoditionRespConditionType
	ENUM    CoditionRespConditionType
	PATTERN CoditionRespConditionType
}

func GetCoditionRespConditionTypeEnum 

func GetCoditionRespConditionTypeEnum() CoditionRespConditionTypeEnum

type CreateAnAppV2Request 

type CreateAnAppV2Request struct {
	ProjectId  string  `json:"project_id"`
	InstanceId string  `json:"instance_id"`
	Body       *AppReq `json:"body,omitempty"`
}

Request Object

func (CreateAnAppV2Request) String 

func (o CreateAnAppV2Request) String() string

type CreateAnAppV2Response 

type CreateAnAppV2Response struct {
	// APP的创建者 - USER：用户自行创建 - MARKET：云市场分配
	Creator *CreateAnAppV2ResponseCreator `json:"creator,omitempty"`
	// 更新时间
	UpdateTime *sdktime.SdkTime `json:"update_time,omitempty"`
	// APP的key
	AppKey *string `json:"app_key,omitempty"`
	// 名称
	Name *string `json:"name,omitempty"`
	// 描述
	Remark *string `json:"remark,omitempty"`
	// 编号
	Id *string `json:"id,omitempty"`
	// 密钥
	AppSecret *string `json:"app_secret,omitempty"`
	// 注册时间
	RegisterTime *sdktime.SdkTime `json:"register_time,omitempty"`
	// 状态
	Status *int32 `json:"status,omitempty"`
	// APP的类型  默认为apig，暂不支持其他类型
	AppType        *CreateAnAppV2ResponseAppType `json:"app_type,omitempty"`
	HttpStatusCode int                           `json:"-"`
}

Response Object

func (CreateAnAppV2Response) String 

func (o CreateAnAppV2Response) String() string

type CreateAnAppV2ResponseAppType 

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

func (CreateAnAppV2ResponseAppType) MarshalJSON 

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

func (*CreateAnAppV2ResponseAppType) UnmarshalJSON 

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

type CreateAnAppV2ResponseAppTypeEnum 

type CreateAnAppV2ResponseAppTypeEnum struct {
	APIG CreateAnAppV2ResponseAppType
	ROMA CreateAnAppV2ResponseAppType
}

func GetCreateAnAppV2ResponseAppTypeEnum 

func GetCreateAnAppV2ResponseAppTypeEnum() CreateAnAppV2ResponseAppTypeEnum

type CreateAnAppV2ResponseCreator 

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

func (CreateAnAppV2ResponseCreator) MarshalJSON 

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

func (*CreateAnAppV2ResponseCreator) UnmarshalJSON 

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

type CreateAnAppV2ResponseCreatorEnum 

type CreateAnAppV2ResponseCreatorEnum struct {
	USER   CreateAnAppV2ResponseCreator
	MARKET CreateAnAppV2ResponseCreator
}

func GetCreateAnAppV2ResponseCreatorEnum 

func GetCreateAnAppV2ResponseCreatorEnum() CreateAnAppV2ResponseCreatorEnum

type CreateApiGroupV2Request 

type CreateApiGroupV2Request struct {
	ProjectId  string       `json:"project_id"`
	InstanceId string       `json:"instance_id"`
	Body       *ApiGroupReq `json:"body,omitempty"`
}

Request Object

func (CreateApiGroupV2Request) String 

func (o CreateApiGroupV2Request) String() string

type CreateApiGroupV2Response 

type CreateApiGroupV2Response struct {
	// 分组上绑定的独立域名列表
	UrlDomains *[]UrlDomainsResp `json:"url_domains,omitempty"`
	// 流控时长内分组下的API的总访问次数限制，默认不限，请根据服务的负载能力自行设置  暂不支持
	CallLimits *int32 `json:"call_limits,omitempty"`
	// 最近修改时间
	UpdateTime *sdktime.SdkTime `json:"update_time,omitempty"`
	// API分组名称
	Name *string `json:"name,omitempty"`
	// 流控的时间单位  暂不支持
	TimeUnit *string `json:"time_unit,omitempty"`
	// 是否已上架云市场： - 1：已上架 - 2：未上架 - 3：审核中
	OnSellStatus *int32 `json:"on_sell_status,omitempty"`
	// 描述
	Remark *string `json:"remark,omitempty"`
	// 系统默认分配的子域名
	SlDomain *string `json:"sl_domain,omitempty"`
	// 系统默认分配的子域名列表
	SlDomains *[]string `json:"sl_domains,omitempty"`
	// 编号
	Id *string `json:"id,omitempty"`
	// 流控时长  暂不支持
	TimeInterval *int32 `json:"time_interval,omitempty"`
	// 创建时间
	RegisterTime *sdktime.SdkTime `json:"register_time,omitempty"`
	// 状态
	Status *int32 `json:"status,omitempty"`
	// 是否为默认分组
	IsDefault      *int32 `json:"is_default,omitempty"`
	HttpStatusCode int    `json:"-"`
}

Response Object

func (CreateApiGroupV2Response) String 

func (o CreateApiGroupV2Response) String() string

type CreateApiV2Request 

type CreateApiV2Request struct {
	ProjectId  string     `json:"project_id"`
	InstanceId string     `json:"instance_id"`
	Body       *ApiCreate `json:"body,omitempty"`
}

Request Object

func (CreateApiV2Request) String 

func (o CreateApiV2Request) String() string

type CreateApiV2Response 

type CreateApiV2Response struct {
	// API名称长度。  为3 ~ 64位的字符串，字符串由中文、英文字母、数字、下划线组成，且只能以英文或中文开头。 > 中文字符必须为UTF-8或者unicode编码。
	Name string `json:"name"`
	// API类型 - 1：公有API - 2：私有API
	Type CreateApiV2ResponseType `json:"type"`
	// API的版本
	Version *string `json:"version,omitempty"`
	// API的请求协议 - HTTP - HTTPS - BOTH：同时支持HTTP和HTTPS
	ReqProtocol CreateApiV2ResponseReqProtocol `json:"req_protocol"`
	// API的请求方式
	ReqMethod CreateApiV2ResponseReqMethod `json:"req_method"`
	// 请求地址。可以包含请求参数，用{}标识，比如/getUserInfo/{userId}，支持 * % - _ . 等特殊字符，总长度不超过512，且满足URI规范。  支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、中划线、下划线组成，且只能以英文开头。 > 需要服从URI规范。
	ReqUri string `json:"req_uri"`
	// API的认证方式 - NONE：无认证 - APP：APP认证 - IAM：IAM认证 - AUTHORIZER：自定义认证
	AuthType CreateApiV2ResponseAuthType `json:"auth_type"`
	AuthOpt  *AuthOpt                    `json:"auth_opt,omitempty"`
	// 是否支持跨域 - TRUE：支持 - FALSE：不支持
	Cors *bool `json:"cors,omitempty"`
	// API的匹配方式 - SWA：前缀匹配 - NORMAL：正常匹配（绝对匹配） 默认：NORMAL
	MatchMode *CreateApiV2ResponseMatchMode `json:"match_mode,omitempty"`
	// 后端类型 - HTTP：web后端 - FUNCTION：函数工作流 - MOCK：模拟的后端
	BackendType CreateApiV2ResponseBackendType `json:"backend_type"`
	// API描述。字符长度不超过255 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// API所属的分组编号
	GroupId string `json:"group_id"`
	// API请求体描述，可以是请求体示例、媒体类型、参数等信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	BodyRemark *string `json:"body_remark,omitempty"`
	// 正常响应示例，描述API的正常返回信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	ResultNormalSample *string `json:"result_normal_sample,omitempty"`
	// 失败返回示例，描述API的异常返回信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	ResultFailureSample *string `json:"result_failure_sample,omitempty"`
	// 前端自定义认证对象的ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
	// 标签。  支持英文，数字，下划线，且只能以英文开头。支持输入多个标签，不同标签以英文逗号分割。
	Tags *[]string `json:"tags,omitempty"`
	// 分组自定义响应ID
	ResponseId *string `json:"response_id,omitempty"`
	// 集成应用ID  暂不支持
	RomaAppId *string `json:"roma_app_id,omitempty"`
	// API绑定的自定义域名  暂不支持
	DomainName *string `json:"domain_name,omitempty"`
	// 标签  待废弃，优先使用tags字段
	Tag *string `json:"tag,omitempty"`
	// API编号
	Id *string `json:"id,omitempty"`
	// API的状态
	Status *int32 `json:"status,omitempty"`
	// 是否需要编排
	ArrangeNecessary *int32 `json:"arrange_necessary,omitempty"`
	// API注册时间
	RegisterTime *sdktime.SdkTime `json:"register_time,omitempty"`
	// API修改时间
	UpdateTime *sdktime.SdkTime `json:"update_time,omitempty"`
	// API所属分组的名称
	GroupName *string `json:"group_name,omitempty"`
	// API所属分组的版本  默认V1，其他版本暂不支持
	GroupVersion *string `json:"group_version,omitempty"`
	// 发布的环境id
	RunEnvId *string `json:"run_env_id,omitempty"`
	// 发布的环境名称
	RunEnvName *string `json:"run_env_name,omitempty"`
	// 发布记录编号  存在多个发布记录时，编号之间用|隔开
	PublishId *string  `json:"publish_id,omitempty"`
	FuncInfo  *ApiFunc `json:"func_info,omitempty"`
	MockInfo  *ApiMock `json:"mock_info,omitempty"`
	// API的请求参数列表
	ReqParams *[]ReqParam `json:"req_params,omitempty"`
	// API的后端参数列表
	BackendParams *[]BackendParam `json:"backend_params,omitempty"`
	// 函数工作流策略后端列表
	PolicyFunctions *[]ApiPolicyFunctionResp `json:"policy_functions,omitempty"`
	// mock策略后端列表
	PolicyMocks *[]ApiPolicyMockResp `json:"policy_mocks,omitempty"`
	BackendApi  *BackendApi          `json:"backend_api,omitempty"`
	// web策略后端列表
	PolicyHttps    *[]ApiPolicyHttpResp `json:"policy_https,omitempty"`
	HttpStatusCode int                  `json:"-"`
}

Response Object

func (CreateApiV2Response) String 

func (o CreateApiV2Response) String() string

type CreateApiV2ResponseAuthType 

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

func (CreateApiV2ResponseAuthType) MarshalJSON 

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

func (*CreateApiV2ResponseAuthType) UnmarshalJSON 

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

type CreateApiV2ResponseAuthTypeEnum 

type CreateApiV2ResponseAuthTypeEnum struct {
	NONE       CreateApiV2ResponseAuthType
	APP        CreateApiV2ResponseAuthType
	IAM        CreateApiV2ResponseAuthType
	AUTHORIZER CreateApiV2ResponseAuthType
}

func GetCreateApiV2ResponseAuthTypeEnum 

func GetCreateApiV2ResponseAuthTypeEnum() CreateApiV2ResponseAuthTypeEnum

type CreateApiV2ResponseBackendType 

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

func (CreateApiV2ResponseBackendType) MarshalJSON 

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

func (*CreateApiV2ResponseBackendType) UnmarshalJSON 

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

type CreateApiV2ResponseBackendTypeEnum 

type CreateApiV2ResponseBackendTypeEnum struct {
	HTTP     CreateApiV2ResponseBackendType
	FUNCTION CreateApiV2ResponseBackendType
	MOCK     CreateApiV2ResponseBackendType
}

func GetCreateApiV2ResponseBackendTypeEnum 

func GetCreateApiV2ResponseBackendTypeEnum() CreateApiV2ResponseBackendTypeEnum

type CreateApiV2ResponseMatchMode 

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

func (CreateApiV2ResponseMatchMode) MarshalJSON 

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

func (*CreateApiV2ResponseMatchMode) UnmarshalJSON 

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

type CreateApiV2ResponseMatchModeEnum 

type CreateApiV2ResponseMatchModeEnum struct {
	SWA    CreateApiV2ResponseMatchMode
	NORMAL CreateApiV2ResponseMatchMode
}

func GetCreateApiV2ResponseMatchModeEnum 

func GetCreateApiV2ResponseMatchModeEnum() CreateApiV2ResponseMatchModeEnum

type CreateApiV2ResponseReqMethod 

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

func (CreateApiV2ResponseReqMethod) MarshalJSON 

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

func (*CreateApiV2ResponseReqMethod) UnmarshalJSON 

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

type CreateApiV2ResponseReqMethodEnum 

type CreateApiV2ResponseReqMethodEnum struct {
	GET     CreateApiV2ResponseReqMethod
	POST    CreateApiV2ResponseReqMethod
	PUT     CreateApiV2ResponseReqMethod
	DELETE  CreateApiV2ResponseReqMethod
	HEAD    CreateApiV2ResponseReqMethod
	PATCH   CreateApiV2ResponseReqMethod
	OPTIONS CreateApiV2ResponseReqMethod
	ANY     CreateApiV2ResponseReqMethod
}

func GetCreateApiV2ResponseReqMethodEnum 

func GetCreateApiV2ResponseReqMethodEnum() CreateApiV2ResponseReqMethodEnum

type CreateApiV2ResponseReqProtocol 

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

func (CreateApiV2ResponseReqProtocol) MarshalJSON 

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

func (*CreateApiV2ResponseReqProtocol) UnmarshalJSON 

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

type CreateApiV2ResponseReqProtocolEnum 

type CreateApiV2ResponseReqProtocolEnum struct {
	HTTP  CreateApiV2ResponseReqProtocol
	HTTPS CreateApiV2ResponseReqProtocol
	BOTH  CreateApiV2ResponseReqProtocol
}

func GetCreateApiV2ResponseReqProtocolEnum 

func GetCreateApiV2ResponseReqProtocolEnum() CreateApiV2ResponseReqProtocolEnum

type CreateApiV2ResponseType 

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

func (CreateApiV2ResponseType) MarshalJSON 

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

func (*CreateApiV2ResponseType) UnmarshalJSON 

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

type CreateApiV2ResponseTypeEnum 

type CreateApiV2ResponseTypeEnum struct {
	E_1 CreateApiV2ResponseType
	E_2 CreateApiV2ResponseType
}

func GetCreateApiV2ResponseTypeEnum 

func GetCreateApiV2ResponseTypeEnum() CreateApiV2ResponseTypeEnum

type CreateAuthorizingAppsV2Request 

type CreateAuthorizingAppsV2Request struct {
	ProjectId  string      `json:"project_id"`
	InstanceId string      `json:"instance_id"`
	Body       *AppAuthReq `json:"body,omitempty"`
}

Request Object

func (CreateAuthorizingAppsV2Request) String 

func (o CreateAuthorizingAppsV2Request) String() string

type CreateAuthorizingAppsV2Response 

type CreateAuthorizingAppsV2Response struct {
	// API与APP的授权关系列表
	Auths          *[]AppAuthResp `json:"auths,omitempty"`
	HttpStatusCode int            `json:"-"`
}

Response Object

func (CreateAuthorizingAppsV2Response) String 

func (o CreateAuthorizingAppsV2Response) String() string

type CreateEnvironmentV2Request 

type CreateEnvironmentV2Request struct {
	ProjectId  string  `json:"project_id"`
	InstanceId string  `json:"instance_id"`
	Body       *EnvReq `json:"body,omitempty"`
}

Request Object

func (CreateEnvironmentV2Request) String 

func (o CreateEnvironmentV2Request) String() string

type CreateEnvironmentV2Response 

type CreateEnvironmentV2Response struct {
	// 创建时间
	CreateTime *sdktime.SdkTime `json:"create_time,omitempty"`
	// 环境名称
	Name *string `json:"name,omitempty"`
	// 描述信息
	Remark *string `json:"remark,omitempty"`
	// 环境id
	Id             *string `json:"id,omitempty"`
	HttpStatusCode int     `json:"-"`
}

Response Object

func (CreateEnvironmentV2Response) String 

func (o CreateEnvironmentV2Response) String() string

type CreateEnvironmentVariableV2Request 

type CreateEnvironmentVariableV2Request struct {
	ProjectId  string          `json:"project_id"`
	InstanceId string          `json:"instance_id"`
	Body       *EnvVariableReq `json:"body,omitempty"`
}

Request Object

func (CreateEnvironmentVariableV2Request) String 

func (o CreateEnvironmentVariableV2Request) String() string

type CreateEnvironmentVariableV2Response 

type CreateEnvironmentVariableV2Response struct {
	// 变量值
	VariableValue *string `json:"variable_value,omitempty"`
	// 环境编号
	EnvId *string `json:"env_id,omitempty"`
	// API分组编号
	GroupId *string `json:"group_id,omitempty"`
	// 环境变量编号
	Id *string `json:"id,omitempty"`
	// 变量名
	VariableName   *string `json:"variable_name,omitempty"`
	HttpStatusCode int     `json:"-"`
}

Response Object

func (CreateEnvironmentVariableV2Response) String 

func (o CreateEnvironmentVariableV2Response) String() string

type CreateOrDeletePublishRecordForApiV2Request 

type CreateOrDeletePublishRecordForApiV2Request struct {
	ProjectId  string         `json:"project_id"`
	InstanceId string         `json:"instance_id"`
	Body       *ApiPublishReq `json:"body,omitempty"`
}

Request Object

func (CreateOrDeletePublishRecordForApiV2Request) String 

func (o CreateOrDeletePublishRecordForApiV2Request) String() string

type CreateOrDeletePublishRecordForApiV2Response 

type CreateOrDeletePublishRecordForApiV2Response struct {
	// 发布记录的ID
	PublishId *string `json:"publish_id,omitempty"`
	// API编号
	ApiId *string `json:"api_id,omitempty"`
	// API名称
	ApiName *string `json:"api_name,omitempty"`
	// 发布的环境编号
	EnvId *string `json:"env_id,omitempty"`
	// 发布描述
	Remark *string `json:"remark,omitempty"`
	// 发布时间
	PublishTime *sdktime.SdkTime `json:"publish_time,omitempty"`
	// 在线的版本号
	VersionId      *string `json:"version_id,omitempty"`
	HttpStatusCode int     `json:"-"`
}

Response Object

func (CreateOrDeletePublishRecordForApiV2Response) String 

func (o CreateOrDeletePublishRecordForApiV2Response) String() string

type CreateRequestThrottlingPolicyV2Request 

type CreateRequestThrottlingPolicyV2Request struct {
	ProjectId  string       `json:"project_id"`
	InstanceId string       `json:"instance_id"`
	Body       *ThrottleReq `json:"body,omitempty"`
}

Request Object

func (CreateRequestThrottlingPolicyV2Request) String 

func (o CreateRequestThrottlingPolicyV2Request) String() string

type CreateRequestThrottlingPolicyV2Response 

type CreateRequestThrottlingPolicyV2Response struct {
	// 流控绑定的API数量
	BindNum *int32 `json:"bind_num,omitempty"`
	// 是否包含特殊流控配置 - 1：包含 - 2：不包含
	IsIncludeSpecialThrottle *CreateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottle `json:"is_include_special_throttle,omitempty"`
	// 创建时间
	CreateTime *sdktime.SdkTime `json:"create_time,omitempty"`
	// 描述
	Remark *string `json:"remark,omitempty"`
	// 流控策略的类型 - 1：独享，表示绑定到流控策略的单个API流控时间内能够被调用多少次。 - 2：共享，表示绑定到流控策略的所有API流控时间内能够被调用多少次
	Type *CreateRequestThrottlingPolicyV2ResponseType `json:"type,omitempty"`
	// 流控的时长
	TimeInterval *int32 `json:"time_interval,omitempty"`
	// 单个IP流控时间内能够访问API的次数限制
	IpCallLimits *int32 `json:"ip_call_limits,omitempty"`
	// 单个APP流控时间内能够访问API的次数限制
	AppCallLimits *int32 `json:"app_call_limits,omitempty"`
	// 流控策略的名称
	Name *string `json:"name,omitempty"`
	// 流控的时间单位
	TimeUnit *CreateRequestThrottlingPolicyV2ResponseTimeUnit `json:"time_unit,omitempty"`
	// 单个API流控时间内能够被访问的次数限制
	ApiCallLimits *int32 `json:"api_call_limits,omitempty"`
	// 流控策略的ID
	Id *string `json:"id,omitempty"`
	// 单个用户流控时间内能够访问API的次数限制
	UserCallLimits *int32 `json:"user_call_limits,omitempty"`
	// 是否开启动态流控  暂不支持
	EnableAdaptiveControl *string `json:"enable_adaptive_control,omitempty"`
	HttpStatusCode        int     `json:"-"`
}

Response Object

func (CreateRequestThrottlingPolicyV2Response) String 

func (o CreateRequestThrottlingPolicyV2Response) String() string

type CreateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottle 

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

func (CreateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottle) MarshalJSON 

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

func (*CreateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottle) UnmarshalJSON 

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

type CreateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottleEnum 

type CreateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottleEnum struct {
	E_1 CreateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottle
	E_2 CreateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottle
}

func GetCreateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottleEnum 

func GetCreateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottleEnum() CreateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottleEnum

type CreateRequestThrottlingPolicyV2ResponseTimeUnit 

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

func (CreateRequestThrottlingPolicyV2ResponseTimeUnit) MarshalJSON 

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

func (*CreateRequestThrottlingPolicyV2ResponseTimeUnit) UnmarshalJSON 

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

type CreateRequestThrottlingPolicyV2ResponseTimeUnitEnum 

type CreateRequestThrottlingPolicyV2ResponseTimeUnitEnum struct {
	SECOND CreateRequestThrottlingPolicyV2ResponseTimeUnit
	MINUTE CreateRequestThrottlingPolicyV2ResponseTimeUnit
	HOUR   CreateRequestThrottlingPolicyV2ResponseTimeUnit
	DAY    CreateRequestThrottlingPolicyV2ResponseTimeUnit
}

func GetCreateRequestThrottlingPolicyV2ResponseTimeUnitEnum 

func GetCreateRequestThrottlingPolicyV2ResponseTimeUnitEnum() CreateRequestThrottlingPolicyV2ResponseTimeUnitEnum

type CreateRequestThrottlingPolicyV2ResponseType 

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

func (CreateRequestThrottlingPolicyV2ResponseType) MarshalJSON 

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

func (*CreateRequestThrottlingPolicyV2ResponseType) UnmarshalJSON 

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

type CreateRequestThrottlingPolicyV2ResponseTypeEnum 

type CreateRequestThrottlingPolicyV2ResponseTypeEnum struct {
	E_1 CreateRequestThrottlingPolicyV2ResponseType
	E_2 CreateRequestThrottlingPolicyV2ResponseType
}

func GetCreateRequestThrottlingPolicyV2ResponseTypeEnum 

func GetCreateRequestThrottlingPolicyV2ResponseTypeEnum() CreateRequestThrottlingPolicyV2ResponseTypeEnum

type CreateSignatureKeyV2Request 

type CreateSignatureKeyV2Request struct {
	ProjectId  string        `json:"project_id"`
	InstanceId string        `json:"instance_id"`
	Body       *SignatureReq `json:"body,omitempty"`
}

Request Object

func (CreateSignatureKeyV2Request) String 

func (o CreateSignatureKeyV2Request) String() string

type CreateSignatureKeyV2Response 

type CreateSignatureKeyV2Response struct {
	// 签名密钥的密钥
	SignSecret *string `json:"sign_secret,omitempty"`
	// 更新时间
	UpdateTime *sdktime.SdkTime `json:"update_time,omitempty"`
	// 创建时间
	CreateTime *sdktime.SdkTime `json:"create_time,omitempty"`
	// 签名密钥的名称
	Name *string `json:"name,omitempty"`
	// 签名密钥的编号
	Id *string `json:"id,omitempty"`
	// 签名密钥的key
	SignKey *string `json:"sign_key,omitempty"`
	// 签名密钥类型。
	SignType       *CreateSignatureKeyV2ResponseSignType `json:"sign_type,omitempty"`
	HttpStatusCode int                                   `json:"-"`
}

Response Object

func (CreateSignatureKeyV2Response) String 

func (o CreateSignatureKeyV2Response) String() string

type CreateSignatureKeyV2ResponseSignType 

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

func (CreateSignatureKeyV2ResponseSignType) MarshalJSON 

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

func (*CreateSignatureKeyV2ResponseSignType) UnmarshalJSON 

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

type CreateSignatureKeyV2ResponseSignTypeEnum 

type CreateSignatureKeyV2ResponseSignTypeEnum struct {
	HMAC  CreateSignatureKeyV2ResponseSignType
	BASIC CreateSignatureKeyV2ResponseSignType
}

func GetCreateSignatureKeyV2ResponseSignTypeEnum 

func GetCreateSignatureKeyV2ResponseSignTypeEnum() CreateSignatureKeyV2ResponseSignTypeEnum

type CreateSpecialThrottlingConfigurationV2Request 

type CreateSpecialThrottlingConfigurationV2Request struct {
	ProjectId  string              `json:"project_id"`
	InstanceId string              `json:"instance_id"`
	ThrottleId string              `json:"throttle_id"`
	Body       *ThrottleSpecialReq `json:"body,omitempty"`
}

Request Object

func (CreateSpecialThrottlingConfigurationV2Request) String 

func (o CreateSpecialThrottlingConfigurationV2Request) String() string

type CreateSpecialThrottlingConfigurationV2Response 

type CreateSpecialThrottlingConfigurationV2Response struct {
	// 特殊对象在流控时间内能够访问API的最大次数限制
	CallLimits *int32 `json:"call_limits,omitempty"`
	// 作用的APP名称
	AppName *string `json:"app_name,omitempty"`
	// 作用的APP或租户的名称
	ObjectName *string `json:"object_name,omitempty"`
	// 特殊对象的身份标识
	ObjectId *string `json:"object_id,omitempty"`
	// 流控策略编号
	ThrottleId *string `json:"throttle_id,omitempty"`
	// 设置时间
	ApplyTime *sdktime.SdkTime `json:"apply_time,omitempty"`
	// 特殊配置的编号
	Id *string `json:"id,omitempty"`
	// 作用的APP编号
	AppId *string `json:"app_id,omitempty"`
	// 特殊对象类型：APP、USER
	ObjectType     *string `json:"object_type,omitempty"`
	HttpStatusCode int     `json:"-"`
}

Response Object

func (CreateSpecialThrottlingConfigurationV2Response) String 

func (o CreateSpecialThrottlingConfigurationV2Response) String() string

type DeleteApiGroupV2Request 

type DeleteApiGroupV2Request struct {
	ProjectId  string `json:"project_id"`
	InstanceId string `json:"instance_id"`
	GroupId    string `json:"group_id"`
}

Request Object

func (DeleteApiGroupV2Request) String 

func (o DeleteApiGroupV2Request) String() string

type DeleteApiGroupV2Response 

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

Response Object

func (DeleteApiGroupV2Response) String 

func (o DeleteApiGroupV2Response) String() string

type DeleteApiV2Request 

type DeleteApiV2Request struct {
	ProjectId  string `json:"project_id"`
	InstanceId string `json:"instance_id"`
	ApiId      string `json:"api_id"`
}

Request Object

func (DeleteApiV2Request) String 

func (o DeleteApiV2Request) String() string

type DeleteApiV2Response 

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

Response Object

func (DeleteApiV2Response) String 

func (o DeleteApiV2Response) String() string

type DeleteAppV2Request 

type DeleteAppV2Request struct {
	ProjectId  string `json:"project_id"`
	InstanceId string `json:"instance_id"`
	AppId      string `json:"app_id"`
}

Request Object

func (DeleteAppV2Request) String 

func (o DeleteAppV2Request) String() string

type DeleteAppV2Response 

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

Response Object

func (DeleteAppV2Response) String 

func (o DeleteAppV2Response) String() string

type DeleteEnvironmentV2Request 

type DeleteEnvironmentV2Request struct {
	ProjectId  string `json:"project_id"`
	InstanceId string `json:"instance_id"`
	EnvId      string `json:"env_id"`
}

Request Object

func (DeleteEnvironmentV2Request) String 

func (o DeleteEnvironmentV2Request) String() string

type DeleteEnvironmentV2Response 

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

Response Object

func (DeleteEnvironmentV2Response) String 

func (o DeleteEnvironmentV2Response) String() string

type DeleteEnvironmentVariableV2Request 

type DeleteEnvironmentVariableV2Request struct {
	ProjectId     string `json:"project_id"`
	InstanceId    string `json:"instance_id"`
	EnvVariableId string `json:"env_variable_id"`
}

Request Object

func (DeleteEnvironmentVariableV2Request) String 

func (o DeleteEnvironmentVariableV2Request) String() string

type DeleteEnvironmentVariableV2Response 

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

Response Object

func (DeleteEnvironmentVariableV2Response) String 

func (o DeleteEnvironmentVariableV2Response) String() string

type DeleteRequestThrottlingPolicyV2Request 

type DeleteRequestThrottlingPolicyV2Request struct {
	ProjectId  string `json:"project_id"`
	InstanceId string `json:"instance_id"`
	ThrottleId string `json:"throttle_id"`
}

Request Object

func (DeleteRequestThrottlingPolicyV2Request) String 

func (o DeleteRequestThrottlingPolicyV2Request) String() string

type DeleteRequestThrottlingPolicyV2Response 

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

Response Object

func (DeleteRequestThrottlingPolicyV2Response) String 

func (o DeleteRequestThrottlingPolicyV2Response) String() string

type DeleteSignatureKeyV2Request 

type DeleteSignatureKeyV2Request struct {
	ProjectId  string `json:"project_id"`
	InstanceId string `json:"instance_id"`
	SignId     string `json:"sign_id"`
}

Request Object

func (DeleteSignatureKeyV2Request) String 

func (o DeleteSignatureKeyV2Request) String() string

type DeleteSignatureKeyV2Response 

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

Response Object

func (DeleteSignatureKeyV2Response) String 

func (o DeleteSignatureKeyV2Response) String() string

type DeleteSpecialThrottlingConfigurationV2Request 

type DeleteSpecialThrottlingConfigurationV2Request struct {
	ProjectId  string `json:"project_id"`
	InstanceId string `json:"instance_id"`
	ThrottleId string `json:"throttle_id"`
	StrategyId string `json:"strategy_id"`
}

Request Object

func (DeleteSpecialThrottlingConfigurationV2Request) String 

func (o DeleteSpecialThrottlingConfigurationV2Request) String() string

type DeleteSpecialThrottlingConfigurationV2Response 

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

Response Object

func (DeleteSpecialThrottlingConfigurationV2Response) String 

func (o DeleteSpecialThrottlingConfigurationV2Response) String() string

type DisassociateCertificateV2Request 

type DisassociateCertificateV2Request struct {
	ProjectId     string `json:"project_id"`
	InstanceId    string `json:"instance_id"`
	GroupId       string `json:"group_id"`
	CertificateId string `json:"certificate_id"`
}

Request Object

func (DisassociateCertificateV2Request) String 

func (o DisassociateCertificateV2Request) String() string

type DisassociateCertificateV2Response 

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

Response Object

func (DisassociateCertificateV2Response) String 

func (o DisassociateCertificateV2Response) String() string

type DisassociateDomainV2Request 

type DisassociateDomainV2Request struct {
	ProjectId  string `json:"project_id"`
	InstanceId string `json:"instance_id"`
	GroupId    string `json:"group_id"`
}

Request Object

func (DisassociateDomainV2Request) String 

func (o DisassociateDomainV2Request) String() string

type DisassociateDomainV2Response 

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

Response Object

func (DisassociateDomainV2Response) String 

func (o DisassociateDomainV2Response) String() string

type DisassociateRequestThrottlingPolicyV2Request 

type DisassociateRequestThrottlingPolicyV2Request struct {
	ProjectId         string `json:"project_id"`
	InstanceId        string `json:"instance_id"`
	ThrottleBindingId string `json:"throttle_binding_id"`
}

Request Object

func (DisassociateRequestThrottlingPolicyV2Request) String 

func (o DisassociateRequestThrottlingPolicyV2Request) String() string

type DisassociateRequestThrottlingPolicyV2Response 

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

Response Object

func (DisassociateRequestThrottlingPolicyV2Response) String 

func (o DisassociateRequestThrottlingPolicyV2Response) String() string

type DisassociateSignatureKeyV2Request 

type DisassociateSignatureKeyV2Request struct {
	ProjectId      string `json:"project_id"`
	InstanceId     string `json:"instance_id"`
	SignBindingsId string `json:"sign_bindings_id"`
}

Request Object

func (DisassociateSignatureKeyV2Request) String 

func (o DisassociateSignatureKeyV2Request) String() string

type DisassociateSignatureKeyV2Response 

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

Response Object

func (DisassociateSignatureKeyV2Response) String 

func (o DisassociateSignatureKeyV2Response) String() string

type DomainCertReq 

type DomainCertReq struct {
	// 证书内容
	CertContent string `json:"cert_content"`
	// 证书名称。长度为4 ~ 50位的字符串，字符串由中文、英文字母、数字、下划线组成，且只能以英文或中文开头。
	Name string `json:"name"`
	// 私钥内容
	PrivateKey string `json:"private_key"`
}

func (DomainCertReq) String 

func (o DomainCertReq) String() string

type DomainReq 

type DomainReq struct {
	// 自定义域名。长度为0-255位的字符串，需要符合域名规范。
	UrlDomain string `json:"url_domain"`
}

func (DomainReq) String 

func (o DomainReq) String() string

type EnvReq 

type EnvReq struct {
	// 环境的名称，支持英文，数字，下划线，且只能以英文字母开头。
	Name string `json:"name"`
	// 描述信息 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
}

func (EnvReq) String 

func (o EnvReq) String() string

type EnvResp 

type EnvResp struct {
	// 创建时间
	CreateTime *sdktime.SdkTime `json:"create_time,omitempty"`
	// 环境名称
	Name *string `json:"name,omitempty"`
	// 描述信息
	Remark *string `json:"remark,omitempty"`
	// 环境id
	Id *string `json:"id,omitempty"`
}

func (EnvResp) String 

func (o EnvResp) String() string

type EnvVariableReq 

type EnvVariableReq struct {
	// 变量值支持英文字母、数字、英文格式的下划线、中划线，斜线（/）、点、冒号，1 ~ 255个字符。
	VariableValue string `json:"variable_value"`
	// 环境编号
	EnvId string `json:"env_id"`
	// API分组编号
	GroupId string `json:"group_id"`
	// 变量名，支持英文字母、数字、英文格式的下划线、中划线，必须以英文字母开头, 3 ~ 32个字符。在API定义中等于#Name的值#部分（区分大小写），发布到环境里的API被变量值换。 > 中文字符必须为UTF-8或者unicode编码。
	VariableName string `json:"variable_name"`
}

func (EnvVariableReq) String 

func (o EnvVariableReq) String() string

type EnvVariableResp 

type EnvVariableResp struct {
	// 变量值
	VariableValue *string `json:"variable_value,omitempty"`
	// 环境编号
	EnvId *string `json:"env_id,omitempty"`
	// API分组编号
	GroupId *string `json:"group_id,omitempty"`
	// 环境变量编号
	Id *string `json:"id,omitempty"`
	// 变量名
	VariableName *string `json:"variable_name,omitempty"`
}

func (EnvVariableResp) String 

func (o EnvVariableResp) String() string

type ListApiGroupsQuantitiesV2Request 

type ListApiGroupsQuantitiesV2Request struct {
	ProjectId  string `json:"project_id"`
	InstanceId string `json:"instance_id"`
}

Request Object

func (ListApiGroupsQuantitiesV2Request) String 

func (o ListApiGroupsQuantitiesV2Request) String() string

type ListApiGroupsQuantitiesV2Response 

type ListApiGroupsQuantitiesV2Response struct {
	// 未上架的API分组个数  暂不支持
	OffsellNums *int32 `json:"offsell_nums,omitempty"`
	// 已上架的API分组个数
	OnsellNums     *int32 `json:"onsell_nums,omitempty"`
	HttpStatusCode int    `json:"-"`
}

Response Object

func (ListApiGroupsQuantitiesV2Response) String 

func (o ListApiGroupsQuantitiesV2Response) String() string

type ListApiGroupsV2Request 

type ListApiGroupsV2Request struct {
	ProjectId     string  `json:"project_id"`
	InstanceId    string  `json:"instance_id"`
	Id            *string `json:"id,omitempty"`
	Name          *string `json:"name,omitempty"`
	Offset        *int64  `json:"offset,omitempty"`
	Limit         *int32  `json:"limit,omitempty"`
	PreciseSearch *string `json:"precise_search,omitempty"`
}

Request Object

func (ListApiGroupsV2Request) String 

func (o ListApiGroupsV2Request) String() string

type ListApiGroupsV2Response 

type ListApiGroupsV2Response struct {
	// 满足条件的分组总数
	Total *int32 `json:"total,omitempty"`
	// 本次返回的列表长度
	Size *int32 `json:"size,omitempty"`
	// 分组列表
	Groups         *[]ApiGroupDetailResp `json:"groups,omitempty"`
	HttpStatusCode int                   `json:"-"`
}

Response Object

func (ListApiGroupsV2Response) String 

func (o ListApiGroupsV2Response) String() string

type ListApiQuantitiesV2Request 

type ListApiQuantitiesV2Request struct {
	ProjectId  string `json:"project_id"`
	InstanceId string `json:"instance_id"`
}

Request Object

func (ListApiQuantitiesV2Request) String 

func (o ListApiQuantitiesV2Request) String() string

type ListApiQuantitiesV2Response 

type ListApiQuantitiesV2Response struct {
	// API总个数
	InstanceNum *int32 `json:"instance_num,omitempty"`
	// 已发布到release环境的API个数
	NumsOnRelease *int32 `json:"nums_on_release,omitempty"`
	// 未发布到release环境的API个数
	NumsOffRelease *int32 `json:"nums_off_release,omitempty"`
	HttpStatusCode int    `json:"-"`
}

Response Object

func (ListApiQuantitiesV2Response) String 

func (o ListApiQuantitiesV2Response) String() string

type ListApisBindedToAppV2Request 

type ListApisBindedToAppV2Request struct {
	ProjectId  string  `json:"project_id"`
	InstanceId string  `json:"instance_id"`
	AppId      string  `json:"app_id"`
	ApiId      *string `json:"api_id,omitempty"`
	ApiName    *string `json:"api_name,omitempty"`
	GroupId    *string `json:"group_id,omitempty"`
	GroupName  *string `json:"group_name,omitempty"`
	EnvId      *string `json:"env_id,omitempty"`
	Offset     *int64  `json:"offset,omitempty"`
	Limit      *int32  `json:"limit,omitempty"`
}

Request Object

func (ListApisBindedToAppV2Request) String 

func (o ListApisBindedToAppV2Request) String() string

type ListApisBindedToAppV2Response 

type ListApisBindedToAppV2Response struct {
	// 符合条件的API总数
	Total *int32 `json:"total,omitempty"`
	// 本次返回的列表长度
	Size *int32 `json:"size,omitempty"`
	// 本次返回的API列表
	Auths          *[]AppAuthBindedApiResp `json:"auths,omitempty"`
	HttpStatusCode int                     `json:"-"`
}

Response Object

func (ListApisBindedToAppV2Response) String 

func (o ListApisBindedToAppV2Response) String() string

type ListApisBindedToRequestThrottlingPolicyV2Request 

type ListApisBindedToRequestThrottlingPolicyV2Request struct {
	ProjectId  string  `json:"project_id"`
	InstanceId string  `json:"instance_id"`
	ThrottleId string  `json:"throttle_id"`
	EnvId      *string `json:"env_id,omitempty"`
	GroupId    *string `json:"group_id,omitempty"`
	ApiId      *string `json:"api_id,omitempty"`
	ApiName    *string `json:"api_name,omitempty"`
	Offset     *int64  `json:"offset,omitempty"`
	Limit      *int32  `json:"limit,omitempty"`
}

Request Object

func (ListApisBindedToRequestThrottlingPolicyV2Request) String 

func (o ListApisBindedToRequestThrottlingPolicyV2Request) String() string

type ListApisBindedToRequestThrottlingPolicyV2Response 

type ListApisBindedToRequestThrottlingPolicyV2Response struct {
	// 满足条件的API总数
	Total *int32 `json:"total,omitempty"`
	// 本次返回的API列表长度
	Size *int32 `json:"size,omitempty"`
	// 本次查询返回的API列表
	Apis           *[]ThrottleBindingApiResp `json:"apis,omitempty"`
	HttpStatusCode int                       `json:"-"`
}

Response Object

func (ListApisBindedToRequestThrottlingPolicyV2Response) String 

func (o ListApisBindedToRequestThrottlingPolicyV2Response) String() string

type ListApisBindedToSignatureKeyV2Request 

type ListApisBindedToSignatureKeyV2Request struct {
	ProjectId  string  `json:"project_id"`
	InstanceId string  `json:"instance_id"`
	SignId     string  `json:"sign_id"`
	EnvId      *string `json:"env_id,omitempty"`
	ApiId      *string `json:"api_id,omitempty"`
	ApiName    *string `json:"api_name,omitempty"`
	GroupId    *string `json:"group_id,omitempty"`
	Offset     *int64  `json:"offset,omitempty"`
	Limit      *int32  `json:"limit,omitempty"`
}

Request Object

func (ListApisBindedToSignatureKeyV2Request) String 

func (o ListApisBindedToSignatureKeyV2Request) String() string

type ListApisBindedToSignatureKeyV2Response 

type ListApisBindedToSignatureKeyV2Response struct {
	// 本次查询满足条件的总数
	Total *int32 `json:"total,omitempty"`
	// 本次查询返回的列表长度
	Size *int32 `json:"size,omitempty"`
	// 本次查询返回的列表
	Bindings       *[]SignBindingApiResp `json:"bindings,omitempty"`
	HttpStatusCode int                   `json:"-"`
}

Response Object

func (ListApisBindedToSignatureKeyV2Response) String 

func (o ListApisBindedToSignatureKeyV2Response) String() string

type ListApisNotBoundWithSignatureKeyV2Request 

type ListApisNotBoundWithSignatureKeyV2Request struct {
	ProjectId  string  `json:"project_id"`
	InstanceId string  `json:"instance_id"`
	SignId     string  `json:"sign_id"`
	EnvId      *string `json:"env_id,omitempty"`
	ApiId      *string `json:"api_id,omitempty"`
	ApiName    *string `json:"api_name,omitempty"`
	GroupId    *string `json:"group_id,omitempty"`
	Offset     *int64  `json:"offset,omitempty"`
	Limit      *int32  `json:"limit,omitempty"`
}

Request Object

func (ListApisNotBoundWithSignatureKeyV2Request) String 

func (o ListApisNotBoundWithSignatureKeyV2Request) String() string

type ListApisNotBoundWithSignatureKeyV2Response 

type ListApisNotBoundWithSignatureKeyV2Response struct {
	// 满足查询条件的API的总个数
	Total *int32 `json:"total,omitempty"`
	// 本次查询返回的API列表长度
	Size *int32 `json:"size,omitempty"`
	// 本次查询返回的API列表
	Apis           *[]SignUnbindingApiResp `json:"apis,omitempty"`
	HttpStatusCode int                     `json:"-"`
}

Response Object

func (ListApisNotBoundWithSignatureKeyV2Response) String 

func (o ListApisNotBoundWithSignatureKeyV2Response) String() string

type ListApisUnbindedToAppV2Request 

type ListApisUnbindedToAppV2Request struct {
	ProjectId  string  `json:"project_id"`
	InstanceId string  `json:"instance_id"`
	AppId      string  `json:"app_id"`
	EnvId      string  `json:"env_id"`
	GroupId    *string `json:"group_id,omitempty"`
	ApiId      *string `json:"api_id,omitempty"`
	ApiName    *string `json:"api_name,omitempty"`
	Offset     *int64  `json:"offset,omitempty"`
	Limit      *int32  `json:"limit,omitempty"`
}

Request Object

func (ListApisUnbindedToAppV2Request) String 

func (o ListApisUnbindedToAppV2Request) String() string

type ListApisUnbindedToAppV2Response 

type ListApisUnbindedToAppV2Response struct {
	// 符合条件的API总数
	Total *int32 `json:"total,omitempty"`
	// 本次返回的列表长度
	Size *int32 `json:"size,omitempty"`
	// 本次返回的API列表
	Apis           *[]AppAuthUnBindedApiResp `json:"apis,omitempty"`
	HttpStatusCode int                       `json:"-"`
}

Response Object

func (ListApisUnbindedToAppV2Response) String 

func (o ListApisUnbindedToAppV2Response) String() string

type ListApisUnbindedToRequestThrottlingPolicyV2Request 

type ListApisUnbindedToRequestThrottlingPolicyV2Request struct {
	ProjectId  string  `json:"project_id"`
	InstanceId string  `json:"instance_id"`
	ThrottleId string  `json:"throttle_id"`
	EnvId      *string `json:"env_id,omitempty"`
	GroupId    *string `json:"group_id,omitempty"`
	ApiId      *string `json:"api_id,omitempty"`
	ApiName    *string `json:"api_name,omitempty"`
	Offset     *int64  `json:"offset,omitempty"`
	Limit      *int32  `json:"limit,omitempty"`
}

Request Object

func (ListApisUnbindedToRequestThrottlingPolicyV2Request) String 

func (o ListApisUnbindedToRequestThrottlingPolicyV2Request) String() string

type ListApisUnbindedToRequestThrottlingPolicyV2Response 

type ListApisUnbindedToRequestThrottlingPolicyV2Response struct {
	// 满足条件的API总数
	Total *int32 `json:"total,omitempty"`
	// 本次返回的API列表长度
	Size *int32 `json:"size,omitempty"`
	// 本次查询返回的API列表
	Apis           *[]ThrottleBindingApiResp `json:"apis,omitempty"`
	HttpStatusCode int                       `json:"-"`
}

Response Object

func (ListApisUnbindedToRequestThrottlingPolicyV2Response) String 

func (o ListApisUnbindedToRequestThrottlingPolicyV2Response) String() string

type ListApisV2Request 

type ListApisV2Request struct {
	ProjectId     string  `json:"project_id"`
	InstanceId    string  `json:"instance_id"`
	Id            *string `json:"id,omitempty"`
	Name          *string `json:"name,omitempty"`
	GroupId       *string `json:"group_id,omitempty"`
	ReqProtocol   *string `json:"req_protocol,omitempty"`
	ReqMethod     *string `json:"req_method,omitempty"`
	ReqUri        *string `json:"req_uri,omitempty"`
	AuthType      *string `json:"auth_type,omitempty"`
	EnvId         *string `json:"env_id,omitempty"`
	Type          *int32  `json:"type,omitempty"`
	Offset        *int64  `json:"offset,omitempty"`
	Limit         *int32  `json:"limit,omitempty"`
	PreciseSearch *string `json:"precise_search,omitempty"`
}

Request Object

func (ListApisV2Request) String 

func (o ListApisV2Request) String() string

type ListApisV2Response 

type ListApisV2Response struct {
	// 满足条件的分组总数
	Total *int32 `json:"total,omitempty"`
	// 本次返回的列表长度
	Size *int32 `json:"size,omitempty"`
	// 本次查询到的API列表
	Apis           *[]ApiInfoPerPage `json:"apis,omitempty"`
	HttpStatusCode int               `json:"-"`
}

Response Object

func (ListApisV2Response) String 

func (o ListApisV2Response) String() string

type ListAppQuantitiesV2Request 

type ListAppQuantitiesV2Request struct {
	ProjectId  string `json:"project_id"`
	InstanceId string `json:"instance_id"`
}

Request Object

func (ListAppQuantitiesV2Request) String 

func (o ListAppQuantitiesV2Request) String() string

type ListAppQuantitiesV2Response 

type ListAppQuantitiesV2Response struct {
	// 已进行API访问授权的APP个数
	AuthedNums *int32 `json:"authed_nums,omitempty"`
	// 未进行API访问授权的APP个数
	UnauthedNums   *int32 `json:"unauthed_nums,omitempty"`
	HttpStatusCode int    `json:"-"`
}

Response Object

func (ListAppQuantitiesV2Response) String 

func (o ListAppQuantitiesV2Response) String() string

type ListAppsBindedToApiV2Request 

type ListAppsBindedToApiV2Request struct {
	ProjectId  string  `json:"project_id"`
	InstanceId string  `json:"instance_id"`
	ApiId      *string `json:"api_id,omitempty"`
	AppName    *string `json:"app_name,omitempty"`
	AppId      *string `json:"app_id,omitempty"`
	EnvId      *string `json:"env_id,omitempty"`
	Offset     *int64  `json:"offset,omitempty"`
	Limit      *int32  `json:"limit,omitempty"`
}

Request Object

func (ListAppsBindedToApiV2Request) String 

func (o ListAppsBindedToApiV2Request) String() string

type ListAppsBindedToApiV2Response 

type ListAppsBindedToApiV2Response struct {
	// 符合条件的API总数
	Total *int32 `json:"total,omitempty"`
	// 本次返回的列表长度
	Size *int32 `json:"size,omitempty"`
	// 本次返回的API列表
	Auths          *[]AppAuthBindedApiResp `json:"auths,omitempty"`
	HttpStatusCode int                     `json:"-"`
}

Response Object

func (ListAppsBindedToApiV2Response) String 

func (o ListAppsBindedToApiV2Response) String() string

type ListAppsV2Request 

type ListAppsV2Request struct {
	ProjectId     string  `json:"project_id"`
	InstanceId    string  `json:"instance_id"`
	Id            *string `json:"id,omitempty"`
	Name          *string `json:"name,omitempty"`
	Status        *int32  `json:"status,omitempty"`
	AppKey        *string `json:"app_key,omitempty"`
	Creator       *string `json:"creator,omitempty"`
	Offset        *int64  `json:"offset,omitempty"`
	Limit         *int32  `json:"limit,omitempty"`
	PreciseSearch *string `json:"precise_search,omitempty"`
}

Request Object

func (ListAppsV2Request) String 

func (o ListAppsV2Request) String() string

type ListAppsV2Response 

type ListAppsV2Response struct {
	// 符合条件的APP总数
	Total *int32 `json:"total,omitempty"`
	// 本次查询返回的列表长度
	Size *int32 `json:"size,omitempty"`
	// APP列表
	Apps           *[]AppInfoWithBindNumResp `json:"apps,omitempty"`
	HttpStatusCode int                       `json:"-"`
}

Response Object

func (ListAppsV2Response) String 

func (o ListAppsV2Response) String() string

type ListEnvironmentVariablesV2Request 

type ListEnvironmentVariablesV2Request struct {
	ProjectId     string  `json:"project_id"`
	InstanceId    string  `json:"instance_id"`
	GroupId       string  `json:"group_id"`
	EnvId         *string `json:"env_id,omitempty"`
	VariableName  *string `json:"variable_name,omitempty"`
	Offset        *int64  `json:"offset,omitempty"`
	Limit         *int32  `json:"limit,omitempty"`
	PreciseSearch *string `json:"precise_search,omitempty"`
}

Request Object

func (ListEnvironmentVariablesV2Request) String 

func (o ListEnvironmentVariablesV2Request) String() string

type ListEnvironmentVariablesV2Response 

type ListEnvironmentVariablesV2Response struct {
	// 满足条件的环境变量总数
	Total *int32 `json:"total,omitempty"`
	// 本次返回的列表长度
	Size *int32 `json:"size,omitempty"`
	// 本次返回的环境变量列表
	Variables      *[]EnvVariableResp `json:"variables,omitempty"`
	HttpStatusCode int                `json:"-"`
}

Response Object

func (ListEnvironmentVariablesV2Response) String 

func (o ListEnvironmentVariablesV2Response) String() string

type ListEnvironmentsV2Request 

type ListEnvironmentsV2Request struct {
	ProjectId  string  `json:"project_id"`
	InstanceId string  `json:"instance_id"`
	Name       *string `json:"name,omitempty"`
	Offset     *int64  `json:"offset,omitempty"`
	Limit      *int32  `json:"limit,omitempty"`
}

Request Object

func (ListEnvironmentsV2Request) String 

func (o ListEnvironmentsV2Request) String() string

type ListEnvironmentsV2Response 

type ListEnvironmentsV2Response struct {
	// 符合条件的环境总数
	Total *int32 `json:"total,omitempty"`
	// 本次返回的列表长度
	Size *int32 `json:"size,omitempty"`
	// 本次返回的环境列表
	Envs           *[]EnvResp `json:"envs,omitempty"`
	HttpStatusCode int        `json:"-"`
}

Response Object

func (ListEnvironmentsV2Response) String 

func (o ListEnvironmentsV2Response) String() string

type ListRequestThrottlingPoliciesBindedToApiV2Request 

type ListRequestThrottlingPoliciesBindedToApiV2Request struct {
	ProjectId    string  `json:"project_id"`
	InstanceId   string  `json:"instance_id"`
	ApiId        string  `json:"api_id"`
	ThrottleId   *string `json:"throttle_id,omitempty"`
	ThrottleName *string `json:"throttle_name,omitempty"`
	EnvId        *string `json:"env_id,omitempty"`
	Offset       *int64  `json:"offset,omitempty"`
	Limit        *int32  `json:"limit,omitempty"`
}

Request Object

func (ListRequestThrottlingPoliciesBindedToApiV2Request) String 

func (o ListRequestThrottlingPoliciesBindedToApiV2Request) String() string

type ListRequestThrottlingPoliciesBindedToApiV2Response 

type ListRequestThrottlingPoliciesBindedToApiV2Response struct {
	// 满足条件的流控策略总数
	Total *int32 `json:"total,omitempty"`
	// 本次查询返回的列表长度
	Size *int32 `json:"size,omitempty"`
	// 本次查询返回的流控策略列表
	Throttles      *[]ThrottleBindingThrottleResp `json:"throttles,omitempty"`
	HttpStatusCode int                            `json:"-"`
}

Response Object

func (ListRequestThrottlingPoliciesBindedToApiV2Response) String 

func (o ListRequestThrottlingPoliciesBindedToApiV2Response) String() string

type ListRequestThrottlingPolicyV2Request 

type ListRequestThrottlingPolicyV2Request struct {
	ProjectId     string  `json:"project_id"`
	InstanceId    string  `json:"instance_id"`
	Id            *string `json:"id,omitempty"`
	Name          *string `json:"name,omitempty"`
	Offset        *int64  `json:"offset,omitempty"`
	Limit         *int32  `json:"limit,omitempty"`
	PreciseSearch *string `json:"precise_search,omitempty"`
}

Request Object

func (ListRequestThrottlingPolicyV2Request) String 

func (o ListRequestThrottlingPolicyV2Request) String() string

type ListRequestThrottlingPolicyV2Response 

type ListRequestThrottlingPolicyV2Response struct {
	// 符合条件的流控策略的数量
	Total *int32 `json:"total,omitempty"`
	// 本次查询返回的列表长度
	Size *int32 `json:"size,omitempty"`
	// 本次查询到的流控策略列表
	Throttles      *[]ThrottleResp `json:"throttles,omitempty"`
	HttpStatusCode int             `json:"-"`
}

Response Object

func (ListRequestThrottlingPolicyV2Response) String 

func (o ListRequestThrottlingPolicyV2Response) String() string

type ListSignatureKeysBindedToApiV2Request 

type ListSignatureKeysBindedToApiV2Request struct {
	ProjectId  string  `json:"project_id"`
	InstanceId string  `json:"instance_id"`
	ApiId      string  `json:"api_id"`
	SignId     *string `json:"sign_id,omitempty"`
	SignName   *string `json:"sign_name,omitempty"`
	EnvId      *string `json:"env_id,omitempty"`
	Offset     *int64  `json:"offset,omitempty"`
	Limit      *int32  `json:"limit,omitempty"`
}

Request Object

func (ListSignatureKeysBindedToApiV2Request) String 

func (o ListSignatureKeysBindedToApiV2Request) String() string

type ListSignatureKeysBindedToApiV2Response 

type ListSignatureKeysBindedToApiV2Response struct {
	// 本次查询满足条件的总数
	Total *int32 `json:"total,omitempty"`
	// 本次查询返回的列表长度
	Size *int32 `json:"size,omitempty"`
	// 本次查询返回的列表
	Bindings       *[]SignBindingApiResp `json:"bindings,omitempty"`
	HttpStatusCode int                   `json:"-"`
}

Response Object

func (ListSignatureKeysBindedToApiV2Response) String 

func (o ListSignatureKeysBindedToApiV2Response) String() string

type ListSignatureKeysV2Request 

type ListSignatureKeysV2Request struct {
	ProjectId     string  `json:"project_id"`
	InstanceId    string  `json:"instance_id"`
	Id            *string `json:"id,omitempty"`
	Name          *string `json:"name,omitempty"`
	Offset        *int64  `json:"offset,omitempty"`
	Limit         *int32  `json:"limit,omitempty"`
	PreciseSearch *string `json:"precise_search,omitempty"`
}

Request Object

func (ListSignatureKeysV2Request) String 

func (o ListSignatureKeysV2Request) String() string

type ListSignatureKeysV2Response 

type ListSignatureKeysV2Response struct {
	// 符合条件的签名密钥的数量
	Total *int32 `json:"total,omitempty"`
	// 本次查询到的签名密钥列表
	Signs *[]SignatureCreateResp `json:"signs,omitempty"`
	// 本次返回的列表长度
	Size           *int32 `json:"size,omitempty"`
	HttpStatusCode int    `json:"-"`
}

Response Object

func (ListSignatureKeysV2Response) String 

func (o ListSignatureKeysV2Response) String() string

type ListSpecialThrottlingConfigurationsV2Request 

type ListSpecialThrottlingConfigurationsV2Request struct {
	ProjectId  string  `json:"project_id"`
	InstanceId string  `json:"instance_id"`
	ThrottleId string  `json:"throttle_id"`
	ObjectType *string `json:"object_type,omitempty"`
	AppName    *string `json:"app_name,omitempty"`
	Offset     *int64  `json:"offset,omitempty"`
	Limit      *int32  `json:"limit,omitempty"`
}

Request Object

func (ListSpecialThrottlingConfigurationsV2Request) String 

func (o ListSpecialThrottlingConfigurationsV2Request) String() string

type ListSpecialThrottlingConfigurationsV2Response 

type ListSpecialThrottlingConfigurationsV2Response struct {
	// 符合条件的特殊设置总数
	Total *int32 `json:"total,omitempty"`
	// 本次查询返回的列表长度
	Size *int32 `json:"size,omitempty"`
	// 本次查询返回的特殊配置列表
	ThrottleSpecials *[]ThrottleSpecialResp `json:"throttle_specials,omitempty"`
	HttpStatusCode   int                    `json:"-"`
}

Response Object

func (ListSpecialThrottlingConfigurationsV2Response) String 

func (o ListSpecialThrottlingConfigurationsV2Response) String() string

type ReqParam 

type ReqParam struct {
	// 参数名称。 长度为1 ~ 32位的字符串，字符串由英文字母、数字、中划线、下划线、英文句号组成，且只能以英文开头。
	Name string `json:"name"`
	// 参数类型
	Type ReqParamType `json:"type"`
	// 参数位置
	Location ReqParamLocation `json:"location"`
	// 参数默认值
	DefaultValue *string `json:"default_value,omitempty"`
	// 参数示例值
	SampleValue *string `json:"sample_value,omitempty"`
	// 是否必须 - 1：是 - 2：否  location为PATH时，required默认为1，其他场景required默认为2
	Required *ReqParamRequired `json:"required,omitempty"`
	// 是否开启校验 - 1：开启校验 - 2：不开启校验
	ValidEnable *ReqParamValidEnable `json:"valid_enable,omitempty"`
	// 描述信息。长度不超过255个字符 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// 参数枚举值
	Enumerations *string `json:"enumerations,omitempty"`
	// 参数最小值  参数类型为NUMBER时有效
	MinNum *int32 `json:"min_num,omitempty"`
	// 参数最大值  参数类型为NUMBER时有效
	MaxNum *int32 `json:"max_num,omitempty"`
	// 参数最小长度  参数类型为STRING时有效
	MinSize *int32 `json:"min_size,omitempty"`
	// 参数最大长度  参数类型为STRING时有效
	MaxSize *int32 `json:"max_size,omitempty"`
	// 正则校验规则  暂不支持
	Regular *string `json:"regular,omitempty"`
	// JSON校验规则  暂不支持
	JsonSchema *string `json:"json_schema,omitempty"`
	// 是否透传 - 1：是 - 2：否
	PassThrough *ReqParamPassThrough `json:"pass_through,omitempty"`
	// 参数编号
	Id *string `json:"id,omitempty"`
}

func (ReqParam) String 

func (o ReqParam) String() string

type ReqParamBase 

type ReqParamBase struct {
	// 参数名称。 长度为1 ~ 32位的字符串，字符串由英文字母、数字、中划线、下划线、英文句号组成，且只能以英文开头。
	Name string `json:"name"`
	// 参数类型
	Type ReqParamBaseType `json:"type"`
	// 参数位置
	Location ReqParamBaseLocation `json:"location"`
	// 参数默认值
	DefaultValue *string `json:"default_value,omitempty"`
	// 参数示例值
	SampleValue *string `json:"sample_value,omitempty"`
	// 是否必须 - 1：是 - 2：否  location为PATH时，required默认为1，其他场景required默认为2
	Required *ReqParamBaseRequired `json:"required,omitempty"`
	// 是否开启校验 - 1：开启校验 - 2：不开启校验
	ValidEnable *ReqParamBaseValidEnable `json:"valid_enable,omitempty"`
	// 描述信息。长度不超过255个字符 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// 参数枚举值
	Enumerations *string `json:"enumerations,omitempty"`
	// 参数最小值  参数类型为NUMBER时有效
	MinNum *int32 `json:"min_num,omitempty"`
	// 参数最大值  参数类型为NUMBER时有效
	MaxNum *int32 `json:"max_num,omitempty"`
	// 参数最小长度  参数类型为STRING时有效
	MinSize *int32 `json:"min_size,omitempty"`
	// 参数最大长度  参数类型为STRING时有效
	MaxSize *int32 `json:"max_size,omitempty"`
	// 正则校验规则  暂不支持
	Regular *string `json:"regular,omitempty"`
	// JSON校验规则  暂不支持
	JsonSchema *string `json:"json_schema,omitempty"`
	// 是否透传 - 1：是 - 2：否
	PassThrough *ReqParamBasePassThrough `json:"pass_through,omitempty"`
}

func (ReqParamBase) String 

func (o ReqParamBase) String() string

type ReqParamBaseLocation 

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

func (ReqParamBaseLocation) MarshalJSON 

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

func (*ReqParamBaseLocation) UnmarshalJSON 

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

type ReqParamBaseLocationEnum 

type ReqParamBaseLocationEnum struct {
	PATH   ReqParamBaseLocation
	QUERY  ReqParamBaseLocation
	HEADER ReqParamBaseLocation
}

func GetReqParamBaseLocationEnum 

func GetReqParamBaseLocationEnum() ReqParamBaseLocationEnum

type ReqParamBasePassThrough 

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

func (ReqParamBasePassThrough) MarshalJSON 

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

func (*ReqParamBasePassThrough) UnmarshalJSON 

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

type ReqParamBasePassThroughEnum 

type ReqParamBasePassThroughEnum struct {
	E_1 ReqParamBasePassThrough
	E_2 ReqParamBasePassThrough
}

func GetReqParamBasePassThroughEnum 

func GetReqParamBasePassThroughEnum() ReqParamBasePassThroughEnum

type ReqParamBaseRequired 

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

func (ReqParamBaseRequired) MarshalJSON 

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

func (*ReqParamBaseRequired) UnmarshalJSON 

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

type ReqParamBaseRequiredEnum 

type ReqParamBaseRequiredEnum struct {
	E_1 ReqParamBaseRequired
	E_2 ReqParamBaseRequired
}

func GetReqParamBaseRequiredEnum 

func GetReqParamBaseRequiredEnum() ReqParamBaseRequiredEnum

type ReqParamBaseType 

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

func (ReqParamBaseType) MarshalJSON 

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

func (*ReqParamBaseType) UnmarshalJSON 

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

type ReqParamBaseTypeEnum 

type ReqParamBaseTypeEnum struct {
	STRING ReqParamBaseType
	NUMBER ReqParamBaseType
}

func GetReqParamBaseTypeEnum 

func GetReqParamBaseTypeEnum() ReqParamBaseTypeEnum

type ReqParamBaseValidEnable 

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

func (ReqParamBaseValidEnable) MarshalJSON 

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

func (*ReqParamBaseValidEnable) UnmarshalJSON 

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

type ReqParamBaseValidEnableEnum 

type ReqParamBaseValidEnableEnum struct {
	E_1 ReqParamBaseValidEnable
	E_2 ReqParamBaseValidEnable
}

func GetReqParamBaseValidEnableEnum 

func GetReqParamBaseValidEnableEnum() ReqParamBaseValidEnableEnum

type ReqParamLocation 

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

func (ReqParamLocation) MarshalJSON 

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

func (*ReqParamLocation) UnmarshalJSON 

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

type ReqParamLocationEnum 

type ReqParamLocationEnum struct {
	PATH   ReqParamLocation
	QUERY  ReqParamLocation
	HEADER ReqParamLocation
}

func GetReqParamLocationEnum 

func GetReqParamLocationEnum() ReqParamLocationEnum

type ReqParamPassThrough 

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

func (ReqParamPassThrough) MarshalJSON 

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

func (*ReqParamPassThrough) UnmarshalJSON 

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

type ReqParamPassThroughEnum 

type ReqParamPassThroughEnum struct {
	E_1 ReqParamPassThrough
	E_2 ReqParamPassThrough
}

func GetReqParamPassThroughEnum 

func GetReqParamPassThroughEnum() ReqParamPassThroughEnum

type ReqParamRequired 

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

func (ReqParamRequired) MarshalJSON 

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

func (*ReqParamRequired) UnmarshalJSON 

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

type ReqParamRequiredEnum 

type ReqParamRequiredEnum struct {
	E_1 ReqParamRequired
	E_2 ReqParamRequired
}

func GetReqParamRequiredEnum 

func GetReqParamRequiredEnum() ReqParamRequiredEnum

type ReqParamType 

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

func (ReqParamType) MarshalJSON 

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

func (*ReqParamType) UnmarshalJSON 

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

type ReqParamTypeEnum 

type ReqParamTypeEnum struct {
	STRING ReqParamType
	NUMBER ReqParamType
}

func GetReqParamTypeEnum 

func GetReqParamTypeEnum() ReqParamTypeEnum

type ReqParamValidEnable 

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

func (ReqParamValidEnable) MarshalJSON 

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

func (*ReqParamValidEnable) UnmarshalJSON 

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

type ReqParamValidEnableEnum 

type ReqParamValidEnableEnum struct {
	E_1 ReqParamValidEnable
	E_2 ReqParamValidEnable
}

func GetReqParamValidEnableEnum 

func GetReqParamValidEnableEnum() ReqParamValidEnableEnum

type ResettingAppSecretV2Request 

type ResettingAppSecretV2Request struct {
	ProjectId  string        `json:"project_id"`
	InstanceId string        `json:"instance_id"`
	AppId      string        `json:"app_id"`
	Body       *AppSecretReq `json:"body,omitempty"`
}

Request Object

func (ResettingAppSecretV2Request) String 

func (o ResettingAppSecretV2Request) String() string

type ResettingAppSecretV2Response 

type ResettingAppSecretV2Response struct {
	// APP的创建者 - USER：用户自行创建 - MARKET：云市场分配
	Creator *ResettingAppSecretV2ResponseCreator `json:"creator,omitempty"`
	// 更新时间
	UpdateTime *sdktime.SdkTime `json:"update_time,omitempty"`
	// APP的key
	AppKey *string `json:"app_key,omitempty"`
	// 名称
	Name *string `json:"name,omitempty"`
	// 描述
	Remark *string `json:"remark,omitempty"`
	// 编号
	Id *string `json:"id,omitempty"`
	// 密钥
	AppSecret *string `json:"app_secret,omitempty"`
	// 注册时间
	RegisterTime *sdktime.SdkTime `json:"register_time,omitempty"`
	// 状态
	Status *int32 `json:"status,omitempty"`
	// APP的类型  默认为apig，暂不支持其他类型
	AppType        *ResettingAppSecretV2ResponseAppType `json:"app_type,omitempty"`
	HttpStatusCode int                                  `json:"-"`
}

Response Object

func (ResettingAppSecretV2Response) String 

func (o ResettingAppSecretV2Response) String() string

type ResettingAppSecretV2ResponseAppType 

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

func (ResettingAppSecretV2ResponseAppType) MarshalJSON 

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

func (*ResettingAppSecretV2ResponseAppType) UnmarshalJSON 

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

type ResettingAppSecretV2ResponseAppTypeEnum 

type ResettingAppSecretV2ResponseAppTypeEnum struct {
	APIG ResettingAppSecretV2ResponseAppType
	ROMA ResettingAppSecretV2ResponseAppType
}

func GetResettingAppSecretV2ResponseAppTypeEnum 

func GetResettingAppSecretV2ResponseAppTypeEnum() ResettingAppSecretV2ResponseAppTypeEnum

type ResettingAppSecretV2ResponseCreator 

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

func (ResettingAppSecretV2ResponseCreator) MarshalJSON 

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

func (*ResettingAppSecretV2ResponseCreator) UnmarshalJSON 

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

type ResettingAppSecretV2ResponseCreatorEnum 

type ResettingAppSecretV2ResponseCreatorEnum struct {
	USER   ResettingAppSecretV2ResponseCreator
	MARKET ResettingAppSecretV2ResponseCreator
}

func GetResettingAppSecretV2ResponseCreatorEnum 

func GetResettingAppSecretV2ResponseCreatorEnum() ResettingAppSecretV2ResponseCreatorEnum

type ShowDetailsOfApiGroupV2Request 

type ShowDetailsOfApiGroupV2Request struct {
	ProjectId  string `json:"project_id"`
	InstanceId string `json:"instance_id"`
	GroupId    string `json:"group_id"`
}

Request Object

func (ShowDetailsOfApiGroupV2Request) String 

func (o ShowDetailsOfApiGroupV2Request) String() string

type ShowDetailsOfApiGroupV2Response 

type ShowDetailsOfApiGroupV2Response struct {
	// 分组上绑定的独立域名列表
	UrlDomains *[]UrlDomainsResp `json:"url_domains,omitempty"`
	// 流控时长内分组下的API的总访问次数限制，默认不限，请根据服务的负载能力自行设置  暂不支持
	CallLimits *int32 `json:"call_limits,omitempty"`
	// 最近修改时间
	UpdateTime *sdktime.SdkTime `json:"update_time,omitempty"`
	// API分组名称
	Name *string `json:"name,omitempty"`
	// 流控的时间单位  暂不支持
	TimeUnit *string `json:"time_unit,omitempty"`
	// 是否已上架云市场： - 1：已上架 - 2：未上架 - 3：审核中
	OnSellStatus *int32 `json:"on_sell_status,omitempty"`
	// 描述
	Remark *string `json:"remark,omitempty"`
	// 系统默认分配的子域名
	SlDomain *string `json:"sl_domain,omitempty"`
	// 系统默认分配的子域名列表
	SlDomains *[]string `json:"sl_domains,omitempty"`
	// 编号
	Id *string `json:"id,omitempty"`
	// 流控时长  暂不支持
	TimeInterval *int32 `json:"time_interval,omitempty"`
	// 创建时间
	RegisterTime *sdktime.SdkTime `json:"register_time,omitempty"`
	// 状态
	Status *int32 `json:"status,omitempty"`
	// 是否为默认分组
	IsDefault      *int32 `json:"is_default,omitempty"`
	HttpStatusCode int    `json:"-"`
}

Response Object

func (ShowDetailsOfApiGroupV2Response) String 

func (o ShowDetailsOfApiGroupV2Response) String() string

type ShowDetailsOfApiV2Request 

type ShowDetailsOfApiV2Request struct {
	ProjectId  string `json:"project_id"`
	InstanceId string `json:"instance_id"`
	ApiId      string `json:"api_id"`
}

Request Object

func (ShowDetailsOfApiV2Request) String 

func (o ShowDetailsOfApiV2Request) String() string

type ShowDetailsOfApiV2Response 

type ShowDetailsOfApiV2Response struct {
	// API名称长度。  为3 ~ 64位的字符串，字符串由中文、英文字母、数字、下划线组成，且只能以英文或中文开头。 > 中文字符必须为UTF-8或者unicode编码。
	Name string `json:"name"`
	// API类型 - 1：公有API - 2：私有API
	Type ShowDetailsOfApiV2ResponseType `json:"type"`
	// API的版本
	Version *string `json:"version,omitempty"`
	// API的请求协议 - HTTP - HTTPS - BOTH：同时支持HTTP和HTTPS
	ReqProtocol ShowDetailsOfApiV2ResponseReqProtocol `json:"req_protocol"`
	// API的请求方式
	ReqMethod ShowDetailsOfApiV2ResponseReqMethod `json:"req_method"`
	// 请求地址。可以包含请求参数，用{}标识，比如/getUserInfo/{userId}，支持 * % - _ . 等特殊字符，总长度不超过512，且满足URI规范。  支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、中划线、下划线组成，且只能以英文开头。 > 需要服从URI规范。
	ReqUri string `json:"req_uri"`
	// API的认证方式 - NONE：无认证 - APP：APP认证 - IAM：IAM认证 - AUTHORIZER：自定义认证
	AuthType ShowDetailsOfApiV2ResponseAuthType `json:"auth_type"`
	AuthOpt  *AuthOpt                           `json:"auth_opt,omitempty"`
	// 是否支持跨域 - TRUE：支持 - FALSE：不支持
	Cors *bool `json:"cors,omitempty"`
	// API的匹配方式 - SWA：前缀匹配 - NORMAL：正常匹配（绝对匹配） 默认：NORMAL
	MatchMode *ShowDetailsOfApiV2ResponseMatchMode `json:"match_mode,omitempty"`
	// 后端类型 - HTTP：web后端 - FUNCTION：函数工作流 - MOCK：模拟的后端
	BackendType ShowDetailsOfApiV2ResponseBackendType `json:"backend_type"`
	// API描述。字符长度不超过255 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// API所属的分组编号
	GroupId string `json:"group_id"`
	// API请求体描述，可以是请求体示例、媒体类型、参数等信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	BodyRemark *string `json:"body_remark,omitempty"`
	// 正常响应示例，描述API的正常返回信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	ResultNormalSample *string `json:"result_normal_sample,omitempty"`
	// 失败返回示例，描述API的异常返回信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	ResultFailureSample *string `json:"result_failure_sample,omitempty"`
	// 前端自定义认证对象的ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
	// 标签。  支持英文，数字，下划线，且只能以英文开头。支持输入多个标签，不同标签以英文逗号分割。
	Tags *[]string `json:"tags,omitempty"`
	// 分组自定义响应ID
	ResponseId *string `json:"response_id,omitempty"`
	// 集成应用ID  暂不支持
	RomaAppId *string `json:"roma_app_id,omitempty"`
	// API绑定的自定义域名  暂不支持
	DomainName *string `json:"domain_name,omitempty"`
	// 标签  待废弃，优先使用tags字段
	Tag *string `json:"tag,omitempty"`
	// API编号
	Id *string `json:"id,omitempty"`
	// API的状态
	Status *int32 `json:"status,omitempty"`
	// 是否需要编排
	ArrangeNecessary *int32 `json:"arrange_necessary,omitempty"`
	// API注册时间
	RegisterTime *sdktime.SdkTime `json:"register_time,omitempty"`
	// API修改时间
	UpdateTime *sdktime.SdkTime `json:"update_time,omitempty"`
	// API所属分组的名称
	GroupName *string `json:"group_name,omitempty"`
	// API所属分组的版本  默认V1，其他版本暂不支持
	GroupVersion *string `json:"group_version,omitempty"`
	// 发布的环境id
	RunEnvId *string `json:"run_env_id,omitempty"`
	// 发布的环境名称
	RunEnvName *string `json:"run_env_name,omitempty"`
	// 发布记录编号  存在多个发布记录时，编号之间用|隔开
	PublishId *string  `json:"publish_id,omitempty"`
	FuncInfo  *ApiFunc `json:"func_info,omitempty"`
	MockInfo  *ApiMock `json:"mock_info,omitempty"`
	// API的请求参数列表
	ReqParams *[]ReqParam `json:"req_params,omitempty"`
	// API的后端参数列表
	BackendParams *[]BackendParam `json:"backend_params,omitempty"`
	// 函数工作流策略后端列表
	PolicyFunctions *[]ApiPolicyFunctionResp `json:"policy_functions,omitempty"`
	// mock策略后端列表
	PolicyMocks *[]ApiPolicyMockResp `json:"policy_mocks,omitempty"`
	BackendApi  *BackendApi          `json:"backend_api,omitempty"`
	// web策略后端列表
	PolicyHttps    *[]ApiPolicyHttpResp `json:"policy_https,omitempty"`
	HttpStatusCode int                  `json:"-"`
}

Response Object

func (ShowDetailsOfApiV2Response) String 

func (o ShowDetailsOfApiV2Response) String() string

type ShowDetailsOfApiV2ResponseAuthType 

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

func (ShowDetailsOfApiV2ResponseAuthType) MarshalJSON 

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

func (*ShowDetailsOfApiV2ResponseAuthType) UnmarshalJSON 

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

type ShowDetailsOfApiV2ResponseAuthTypeEnum 

type ShowDetailsOfApiV2ResponseAuthTypeEnum struct {
	NONE       ShowDetailsOfApiV2ResponseAuthType
	APP        ShowDetailsOfApiV2ResponseAuthType
	IAM        ShowDetailsOfApiV2ResponseAuthType
	AUTHORIZER ShowDetailsOfApiV2ResponseAuthType
}

func GetShowDetailsOfApiV2ResponseAuthTypeEnum 

func GetShowDetailsOfApiV2ResponseAuthTypeEnum() ShowDetailsOfApiV2ResponseAuthTypeEnum

type ShowDetailsOfApiV2ResponseBackendType 

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

func (ShowDetailsOfApiV2ResponseBackendType) MarshalJSON 

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

func (*ShowDetailsOfApiV2ResponseBackendType) UnmarshalJSON 

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

type ShowDetailsOfApiV2ResponseBackendTypeEnum 

type ShowDetailsOfApiV2ResponseBackendTypeEnum struct {
	HTTP     ShowDetailsOfApiV2ResponseBackendType
	FUNCTION ShowDetailsOfApiV2ResponseBackendType
	MOCK     ShowDetailsOfApiV2ResponseBackendType
}

func GetShowDetailsOfApiV2ResponseBackendTypeEnum 

func GetShowDetailsOfApiV2ResponseBackendTypeEnum() ShowDetailsOfApiV2ResponseBackendTypeEnum

type ShowDetailsOfApiV2ResponseMatchMode 

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

func (ShowDetailsOfApiV2ResponseMatchMode) MarshalJSON 

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

func (*ShowDetailsOfApiV2ResponseMatchMode) UnmarshalJSON 

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

type ShowDetailsOfApiV2ResponseMatchModeEnum 

type ShowDetailsOfApiV2ResponseMatchModeEnum struct {
	SWA    ShowDetailsOfApiV2ResponseMatchMode
	NORMAL ShowDetailsOfApiV2ResponseMatchMode
}

func GetShowDetailsOfApiV2ResponseMatchModeEnum 

func GetShowDetailsOfApiV2ResponseMatchModeEnum() ShowDetailsOfApiV2ResponseMatchModeEnum

type ShowDetailsOfApiV2ResponseReqMethod 

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

func (ShowDetailsOfApiV2ResponseReqMethod) MarshalJSON 

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

func (*ShowDetailsOfApiV2ResponseReqMethod) UnmarshalJSON 

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

type ShowDetailsOfApiV2ResponseReqMethodEnum 

type ShowDetailsOfApiV2ResponseReqMethodEnum struct {
	GET     ShowDetailsOfApiV2ResponseReqMethod
	POST    ShowDetailsOfApiV2ResponseReqMethod
	PUT     ShowDetailsOfApiV2ResponseReqMethod
	DELETE  ShowDetailsOfApiV2ResponseReqMethod
	HEAD    ShowDetailsOfApiV2ResponseReqMethod
	PATCH   ShowDetailsOfApiV2ResponseReqMethod
	OPTIONS ShowDetailsOfApiV2ResponseReqMethod
	ANY     ShowDetailsOfApiV2ResponseReqMethod
}

func GetShowDetailsOfApiV2ResponseReqMethodEnum 

func GetShowDetailsOfApiV2ResponseReqMethodEnum() ShowDetailsOfApiV2ResponseReqMethodEnum

type ShowDetailsOfApiV2ResponseReqProtocol 

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

func (ShowDetailsOfApiV2ResponseReqProtocol) MarshalJSON 

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

func (*ShowDetailsOfApiV2ResponseReqProtocol) UnmarshalJSON 

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

type ShowDetailsOfApiV2ResponseReqProtocolEnum 

type ShowDetailsOfApiV2ResponseReqProtocolEnum struct {
	HTTP  ShowDetailsOfApiV2ResponseReqProtocol
	HTTPS ShowDetailsOfApiV2ResponseReqProtocol
	BOTH  ShowDetailsOfApiV2ResponseReqProtocol
}

func GetShowDetailsOfApiV2ResponseReqProtocolEnum 

func GetShowDetailsOfApiV2ResponseReqProtocolEnum() ShowDetailsOfApiV2ResponseReqProtocolEnum

type ShowDetailsOfApiV2ResponseType 

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

func (ShowDetailsOfApiV2ResponseType) MarshalJSON 

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

func (*ShowDetailsOfApiV2ResponseType) UnmarshalJSON 

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

type ShowDetailsOfApiV2ResponseTypeEnum 

type ShowDetailsOfApiV2ResponseTypeEnum struct {
	E_1 ShowDetailsOfApiV2ResponseType
	E_2 ShowDetailsOfApiV2ResponseType
}

func GetShowDetailsOfApiV2ResponseTypeEnum 

func GetShowDetailsOfApiV2ResponseTypeEnum() ShowDetailsOfApiV2ResponseTypeEnum

type ShowDetailsOfAppV2Request 

type ShowDetailsOfAppV2Request struct {
	ProjectId  string `json:"project_id"`
	InstanceId string `json:"instance_id"`
	AppId      string `json:"app_id"`
}

Request Object

func (ShowDetailsOfAppV2Request) String 

func (o ShowDetailsOfAppV2Request) String() string

type ShowDetailsOfAppV2Response 

type ShowDetailsOfAppV2Response struct {
	// APP的创建者 - USER：用户自行创建 - MARKET：云市场分配
	Creator *ShowDetailsOfAppV2ResponseCreator `json:"creator,omitempty"`
	// 更新时间
	UpdateTime *sdktime.SdkTime `json:"update_time,omitempty"`
	// APP的key
	AppKey *string `json:"app_key,omitempty"`
	// 名称
	Name *string `json:"name,omitempty"`
	// 描述
	Remark *string `json:"remark,omitempty"`
	// 编号
	Id *string `json:"id,omitempty"`
	// 密钥
	AppSecret *string `json:"app_secret,omitempty"`
	// 注册时间
	RegisterTime *sdktime.SdkTime `json:"register_time,omitempty"`
	// 状态
	Status *int32 `json:"status,omitempty"`
	// APP的类型  默认为apig，暂不支持其他类型
	AppType        *ShowDetailsOfAppV2ResponseAppType `json:"app_type,omitempty"`
	HttpStatusCode int                                `json:"-"`
}

Response Object

func (ShowDetailsOfAppV2Response) String 

func (o ShowDetailsOfAppV2Response) String() string

type ShowDetailsOfAppV2ResponseAppType 

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

func (ShowDetailsOfAppV2ResponseAppType) MarshalJSON 

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

func (*ShowDetailsOfAppV2ResponseAppType) UnmarshalJSON 

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

type ShowDetailsOfAppV2ResponseAppTypeEnum 

type ShowDetailsOfAppV2ResponseAppTypeEnum struct {
	APIG ShowDetailsOfAppV2ResponseAppType
	ROMA ShowDetailsOfAppV2ResponseAppType
}

func GetShowDetailsOfAppV2ResponseAppTypeEnum 

func GetShowDetailsOfAppV2ResponseAppTypeEnum() ShowDetailsOfAppV2ResponseAppTypeEnum

type ShowDetailsOfAppV2ResponseCreator 

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

func (ShowDetailsOfAppV2ResponseCreator) MarshalJSON 

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

func (*ShowDetailsOfAppV2ResponseCreator) UnmarshalJSON 

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

type ShowDetailsOfAppV2ResponseCreatorEnum 

type ShowDetailsOfAppV2ResponseCreatorEnum struct {
	USER   ShowDetailsOfAppV2ResponseCreator
	MARKET ShowDetailsOfAppV2ResponseCreator
}

func GetShowDetailsOfAppV2ResponseCreatorEnum 

func GetShowDetailsOfAppV2ResponseCreatorEnum() ShowDetailsOfAppV2ResponseCreatorEnum

type ShowDetailsOfDomainNameCertificateV2Request 

type ShowDetailsOfDomainNameCertificateV2Request struct {
	ProjectId     string `json:"project_id"`
	InstanceId    string `json:"instance_id"`
	GroupId       string `json:"group_id"`
	CertificateId string `json:"certificate_id"`
}

Request Object

func (ShowDetailsOfDomainNameCertificateV2Request) String 

func (o ShowDetailsOfDomainNameCertificateV2Request) String() string

type ShowDetailsOfDomainNameCertificateV2Response 

type ShowDetailsOfDomainNameCertificateV2Response struct {
	// 证书域名
	CommonName *string `json:"common_name,omitempty"`
	// SAN域名
	San *[]string `json:"san,omitempty"`
	// 证书版本
	Version *string `json:"version,omitempty"`
	// 公司、组织
	Organization *[]string `json:"organization,omitempty"`
	// 部门
	OrganizationalUnit *[]string `json:"organizational_unit,omitempty"`
	// 城市
	Locality *[]string `json:"locality,omitempty"`
	// 省份
	State *[]string `json:"state,omitempty"`
	// 国家
	Country *[]string `json:"country,omitempty"`
	// 证书有效期起始时间
	NotBefore *string `json:"not_before,omitempty"`
	// 证书有效期截止时间
	NotAfter *string `json:"not_after,omitempty"`
	// 序列号
	SerialNumber *string `json:"serial_number,omitempty"`
	// 颁发者
	Issuer *[]string `json:"issuer,omitempty"`
	// 签名算法
	SignatureAlgorithm *string `json:"signature_algorithm,omitempty"`
	HttpStatusCode     int     `json:"-"`
}

Response Object

func (ShowDetailsOfDomainNameCertificateV2Response) String 

func (o ShowDetailsOfDomainNameCertificateV2Response) String() string

type ShowDetailsOfEnvironmentVariableV2Request 

type ShowDetailsOfEnvironmentVariableV2Request struct {
	ProjectId     string `json:"project_id"`
	InstanceId    string `json:"instance_id"`
	EnvVariableId string `json:"env_variable_id"`
}

Request Object

func (ShowDetailsOfEnvironmentVariableV2Request) String 

func (o ShowDetailsOfEnvironmentVariableV2Request) String() string

type ShowDetailsOfEnvironmentVariableV2Response 

type ShowDetailsOfEnvironmentVariableV2Response struct {
	// 变量值
	VariableValue *string `json:"variable_value,omitempty"`
	// 环境编号
	EnvId *string `json:"env_id,omitempty"`
	// API分组编号
	GroupId *string `json:"group_id,omitempty"`
	// 环境变量编号
	Id *string `json:"id,omitempty"`
	// 变量名
	VariableName   *string `json:"variable_name,omitempty"`
	HttpStatusCode int     `json:"-"`
}

Response Object

func (ShowDetailsOfEnvironmentVariableV2Response) String 

func (o ShowDetailsOfEnvironmentVariableV2Response) String() string

type ShowDetailsOfRequestThrottlingPolicyV2Request 

type ShowDetailsOfRequestThrottlingPolicyV2Request struct {
	ProjectId  string `json:"project_id"`
	InstanceId string `json:"instance_id"`
	ThrottleId string `json:"throttle_id"`
}

Request Object

func (ShowDetailsOfRequestThrottlingPolicyV2Request) String 

func (o ShowDetailsOfRequestThrottlingPolicyV2Request) String() string

type ShowDetailsOfRequestThrottlingPolicyV2Response 

type ShowDetailsOfRequestThrottlingPolicyV2Response struct {
	// 流控绑定的API数量
	BindNum *int32 `json:"bind_num,omitempty"`
	// 是否包含特殊流控配置 - 1：包含 - 2：不包含
	IsIncludeSpecialThrottle *ShowDetailsOfRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottle `json:"is_include_special_throttle,omitempty"`
	// 创建时间
	CreateTime *sdktime.SdkTime `json:"create_time,omitempty"`
	// 描述
	Remark *string `json:"remark,omitempty"`
	// 流控策略的类型 - 1：独享，表示绑定到流控策略的单个API流控时间内能够被调用多少次。 - 2：共享，表示绑定到流控策略的所有API流控时间内能够被调用多少次
	Type *ShowDetailsOfRequestThrottlingPolicyV2ResponseType `json:"type,omitempty"`
	// 流控的时长
	TimeInterval *int32 `json:"time_interval,omitempty"`
	// 单个IP流控时间内能够访问API的次数限制
	IpCallLimits *int32 `json:"ip_call_limits,omitempty"`
	// 单个APP流控时间内能够访问API的次数限制
	AppCallLimits *int32 `json:"app_call_limits,omitempty"`
	// 流控策略的名称
	Name *string `json:"name,omitempty"`
	// 流控的时间单位
	TimeUnit *ShowDetailsOfRequestThrottlingPolicyV2ResponseTimeUnit `json:"time_unit,omitempty"`
	// 单个API流控时间内能够被访问的次数限制
	ApiCallLimits *int32 `json:"api_call_limits,omitempty"`
	// 流控策略的ID
	Id *string `json:"id,omitempty"`
	// 单个用户流控时间内能够访问API的次数限制
	UserCallLimits *int32 `json:"user_call_limits,omitempty"`
	// 是否开启动态流控  暂不支持
	EnableAdaptiveControl *string `json:"enable_adaptive_control,omitempty"`
	HttpStatusCode        int     `json:"-"`
}

Response Object

func (ShowDetailsOfRequestThrottlingPolicyV2Response) String 

func (o ShowDetailsOfRequestThrottlingPolicyV2Response) String() string

type ShowDetailsOfRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottle 

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

func (ShowDetailsOfRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottle) MarshalJSON 

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

func (*ShowDetailsOfRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottle) UnmarshalJSON 

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

type ShowDetailsOfRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottleEnum 

type ShowDetailsOfRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottleEnum struct {
	E_1 ShowDetailsOfRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottle
	E_2 ShowDetailsOfRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottle
}

func GetShowDetailsOfRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottleEnum 

func GetShowDetailsOfRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottleEnum() ShowDetailsOfRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottleEnum

type ShowDetailsOfRequestThrottlingPolicyV2ResponseTimeUnit 

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

func (ShowDetailsOfRequestThrottlingPolicyV2ResponseTimeUnit) MarshalJSON 

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

func (*ShowDetailsOfRequestThrottlingPolicyV2ResponseTimeUnit) UnmarshalJSON 

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

type ShowDetailsOfRequestThrottlingPolicyV2ResponseTimeUnitEnum 

type ShowDetailsOfRequestThrottlingPolicyV2ResponseTimeUnitEnum struct {
	SECOND ShowDetailsOfRequestThrottlingPolicyV2ResponseTimeUnit
	MINUTE ShowDetailsOfRequestThrottlingPolicyV2ResponseTimeUnit
	HOUR   ShowDetailsOfRequestThrottlingPolicyV2ResponseTimeUnit
	DAY    ShowDetailsOfRequestThrottlingPolicyV2ResponseTimeUnit
}

func GetShowDetailsOfRequestThrottlingPolicyV2ResponseTimeUnitEnum 

func GetShowDetailsOfRequestThrottlingPolicyV2ResponseTimeUnitEnum() ShowDetailsOfRequestThrottlingPolicyV2ResponseTimeUnitEnum

type ShowDetailsOfRequestThrottlingPolicyV2ResponseType 

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

func (ShowDetailsOfRequestThrottlingPolicyV2ResponseType) MarshalJSON 

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

func (*ShowDetailsOfRequestThrottlingPolicyV2ResponseType) UnmarshalJSON 

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

type ShowDetailsOfRequestThrottlingPolicyV2ResponseTypeEnum 

type ShowDetailsOfRequestThrottlingPolicyV2ResponseTypeEnum struct {
	E_1 ShowDetailsOfRequestThrottlingPolicyV2ResponseType
	E_2 ShowDetailsOfRequestThrottlingPolicyV2ResponseType
}

func GetShowDetailsOfRequestThrottlingPolicyV2ResponseTypeEnum 

func GetShowDetailsOfRequestThrottlingPolicyV2ResponseTypeEnum() ShowDetailsOfRequestThrottlingPolicyV2ResponseTypeEnum

type SignBindingApiResp 

type SignBindingApiResp struct {
	// API的发布编号
	PublishId *string `json:"publish_id,omitempty"`
	// API编号
	ApiId *string `json:"api_id,omitempty"`
	// 签名密钥的密钥
	SignSecret *string `json:"sign_secret,omitempty"`
	// API所属分组的名称
	GroupName *string `json:"group_name,omitempty"`
	// 签名密钥的编号
	SignId *string `json:"sign_id,omitempty"`
	// 签名密钥的key
	SignKey *string `json:"sign_key,omitempty"`
	// 绑定时间
	BindingTime *sdktime.SdkTime `json:"binding_time,omitempty"`
	// API所属环境的编号
	EnvId *string `json:"env_id,omitempty"`
	// API所属环境的名称
	EnvName *string `json:"env_name,omitempty"`
	// 签名密钥的名称
	SignName *string `json:"sign_name,omitempty"`
	// API类型
	ApiType *int32 `json:"api_type,omitempty"`
	// API名称
	ApiName *string `json:"api_name,omitempty"`
	// 绑定关系的ID
	Id *string `json:"id,omitempty"`
	// API描述
	ApiRemark *string `json:"api_remark,omitempty"`
}

func (SignBindingApiResp) String 

func (o SignBindingApiResp) String() string

type SignBindingReq 

type SignBindingReq struct {
	// 签名密钥编号
	SignId string `json:"sign_id"`
	// API的发布记录编号
	PublishIds []string `json:"publish_ids"`
}

func (SignBindingReq) String 

func (o SignBindingReq) String() string

type SignUnbindingApiResp 

type SignUnbindingApiResp struct {
	// API的认证方式
	AuthType *string `json:"auth_type,omitempty"`
	// 发布的环境名
	RunEnvName *string `json:"run_env_name,omitempty"`
	// API所属分组的名称
	GroupName *string `json:"group_name,omitempty"`
	// API的发布记录编号
	PublishId *string `json:"publish_id,omitempty"`
	// API所属分组的编号
	GroupId *string `json:"group_id,omitempty"`
	// API名称
	Name *string `json:"name,omitempty"`
	// 已绑定的签名密钥名称
	SignatureName *string `json:"signature_name,omitempty"`
	// API描述
	Remark *string `json:"remark,omitempty"`
	// 发布的环境id
	RunEnvId *string `json:"run_env_id,omitempty"`
	// API编号
	Id *string `json:"id,omitempty"`
	// API类型
	Type *int32 `json:"type,omitempty"`
	// API的访问地址
	ReqUri *string `json:"req_uri,omitempty"`
}

func (SignUnbindingApiResp) String 

func (o SignUnbindingApiResp) String() string

type SignatureCreateResp 

type SignatureCreateResp struct {
	// 签名密钥的密钥
	SignSecret *string `json:"sign_secret,omitempty"`
	// 更新时间
	UpdateTime *sdktime.SdkTime `json:"update_time,omitempty"`
	// 创建时间
	CreateTime *sdktime.SdkTime `json:"create_time,omitempty"`
	// 签名密钥的名称
	Name *string `json:"name,omitempty"`
	// 签名密钥的编号
	Id *string `json:"id,omitempty"`
	// 签名密钥的key
	SignKey *string `json:"sign_key,omitempty"`
	// 签名密钥的类型
	SignType *string `json:"sign_type,omitempty"`
	// 绑定的API数量
	BindNum *int32 `json:"bind_num,omitempty"`
	// 绑定的自定义后端数量  暂不支持
	LdapiBindNum *int32 `json:"ldapi_bind_num,omitempty"`
}

func (SignatureCreateResp) String 

func (o SignatureCreateResp) String() string

type SignatureReq 

type SignatureReq struct {
	// 签名密钥的密钥。支持英文，数字，下划线，中划线，!，@，#，$，%，且只能以英文字母开头，16 ~ 64字符。未填写时后台自动生成。
	SignSecret *string `json:"sign_secret,omitempty"`
	// 签名密钥的名称。支持汉字，英文，数字，下划线，且只能以英文和汉字开头，3 ~ 64字符。 > 中文字符必须为UTF-8或者unicode编码。
	Name string `json:"name"`
	// 签名密钥的key。支持英文，数字，下划线，中划线，且只能以英文字母开头，8 ~ 32字符。未填写时后台自动生成。
	SignKey *string `json:"sign_key,omitempty"`
	// 签名密钥类型。
	SignType *SignatureReqSignType `json:"sign_type,omitempty"`
}

func (SignatureReq) String 

func (o SignatureReq) String() string

type SignatureReqSignType 

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

func (SignatureReqSignType) MarshalJSON 

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

func (*SignatureReqSignType) UnmarshalJSON 

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

type SignatureReqSignTypeEnum 

type SignatureReqSignTypeEnum struct {
	HMAC  SignatureReqSignType
	BASIC SignatureReqSignType
}

func GetSignatureReqSignTypeEnum 

func GetSignatureReqSignTypeEnum() SignatureReqSignTypeEnum

type ThrottleBindingApiResp 

type ThrottleBindingApiResp struct {
	// API的认证方式
	AuthType *string `json:"auth_type,omitempty"`
	// API所属分组的名称
	GroupName *string `json:"group_name,omitempty"`
	// API的发布记录编号
	PublishId *string `json:"publish_id,omitempty"`
	// 与流控策略的绑定关系编号
	ThrottleApplyId *string `json:"throttle_apply_id,omitempty"`
	// 已绑定的流控策略的绑定时间
	ApplyTime *sdktime.SdkTime `json:"apply_time,omitempty"`
	// API描述
	Remark *string `json:"remark,omitempty"`
	// 发布的环境id
	RunEnvId *string `json:"run_env_id,omitempty"`
	// API类型
	Type *int32 `json:"type,omitempty"`
	// 绑定的流控策略名称
	ThrottleName *string `json:"throttle_name,omitempty"`
	// API的访问地址
	ReqUri *string `json:"req_uri,omitempty"`
	// 发布的环境名
	RunEnvName *string `json:"run_env_name,omitempty"`
	// API所属分组的编号
	GroupId *string `json:"group_id,omitempty"`
	// API名称
	Name *string `json:"name,omitempty"`
	// API编号
	Id *string `json:"id,omitempty"`
}

func (ThrottleBindingApiResp) String 

func (o ThrottleBindingApiResp) String() string

type ThrottleBindingBatchDelete 

type ThrottleBindingBatchDelete struct {
	// 需要解除绑定的API和流控策略绑定关系ID列表
	ThrottleBindings *[]string `json:"throttle_bindings,omitempty"`
}

func (ThrottleBindingBatchDelete) String 

func (o ThrottleBindingBatchDelete) String() string

type ThrottleBindingBatchResultFailureResp 

type ThrottleBindingBatchResultFailureResp struct {
	// 解除绑定失败的API和流控策略绑定关系ID
	BindId *string `json:"bind_id,omitempty"`
	// 解除绑定失败的错误码
	ErrorCode *string `json:"error_code,omitempty"`
	// 解除绑定失败的错误信息
	ErrorMsg *string `json:"error_msg,omitempty"`
	// 解除绑定失败的API的ID
	ApiId *string `json:"api_id,omitempty"`
	// 解除绑定失败的API的名称
	ApiName *string `json:"api_name,omitempty"`
}

func (ThrottleBindingBatchResultFailureResp) String 

func (o ThrottleBindingBatchResultFailureResp) String() string

type ThrottleBindingReq 

type ThrottleBindingReq struct {
	// 流控策略编号
	StrategyId string `json:"strategy_id"`
	// API的发布记录编号
	PublishIds []string `json:"publish_ids"`
}

func (ThrottleBindingReq) String 

func (o ThrottleBindingReq) String() string

type ThrottleBindingResp 

type ThrottleBindingResp struct {
	// API的发布记录编号
	PublishId *string `json:"publish_id,omitempty"`
	// 策略作用域，取值如下： - 1：整个API - 2： 单个用户 - 3：单个APP  目前只支持1
	Scope *ThrottleBindingRespScope `json:"scope,omitempty"`
	// 流控策略的ID
	StrategyId *string `json:"strategy_id,omitempty"`
	// 绑定时间
	ApplyTime *sdktime.SdkTime `json:"apply_time,omitempty"`
	// 绑定关系的ID
	Id *string `json:"id,omitempty"`
}

func (ThrottleBindingResp) String 

func (o ThrottleBindingResp) String() string

type ThrottleBindingRespScope 

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

func (ThrottleBindingRespScope) MarshalJSON 

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

func (*ThrottleBindingRespScope) UnmarshalJSON 

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

type ThrottleBindingRespScopeEnum 

type ThrottleBindingRespScopeEnum struct {
	E_1 ThrottleBindingRespScope
	E_2 ThrottleBindingRespScope
	E_3 ThrottleBindingRespScope
}

func GetThrottleBindingRespScopeEnum 

func GetThrottleBindingRespScopeEnum() ThrottleBindingRespScopeEnum

type ThrottleBindingThrottleResp 

type ThrottleBindingThrottleResp struct {
	// 流控策略的ID
	Id *string `json:"id,omitempty"`
	// 流控策略的名称
	Name *string `json:"name,omitempty"`
	// 单个API流控时间内能够被访问的次数限制
	ApiCallLimits *int32 `json:"api_call_limits,omitempty"`
	// 单个用户流控时间内能够访问API的次数限制
	UserCallLimits *int32 `json:"user_call_limits,omitempty"`
	// 单个APP流控时间内能够访问API的次数限制
	AppCallLimits *int32 `json:"app_call_limits,omitempty"`
	// 单个源IP流控时间内能够访问API的次数限制
	IpCallLimits *int32 `json:"ip_call_limits,omitempty"`
	// 流控的时长
	TimeInterval *int32 `json:"time_interval,omitempty"`
	// 流控的时间单位
	TimeUnit *string `json:"time_unit,omitempty"`
	// 描述
	Remark *string `json:"remark,omitempty"`
	// 创建时间
	CreateTime *sdktime.SdkTime `json:"create_time,omitempty"`
	// 是否包含特殊流控 - 1：包含 - 2：不包含
	IsIncludeSpecialThrottle *ThrottleBindingThrottleRespIsIncludeSpecialThrottle `json:"is_include_special_throttle,omitempty"`
	// 流控策略生效的环境（即在哪个环境上有效）
	EnvName *string `json:"env_name,omitempty"`
	// 流控策略的类型
	Type *int32 `json:"type,omitempty"`
	// 流控策略与API绑定关系编号
	BindId *string `json:"bind_id,omitempty"`
	// 流控策略与API绑定时间
	BindTime *sdktime.SdkTime `json:"bind_time,omitempty"`
	// 流控策略绑定的API数量
	BindNum *int32 `json:"bind_num,omitempty"`
	// 是否开启动态流控，暂不支持
	EnableAdaptiveControl *string `json:"enable_adaptive_control,omitempty"`
}

func (ThrottleBindingThrottleResp) String 

func (o ThrottleBindingThrottleResp) String() string

type ThrottleBindingThrottleRespIsIncludeSpecialThrottle 

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

func (ThrottleBindingThrottleRespIsIncludeSpecialThrottle) MarshalJSON 

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

func (*ThrottleBindingThrottleRespIsIncludeSpecialThrottle) UnmarshalJSON 

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

type ThrottleBindingThrottleRespIsIncludeSpecialThrottleEnum 

type ThrottleBindingThrottleRespIsIncludeSpecialThrottleEnum struct {
	E_1 ThrottleBindingThrottleRespIsIncludeSpecialThrottle
	E_2 ThrottleBindingThrottleRespIsIncludeSpecialThrottle
}

func GetThrottleBindingThrottleRespIsIncludeSpecialThrottleEnum 

func GetThrottleBindingThrottleRespIsIncludeSpecialThrottleEnum() ThrottleBindingThrottleRespIsIncludeSpecialThrottleEnum

type ThrottleReq 

type ThrottleReq struct {
	// APP流量限制是指一个API在时长之内被每个APP访问的次数上限，该数值不超过用户流量限制值。输入的值不超过2147483647。正整数。
	AppCallLimits *int32 `json:"app_call_limits,omitempty"`
	// 流控策略名称。支持汉字，英文，数字，下划线，且只能以英文和汉字开头，3 ~ 64字符。 > 中文字符必须为UTF-8或者unicode编码。
	Name string `json:"name"`
	// 流控的时间单位
	TimeUnit ThrottleReqTimeUnit `json:"time_unit"`
	// 流控策略描述字符长度不超过255。 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// API流量限制是指时长内一个API能够被访问的次数上限。该值不超过系统默认配额限制，系统默认配额为200tps，用户可根据实际情况修改该系统默认配额。输入的值不超过2147483647。正整数。
	ApiCallLimits int32 `json:"api_call_limits"`
	// 流控策略的类型 - 1：独享，表示绑定到流控策略的单个API流控时间内能够被调用多少次。 - 2：共享，表示绑定到流控策略的所有API流控时间内能够被调用多少次。
	Type *ThrottleReqType `json:"type,omitempty"`
	// 是否开启动态流控： - TRUE - FALSE  暂不支持
	EnableAdaptiveControl *string `json:"enable_adaptive_control,omitempty"`
	// 用户流量限制是指一个API在时长之内每一个用户能访问的次数上限，该数值不超过API流量限制值。输入的值不超过2147483647。正整数。
	UserCallLimits *int32 `json:"user_call_limits,omitempty"`
	// 流量控制的时长单位。与“流量限制次数”配合使用，表示单位时间内的API请求次数上限。输入的值不超过2147483647。正整数。
	TimeInterval int32 `json:"time_interval"`
	// 源IP流量限制是指一个API在时长之内被每个IP访问的次数上限，该数值不超过API流量限制值。输入的值不超过2147483647。正整数。
	IpCallLimits *int32 `json:"ip_call_limits,omitempty"`
}

func (ThrottleReq) String 

func (o ThrottleReq) String() string

type ThrottleReqTimeUnit 

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

func (ThrottleReqTimeUnit) MarshalJSON 

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

func (*ThrottleReqTimeUnit) UnmarshalJSON 

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

type ThrottleReqTimeUnitEnum 

type ThrottleReqTimeUnitEnum struct {
	SECOND ThrottleReqTimeUnit
	MINUTE ThrottleReqTimeUnit
	HOUR   ThrottleReqTimeUnit
	DAY    ThrottleReqTimeUnit
}

func GetThrottleReqTimeUnitEnum 

func GetThrottleReqTimeUnitEnum() ThrottleReqTimeUnitEnum

type ThrottleReqType 

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

func (ThrottleReqType) MarshalJSON 

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

func (*ThrottleReqType) UnmarshalJSON 

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

type ThrottleReqTypeEnum 

type ThrottleReqTypeEnum struct {
	E_1 ThrottleReqType
	E_2 ThrottleReqType
}

func GetThrottleReqTypeEnum 

func GetThrottleReqTypeEnum() ThrottleReqTypeEnum

type ThrottleResp 

type ThrottleResp struct {
	// 流控绑定的API数量
	BindNum *int32 `json:"bind_num,omitempty"`
	// 是否包含特殊流控配置 - 1：包含 - 2：不包含
	IsIncludeSpecialThrottle *ThrottleRespIsIncludeSpecialThrottle `json:"is_include_special_throttle,omitempty"`
	// 创建时间
	CreateTime *sdktime.SdkTime `json:"create_time,omitempty"`
	// 描述
	Remark *string `json:"remark,omitempty"`
	// 流控策略的类型 - 1：独享，表示绑定到流控策略的单个API流控时间内能够被调用多少次。 - 2：共享，表示绑定到流控策略的所有API流控时间内能够被调用多少次
	Type *ThrottleRespType `json:"type,omitempty"`
	// 流控的时长
	TimeInterval *int32 `json:"time_interval,omitempty"`
	// 单个IP流控时间内能够访问API的次数限制
	IpCallLimits *int32 `json:"ip_call_limits,omitempty"`
	// 单个APP流控时间内能够访问API的次数限制
	AppCallLimits *int32 `json:"app_call_limits,omitempty"`
	// 流控策略的名称
	Name *string `json:"name,omitempty"`
	// 流控的时间单位
	TimeUnit *ThrottleRespTimeUnit `json:"time_unit,omitempty"`
	// 单个API流控时间内能够被访问的次数限制
	ApiCallLimits *int32 `json:"api_call_limits,omitempty"`
	// 流控策略的ID
	Id *string `json:"id,omitempty"`
	// 单个用户流控时间内能够访问API的次数限制
	UserCallLimits *int32 `json:"user_call_limits,omitempty"`
	// 是否开启动态流控  暂不支持
	EnableAdaptiveControl *string `json:"enable_adaptive_control,omitempty"`
}

func (ThrottleResp) String 

func (o ThrottleResp) String() string

type ThrottleRespIsIncludeSpecialThrottle 

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

func (ThrottleRespIsIncludeSpecialThrottle) MarshalJSON 

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

func (*ThrottleRespIsIncludeSpecialThrottle) UnmarshalJSON 

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

type ThrottleRespIsIncludeSpecialThrottleEnum 

type ThrottleRespIsIncludeSpecialThrottleEnum struct {
	E_1 ThrottleRespIsIncludeSpecialThrottle
	E_2 ThrottleRespIsIncludeSpecialThrottle
}

func GetThrottleRespIsIncludeSpecialThrottleEnum 

func GetThrottleRespIsIncludeSpecialThrottleEnum() ThrottleRespIsIncludeSpecialThrottleEnum

type ThrottleRespTimeUnit 

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

func (ThrottleRespTimeUnit) MarshalJSON 

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

func (*ThrottleRespTimeUnit) UnmarshalJSON 

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

type ThrottleRespTimeUnitEnum 

type ThrottleRespTimeUnitEnum struct {
	SECOND ThrottleRespTimeUnit
	MINUTE ThrottleRespTimeUnit
	HOUR   ThrottleRespTimeUnit
	DAY    ThrottleRespTimeUnit
}

func GetThrottleRespTimeUnitEnum 

func GetThrottleRespTimeUnitEnum() ThrottleRespTimeUnitEnum

type ThrottleRespType 

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

func (ThrottleRespType) MarshalJSON 

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

func (*ThrottleRespType) UnmarshalJSON 

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

type ThrottleRespTypeEnum 

type ThrottleRespTypeEnum struct {
	E_1 ThrottleRespType
	E_2 ThrottleRespType
}

func GetThrottleRespTypeEnum 

func GetThrottleRespTypeEnum() ThrottleRespTypeEnum

type ThrottleSpecialReq 

type ThrottleSpecialReq struct {
	// 流控时间内特殊对象能够访问API的最大次数限制
	CallLimits int32 `json:"call_limits"`
	// 特殊APP的编号或特殊租户的账号ID
	ObjectId string `json:"object_id"`
	// 特殊对象类型
	ObjectType ThrottleSpecialReqObjectType `json:"object_type"`
}

func (ThrottleSpecialReq) String 

func (o ThrottleSpecialReq) String() string

type ThrottleSpecialReqObjectType 

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

func (ThrottleSpecialReqObjectType) MarshalJSON 

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

func (*ThrottleSpecialReqObjectType) UnmarshalJSON 

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

type ThrottleSpecialReqObjectTypeEnum 

type ThrottleSpecialReqObjectTypeEnum struct {
	APP  ThrottleSpecialReqObjectType
	USER ThrottleSpecialReqObjectType
}

func GetThrottleSpecialReqObjectTypeEnum 

func GetThrottleSpecialReqObjectTypeEnum() ThrottleSpecialReqObjectTypeEnum

type ThrottleSpecialResp 

type ThrottleSpecialResp struct {
	// 特殊对象在流控时间内能够访问API的最大次数限制
	CallLimits *int32 `json:"call_limits,omitempty"`
	// 作用的APP名称
	AppName *string `json:"app_name,omitempty"`
	// 作用的APP或租户的名称
	ObjectName *string `json:"object_name,omitempty"`
	// 特殊对象的身份标识
	ObjectId *string `json:"object_id,omitempty"`
	// 流控策略编号
	ThrottleId *string `json:"throttle_id,omitempty"`
	// 设置时间
	ApplyTime *sdktime.SdkTime `json:"apply_time,omitempty"`
	// 特殊配置的编号
	Id *string `json:"id,omitempty"`
	// 作用的APP编号
	AppId *string `json:"app_id,omitempty"`
	// 特殊对象类型：APP、USER
	ObjectType *string `json:"object_type,omitempty"`
}

func (ThrottleSpecialResp) String 

func (o ThrottleSpecialResp) String() string

type ThrottleSpecialUpdateReq 

type ThrottleSpecialUpdateReq struct {
	// 流控时间内特殊对象能够访问API的最大次数限制
	CallLimits int32 `json:"call_limits"`
}

func (ThrottleSpecialUpdateReq) String 

func (o ThrottleSpecialUpdateReq) String() string

type UpdateApiGroupV2Request 

type UpdateApiGroupV2Request struct {
	ProjectId  string       `json:"project_id"`
	InstanceId string       `json:"instance_id"`
	GroupId    string       `json:"group_id"`
	Body       *ApiGroupReq `json:"body,omitempty"`
}

Request Object

func (UpdateApiGroupV2Request) String 

func (o UpdateApiGroupV2Request) String() string

type UpdateApiGroupV2Response 

type UpdateApiGroupV2Response struct {
	// 分组上绑定的独立域名列表
	UrlDomains *[]UrlDomainsResp `json:"url_domains,omitempty"`
	// 流控时长内分组下的API的总访问次数限制，默认不限，请根据服务的负载能力自行设置  暂不支持
	CallLimits *int32 `json:"call_limits,omitempty"`
	// 最近修改时间
	UpdateTime *sdktime.SdkTime `json:"update_time,omitempty"`
	// API分组名称
	Name *string `json:"name,omitempty"`
	// 流控的时间单位  暂不支持
	TimeUnit *string `json:"time_unit,omitempty"`
	// 是否已上架云市场： - 1：已上架 - 2：未上架 - 3：审核中
	OnSellStatus *int32 `json:"on_sell_status,omitempty"`
	// 描述
	Remark *string `json:"remark,omitempty"`
	// 系统默认分配的子域名
	SlDomain *string `json:"sl_domain,omitempty"`
	// 系统默认分配的子域名列表
	SlDomains *[]string `json:"sl_domains,omitempty"`
	// 编号
	Id *string `json:"id,omitempty"`
	// 流控时长  暂不支持
	TimeInterval *int32 `json:"time_interval,omitempty"`
	// 创建时间
	RegisterTime *sdktime.SdkTime `json:"register_time,omitempty"`
	// 状态
	Status *int32 `json:"status,omitempty"`
	// 是否为默认分组
	IsDefault      *int32 `json:"is_default,omitempty"`
	HttpStatusCode int    `json:"-"`
}

Response Object

func (UpdateApiGroupV2Response) String 

func (o UpdateApiGroupV2Response) String() string

type UpdateApiV2Request 

type UpdateApiV2Request struct {
	ProjectId  string     `json:"project_id"`
	InstanceId string     `json:"instance_id"`
	ApiId      string     `json:"api_id"`
	Body       *ApiCreate `json:"body,omitempty"`
}

Request Object

func (UpdateApiV2Request) String 

func (o UpdateApiV2Request) String() string

type UpdateApiV2Response 

type UpdateApiV2Response struct {
	// API名称长度。  为3 ~ 64位的字符串，字符串由中文、英文字母、数字、下划线组成，且只能以英文或中文开头。 > 中文字符必须为UTF-8或者unicode编码。
	Name string `json:"name"`
	// API类型 - 1：公有API - 2：私有API
	Type UpdateApiV2ResponseType `json:"type"`
	// API的版本
	Version *string `json:"version,omitempty"`
	// API的请求协议 - HTTP - HTTPS - BOTH：同时支持HTTP和HTTPS
	ReqProtocol UpdateApiV2ResponseReqProtocol `json:"req_protocol"`
	// API的请求方式
	ReqMethod UpdateApiV2ResponseReqMethod `json:"req_method"`
	// 请求地址。可以包含请求参数，用{}标识，比如/getUserInfo/{userId}，支持 * % - _ . 等特殊字符，总长度不超过512，且满足URI规范。  支持环境变量，使用环境变量时，每个变量名的长度为3 ~ 32位的字符串，字符串由英文字母、数字、中划线、下划线组成，且只能以英文开头。 > 需要服从URI规范。
	ReqUri string `json:"req_uri"`
	// API的认证方式 - NONE：无认证 - APP：APP认证 - IAM：IAM认证 - AUTHORIZER：自定义认证
	AuthType UpdateApiV2ResponseAuthType `json:"auth_type"`
	AuthOpt  *AuthOpt                    `json:"auth_opt,omitempty"`
	// 是否支持跨域 - TRUE：支持 - FALSE：不支持
	Cors *bool `json:"cors,omitempty"`
	// API的匹配方式 - SWA：前缀匹配 - NORMAL：正常匹配（绝对匹配） 默认：NORMAL
	MatchMode *UpdateApiV2ResponseMatchMode `json:"match_mode,omitempty"`
	// 后端类型 - HTTP：web后端 - FUNCTION：函数工作流 - MOCK：模拟的后端
	BackendType UpdateApiV2ResponseBackendType `json:"backend_type"`
	// API描述。字符长度不超过255 > 中文字符必须为UTF-8或者unicode编码。
	Remark *string `json:"remark,omitempty"`
	// API所属的分组编号
	GroupId string `json:"group_id"`
	// API请求体描述，可以是请求体示例、媒体类型、参数等信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	BodyRemark *string `json:"body_remark,omitempty"`
	// 正常响应示例，描述API的正常返回信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	ResultNormalSample *string `json:"result_normal_sample,omitempty"`
	// 失败返回示例，描述API的异常返回信息。字符长度不超过20480 > 中文字符必须为UTF-8或者unicode编码。
	ResultFailureSample *string `json:"result_failure_sample,omitempty"`
	// 前端自定义认证对象的ID
	AuthorizerId *string `json:"authorizer_id,omitempty"`
	// 标签。  支持英文，数字，下划线，且只能以英文开头。支持输入多个标签，不同标签以英文逗号分割。
	Tags *[]string `json:"tags,omitempty"`
	// 分组自定义响应ID
	ResponseId *string `json:"response_id,omitempty"`
	// 集成应用ID  暂不支持
	RomaAppId *string `json:"roma_app_id,omitempty"`
	// API绑定的自定义域名  暂不支持
	DomainName *string `json:"domain_name,omitempty"`
	// 标签  待废弃，优先使用tags字段
	Tag *string `json:"tag,omitempty"`
	// API编号
	Id *string `json:"id,omitempty"`
	// API的状态
	Status *int32 `json:"status,omitempty"`
	// 是否需要编排
	ArrangeNecessary *int32 `json:"arrange_necessary,omitempty"`
	// API注册时间
	RegisterTime *sdktime.SdkTime `json:"register_time,omitempty"`
	// API修改时间
	UpdateTime *sdktime.SdkTime `json:"update_time,omitempty"`
	// API所属分组的名称
	GroupName *string `json:"group_name,omitempty"`
	// API所属分组的版本  默认V1，其他版本暂不支持
	GroupVersion *string `json:"group_version,omitempty"`
	// 发布的环境id
	RunEnvId *string `json:"run_env_id,omitempty"`
	// 发布的环境名称
	RunEnvName *string `json:"run_env_name,omitempty"`
	// 发布记录编号  存在多个发布记录时，编号之间用|隔开
	PublishId *string  `json:"publish_id,omitempty"`
	FuncInfo  *ApiFunc `json:"func_info,omitempty"`
	MockInfo  *ApiMock `json:"mock_info,omitempty"`
	// API的请求参数列表
	ReqParams *[]ReqParam `json:"req_params,omitempty"`
	// API的后端参数列表
	BackendParams *[]BackendParam `json:"backend_params,omitempty"`
	// 函数工作流策略后端列表
	PolicyFunctions *[]ApiPolicyFunctionResp `json:"policy_functions,omitempty"`
	// mock策略后端列表
	PolicyMocks *[]ApiPolicyMockResp `json:"policy_mocks,omitempty"`
	BackendApi  *BackendApi          `json:"backend_api,omitempty"`
	// web策略后端列表
	PolicyHttps    *[]ApiPolicyHttpResp `json:"policy_https,omitempty"`
	HttpStatusCode int                  `json:"-"`
}

Response Object

func (UpdateApiV2Response) String 

func (o UpdateApiV2Response) String() string

type UpdateApiV2ResponseAuthType 

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

func (UpdateApiV2ResponseAuthType) MarshalJSON 

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

func (*UpdateApiV2ResponseAuthType) UnmarshalJSON 

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

type UpdateApiV2ResponseAuthTypeEnum 

type UpdateApiV2ResponseAuthTypeEnum struct {
	NONE       UpdateApiV2ResponseAuthType
	APP        UpdateApiV2ResponseAuthType
	IAM        UpdateApiV2ResponseAuthType
	AUTHORIZER UpdateApiV2ResponseAuthType
}

func GetUpdateApiV2ResponseAuthTypeEnum 

func GetUpdateApiV2ResponseAuthTypeEnum() UpdateApiV2ResponseAuthTypeEnum

type UpdateApiV2ResponseBackendType 

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

func (UpdateApiV2ResponseBackendType) MarshalJSON 

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

func (*UpdateApiV2ResponseBackendType) UnmarshalJSON 

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

type UpdateApiV2ResponseBackendTypeEnum 

type UpdateApiV2ResponseBackendTypeEnum struct {
	HTTP     UpdateApiV2ResponseBackendType
	FUNCTION UpdateApiV2ResponseBackendType
	MOCK     UpdateApiV2ResponseBackendType
}

func GetUpdateApiV2ResponseBackendTypeEnum 

func GetUpdateApiV2ResponseBackendTypeEnum() UpdateApiV2ResponseBackendTypeEnum

type UpdateApiV2ResponseMatchMode 

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

func (UpdateApiV2ResponseMatchMode) MarshalJSON 

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

func (*UpdateApiV2ResponseMatchMode) UnmarshalJSON 

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

type UpdateApiV2ResponseMatchModeEnum 

type UpdateApiV2ResponseMatchModeEnum struct {
	SWA    UpdateApiV2ResponseMatchMode
	NORMAL UpdateApiV2ResponseMatchMode
}

func GetUpdateApiV2ResponseMatchModeEnum 

func GetUpdateApiV2ResponseMatchModeEnum() UpdateApiV2ResponseMatchModeEnum

type UpdateApiV2ResponseReqMethod 

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

func (UpdateApiV2ResponseReqMethod) MarshalJSON 

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

func (*UpdateApiV2ResponseReqMethod) UnmarshalJSON 

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

type UpdateApiV2ResponseReqMethodEnum 

type UpdateApiV2ResponseReqMethodEnum struct {
	GET     UpdateApiV2ResponseReqMethod
	POST    UpdateApiV2ResponseReqMethod
	PUT     UpdateApiV2ResponseReqMethod
	DELETE  UpdateApiV2ResponseReqMethod
	HEAD    UpdateApiV2ResponseReqMethod
	PATCH   UpdateApiV2ResponseReqMethod
	OPTIONS UpdateApiV2ResponseReqMethod
	ANY     UpdateApiV2ResponseReqMethod
}

func GetUpdateApiV2ResponseReqMethodEnum 

func GetUpdateApiV2ResponseReqMethodEnum() UpdateApiV2ResponseReqMethodEnum

type UpdateApiV2ResponseReqProtocol 

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

func (UpdateApiV2ResponseReqProtocol) MarshalJSON 

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

func (*UpdateApiV2ResponseReqProtocol) UnmarshalJSON 

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

type UpdateApiV2ResponseReqProtocolEnum 

type UpdateApiV2ResponseReqProtocolEnum struct {
	HTTP  UpdateApiV2ResponseReqProtocol
	HTTPS UpdateApiV2ResponseReqProtocol
	BOTH  UpdateApiV2ResponseReqProtocol
}

func GetUpdateApiV2ResponseReqProtocolEnum 

func GetUpdateApiV2ResponseReqProtocolEnum() UpdateApiV2ResponseReqProtocolEnum

type UpdateApiV2ResponseType 

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

func (UpdateApiV2ResponseType) MarshalJSON 

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

func (*UpdateApiV2ResponseType) UnmarshalJSON 

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

type UpdateApiV2ResponseTypeEnum 

type UpdateApiV2ResponseTypeEnum struct {
	E_1 UpdateApiV2ResponseType
	E_2 UpdateApiV2ResponseType
}

func GetUpdateApiV2ResponseTypeEnum 

func GetUpdateApiV2ResponseTypeEnum() UpdateApiV2ResponseTypeEnum

type UpdateAppV2Request 

type UpdateAppV2Request struct {
	ProjectId  string  `json:"project_id"`
	InstanceId string  `json:"instance_id"`
	AppId      string  `json:"app_id"`
	Body       *AppReq `json:"body,omitempty"`
}

Request Object

func (UpdateAppV2Request) String 

func (o UpdateAppV2Request) String() string

type UpdateAppV2Response 

type UpdateAppV2Response struct {
	// APP的创建者 - USER：用户自行创建 - MARKET：云市场分配
	Creator *UpdateAppV2ResponseCreator `json:"creator,omitempty"`
	// 更新时间
	UpdateTime *sdktime.SdkTime `json:"update_time,omitempty"`
	// APP的key
	AppKey *string `json:"app_key,omitempty"`
	// 名称
	Name *string `json:"name,omitempty"`
	// 描述
	Remark *string `json:"remark,omitempty"`
	// 编号
	Id *string `json:"id,omitempty"`
	// 密钥
	AppSecret *string `json:"app_secret,omitempty"`
	// 注册时间
	RegisterTime *sdktime.SdkTime `json:"register_time,omitempty"`
	// 状态
	Status *int32 `json:"status,omitempty"`
	// APP的类型  默认为apig，暂不支持其他类型
	AppType        *UpdateAppV2ResponseAppType `json:"app_type,omitempty"`
	HttpStatusCode int                         `json:"-"`
}

Response Object

func (UpdateAppV2Response) String 

func (o UpdateAppV2Response) String() string

type UpdateAppV2ResponseAppType 

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

func (UpdateAppV2ResponseAppType) MarshalJSON 

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

func (*UpdateAppV2ResponseAppType) UnmarshalJSON 

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

type UpdateAppV2ResponseAppTypeEnum 

type UpdateAppV2ResponseAppTypeEnum struct {
	APIG UpdateAppV2ResponseAppType
	ROMA UpdateAppV2ResponseAppType
}

func GetUpdateAppV2ResponseAppTypeEnum 

func GetUpdateAppV2ResponseAppTypeEnum() UpdateAppV2ResponseAppTypeEnum

type UpdateAppV2ResponseCreator 

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

func (UpdateAppV2ResponseCreator) MarshalJSON 

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

func (*UpdateAppV2ResponseCreator) UnmarshalJSON 

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

type UpdateAppV2ResponseCreatorEnum 

type UpdateAppV2ResponseCreatorEnum struct {
	USER   UpdateAppV2ResponseCreator
	MARKET UpdateAppV2ResponseCreator
}

func GetUpdateAppV2ResponseCreatorEnum 

func GetUpdateAppV2ResponseCreatorEnum() UpdateAppV2ResponseCreatorEnum

type UpdateEnvironmentV2Request 

type UpdateEnvironmentV2Request struct {
	ProjectId  string  `json:"project_id"`
	InstanceId string  `json:"instance_id"`
	EnvId      string  `json:"env_id"`
	Body       *EnvReq `json:"body,omitempty"`
}

Request Object

func (UpdateEnvironmentV2Request) String 

func (o UpdateEnvironmentV2Request) String() string

type UpdateEnvironmentV2Response 

type UpdateEnvironmentV2Response struct {
	// 创建时间
	CreateTime *sdktime.SdkTime `json:"create_time,omitempty"`
	// 环境名称
	Name *string `json:"name,omitempty"`
	// 描述信息
	Remark *string `json:"remark,omitempty"`
	// 环境id
	Id             *string `json:"id,omitempty"`
	HttpStatusCode int     `json:"-"`
}

Response Object

func (UpdateEnvironmentV2Response) String 

func (o UpdateEnvironmentV2Response) String() string

type UpdateRequestThrottlingPolicyV2Request 

type UpdateRequestThrottlingPolicyV2Request struct {
	ProjectId  string       `json:"project_id"`
	InstanceId string       `json:"instance_id"`
	ThrottleId string       `json:"throttle_id"`
	Body       *ThrottleReq `json:"body,omitempty"`
}

Request Object

func (UpdateRequestThrottlingPolicyV2Request) String 

func (o UpdateRequestThrottlingPolicyV2Request) String() string

type UpdateRequestThrottlingPolicyV2Response 

type UpdateRequestThrottlingPolicyV2Response struct {
	// 流控绑定的API数量
	BindNum *int32 `json:"bind_num,omitempty"`
	// 是否包含特殊流控配置 - 1：包含 - 2：不包含
	IsIncludeSpecialThrottle *UpdateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottle `json:"is_include_special_throttle,omitempty"`
	// 创建时间
	CreateTime *sdktime.SdkTime `json:"create_time,omitempty"`
	// 描述
	Remark *string `json:"remark,omitempty"`
	// 流控策略的类型 - 1：独享，表示绑定到流控策略的单个API流控时间内能够被调用多少次。 - 2：共享，表示绑定到流控策略的所有API流控时间内能够被调用多少次
	Type *UpdateRequestThrottlingPolicyV2ResponseType `json:"type,omitempty"`
	// 流控的时长
	TimeInterval *int32 `json:"time_interval,omitempty"`
	// 单个IP流控时间内能够访问API的次数限制
	IpCallLimits *int32 `json:"ip_call_limits,omitempty"`
	// 单个APP流控时间内能够访问API的次数限制
	AppCallLimits *int32 `json:"app_call_limits,omitempty"`
	// 流控策略的名称
	Name *string `json:"name,omitempty"`
	// 流控的时间单位
	TimeUnit *UpdateRequestThrottlingPolicyV2ResponseTimeUnit `json:"time_unit,omitempty"`
	// 单个API流控时间内能够被访问的次数限制
	ApiCallLimits *int32 `json:"api_call_limits,omitempty"`
	// 流控策略的ID
	Id *string `json:"id,omitempty"`
	// 单个用户流控时间内能够访问API的次数限制
	UserCallLimits *int32 `json:"user_call_limits,omitempty"`
	// 是否开启动态流控  暂不支持
	EnableAdaptiveControl *string `json:"enable_adaptive_control,omitempty"`
	HttpStatusCode        int     `json:"-"`
}

Response Object

func (UpdateRequestThrottlingPolicyV2Response) String 

func (o UpdateRequestThrottlingPolicyV2Response) String() string

type UpdateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottle 

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

func (UpdateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottle) MarshalJSON 

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

func (*UpdateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottle) UnmarshalJSON 

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

type UpdateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottleEnum 

type UpdateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottleEnum struct {
	E_1 UpdateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottle
	E_2 UpdateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottle
}

func GetUpdateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottleEnum 

func GetUpdateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottleEnum() UpdateRequestThrottlingPolicyV2ResponseIsIncludeSpecialThrottleEnum

type UpdateRequestThrottlingPolicyV2ResponseTimeUnit 

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

func (UpdateRequestThrottlingPolicyV2ResponseTimeUnit) MarshalJSON 

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

func (*UpdateRequestThrottlingPolicyV2ResponseTimeUnit) UnmarshalJSON 

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

type UpdateRequestThrottlingPolicyV2ResponseTimeUnitEnum 

type UpdateRequestThrottlingPolicyV2ResponseTimeUnitEnum struct {
	SECOND UpdateRequestThrottlingPolicyV2ResponseTimeUnit
	MINUTE UpdateRequestThrottlingPolicyV2ResponseTimeUnit
	HOUR   UpdateRequestThrottlingPolicyV2ResponseTimeUnit
	DAY    UpdateRequestThrottlingPolicyV2ResponseTimeUnit
}

func GetUpdateRequestThrottlingPolicyV2ResponseTimeUnitEnum 

func GetUpdateRequestThrottlingPolicyV2ResponseTimeUnitEnum() UpdateRequestThrottlingPolicyV2ResponseTimeUnitEnum

type UpdateRequestThrottlingPolicyV2ResponseType 

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

func (UpdateRequestThrottlingPolicyV2ResponseType) MarshalJSON 

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

func (*UpdateRequestThrottlingPolicyV2ResponseType) UnmarshalJSON 

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

type UpdateRequestThrottlingPolicyV2ResponseTypeEnum 

type UpdateRequestThrottlingPolicyV2ResponseTypeEnum struct {
	E_1 UpdateRequestThrottlingPolicyV2ResponseType
	E_2 UpdateRequestThrottlingPolicyV2ResponseType
}

func GetUpdateRequestThrottlingPolicyV2ResponseTypeEnum 

func GetUpdateRequestThrottlingPolicyV2ResponseTypeEnum() UpdateRequestThrottlingPolicyV2ResponseTypeEnum

type UpdateSignatureKeyV2Request 

type UpdateSignatureKeyV2Request struct {
	ProjectId  string        `json:"project_id"`
	InstanceId string        `json:"instance_id"`
	SignId     string        `json:"sign_id"`
	Body       *SignatureReq `json:"body,omitempty"`
}

Request Object

func (UpdateSignatureKeyV2Request) String 

func (o UpdateSignatureKeyV2Request) String() string

type UpdateSignatureKeyV2Response 

type UpdateSignatureKeyV2Response struct {
	// 签名密钥的密钥
	SignSecret *string `json:"sign_secret,omitempty"`
	// 更新时间
	UpdateTime *sdktime.SdkTime `json:"update_time,omitempty"`
	// 创建时间
	CreateTime *sdktime.SdkTime `json:"create_time,omitempty"`
	// 签名密钥的名称
	Name *string `json:"name,omitempty"`
	// 签名密钥的编号
	Id *string `json:"id,omitempty"`
	// 签名密钥的key
	SignKey *string `json:"sign_key,omitempty"`
	// 签名密钥类型。
	SignType       *UpdateSignatureKeyV2ResponseSignType `json:"sign_type,omitempty"`
	HttpStatusCode int                                   `json:"-"`
}

Response Object

func (UpdateSignatureKeyV2Response) String 

func (o UpdateSignatureKeyV2Response) String() string

type UpdateSignatureKeyV2ResponseSignType 

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

func (UpdateSignatureKeyV2ResponseSignType) MarshalJSON 

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

func (*UpdateSignatureKeyV2ResponseSignType) UnmarshalJSON 

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

type UpdateSignatureKeyV2ResponseSignTypeEnum 

type UpdateSignatureKeyV2ResponseSignTypeEnum struct {
	HMAC  UpdateSignatureKeyV2ResponseSignType
	BASIC UpdateSignatureKeyV2ResponseSignType
}

func GetUpdateSignatureKeyV2ResponseSignTypeEnum 

func GetUpdateSignatureKeyV2ResponseSignTypeEnum() UpdateSignatureKeyV2ResponseSignTypeEnum

type UpdateSpecialThrottlingConfigurationV2Request 

type UpdateSpecialThrottlingConfigurationV2Request struct {
	ProjectId  string                    `json:"project_id"`
	InstanceId string                    `json:"instance_id"`
	ThrottleId string                    `json:"throttle_id"`
	StrategyId string                    `json:"strategy_id"`
	Body       *ThrottleSpecialUpdateReq `json:"body,omitempty"`
}

Request Object

func (UpdateSpecialThrottlingConfigurationV2Request) String 

func (o UpdateSpecialThrottlingConfigurationV2Request) String() string

type UpdateSpecialThrottlingConfigurationV2Response 

type UpdateSpecialThrottlingConfigurationV2Response struct {
	// 特殊对象在流控时间内能够访问API的最大次数限制
	CallLimits *int32 `json:"call_limits,omitempty"`
	// 作用的APP名称
	AppName *string `json:"app_name,omitempty"`
	// 作用的APP或租户的名称
	ObjectName *string `json:"object_name,omitempty"`
	// 特殊对象的身份标识
	ObjectId *string `json:"object_id,omitempty"`
	// 流控策略编号
	ThrottleId *string `json:"throttle_id,omitempty"`
	// 设置时间
	ApplyTime *sdktime.SdkTime `json:"apply_time,omitempty"`
	// 特殊配置的编号
	Id *string `json:"id,omitempty"`
	// 作用的APP编号
	AppId *string `json:"app_id,omitempty"`
	// 特殊对象类型：APP、USER
	ObjectType     *string `json:"object_type,omitempty"`
	HttpStatusCode int     `json:"-"`
}

Response Object

func (UpdateSpecialThrottlingConfigurationV2Response) String 

func (o UpdateSpecialThrottlingConfigurationV2Response) String() string

type UrlDomainsResp 

type UrlDomainsResp struct {
	// 域名编号
	Id *string `json:"id,omitempty"`
	// 访问域名
	Domain *string `json:"domain,omitempty"`
	// 域名cname状态： - 1：未解析 - 2：解析中 - 3：解析成功 - 4：解析失败
	CnameStatus *int32 `json:"cname_status,omitempty"`
	// SSL证书编号
	SslId *string `json:"ssl_id,omitempty"`
	// SSL证书名称
	SslName *string `json:"ssl_name,omitempty"`
}

func (UrlDomainsResp) String 

func (o UrlDomainsResp) String() string

type VpcBaseInfo 

type VpcBaseInfo struct {
	// 云服务器ID
	EcsId *string `json:"ecs_id,omitempty"`
	// 云服务器名称
	EcsName *int32 `json:"ecs_name,omitempty"`
	// 是否使用级联方式  暂不支持
	CascadeFlag *bool `json:"cascade_flag,omitempty"`
}

func (VpcBaseInfo) String 

func (o VpcBaseInfo) String() string

type VpcInfo 

type VpcInfo struct {
	// 云服务器ID
	EcsId *string `json:"ecs_id,omitempty"`
	// 云服务器名称
	EcsName *int32 `json:"ecs_name,omitempty"`
	// 是否使用级联方式  暂不支持
	CascadeFlag *bool `json:"cascade_flag,omitempty"`
	// 代理主机
	VpcChannelProxyHost *string `json:"vpc_channel_proxy_host,omitempty"`
	// VPC通道编号
	VpcChannelId *string `json:"vpc_channel_id,omitempty"`
	// VPC通道端口
	VpcChannelPort *string `json:"vpc_channel_port,omitempty"`
}

VPC通道详情。如果vpc_channel_status = 1，则这个object类型为必填信息

func (VpcInfo) String 

func (o VpcInfo) 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.